git.diff (133,696 bytes)
2011-04-01 02:20 
diff --git a/rts/Game/Camera.cpp b/rts/Game/Camera.cpp
index 3a13aae..aec1220 100644
--- a/rts/Game/Camera.cpp
+++ b/rts/Game/Camera.cpp
@@ -132,9 +132,8 @@ void CCamera::Update(bool freeze, bool resetUp)
const float gndHeight = ground->GetHeightAboveWater(pos.x, pos.z);
const float rangemod = 1.0f + std::max(0.0f, pos.y - gndHeight - 500.0f) * 0.0003f;
- const float zNear = (CGlobalRendering::NEAR_PLANE * rangemod);
-
- globalRendering->viewRange = CGlobalRendering::MAX_VIEW_RANGE * rangemod;
+ const float zNear = (NEAR_PLANE * rangemod);
+ globalRendering->viewRange = MAX_VIEW_RANGE * rangemod;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
diff --git a/rts/Game/Game.cpp b/rts/Game/Game.cpp
index 4e046dc..85ea86f 100644
--- a/rts/Game/Game.cpp
+++ b/rts/Game/Game.cpp
@@ -217,6 +217,7 @@ CR_REG_METADATA(CGame,(
CGame::CGame(const std::string& mapname, const std::string& modName, ILoadSaveHandler* saveFile) :
+ finishedLoading(false),
gameDrawMode(gameNotDrawing),
defsParser(NULL),
fps(0),
@@ -230,7 +231,6 @@ CGame::CGame(const std::string& mapname, const std::string& modName, ILoadSaveHa
gameOver(false),
noSpectatorChat(false),
- finishedLoading(false),
infoConsole(NULL),
consoleHistory(NULL),
@@ -708,23 +708,20 @@ void CGame::ResizeEvent()
}
-int CGame::KeyPressed(unsigned short key, bool isRepeat)
+int CGame::KeyPressed(unsigned short k, bool isRepeat)
{
if (!gameOver && !isRepeat) {
playerHandler->Player(gu->myPlayerNum)->currentStats.keyPresses++;
}
- // Get the list of possible key actions
- const CKeySet ks(key, false);
- const CKeyBindings::ActionList& actionList = keyBindings->GetActionList(ks);
-
if (!hotBinding.empty()) {
- if (key == SDLK_ESCAPE) {
+ if (k == SDLK_ESCAPE) {
hotBinding.clear();
}
- else if (!keyCodes->IsModifier(key) && (key != keyBindings->GetFakeMetaKey())) {
+ else if (!keyCodes->IsModifier(k) && (k != keyBindings->GetFakeMetaKey())) {
+ CKeySet ks(k, false);
string cmd = "bind";
- cmd += " " + ks.GetString(false);
+ cmd += " " + ks.GetString(false) ;
cmd += " " + hotBinding;
keyBindings->Command(cmd);
hotBinding.clear();
@@ -733,15 +730,173 @@ int CGame::KeyPressed(unsigned short key, bool isRepeat)
return 0;
}
+ // Get the list of possible key actions
+ CKeySet ks(k, false);
+ const CKeyBindings::ActionList& actionList = keyBindings->GetActionList(ks);
+
if (userWriting) {
- for (unsigned int actionIndex = 0; actionIndex < actionList.size(); actionIndex++) {
- if (ProcessKeyPressAction(key, actionList[actionIndex])) {
- // the key was used, ignore it (ex: alt+a)
- ignoreNextChar = (actionIndex < (actionList.size() - 1));
+ unsigned int actionIndex;
+ for (actionIndex = 0; actionIndex < actionList.size(); actionIndex++) {
+ const Action& action = actionList[actionIndex];
+
+ if (action.command == "edit_return") {
+ userWriting=false;
+ writingPos = 0;
+
+ if (k == SDLK_RETURN) {
+ keyInput->SetKeyState(k, 0); //prevent game start when server chats
+ }
+ if (chatting) {
+ string command;
+ if ((userInput.find_first_of("aAsS") == 0) && (userInput[1] == ':')) {
+ command = userInput.substr(2);
+ } else {
+ command = userInput;
+ }
+ if ((command[0] == '/') && (command[1] != '/')) {
+ // execute an action
+ consoleHistory->AddLine(command);
+ const string actionLine = command.substr(1); // strip the '/'
+ chatting = false;
+ userInput = "";
+ writingPos = 0;
+ logOutput.Print(command);
+ CKeySet ks(k, false);
+ Action fakeAction(actionLine);
+ ActionPressed(fakeAction, ks, isRepeat);
+ }
+ }
+ break;
+ }
+ else if ((action.command == "edit_escape") &&
+ (chatting || inMapDrawer->wantLabel)) {
+ if (chatting) {
+ consoleHistory->AddLine(userInput);
+ }
+ userWriting=false;
+ chatting=false;
+ inMapDrawer->wantLabel=false;
+ userInput="";
+ writingPos = 0;
+ break;
+ }
+ else if (action.command == "edit_complete") {
+ string head = userInput.substr(0, writingPos);
+ string tail = userInput.substr(writingPos);
+ const vector<string> &partials = wordCompletion->Complete(head);
+ userInput = head + tail;
+ writingPos = (int)head.length();
+ if (!partials.empty()) {
+ string msg;
+ for (unsigned int i = 0; i < partials.size(); i++) {
+ msg += " ";
+ msg += partials[i];
+ }
+ logOutput.Print(msg);
+ }
+ break;
+ }
+ else if (action.command == "chatswitchall") {
+ if ((userInput.find_first_of("aAsS") == 0) && (userInput[1] == ':')) {
+ userInput = userInput.substr(2);
+ writingPos = std::max(0, writingPos - 2);
+ }
+ userInputPrefix = "";
+ break;
+ }
+ else if (action.command == "chatswitchally") {
+ if ((userInput.find_first_of("aAsS") == 0) && (userInput[1] == ':')) {
+ userInput[0] = 'a';
+ } else {
+ userInput = "a:" + userInput;
+ writingPos += 2;
+ }
+ userInputPrefix = "a:";
+ break;
+ }
+ else if (action.command == "chatswitchspec") {
+ if ((userInput.find_first_of("aAsS") == 0) && (userInput[1] == ':')) {
+ userInput[0] = 's';
+ } else {
+ userInput = "s:" + userInput;
+ writingPos += 2;
+ }
+ userInputPrefix = "s:";
+ break;
+ }
+ else if (action.command == "pastetext") {
+ if (!action.extra.empty()) {
+ userInput.insert(writingPos, action.extra);
+ writingPos += action.extra.length();
+ } else {
+ PasteClipboard();
+ }
+ break;
+ }
+
+ else if (action.command == "edit_backspace") {
+ if (!userInput.empty() && (writingPos > 0)) {
+ userInput.erase(writingPos - 1, 1);
+ writingPos--;
+ }
+ break;
+ }
+ else if (action.command == "edit_delete") {
+ if (!userInput.empty() && (writingPos < (int)userInput.size())) {
+ userInput.erase(writingPos, 1);
+ }
+ break;
+ }
+ else if (action.command == "edit_home") {
+ writingPos = 0;
+ break;
+ }
+ else if (action.command == "edit_end") {
+ writingPos = (int)userInput.length();
+ break;
+ }
+ else if (action.command == "edit_prev_char") {
+ writingPos = std::max(0, std::min((int)userInput.length(), writingPos - 1));
+ break;
+ }
+ else if (action.command == "edit_next_char") {
+ writingPos = std::max(0, std::min((int)userInput.length(), writingPos + 1));
+ break;
+ }
+ else if (action.command == "edit_prev_word") {
+ // prev word
+ const char* s = userInput.c_str();
+ int p = writingPos;
+ while ((p > 0) && !isalnum(s[p - 1])) { p--; }
+ while ((p > 0) && isalnum(s[p - 1])) { p--; }
+ writingPos = p;
+ break;
+ }
+ else if (action.command == "edit_next_word") {
+ const int len = (int)userInput.length();
+ const char* s = userInput.c_str();
+ int p = writingPos;
+ while ((p < len) && !isalnum(s[p])) { p++; }
+ while ((p < len) && isalnum(s[p])) { p++; }
+ writingPos = p;
+ break;
+ }
+ else if ((action.command == "edit_prev_line") && chatting) {
+ userInput = consoleHistory->PrevLine(userInput);
+ writingPos = (int)userInput.length();
+ break;
+ }
+ else if ((action.command == "edit_next_line") && chatting) {
+ userInput = consoleHistory->NextLine(userInput);
+ writingPos = (int)userInput.length();
break;
}
}
+ if (actionIndex != actionList.size()) {
+ ignoreNextChar = true; // the key was used, ignore it (ex: alt+a)
+ }
+
return 0;
}
@@ -749,15 +904,15 @@ int CGame::KeyPressed(unsigned short key, bool isRepeat)
std::deque<CInputReceiver*>& inputReceivers = GetInputReceivers();
std::deque<CInputReceiver*>::iterator ri;
for (ri = inputReceivers.begin(); ri != inputReceivers.end(); ++ri) {
- CInputReceiver* recv = *ri;
- if (recv && recv->KeyPressed(key, isRepeat)) {
+ CInputReceiver* recv=*ri;
+ if (recv && recv->KeyPressed(k, isRepeat)) {
return 0;
}
}
// try our list of actions
- for (unsigned int i = 0; i < actionList.size(); ++i) {
- if (ActionPressed(key, actionList[i], isRepeat)) {
+ for (int i = 0; i < (int)actionList.size(); ++i) {
+ if (ActionPressed(actionList[i], ks, isRepeat)) {
return 0;
}
}
@@ -1609,12 +1764,9 @@ void CGame::SimFrame() {
m_validateAllAllocUnits();
#endif
- // Important: gs->frameNum must be updated *before* GameFrame is called,
- // or any call-outs called by Lua will see a stale gs->frameNum.
- // (e.g. effective TTL of CEGs emitted in GameFrame will be reduced...)
- // It must still be passed the old frameNum because Lua may depend on it.
- // (e.g. initialization in frame 0...)
- eventHandler.GameFrame(gs->frameNum++);
+ eventHandler.GameFrame(gs->frameNum);
+
+ gs->frameNum++;
if (!skipping) {
infoConsole->Update();
diff --git a/rts/Game/Game.h b/rts/Game/Game.h
index bfcb914..5837b90 100644
--- a/rts/Game/Game.h
+++ b/rts/Game/Game.h
@@ -47,7 +47,6 @@ private:
public:
CGame(const std::string& mapname, const std::string& modName, ILoadSaveHandler* saveFile);
- virtual ~CGame();
bool Draw();
bool DrawMT();
@@ -57,22 +56,20 @@ public:
/// Called when a key is released by the user
int KeyReleased(unsigned short k);
/// Called when the key is pressed by the user (can be called several times due to key repeat)
- int KeyPressed(unsigned short k, bool isRepeat);
+ int KeyPressed(unsigned short k,bool isRepeat);
void ResizeEvent();
+ virtual ~CGame();
-
- bool ProcessCommandText(unsigned int key, const std::string& command);
- bool ProcessKeyPressAction(unsigned int key, const Action& action);
-
- bool ActionPressed(unsigned int key, const Action&, bool isRepeat);
+ bool ActionPressed(const Action&, const CKeySet& ks, bool isRepeat);
bool ActionReleased(const Action&);
-
+
bool HasLag() const;
+ volatile bool finishedLoading;
+
/// show GameEnd-window, calculate mouse movement etc.
void GameEnd(const std::vector<unsigned char>& winningAllyTeams);
-
enum GameDrawMode {
gameNotDrawing = 0,
gameNormalDraw = 1,
@@ -120,7 +117,6 @@ public:
bool showMTInfo;
/// Prevents spectator msgs from being seen by players
bool noSpectatorChat;
- volatile bool finishedLoading;
unsigned char gameID[16];
@@ -142,7 +138,7 @@ private:
void SendNetChat(std::string message, int destination = -1);
/// Format and display a chat message received over network
void HandleChatMsg(const ChatMessage& msg);
-
+
/// synced actions (received from server) go in here
void ActionReceived(const Action&, int playernum);
diff --git a/rts/Game/GameHelper.cpp b/rts/Game/GameHelper.cpp
index 404c9af..53b72de 100644
--- a/rts/Game/GameHelper.cpp
+++ b/rts/Game/GameHelper.cpp
@@ -829,7 +829,7 @@ public:
-void CGameHelper::GenerateWeaponTargets(const CWeapon* weapon, const CUnit* lastTargetUnit, std::multimap<float, CUnit*>& targets)
+void CGameHelper::GenerateWeaponTargets(const CWeapon* weapon, CUnit* lastTarget, std::multimap<float, CUnit*>& targets)
{
GML_RECMUTEX_LOCK(qnum); // GenerateTargets
@@ -845,7 +845,7 @@ void CGameHelper::GenerateWeaponTargets(const CWeapon* weapon, const CUnit* last
const std::vector<int>& quads = qf->GetQuads(pos, radius + (aHeight - std::max(0.f, readmap->minheight)) * heightMod);
- const int tempNum = gs->tempNum++;
+ int tempNum = gs->tempNum++;
typedef std::vector<int>::const_iterator VectorIt;
typedef std::list<CUnit*>::const_iterator ListIt;
@@ -893,16 +893,13 @@ void CGameHelper::GenerateWeaponTargets(const CWeapon* weapon, const CUnit* last
const float modRange = radius + (aHeight - targPos.y) * heightMod;
if ((pos - targPos).SqLength2D() <= modRange * modRange) {
- const float dist2D = (pos - targPos).Length2D();
- const float rangeMul = (dist2D * weapon->weaponDef->proximityPriority + modRange * 0.4f + 100.0f);
- const float damageMul = weapon->weaponDef->damages[targetUnit->armorType] * targetUnit->curArmorMultiple;
-
- targetPriority *= rangeMul;
+ float dist2d = (pos - targPos).Length2D();
+ targetPriority *= (dist2d * weapon->weaponDef->proximityPriority + modRange * 0.4f + 100.0f);
if (targetLOSState & LOS_INLOS) {
targetPriority *= (secDamage + targetUnit->health);
- if (targetUnit == lastTargetUnit) {
+ if (targetUnit == lastTarget) {
targetPriority *= weapon->avoidTarget ? 10.0f : 0.4f;
}
@@ -918,7 +915,9 @@ void CGameHelper::GenerateWeaponTargets(const CWeapon* weapon, const CUnit* last
}
if (targetLOSState & LOS_PREVLOS) {
- targetPriority /= (damageMul * targetUnit->power * (0.7f + gs->randFloat() * 0.6f));
+ targetPriority /=
+ weapon->weaponDef->damages[targetUnit->armorType] * targetUnit->curArmorMultiple *
+ targetUnit->power * (0.7f + gs->randFloat() * 0.6f);
if (targetUnit->category & weapon->badTargetCategory) {
targetPriority *= 100.0f;
@@ -945,6 +944,7 @@ void CGameHelper::GenerateWeaponTargets(const CWeapon* weapon, const CUnit* last
tracefile << "\n";
}
#endif
+
}
CUnit* CGameHelper::GetClosestUnit(const float3 &pos, float searchRadius)
diff --git a/rts/Game/GameHelper.h b/rts/Game/GameHelper.h
index b079d10..8d4845d 100644
--- a/rts/Game/GameHelper.h
+++ b/rts/Game/GameHelper.h
@@ -55,7 +55,7 @@ public:
CUnit* GetClosestFriendlyUnit(const float3& pos, float searchRadius, int searchAllyteam);
CUnit* GetClosestEnemyAircraft(const float3& pos, float searchRadius, int searchAllyteam);
- void GenerateWeaponTargets(const CWeapon* attacker, const CUnit* lastTarget, std::multimap<float, CUnit*>& targets);
+ void GenerateWeaponTargets(const CWeapon* attacker, CUnit* lastTarget, std::multimap<float, CUnit*>& targets);
float TraceRay(const float3& start, const float3& dir, float length, float power, const CUnit* owner, const CUnit*& hit, int collisionFlags = 0, const CFeature** hitFeature = NULL);
float GuiTraceRay(const float3& start, const float3& dir, float length, const CUnit*& hit, bool useRadar, const CUnit* exclude = NULL);
float GuiTraceRayFeature(const float3& start, const float3& dir, float length, const CFeature*& feature);
diff --git a/rts/Game/PreGame.cpp b/rts/Game/PreGame.cpp
index 69c4927..476d066 100644
--- a/rts/Game/PreGame.cpp
+++ b/rts/Game/PreGame.cpp
@@ -214,23 +214,19 @@ void CPreGame::UpdateClientNet()
std::string message;
pckt >> message;
logOutput.Print(message);
- handleerror(NULL, "Remote requested quit: " + message, "Quit message", MBF_OK | MBF_EXCL);
+ handleerror(NULL, message, "Quit message", MBF_OK | MBF_EXCL);
} catch (netcode::UnpackPacketException &e) {
logOutput.Print("Got invalid QuitMessage: %s", e.err.c_str());
}
break;
}
- case NETMSG_CREATE_NEWPLAYER: {
- // server will send this first if we're using mid-game join
- // feature, to let us know about ourself (we won't be in
- // gamedata), otherwise skip to gamedata
+ case NETMSG_CREATE_NEWPLAYER: { // server will send this first if we're using midgame join feature, to let us know about ourself (we won't be in gamedata), otherwise skip to gamedata
try {
netcode::UnpackPacket pckt(packet, 3);
unsigned char spectator, team, playerNum;
std::string name;
- // since the >> operator uses dest size to extract data from
- // the packet, we need to use temp variables of the same
- // size of the packet, before converting to dest variable
+ // since the >> operator uses dest size to extract data from the packet, we need to use temp variables
+ // of the same size of the packet, then convert to dest variable
pckt >> playerNum;
pckt >> spectator;
pckt >> team;
@@ -241,30 +237,22 @@ void CPreGame::UpdateClientNet()
player.spectator = spectator;
player.team = team;
player.playerNum = playerNum;
- // add ourself, to avoid crashing if our player num gets
- // queried we will receive the same message later, in the
- // game class, which is the global broadcast version
- // the global broadcast will overwrite the user with the
- // same values as here
+ // add ourself, to avoid crashing if our player num gets queried
+ // we'll receive the same message later, in the game class, which is the global broadcast version
+ // the global broadcast will overwrite the user with the same values as here
playerHandler->AddPlayer(player);
} catch (netcode::UnpackPacketException &e) {
logOutput.Print("Got invalid New player message: %s", e.err.c_str());
}
break;
}
- case NETMSG_GAMEDATA: {
- // server first sends this to let us know about teams, allyteams
- // etc.
- // (not if we are joining mid-game as extra players)
- // see NETMSG_SETPLAYERNUM
+ case NETMSG_GAMEDATA: { // server first ( not if we're joining midgame as extra players ) sends this to let us know about teams, allyteams etc.
if (gameSetup)
throw content_error("Duplicate game data received from server");
GameDataReceived(packet);
break;
}
- case NETMSG_SETPLAYERNUM: {
- // this is sent after NETMSG_GAMEDATA, to let us know which
- // playernum we have
+ case NETMSG_SETPLAYERNUM: { // this is sent afterwards to let us know which playernum we have
if (!gameSetup)
throw content_error("No game data received from server");
diff --git a/rts/Game/UI/GuiHandler.cpp b/rts/Game/UI/GuiHandler.cpp
index 0c298c2..87be01c 100644
--- a/rts/Game/UI/GuiHandler.cpp
+++ b/rts/Game/UI/GuiHandler.cpp
@@ -1412,7 +1412,8 @@ void CGuiHandler::RunCustomCommands(const std::vector<std::string>& cmds, bool r
Action action(copy);
if (!ProcessLocalActions(action)) {
- game->ActionPressed(-1, action, false /*isRepeat*/);
+ CKeySet ks;
+ game->ActionPressed(action, ks, false /*isRepeat*/);
}
keyInput->SetKeyState(SDLK_LALT, tmpAlt);
diff --git a/rts/Game/UnsyncedGameCommands.cpp b/rts/Game/UnsyncedGameCommands.cpp
index d7aae2a..ffb936b 100644
--- a/rts/Game/UnsyncedGameCommands.cpp
+++ b/rts/Game/UnsyncedGameCommands.cpp
@@ -15,7 +15,7 @@
#include "PlayerRoster.h"
#include "TimeProfiler.h"
#include "IVideoCapturing.h"
-#include "WordCompletion.h"
+#include "Game/UI/UnitTracker.h"
#ifdef _WIN32
# include "winerror.h"
#endif
@@ -55,7 +55,6 @@
#include "UI/SelectionKeyHandler.h"
#include "UI/ShareBox.h"
#include "UI/TooltipConsole.h"
-#include "UI/UnitTracker.h"
#include "UI/ProfileDrawer.h"
#include "System/ConfigHandler.h"
#include "System/EventHandler.h"
@@ -89,186 +88,9 @@ static std::vector<std::string> _local_strSpaceTokenize(const std::string& text)
}
-
-bool CGame::ProcessCommandText(unsigned int key, const std::string& command) {
- if (command.size() <= 2)
- return false;
-
- if ((command[0] == '/') && (command[1] != '/')) {
- const string actionLine = command.substr(1); // strip the '/'
-
- Action fakeAction(actionLine);
- ActionPressed(key, fakeAction, false);
- return true;
- }
-
- return false;
-}
-
-bool CGame::ProcessKeyPressAction(unsigned int key, const Action& action) {
- if (action.command == "edit_return") {
- userWriting = false;
- writingPos = 0;
-
- if (key == SDLK_RETURN) {
- // prevent game start when host enters a chat message
- keyInput->SetKeyState(key, 0);
- }
- if (chatting) {
- string command;
-
- if ((userInput.find_first_of("aAsS") == 0) && (userInput[1] == ':')) {
- command = userInput.substr(2);
- } else {
- command = userInput;
- }
-
- if (ProcessCommandText(key, command)) {
- // execute an action
- consoleHistory->AddLine(command);
- logOutput.Print(command);
-
- chatting = false;
- userInput = "";
- writingPos = 0;
- }
- }
- return true;
- }
- else if ((action.command == "edit_escape") && (chatting || inMapDrawer->wantLabel)) {
- if (chatting) {
- consoleHistory->AddLine(userInput);
- }
- userWriting = false;
- chatting = false;
- inMapDrawer->wantLabel = false;
- userInput = "";
- writingPos = 0;
- return true;
- }
- else if (action.command == "edit_complete") {
- string head = userInput.substr(0, writingPos);
- string tail = userInput.substr(writingPos);
- const vector<string> &partials = wordCompletion->Complete(head);
- userInput = head + tail;
- writingPos = (int)head.length();
-
- if (!partials.empty()) {
- string msg;
- for (unsigned int i = 0; i < partials.size(); i++) {
- msg += " ";
- msg += partials[i];
- }
- logOutput.Print(msg);
- }
- return true;
- }
- else if (action.command == "chatswitchall") {
- if ((userInput.find_first_of("aAsS") == 0) && (userInput[1] == ':')) {
- userInput = userInput.substr(2);
- writingPos = std::max(0, writingPos - 2);
- }
-
- userInputPrefix = "";
- return true;
- }
- else if (action.command == "chatswitchally") {
- if ((userInput.find_first_of("aAsS") == 0) && (userInput[1] == ':')) {
- userInput[0] = 'a';
- } else {
- userInput = "a:" + userInput;
- writingPos += 2;
- }
-
- userInputPrefix = "a:";
- return true;
- }
- else if (action.command == "chatswitchspec") {
- if ((userInput.find_first_of("aAsS") == 0) && (userInput[1] == ':')) {
- userInput[0] = 's';
- } else {
- userInput = "s:" + userInput;
- writingPos += 2;
- }
-
- userInputPrefix = "s:";
- return true;
- }
- else if (action.command == "pastetext") {
- if (!action.extra.empty()) {
- userInput.insert(writingPos, action.extra);
- writingPos += action.extra.length();
- } else {
- PasteClipboard();
- }
- return true;
- }
-
- else if (action.command == "edit_backspace") {
- if (!userInput.empty() && (writingPos > 0)) {
- userInput.erase(writingPos - 1, 1);
- writingPos--;
- }
- return true;
- }
- else if (action.command == "edit_delete") {
- if (!userInput.empty() && (writingPos < (int)userInput.size())) {
- userInput.erase(writingPos, 1);
- }
- return true;
- }
- else if (action.command == "edit_home") {
- writingPos = 0;
- return true;
- }
- else if (action.command == "edit_end") {
- writingPos = (int)userInput.length();
- return true;
- }
- else if (action.command == "edit_prev_char") {
- writingPos = std::max(0, std::min((int)userInput.length(), writingPos - 1));
- return true;
- }
- else if (action.command == "edit_next_char") {
- writingPos = std::max(0, std::min((int)userInput.length(), writingPos + 1));
- return true;
- }
- else if (action.command == "edit_prev_word") {
- // prev word
- const char* s = userInput.c_str();
- int p = writingPos;
- while ((p > 0) && !isalnum(s[p - 1])) { p--; }
- while ((p > 0) && isalnum(s[p - 1])) { p--; }
- writingPos = p;
- return true;
- }
- else if (action.command == "edit_next_word") {
- const int len = (int)userInput.length();
- const char* s = userInput.c_str();
- int p = writingPos;
- while ((p < len) && !isalnum(s[p])) { p++; }
- while ((p < len) && isalnum(s[p])) { p++; }
- writingPos = p;
- return true;
- }
- else if ((action.command == "edit_prev_line") && chatting) {
- userInput = consoleHistory->PrevLine(userInput);
- writingPos = (int)userInput.length();
- return true;
- }
- else if ((action.command == "edit_next_line") && chatting) {
- userInput = consoleHistory->NextLine(userInput);
- writingPos = (int)userInput.length();
- return true;
- }
-
- return false;
-}
-
-
-
// FOR UNSYNCED MESSAGES
-bool CGame::ActionPressed(unsigned int key, const Action& action, bool isRepeat)
+bool CGame::ActionPressed(const Action& action,
+ const CKeySet& ks, bool isRepeat)
{
// we may need these later
CBaseGroundDrawer* gd = readmap->GetGroundDrawer();
@@ -409,7 +231,7 @@ bool CGame::ActionPressed(unsigned int key, const Action& action, bool isRepeat)
if (pos.x >= 0) {
inMapDrawer->keyPressed = false;
inMapDrawer->PromptLabel(pos);
- if ((key >= SDLK_SPACE) && (key <= SDLK_DELETE)) {
+ if ((ks.Key() >= SDLK_SPACE) && (ks.Key() <= SDLK_DELETE)) {
ignoreNextChar=true;
}
}
@@ -803,7 +625,7 @@ bool CGame::ActionPressed(unsigned int key, const Action& action, bool isRepeat)
else if (((cmd == "chat") || (cmd == "chatall") ||
(cmd == "chatally") || (cmd == "chatspec")) &&
// if chat is bound to enter and we're waiting for user to press enter to start game, ignore.
- (key != SDLK_RETURN || playing || !keyInput->IsKeyPressed(SDLK_LCTRL))) {
+ (ks.Key() != SDLK_RETURN || playing || !keyInput->IsKeyPressed(SDLK_LCTRL))) {
if (cmd == "chatall") { userInputPrefix = ""; }
if (cmd == "chatally") { userInputPrefix = "a:"; }
@@ -814,7 +636,7 @@ bool CGame::ActionPressed(unsigned int key, const Action& action, bool isRepeat)
writingPos = (int)userInput.length();
chatting = true;
- if (key != SDLK_RETURN) {
+ if (ks.Key() != SDLK_RETURN) {
ignoreNextChar = true;
}
@@ -1646,3 +1468,5 @@ bool CGame::ActionPressed(unsigned int key, const Action& action, bool isRepeat)
return true;
}
+
+
diff --git a/rts/Rendering/Env/AdvSky.cpp b/rts/Rendering/Env/AdvSky.cpp
index 08393fe..680fa0f 100644
--- a/rts/Rendering/Env/AdvSky.cpp
+++ b/rts/Rendering/Env/AdvSky.cpp
@@ -46,7 +46,6 @@ CAdvSky::CAdvSky()
domeWidth = sin(2*PI/32)*400*1.7f;
UpdateSkyDir();
- InitSun();
UpdateSunDir();
for(int a=0;a<CLOUD_DETAIL;a++)
@@ -65,15 +64,11 @@ CAdvSky::CAdvSky()
CreateClouds();
dynamicSky = configHandler->Get("DynamicSky", false);
+ InitSun();
oldCoverBaseX=-5;
cloudFP = LoadFragmentProgram("ARB/clouds.fp");
- CreateSkyDomeList();
-}
-
-void CAdvSky::CreateSkyDomeList()
-{
glGetError();
skyDomeList = glGenLists(1);
glNewList(skyDomeList, GL_COMPILE);
@@ -665,7 +660,7 @@ void CAdvSky::InitSun()
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
// gluBuild2DMipmaps(GL_TEXTURE_2D,1 ,32, 2, GL_ALPHA, GL_UNSIGNED_BYTE, mem);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE ,32, 4, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, mem);
+ glTexImage2D(GL_TEXTURE_2D,0,GL_LUMINANCE ,32, 4,0, GL_LUMINANCE, GL_UNSIGNED_BYTE, mem);
delete [] mem;
}
diff --git a/rts/Rendering/Env/AdvSky.h b/rts/Rendering/Env/AdvSky.h
index f963437..5686ce9 100644
--- a/rts/Rendering/Env/AdvSky.h
+++ b/rts/Rendering/Env/AdvSky.h
@@ -21,7 +21,6 @@ public:
void UpdateSkyTexture();
private:
- void CreateSkyDomeList();
void InitSun();
void UpdateSunFlare();
void CreateCover(int baseX, int baseY, float* buf);
diff --git a/rts/Rendering/Env/BaseTreeDrawer.cpp b/rts/Rendering/Env/BaseTreeDrawer.cpp
index bcfcd20..31ebe22 100644
--- a/rts/Rendering/Env/BaseTreeDrawer.cpp
+++ b/rts/Rendering/Env/BaseTreeDrawer.cpp
@@ -7,7 +7,6 @@
#include "BasicTreeDrawer.h"
#include "AdvTreeDrawer.h"
#include "Game/Camera.h"
-#include "Rendering/GlobalRendering.h"
#include "Sim/Features/FeatureHandler.h"
#include "Sim/Features/Feature.h"
#include "Sim/Misc/GlobalConstants.h"
@@ -83,8 +82,7 @@ void CBaseTreeDrawer::DrawShadowPass()
void CBaseTreeDrawer::Draw(bool drawReflection)
{
- const float maxDistance = CGlobalRendering::MAX_VIEW_RANGE / (SQUARE_SIZE * TREE_SQUARE_SIZE);
- const float treeDistance = Clamp(baseTreeDistance, 1.0f, maxDistance);
+ const float treeDistance = Clamp(baseTreeDistance, 1.0f, (float)MAX_VIEW_RANGE / (SQUARE_SIZE * TREE_SQUARE_SIZE));
Draw(treeDistance, drawReflection);
}
diff --git a/rts/Rendering/Env/BasicSky.cpp b/rts/Rendering/Env/BasicSky.cpp
index 67621f5..10b2b3e 100644
--- a/rts/Rendering/Env/BasicSky.cpp
+++ b/rts/Rendering/Env/BasicSky.cpp
@@ -48,7 +48,6 @@ CBasicSky::CBasicSky()
domeWidth=sin(PI/16)*400*1.7f;
UpdateSkyDir();
- InitSun();
UpdateSunDir();
cloudDensity = 0.25f + mapInfo->atmosphere.cloudDensity * 0.5f;
@@ -67,9 +66,8 @@ CBasicSky::CBasicSky()
CreateClouds();
dynamicSky = configHandler->Get("DynamicSky", false);
+ InitSun();
oldCoverBaseX=-5;
-
- CreateSkyDomeList();
}
void CBasicSky::CreateSkyDomeList()
@@ -514,7 +512,7 @@ void CBasicSky::DrawSun()
glDisable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST);
- static unsigned char buf[32];
+ static unsigned char buf[128];
glEnable(GL_TEXTURE_2D);
float3 modCamera=sundir1*camera->pos.x+sundir2*camera->pos.z;
@@ -538,6 +536,7 @@ void CBasicSky::DrawSun()
}
float mid=0;
+ unsigned char *bf=buf+32, *bf2=buf+64;
for(int x=0;x<32;++x){
float cx1=(*cvs++)*(1-fx)+(*cvs1++)*fx;
float cx2=(*cvs2++)*(1-fx)+(*cvs3++)*fx;
@@ -546,6 +545,9 @@ void CBasicSky::DrawSun()
if(cover>127.5f)
cover=127.5f;
mid+=cover;
+
+ (*bf++)=(unsigned char)(255-cover*2);
+ (*bf2++)=(unsigned char)(128-cover);
}
mid*=1.0f/32;
for(int x=0;x<32;++x){
@@ -553,7 +555,7 @@ void CBasicSky::DrawSun()
}
glBindTexture(GL_TEXTURE_2D, sunFlareTex);
- glTexSubImage2D(GL_TEXTURE_2D,0,0,0,32,1,GL_LUMINANCE,GL_UNSIGNED_BYTE,buf);
+ glTexSubImage2D(GL_TEXTURE_2D,0,0,0,32,3,GL_LUMINANCE,GL_UNSIGNED_BYTE,buf);
const float si = skyLight->GetLightIntensity();
const float3 sc = sunColor * si;
@@ -584,9 +586,9 @@ void CBasicSky::UpdateSunFlare() {
float dx=sin(x*2*PI/256.0f);
float dy=cos(x*2*PI/256.0f);
- glTexCoord2f(x/256.0f,0.25f);
+ glTexCoord2f(x/256.0f,0.125f);
glVertexf3(modSunDir*5+ldir*dx*0.0014f+udir*dy*0.0014f);
- glTexCoord2f(x/256.0f,0.75f);
+ glTexCoord2f(x/256.0f,0.875f);
glVertexf3(modSunDir*5+ldir*dx*4+udir*dy*4);
}
glEnd();
@@ -621,7 +623,7 @@ void CBasicSky::InitSun()
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
glBuildMipmaps(GL_TEXTURE_2D,GL_RGBA8 ,128, 128, GL_RGBA, GL_UNSIGNED_BYTE, mem);
- for(int y=0;y<2;++y){
+ for(int y=0;y<4;++y){
for(int x=0;x<32;++x){
if(y==0 && x%2)
mem[(y*32+x)]=255;
@@ -635,7 +637,7 @@ void CBasicSky::InitSun()
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE ,32, 2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, mem);
+ glTexImage2D(GL_TEXTURE_2D,0, GL_LUMINANCE, 32, 4, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, mem);
delete[] mem;
}
@@ -793,13 +795,14 @@ void CBasicSky::UpdateTexPartDot3(int x, int y, unsigned char (*texp)[4]) {
const float sunInt = skyLight->GetLightIntensity();
const float sunDist = acos(dir.dot(skyLight->GetLightDir())) * 50;
- const float sunMod = sunInt * (0.3f / math::sqrt(sunDist) + 2.0f / sunDist);
+ const float sunMod = sunInt * (0.3f / math::sqrt(sunDist) + 3.0f / (1 + sunDist));
const float green = std::min(1.0f, (0.55f + sunMod));
+ const float blue = 203 - sunInt * (40.0f / (3 + sunDist));
texp[x][0] = (unsigned char) (sunInt * (255 - std::min(255.0f, sunDist))); // sun on borders
texp[x][1] = (unsigned char) (green * 255); // sun light through
- texp[x][2] = (unsigned char) 203; // ambient
+ texp[x][2] = (unsigned char) blue; // ambient
texp[x][3] = 255;
}
diff --git a/rts/Rendering/FarTextureHandler.cpp b/rts/Rendering/FarTextureHandler.cpp
old mode 100644
new mode 100755
index 3a7978a..74f20f4
--- a/rts/Rendering/FarTextureHandler.cpp
+++ b/rts/Rendering/FarTextureHandler.cpp
@@ -181,7 +181,7 @@ void CFarTextureHandler::CreateFarTexture(const CSolidObject* obj)
unitDrawer->SetupForUnitDrawing();
unitDrawer->GetOpaqueModelRenderer(model->type)->PushRenderState();
- if (model->type == MODELTYPE_S3O || model->type == MODELTYPE_OBJ) {
+ if (model->type == MODELTYPE_S3O || model->type == MODELTYPE_OBJ || model->type == MODELTYPE_ASS) {
// FIXME for some strange reason we need to invert the culling, why?
if (model->type == MODELTYPE_S3O) {
glCullFace(GL_FRONT);
diff --git a/rts/Rendering/FeatureDrawer.cpp b/rts/Rendering/FeatureDrawer.cpp
old mode 100644
new mode 100755
index 4385a71..b88eab3
--- a/rts/Rendering/FeatureDrawer.cpp
+++ b/rts/Rendering/FeatureDrawer.cpp
@@ -229,7 +229,7 @@ void CFeatureDrawer::DrawOpaqueFeatures(int modelType)
FeatureSet::iterator featureSetIt;
for (featureBinIt = featureBin.begin(); featureBinIt != featureBin.end(); ++featureBinIt) {
- if (modelType == MODELTYPE_S3O || modelType == MODELTYPE_OBJ) {
+ if (modelType == MODELTYPE_S3O || modelType == MODELTYPE_OBJ || modelType == MODELTYPE_ASS) {
texturehandlerS3O->SetS3oTexture(featureBinIt->first);
}
@@ -371,7 +371,7 @@ void CFeatureDrawer::DrawFadeFeaturesHelper(int modelType) {
FeatureRenderBin& featureBin = cloakedModelRenderers[modelType]->GetFeatureBinMutable();
for (FeatureRenderBinIt it = featureBin.begin(); it != featureBin.end(); ++it) {
- if (modelType == MODELTYPE_S3O || modelType == MODELTYPE_OBJ) {
+ if (modelType == MODELTYPE_S3O || modelType == MODELTYPE_OBJ || modelType == MODELTYPE_ASS) {
texturehandlerS3O->SetS3oTexture(it->first);
}
diff --git a/rts/Rendering/GlobalRendering.cpp b/rts/Rendering/GlobalRendering.cpp
index 60bd337..86d328b 100644
--- a/rts/Rendering/GlobalRendering.cpp
+++ b/rts/Rendering/GlobalRendering.cpp
@@ -22,8 +22,6 @@
*/
CGlobalRendering* globalRendering;
-const float CGlobalRendering::MAX_VIEW_RANGE = 8000.0f;
-const float CGlobalRendering::NEAR_PLANE = 2.8f;
CR_BIND(CGlobalRendering, );
diff --git a/rts/Rendering/GlobalRendering.h b/rts/Rendering/GlobalRendering.h
index 38525b0..e60ba46 100644
--- a/rts/Rendering/GlobalRendering.h
+++ b/rts/Rendering/GlobalRendering.h
@@ -4,6 +4,8 @@
#define _GLOBAL_RENDERING_H
#include "System/creg/creg_cond.h"
+#include "System/float4.h"
+#include "System/Matrix44f.h"
/**
* @brief Globally accessible unsynced, rendering related data
@@ -180,18 +182,6 @@ public:
* @brief full-screen or windowed rendering
*/
bool fullScreen;
-
-
-
- /**
- * @brief max view range in elmos
- */
- static const float MAX_VIEW_RANGE;
-
- /**
- * @brief near z-plane distance in elmos
- */
- static const float NEAR_PLANE;
};
extern CGlobalRendering* globalRendering;
diff --git a/rts/Rendering/Models/3DModel.cpp b/rts/Rendering/Models/3DModel.cpp
old mode 100644
new mode 100755
index 5c3d98d..02df7b7
--- a/rts/Rendering/Models/3DModel.cpp
+++ b/rts/Rendering/Models/3DModel.cpp
@@ -18,6 +18,18 @@
//////////////////////////////////////////////////////////////////////
+// S3DModel
+//
+
+S3DModelPiece* S3DModel::FindPiece( std::string name )
+{
+ const ModelPieceMap::const_iterator it = pieces.find(name);
+ if (it != pieces.end()) return it->second;
+ return NULL;
+}
+
+
+//////////////////////////////////////////////////////////////////////
// S3DModelPiece
//
diff --git a/rts/Rendering/Models/3DModel.h b/rts/Rendering/Models/3DModel.h
old mode 100644
new mode 100755
index ba577b7..0501a41
--- a/rts/Rendering/Models/3DModel.h
+++ b/rts/Rendering/Models/3DModel.h
@@ -5,23 +5,26 @@
#include <vector>
#include <string>
-
+#include <set>
+#include <map>
#include "System/Matrix44f.h"
-
const int
MODELTYPE_3DO = 0,
MODELTYPE_S3O = 1,
MODELTYPE_OBJ = 2,
- MODELTYPE_OTHER = 3;
+ MODELTYPE_ASS = 3, // Model loaded by Assimp library
+ MODELTYPE_OTHER = 4; // For future use. Still used in some parts of code.
struct CollisionVolume;
struct S3DModel;
struct S3DModelPiece;
struct LocalModel;
struct LocalModelPiece;
+struct aiScene;
+typedef std::map<std::string, S3DModelPiece*> ModelPieceMap;
struct S3DModelPiece {
S3DModelPiece(): type(-1) {
@@ -53,8 +56,10 @@ struct S3DModelPiece {
std::string name;
+ std::string parentName;
std::vector<S3DModelPiece*> childs;
+ S3DModel* model;
S3DModelPiece* parent;
CollisionVolume* colvol;
@@ -68,23 +73,32 @@ struct S3DModelPiece {
float3 maxs;
float3 offset; // wrt. parent
float3 goffset; // wrt. root
+ float3 rot;
+ float3 scale;
};
struct S3DModel
{
S3DModel(): id(-1), type(-1), textureType(-1) {
- numPieces = 0;
-
- radius = 0.0f;
- height = 0.0f;
-
- rootPiece = NULL;
+ height = 0.0f;
+ radius = 0.0f;
+ relMidPos = float3(0.0f, 0.0f, 0.0f);
+ mins = float3(10000.0f, 10000.0f, 10000.0f);
+ maxs = float3(-10000.0f, -10000.0f, -10000.0f);
+ tex1 = "default.png";
+ tex2 = "";
+ flipTexY = false;
+ invertTexAlpha = false;
+ numPieces = 0;
+ rootPiece = NULL;
+ scene = NULL;
}
S3DModelPiece* GetRootPiece() { return rootPiece; }
void SetRootPiece(S3DModelPiece* p) { rootPiece = p; }
void DrawStatic() const { rootPiece->DrawStatic(); }
+ S3DModelPiece* FindPiece( std::string name );
std::string name;
std::string tex1;
@@ -93,8 +107,9 @@ struct S3DModel
int id; //! unsynced ID, starting with 1
int type; //! MODELTYPE_*
int textureType; //! FIXME: MAKE S3O ONLY (0 = 3DO, otherwise S3O or OBJ)
+ bool flipTexY; //! Turn both textures upside down before use
+ bool invertTexAlpha; //! Invert teamcolor alpha channel in S3O texture 1
- int numPieces;
float radius;
float height;
@@ -102,7 +117,10 @@ struct S3DModel
float3 maxs;
float3 relMidPos;
- S3DModelPiece* rootPiece;
+ int numPieces;
+ S3DModelPiece* rootPiece; //! The piece at the base of the model hierarchy
+ ModelPieceMap pieces; //! Lookup table for pieces by name
+ const aiScene* scene; //! Assimp scene containing all loaded model data. NULL for S30/3DO.
};
diff --git a/rts/Rendering/Models/3DModelLog.h b/rts/Rendering/Models/3DModelLog.h
new file mode 100644
index 0000000..c1b38e2
--- /dev/null
+++ b/rts/Rendering/Models/3DModelLog.h
@@ -0,0 +1,14 @@
+/* This file is part of the Spring engine (GPL v2 or later), see LICENSE.html */
+
+#ifndef _3DMODELLOG_H_
+#define _3DMODELLOG_H_
+
+#include "System/LogOutput.h"
+
+// Enabling the "Model" and "Piece" log subsystems will help debug model loading. "Model-detail" is extremely verbose.
+static CLogSubsystem LOG_MODEL("Model");
+static CLogSubsystem LOG_MODEL_DETAIL("Model-detail");
+static CLogSubsystem LOG_PIECE("Piece");
+static CLogSubsystem LOG_PIECE_DETAIL("Piece-detail");
+
+#endif // _3DMODELLOG_H_
diff --git a/rts/Rendering/Models/AssIO.cpp b/rts/Rendering/Models/AssIO.cpp
new file mode 100644
index 0000000..9a2a1cb
--- /dev/null
+++ b/rts/Rendering/Models/AssIO.cpp
@@ -0,0 +1,96 @@
+#include "StdAfx.h"
+
+#include <string>
+
+#include "AssIO.h"
+
+#include "FileSystem/FileHandler.h"
+
+AssVFSStream::AssVFSStream(const std::string& pFile, const std::string& pMode)
+{
+ file = new CFileHandler(pFile, pMode);
+}
+
+AssVFSStream::~AssVFSStream(void)
+{
+ delete file;
+}
+
+size_t AssVFSStream::Read( void* pvBuffer, size_t pSize, size_t pCount)
+{
+ // Spring VFS only supports reading chars. Need to convert.
+ int length = pSize * pCount;
+ return file->Read(pvBuffer, length);
+}
+
+size_t AssVFSStream::Write( const void* pvBuffer, size_t pSize, size_t pCount)
+{
+ // FAKE. Shouldn't need to write back to VFS
+ return pSize * pCount;
+}
+
+aiReturn AssVFSStream::Seek( size_t pOffset, aiOrigin pOrigin)
+{
+ switch(pOrigin){
+ case aiOrigin_SET: // from start of file
+ if ( pOffset >= file->FileSize() ) return AI_FAILURE;
+ file->Seek( pOffset, std::ios_base::beg );
+ break;
+ case aiOrigin_CUR: // from current position in file
+ if ( pOffset >= ( file->FileSize() + file->GetPos() ) ) return AI_FAILURE;
+ file->Seek( pOffset, std::ios_base::cur );
+ break;
+ case aiOrigin_END: // reverse from end of file
+ if ( pOffset >= file->FileSize() ) return AI_FAILURE;
+ file->Seek( pOffset, std::ios_base::end );
+ break;
+ }
+ return AI_SUCCESS;
+}
+
+size_t AssVFSStream::Tell() const
+{
+ return file->GetPos();
+}
+
+
+size_t AssVFSStream::FileSize() const
+{
+ int filesize = file->FileSize();
+ if ( filesize < 0 ) filesize = 0;
+ return filesize;
+}
+
+void AssVFSStream::Flush () // FAKE
+{
+}
+
+
+// Check whether a specific file exists
+bool AssVFSSystem::Exists( const char* pFile) const
+{
+ CFileHandler file(pFile);
+ return file.FileExists();
+}
+
+// Get the path delimiter character we'd like to get
+char AssVFSSystem::getOsSeparator() const
+{
+ return '/';
+}
+
+bool AssVFSSystem::ComparePaths (const std::string& one, const std::string& second) const
+{
+ return one == second; // too naive? probably should convert to absolute paths
+}
+
+// open a custom stream
+Assimp::IOStream* AssVFSSystem::Open( const char* pFile, const char* pMode)
+{
+ return new AssVFSStream( pFile, pMode );
+}
+
+void AssVFSSystem::Close( Assimp::IOStream* pFile)
+{
+ delete pFile;
+}
diff --git a/rts/Rendering/Models/AssIO.h b/rts/Rendering/Models/AssIO.h
new file mode 100644
index 0000000..7b34efa
--- /dev/null
+++ b/rts/Rendering/Models/AssIO.h
@@ -0,0 +1,52 @@
+#ifndef ASSIO_H
+#define ASSIO_H
+
+#include "IOStream.h"
+#include "IOSystem.h"
+class CFileHandler;
+
+// Custom implementation of Assimp IOStream to support Spring's VFS
+// Required because Assimp models often need to load textures from other files
+
+class AssVFSStream : public Assimp::IOStream
+{
+ friend class AssVFSSystem;
+ CFileHandler* file;
+
+protected:
+ // Constructor protected for private usage by AssVFSSystem
+ AssVFSStream(const std::string& pFile, const std::string& pMode);
+
+public:
+ ~AssVFSStream(void);
+ size_t Read( void* pvBuffer, size_t pSize, size_t pCount);
+ size_t Write( const void* pvBuffer, size_t pSize, size_t pCount);
+ aiReturn Seek( size_t pOffset, aiOrigin pOrigin);
+ size_t Tell() const;
+ size_t FileSize() const;
+ void Flush ();
+};
+
+
+// Spring VFS Filesystem Wrapper for Assimp
+
+class AssVFSSystem : public Assimp::IOSystem
+{
+public:
+ AssVFSSystem() { }
+ ~AssVFSSystem() { }
+
+ // Check whether a specific file exists
+ bool Exists( const char* pFile) const;
+
+ // Get the path delimiter character we'd like to get
+ char getOsSeparator() const;
+ bool ComparePaths (const std::string& one, const std::string& second) const;
+
+ // open a custom stream
+ Assimp::IOStream* Open( const char* pFile, const char* pMode = "rb" );
+
+ void Close( Assimp::IOStream* pFile);
+};
+
+#endif
diff --git a/rts/Rendering/Models/AssParser.cpp b/rts/Rendering/Models/AssParser.cpp
new file mode 100755
index 0000000..2678a01
--- /dev/null
+++ b/rts/Rendering/Models/AssParser.cpp
@@ -0,0 +1,565 @@
+// AssParser.cpp: implementation of the CAssParser class. Reads 3D formats supported by Assimp lib.
+//
+//////////////////////////////////////////////////////////////////////
+//#include "StdAfx.h"
+
+#include "Util.h"
+#include "LogOutput.h"
+#include "Platform/errorhandler.h"
+#include "System/Exceptions.h"
+#include "Sim/Misc/CollisionVolume.h"
+#include "FileSystem/FileHandler.h"
+#include "Lua/LuaParser.h"
+#include "3DModel.h"
+#include "3DModelLog.h"
+#include "S3OParser.h"
+#include "AssIO.h"
+#include "AssParser.h"
+
+#include "assimp.hpp"
+#include "aiDefines.h"
+#include "aiTypes.h"
+#include "aiScene.h"
+#include "aiPostProcess.h"
+#include "DefaultLogger.h"
+#include "Rendering/Textures/S3OTextureHandler.h"
+
+#define IS_QNAN(f) (f != f)
+#define DEGTORAD 0.0174532925
+
+// triangulate guarantees the most complex mesh is a triangle
+// sortbytype ensure only 1 type of primitive type per mesh is used
+#define ASS_POSTPROCESS_OPTIONS \
+ aiProcess_RemoveComponent | \
+ aiProcess_FindInvalidData | \
+ aiProcess_CalcTangentSpace | \
+ aiProcess_GenSmoothNormals | \
+ aiProcess_SplitLargeMeshes | \
+ aiProcess_Triangulate | \
+ aiProcess_GenUVCoords | \
+ aiProcess_SortByPType | \
+ aiProcess_JoinIdenticalVertices
+
+//aiProcess_ImproveCacheLocality
+
+// Convert Assimp quaternion to radians around x, y and z
+float3 QuaternionToRadianAngles( aiQuaternion q1 )
+{
+ float sqw = q1.w*q1.w;
+ float sqx = q1.x*q1.x;
+ float sqy = q1.y*q1.y;
+ float sqz = q1.z*q1.z;
+ float unit = sqx + sqy + sqz + sqw; // if normalised is one, otherwise is correction factor
+ float test = q1.x*q1.y + q1.z*q1.w;
+
+ float3 result(0.0f, 0.0f, 0.0f);
+
+ if (test > 0.499f * unit) { // singularity at north pole
+ result.x = 2 * atan2(q1.x,q1.w);
+ result.y = PI/2;
+ } else if (test < -0.499f * unit) { // singularity at south pole
+ result.x = -2 * atan2(q1.x,q1.w);
+ result.y = -PI/2;
+ } else {
+ result.x = atan2(2*q1.y*q1.w-2*q1.x*q1.z , sqx - sqy - sqz + sqw);
+ result.y = asin(2*test/unit);
+ result.z = atan2(2*q1.x*q1.w-2*q1.y*q1.z , -sqx + sqy - sqz + sqw);
+ }
+ return result;
+}
+
+// Convert float3 rotations in degrees to radians
+void DegreesToRadianAngles( float3& angles )
+{
+ angles.x *= DEGTORAD;
+ angles.y *= DEGTORAD;
+ angles.z *= DEGTORAD;
+}
+
+class AssLogStream : public Assimp::LogStream
+{
+public:
+ AssLogStream() {}
+ ~AssLogStream() {}
+ void write(const char* message)
+ {
+ logOutput.Print (LOG_MODEL_DETAIL, "Assimp: %s", message);
+ }
+};
+
+
+
+S3DModel* CAssParser::Load(const std::string& modelFileName)
+{
+ logOutput.Print (LOG_MODEL, "Loading model: %s\n", modelFileName.c_str() );
+ std::string modelPath = modelFileName.substr(0, modelFileName.find_last_of('/'));
+ std::string modelFileNameNoPath = modelFileName.substr(modelPath.length()+1, modelFileName.length());
+ std::string modelName = modelFileNameNoPath.substr(0, modelFileNameNoPath.find_last_of('.'));
+ std::string modelExt = modelFileNameNoPath.substr(modelFileNameNoPath.find_last_of('.'), modelFileName.length());
+
+ // LOAD METADATA
+ // Load the lua metafile. This contains properties unique to Spring models and must return a table
+ std::string metaFileName = modelFileName + ".lua";
+ CFileHandler* metaFile = new CFileHandler(metaFileName);
+ if (!metaFile->FileExists()) {
+ // Try again without the model file extension
+ metaFileName = modelPath + '/' + modelName + ".lua";
+ metaFile = new CFileHandler(metaFileName);
+ }
+ LuaParser metaFileParser(metaFileName, SPRING_VFS_MOD_BASE, SPRING_VFS_ZIP);
+ if (!metaFileParser.Execute()) {
+ if (!metaFile->FileExists()) {
+ logOutput.Print(LOG_MODEL, "No meta-file '%s'. Using defaults.", metaFileName.c_str());
+ } else {
+ logOutput.Print(LOG_MODEL, "ERROR in '%s': %s. Using defaults.", metaFileName.c_str(), metaFileParser.GetErrorLog().c_str());
+ }
+ }
+ // Get the (root-level) model table
+ const LuaTable& metaTable = metaFileParser.GetRoot();
+ if (metaTable.IsValid()) logOutput.Print(LOG_MODEL, "Found valid model metadata in '%s'", metaFileName.c_str());
+
+
+ // LOAD MODEL DATA
+ // Create a model importer instance
+ Assimp::Importer importer;
+
+ // Create a logger for debugging model loading issues
+ Assimp::DefaultLogger::create("",Assimp::Logger::VERBOSE);
+ const unsigned int severity = Assimp::Logger::DEBUGGING|Assimp::Logger::INFO|Assimp::Logger::ERR|Assimp::Logger::WARN;
+ Assimp::DefaultLogger::get()->attachStream( new AssLogStream(), severity );
+
+ // Give the importer an IO class that handles Spring's VFS
+ importer.SetIOHandler( new AssVFSSystem() );
+
+ // Speed-up processing by skipping things we don't need
+ importer.SetPropertyInteger(AI_CONFIG_PP_RVC_FLAGS, aiComponent_CAMERAS|aiComponent_LIGHTS|aiComponent_TEXTURES|aiComponent_ANIMATIONS);
+
+ // Read the model file to build a scene object
+ logOutput.Print(LOG_MODEL, "Importing model file: %s\n", modelFileName.c_str() );
+ const aiScene* scene = importer.ReadFile( modelFileName, ASS_POSTPROCESS_OPTIONS );
+ if (scene != NULL) {
+ logOutput.Print(LOG_MODEL, "Processing scene for model: %s (%d meshes / %d materials / %d textures)", modelFileName.c_str(), scene->mNumMeshes, scene->mNumMaterials, scene->mNumTextures );
+ } else {
+ logOutput.Print (LOG_MODEL, "Model Import Error: %s\n", importer.GetErrorString());
+ }
+
+ S3DModel* model = new S3DModel;
+ model->name = modelFileName;
+ model->type = MODELTYPE_ASS;
+ model->numPieces = 0;
+ model->scene = scene;
+ //model->meta = &metaTable;
+
+ // Assign textures
+ // The S3O texture handler uses two textures.
+ // The first contains diffuse color (RGB) and teamcolor (A)
+ // The second contains glow (R), reflectivity (G) and 1-bit Alpha (A).
+ if (metaTable.KeyExists("tex1")) {
+ model->tex1 = metaTable.GetString("tex1", "default.png");
+ } else {
+ // Search for a texture
+ std::vector<std::string> files = CFileHandler::FindFiles("unittextures/", modelName + ".*");
+ for(std::vector<std::string>::iterator fi = files.begin(); fi != files.end(); ++fi) {
+ std::string texPath = std::string(*fi);
+ model->tex1 = texPath.substr(texPath.find('/')+1, texPath.length());
+ break; // there can be only one!
+ }
+ }
+ if (metaTable.KeyExists("tex2")) {
+ model->tex2 = metaTable.GetString("tex2", "");
+ } else {
+ // Search for a texture
+ std::vector<std::string> files = CFileHandler::FindFiles("unittextures/", modelName + "2.*");
+ for(std::vector<std::string>::iterator fi = files.begin(); fi != files.end(); ++fi) {
+ std::string texPath = std::string(*fi);
+ model->tex2 = texPath.substr(texPath.find('/')+1, texPath.length());
+ break; // there can be only one!
+ }
+ }
+ model->flipTexY = metaTable.GetBool("fliptextures", true); // Flip texture upside down
+ model->invertTexAlpha = metaTable.GetBool("invertteamcolor", true); // Reverse teamcolor levels
+
+ // Load textures
+ logOutput.Print(LOG_MODEL, "Loading textures. Tex1: '%s' Tex2: '%s'", model->tex1.c_str(), model->tex2.c_str());
+ texturehandlerS3O->LoadS3OTexture(model);
+
+ // Load all pieces in the model
+ logOutput.Print(LOG_MODEL, "Loading pieces from root node '%s'", scene->mRootNode->mName.data);
+ LoadPiece( model, scene->mRootNode, metaTable );
+
+ // Update piece hierarchy based on metadata
+ BuildPieceHierarchy( model );
+
+ // Simplified dimensions used for rough calculations
+ model->radius = metaTable.GetFloat("radius", model->radius);
+ model->height = metaTable.GetFloat("height", model->height);
+ model->relMidPos = metaTable.GetFloat3("midpos", model->relMidPos);
+ model->mins = metaTable.GetFloat3("mins", model->mins);
+ model->maxs = metaTable.GetFloat3("maxs", model->maxs);
+
+ // Calculate model dimensions if not set
+ if (!metaTable.KeyExists("mins") || !metaTable.KeyExists("maxs")) CalculateMinMax( model->rootPiece );
+ if (model->radius < 0.0001f) CalculateRadius( model );
+ if (model->height < 0.0001f) CalculateHeight( model );
+
+ // Verbose logging of model properties
+ logOutput.Print(LOG_MODEL_DETAIL, "model->name: %s", model->name.c_str());
+ logOutput.Print(LOG_MODEL_DETAIL, "model->numobjects: %d", model->numPieces);
+ logOutput.Print(LOG_MODEL_DETAIL, "model->radius: %f", model->radius);
+ logOutput.Print(LOG_MODEL_DETAIL, "model->height: %f", model->height);
+ logOutput.Print(LOG_MODEL_DETAIL, "model->mins: (%f,%f,%f)", model->mins[0], model->mins[1], model->mins[2]);
+ logOutput.Print(LOG_MODEL_DETAIL, "model->maxs: (%f,%f,%f)", model->maxs[0], model->maxs[1], model->maxs[2]);
+
+ logOutput.Print (LOG_MODEL, "Model %s Imported.", model->name.c_str());
+ return model;
+}
+
+SAssPiece* CAssParser::LoadPiece(S3DModel* model, aiNode* node, const LuaTable& metaTable)
+{
+ // Create new piece
+ model->numPieces++;
+ SAssPiece* piece = new SAssPiece;
+ piece->type = MODELTYPE_OTHER;
+ piece->node = node;
+ piece->model = model;
+ piece->isEmpty = node->mNumMeshes == 0;
+
+ if (node->mParent) {
+ piece->name = std::string(node->mName.data);
+ } else {
+ piece->name = "root"; // The real model root
+ }
+ logOutput.Print(LOG_PIECE, "Converting node '%s' to piece '%s' (%d meshes).", node->mName.data, piece->name.c_str(), node->mNumMeshes);
+
+ // Load additional piece properties from metadata
+ const LuaTable& pieceTable = metaTable.SubTable("pieces").SubTable(piece->name);
+ if (pieceTable.IsValid()) logOutput.Print(LOG_PIECE, "Found metadata for piece '%s'", piece->name.c_str());
+
+ // Process transforms
+ float3 rotate, scale, offset;
+ aiVector3D _scale, _offset;
+ aiQuaternion _rotate;
+ node->mTransformation.Decompose(_scale,_rotate,_offset);
+
+ logOutput.Print(LOG_PIECE, "(%d:%s) Assimp offset (%f,%f,%f), rotate (%f,%f,%f), scale (%f,%f,%f)", model->numPieces, piece->name.c_str(),
+ _offset.x, _offset.y, _offset.z,
+ _rotate.x, _rotate.y, _rotate.z,
+ _scale.x, _scale.y, _scale.z
+ );
+
+ offset = pieceTable.GetFloat3("offset", float3(_offset.x, _offset.y, _offset.z));
+ offset.x = pieceTable.GetFloat("offsetx", offset.x);
+ offset.y = pieceTable.GetFloat("offsety", offset.y);
+ offset.z = pieceTable.GetFloat("offsetz", offset.z);
+
+ if (pieceTable.KeyExists("rotate")) {
+ rotate = pieceTable.GetFloat3("rotate", float3(0.0f, 0.0f, 0.0f));
+ DegreesToRadianAngles(rotate);
+ } else {
+ rotate = QuaternionToRadianAngles(_rotate);
+ rotate = float3(rotate.z, rotate.x, rotate.y);
+ }
+ if (pieceTable.KeyExists("rotatex")) rotate.x = pieceTable.GetFloat("rotatex", 0.0f) * DEGTORAD;
+ if (pieceTable.KeyExists("rotatey")) rotate.y = pieceTable.GetFloat("rotatey", 0.0f) * DEGTORAD;
+ if (pieceTable.KeyExists("rotatez")) rotate.z = pieceTable.GetFloat("rotatez", 0.0f) * DEGTORAD;
+
+ scale = pieceTable.GetFloat3("scale", float3(_scale.x, _scale.z, _scale.y));
+ scale.x = pieceTable.GetFloat("scalex", scale.x);
+ scale.y = pieceTable.GetFloat("scaley", scale.y);
+ scale.z = pieceTable.GetFloat("scalez", scale.z);
+
+ logOutput.Print(LOG_PIECE, "(%d:%s) Relative offset (%f,%f,%f), rotate (%f,%f,%f), scale (%f,%f,%f)", model->numPieces, piece->name.c_str(),
+ offset.x, offset.y, offset.z,
+ rotate.x, rotate.y, rotate.z,
+ scale.x, scale.y, scale.z
+ );
+ piece->offset = offset;
+ piece->rot = rotate;
+ piece->scale = scale;
+
+ // Get vertex data from node meshes
+ for ( unsigned meshListIndex = 0; meshListIndex < node->mNumMeshes; meshListIndex++ ) {
+ unsigned int meshIndex = node->mMeshes[meshListIndex];
+ logOutput.Print(LOG_PIECE_DETAIL, "Fetching mesh %d from scene", meshIndex );
+ aiMesh* mesh = model->scene->mMeshes[meshIndex];
+ std::vector<unsigned> mesh_vertex_mapping;
+ // extract vertex data
+ logOutput.Print(LOG_PIECE_DETAIL, "Processing vertices for mesh %d (%d vertices)", meshIndex, mesh->mNumVertices );
+ logOutput.Print(LOG_PIECE_DETAIL, "Normals: %s Tangents/Bitangents: %s TexCoords: %s",
+ (mesh->HasNormals())?"Y":"N",
+ (mesh->HasTangentsAndBitangents())?"Y":"N",
+ (mesh->HasTextureCoords(0)?"Y":"N")
+ );
+ for ( unsigned vertexIndex= 0; vertexIndex < mesh->mNumVertices; vertexIndex++) {
+ SAssVertex vertex;
+
+ // vertex coordinates
+ logOutput.Print(LOG_PIECE_DETAIL, "Fetching vertex %d from mesh", vertexIndex );
+ aiVector3D& aiVertex = mesh->mVertices[vertexIndex];
+ vertex.pos.x = aiVertex.x;
+ vertex.pos.y = aiVertex.y;
+ vertex.pos.z = aiVertex.z;
+
+ // update piece min/max extents
+ piece->mins.x = std::min(piece->mins.x, aiVertex.x);
+ piece->mins.y = std::min(piece->mins.y, aiVertex.y);
+ piece->mins.z = std::min(piece->mins.z, aiVertex.z);
+ piece->maxs.x = std::max(piece->maxs.x, aiVertex.x);
+ piece->maxs.y = std::max(piece->maxs.y, aiVertex.y);
+ piece->maxs.z = std::max(piece->maxs.z, aiVertex.z);
+
+ logOutput.Print(LOG_PIECE_DETAIL, "vertex position %d: %f %f %f", vertexIndex, vertex.pos.x, vertex.pos.y, vertex.pos.z );
+
+ // vertex normal
+ logOutput.Print(LOG_PIECE_DETAIL, "Fetching normal for vertex %d", vertexIndex );
+ aiVector3D& aiNormal = mesh->mNormals[vertexIndex];
+ vertex.hasNormal = !IS_QNAN(aiNormal);
+ if ( vertex.hasNormal ) {
+ vertex.normal.x = aiNormal.x;
+ vertex.normal.y = aiNormal.y;
+ vertex.normal.z = aiNormal.z;
+ logOutput.Print(LOG_PIECE_DETAIL, "vertex normal %d: %f %f %f",vertexIndex, vertex.normal.x, vertex.normal.y,vertex.normal.z );
+ }
+
+ // vertex tangent, x is positive in texture axis
+ if (mesh->HasTangentsAndBitangents()) {
+ logOutput.Print(LOG_PIECE_DETAIL, "Fetching tangent for vertex %d", vertexIndex );
+ aiVector3D& aiTangent = mesh->mTangents[vertexIndex];
+ vertex.hasTangent = !IS_QNAN(aiTangent);
+ if ( vertex.hasTangent ) {
+ float3 tangent;
+ tangent.x = aiTangent.x;
+ tangent.y = aiTangent.y;
+ tangent.z = aiTangent.z;
+ logOutput.Print(LOG_PIECE_DETAIL, "vertex tangent %d: %f %f %f",vertexIndex, tangent.x, tangent.y,tangent.z );
+ piece->sTangents.push_back(tangent);
+ // bitangent is cross product of tangent and normal
+ float3 bitangent;
+ if ( vertex.hasNormal ) {
+ bitangent = tangent.cross(vertex.normal);
+ logOutput.Print(LOG_PIECE_DETAIL, "vertex bitangent %d: %f %f %f",vertexIndex, bitangent.x, bitangent.y,bitangent.z );
+ piece->tTangents.push_back(bitangent);
+ }
+ }
+ } else {
+ vertex.hasTangent = false;
+ }
+
+ // vertex texcoords
+ if (mesh->HasTextureCoords(0)) {
+ vertex.textureX = mesh->mTextureCoords[0][vertexIndex].x;
+ vertex.textureY = mesh->mTextureCoords[0][vertexIndex].y;
+ logOutput.Print(LOG_PIECE_DETAIL, "vertex texcoords %d: %f %f", vertexIndex, vertex.textureX, vertex.textureY );
+ }
+
+ mesh_vertex_mapping.push_back(piece->vertices.size());
+ piece->vertices.push_back(vertex);
+ }
+
+ // extract face data
+ if ( mesh->HasFaces() ) {
+ logOutput.Print(LOG_PIECE_DETAIL, "Processing faces for mesh %d (%d faces)", meshIndex, mesh->mNumFaces);
+ for ( unsigned faceIndex = 0; faceIndex < mesh->mNumFaces; faceIndex++ ) {
+ aiFace& face = mesh->mFaces[faceIndex];
+ // get the vertex belonging to the mesh
+ for ( unsigned vertexListID = 0; vertexListID < face.mNumIndices; vertexListID++ ) {
+ unsigned int vertexID = mesh_vertex_mapping[face.mIndices[vertexListID]];
+ logOutput.Print(LOG_PIECE_DETAIL, "face %d vertex %d", faceIndex, vertexID );
+ piece->vertexDrawOrder.push_back(vertexID);
+ }
+ }
+ }
+ }
+
+ // Check if piece is special (ie, used to set Spring model properties)
+ if (strcmp(node->mName.data, "SpringHeight") == 0) {
+ // Set the model height to this nodes Z value
+ if (!metaTable.KeyExists("height")) {
+ model->height = piece->offset.z;
+ logOutput.Print (LOG_MODEL, "Model height of %f set by special node 'SpringHeight'", model->height);
+ }
+ return NULL;
+ }
+ if (strcmp(node->mName.data, "SpringRadius") == 0) {
+ if (!metaTable.KeyExists("midpos")) {
+ model->relMidPos = float3(piece->offset.x, piece->offset.z, piece->offset.y); // Y and Z are swapped because this piece isn't rotated
+ logOutput.Print (LOG_MODEL, "Model midpos of (%f,%f,%f) set by special node 'SpringRadius'", model->relMidPos.x, model->relMidPos.y, model->relMidPos.z);
+ }
+ if (!metaTable.KeyExists("radius")) {
+ if (piece->maxs.x <= 0.00001f) {
+ model->radius = piece->scale.x; // the blender import script only sets the scale property
+ } else {
+ model->radius = piece->maxs.x; // use the transformed mesh extents
+ }
+ logOutput.Print (LOG_MODEL, "Model radius of %f set by special node 'SpringRadius'", model->radius);
+ }
+ return NULL;
+ }
+
+ // collision volume for piece (not sure about these coords)
+ const float3 cvScales = (piece->maxs) - (piece->mins);
+ const float3 cvOffset = (piece->maxs - piece->offset) + (piece->mins - piece->offset);
+ //const float3 cvOffset(piece->offset.x, piece->offset.y, piece->offset.z);
+ piece->colvol = new CollisionVolume("box", cvScales, cvOffset, CollisionVolume::COLVOL_HITTEST_CONT);
+
+ // Get parent name from metadata or model
+ if (pieceTable.KeyExists("parent")) {
+ piece->parentName = pieceTable.GetString("parent", "");
+ } else if (node->mParent) {
+ if (node->mParent->mParent) {
+ piece->parentName = std::string(node->mParent->mName.data);
+ } else { // my parent is the root, which gets renamed
+ piece->parentName = "root";
+ }
+ } else {
+ piece->parentName = "";
+ }
+
+ logOutput.Print(LOG_PIECE, "Loaded model piece: %s with %d meshes\n", piece->name.c_str(), node->mNumMeshes );
+
+ // Verbose logging of piece properties
+ logOutput.Print(LOG_PIECE, "piece->name: %s", piece->name.c_str());
+ logOutput.Print(LOG_PIECE, "piece->parent: %s", piece->parentName.c_str());
+
+ // Recursively process all child pieces
+ for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+ LoadPiece(model, node->mChildren[i], metaTable);
+ }
+
+ model->pieces[piece->name] = piece;
+ return piece;
+}
+
+// Because of metadata overrides we don't know the true hierarchy until all pieces have been loaded
+void CAssParser::BuildPieceHierarchy( S3DModel* model )
+{
+ // Loop through all pieces and create missing hierarchy info
+ ModelPieceMap::const_iterator end = model->pieces.end();
+ for (ModelPieceMap::const_iterator it = model->pieces.begin(); it != end; ++it)
+ {
+ S3DModelPiece* piece = it->second;
+ if (piece->name == "root") {
+ piece->parent = NULL;
+ model->SetRootPiece(piece);
+ } else if (piece->parentName != "") {
+ piece->parent = model->FindPiece(piece->parentName);
+ if (piece->parent == NULL) {
+ logOutput.Print( LOG_PIECE, "Error: Missing piece '%s' declared as parent of '%s'.\n", piece->parentName.c_str(), piece->name.c_str() );
+ } else {
+ piece->parent->childs.push_back(piece);
+ }
+ } else {
+ // A piece with no parent that isn't the root (orphan)
+ piece->parent = model->FindPiece("root");
+ if (piece->parent == NULL) {
+ logOutput.Print( LOG_PIECE, "Error: Missing root piece.\n" );
+ } else {
+ piece->parent->childs.push_back(piece);
+ }
+ }
+ }
+}
+
+// Iterate over the model and calculate its overall dimensions
+void CAssParser::CalculateMinMax( S3DModelPiece* piece )
+{
+ piece->goffset = piece->parent ? piece->parent->goffset + piece->offset : piece->offset;
+
+ // update model min/max extents
+ piece->model->mins.x = std::min(piece->goffset.x + piece->mins.x, piece->model->mins.x);
+ piece->model->mins.y = std::min(piece->goffset.y + piece->mins.y, piece->model->mins.y);
+ piece->model->mins.z = std::min(piece->goffset.z + piece->mins.z, piece->model->mins.z);
+ piece->model->maxs.x = std::max(piece->goffset.x + piece->maxs.x, piece->model->maxs.x);
+ piece->model->maxs.y = std::max(piece->goffset.y + piece->maxs.y, piece->model->maxs.y);
+ piece->model->maxs.z = std::max(piece->goffset.z + piece->maxs.z, piece->model->maxs.z);
+
+ // Repeat with childs
+ for (unsigned int i = 0; i < piece->childs.size(); i++) {
+ CalculateMinMax(piece->childs[i]);
+ }
+}
+
+// Calculate model radius from the min/max extents
+void CAssParser::CalculateRadius( S3DModel* model )
+{
+ model->radius = std::max(model->radius, model->maxs.x);
+ model->radius = std::max(model->radius, model->maxs.y);
+ model->radius = std::max(model->radius, model->maxs.z);
+}
+
+// Calculate model height from the min/max extents
+void CAssParser::CalculateHeight( S3DModel* model )
+{
+ model->height = model->maxs.z;
+}
+
+void DrawPiecePrimitive( const S3DModelPiece* o)
+{
+ if (o->isEmpty) {
+ return;
+ }
+ logOutput.Print(LOG_PIECE_DETAIL, "Compiling piece %s", o->name.c_str());
+ // Add GL commands to the pieces displaylist
+
+ const SAssPiece* so = static_cast<const SAssPiece*>(o);
+ const SAssVertex* sAssV = static_cast<const SAssVertex*>(&so->vertices[0]);
+
+
+ // pass the tangents as 3D texture coordinates
+ // (array elements are float3's, which are 12
+ // bytes in size and each represent a single
+ // xyz triple)
+ // TODO: test if we have this many texunits
+ // (if not, could only send the s-tangents)?
+
+ if (!so->sTangents.empty()) {
+ glClientActiveTexture(GL_TEXTURE5);
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ glTexCoordPointer(3, GL_FLOAT, sizeof(float3), &so->sTangents[0].x);
+ }
+ if (!so->tTangents.empty()) {
+ glClientActiveTexture(GL_TEXTURE6);
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ glTexCoordPointer(3, GL_FLOAT, sizeof(float3), &so->tTangents[0].x);
+ }
+
+ glClientActiveTexture(GL_TEXTURE0);
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ glTexCoordPointer(2, GL_FLOAT, sizeof(SAssVertex), &sAssV->textureX);
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glVertexPointer(3, GL_FLOAT, sizeof(SAssVertex), &sAssV->pos.x);
+
+ glEnableClientState(GL_NORMAL_ARRAY);
+ glNormalPointer(GL_FLOAT, sizeof(SAssVertex), &sAssV->normal.x);
+
+ // since aiProcess_SortByPType is being used, we're sure we'll get only 1 type here, so combination check isn't needed, also anything more complex than triangles is being split thanks to aiProcess_Triangulate
+ glDrawElements(GL_TRIANGLES, so->vertexDrawOrder.size(), GL_UNSIGNED_INT, &so->vertexDrawOrder[0]);
+
+ if (!so->sTangents.empty()) {
+ glClientActiveTexture(GL_TEXTURE6);
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ }
+ if (!so->tTangents.empty()) {
+ glClientActiveTexture(GL_TEXTURE5);
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ }
+
+ glClientActiveTexture(GL_TEXTURE0);
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisableClientState(GL_NORMAL_ARRAY);
+
+ logOutput.Print(LOG_PIECE_DETAIL, "Completed compiling piece %s", o->name.c_str());
+}
+
+void CAssParser::Draw( const S3DModelPiece* o) const
+{
+ DrawPiecePrimitive( o );
+}
+
+void SAssPiece::DrawList() const
+{
+ DrawPiecePrimitive(this);
+}
diff --git a/rts/Rendering/Models/AssParser.h b/rts/Rendering/Models/AssParser.h
new file mode 100755
index 0000000..e7a5b70
--- /dev/null
+++ b/rts/Rendering/Models/AssParser.h
@@ -0,0 +1,51 @@
+#ifndef ASSPARSER_H
+#define ASSPARSER_H
+
+#include <map>
+#include "IModelParser.h"
+#include "float3.h"
+
+struct aiNode;
+struct aiScene;
+class LuaTable;
+
+struct SAssVertex {
+ float3 pos;
+ float3 normal;
+ float textureX;
+ float textureY;
+ bool hasNormal;
+ bool hasTangent;
+};
+
+struct SAssPiece: public S3DModelPiece
+{
+public:
+ aiNode* node;
+
+ const float3& GetVertexPos(int idx) const { return vertices[idx].pos; }
+ void DrawList() const;
+ std::vector<SAssVertex> vertices;
+
+ std::vector<unsigned int> vertexDrawOrder;
+ // cannot store these in SAssVertex
+ std::vector<float3> sTangents; // == T(angent) dirs
+ std::vector<float3> tTangents; // == B(itangent) dirs
+};
+
+
+class CAssParser: public IModelParser
+{
+public:
+ S3DModel* Load(const std::string& modelFileName);
+ void Draw(const S3DModelPiece* o) const;
+
+private:
+ SAssPiece* LoadPiece(S3DModel* model, aiNode* node, const LuaTable& metaTable);
+ void BuildPieceHierarchy(S3DModel* model);
+ void CalculateRadius( S3DModel* model );
+ void CalculateHeight( S3DModel* model );
+ void CalculateMinMax( S3DModelPiece* piece );
+};
+
+#endif /* ASSPARSER_H */
diff --git a/rts/Rendering/Models/IModelParser.cpp b/rts/Rendering/Models/IModelParser.cpp
old mode 100644
new mode 100755
index aff59ad..e9513ee
--- a/rts/Rendering/Models/IModelParser.cpp
+++ b/rts/Rendering/Models/IModelParser.cpp
@@ -8,9 +8,12 @@
#include "IModelParser.h"
#include "3DModel.h"
+#include "3DModelLog.h"
#include "3DOParser.h"
#include "S3OParser.h"
#include "OBJParser.h"
+#include "AssParser.h"
+#include "assimp.hpp"
#include "Sim/Misc/CollisionVolume.h"
#include "Sim/Units/Unit.h"
#include "System/FileSystem/FileSystem.h"
@@ -18,10 +21,8 @@
#include "System/LogOutput.h"
#include "System/Exceptions.h"
-
C3DModelLoader* modelParser = NULL;
-
//////////////////////////////////////////////////////////////////////
// C3DModelLoader
//
@@ -31,7 +32,26 @@ C3DModelLoader::C3DModelLoader()
// file-extension should be lowercase
parsers["3do"] = new C3DOParser();
parsers["s3o"] = new CS3OParser();
- parsers["obj"] = new COBJParser();
+ //parsers["obj"] = new COBJParser(); // replaced by Assimp
+
+ // assimp library
+ CAssParser* unitassparser = new CAssParser();
+ std::string extensionlist;
+
+ Assimp::Importer importer;
+ importer.GetExtensionList(extensionlist); // get a ";" separated list of wildcards
+ char* charextensionlist = new char[extensionlist.size() +1];
+ strcpy (charextensionlist, extensionlist.c_str());
+ logOutput.Print("Assimp: Supported model formats: %s", extensionlist.c_str());
+ char* extensionchar = strtok( charextensionlist, ";" );
+ while( extensionchar )
+ {
+ std::string extension = extensionchar;
+ extension = extension.substr( 2 ); // strip wildcard and dot
+ parsers[extension] = unitassparser; // register extension
+ extensionchar = strtok( NULL, ";" );
+ }
+ delete charextensionlist;
}
@@ -48,11 +68,15 @@ C3DModelLoader::~C3DModelLoader()
cache.clear();
// delete parsers
+ std::set<IModelParser*> dedupe_parsers; // this is to avoid deleting the same parser twice, if it's assigned to multiple model formats
std::map<std::string, IModelParser*>::iterator pi;
for (pi = parsers.begin(); pi != parsers.end(); ++pi) {
+ if ( dedupe_parsers.count( pi->second ) != 0 ) continue;
+ dedupe_parsers.insert( pi->second );
delete pi->second;
}
parsers.clear();
+ dedupe_parsers.clear();
#if defined(USE_GML) && GML_ENABLE_SIM
createLists.clear();
@@ -67,7 +91,7 @@ inline int ModelExtToModelType(const std::string& ext) {
if (ext == "3do") { return MODELTYPE_3DO; }
if (ext == "s3o") { return MODELTYPE_S3O; }
if (ext == "obj") { return MODELTYPE_OBJ; }
- return -1;
+ return MODELTYPE_ASS; // FIXME: Return -1 if Assimp cant handle extension
}
inline S3DModelPiece* ModelTypeToModelPiece(int type) {
if (type == MODELTYPE_3DO) { return (new S3DOPiece()); }
diff --git a/rts/Rendering/Models/WorldObjectModelRenderer.cpp b/rts/Rendering/Models/WorldObjectModelRenderer.cpp
old mode 100644
new mode 100755
index 778f11b..bd8237b
--- a/rts/Rendering/Models/WorldObjectModelRenderer.cpp
+++ b/rts/Rendering/Models/WorldObjectModelRenderer.cpp
@@ -14,6 +14,7 @@ IWorldObjectModelRenderer* IWorldObjectModelRenderer::GetInstance(int modelType)
case MODELTYPE_3DO: { return (new WorldObjectModelRenderer3DO()); } break;
case MODELTYPE_S3O: { return (new WorldObjectModelRendererS3O()); } break;
case MODELTYPE_OBJ: { return (new WorldObjectModelRendererOBJ()); } break;
+ case MODELTYPE_ASS: { return (new WorldObjectModelRendererASS()); } break;
default: { return (new IWorldObjectModelRenderer(MODELTYPE_OTHER)); } break;
}
}
@@ -226,7 +227,18 @@ void WorldObjectModelRendererOBJ::PopRenderState()
// WRITEME
}
-
+void WorldObjectModelRendererASS::PushRenderState()
+{
+ #if (WORLDOBJECT_MODEL_RENDERER_DEBUG == 1)
+ #endif
+ // WRITEME
+}
+void WorldObjectModelRendererASS::PopRenderState()
+{
+ #if (WORLDOBJECT_MODEL_RENDERER_DEBUG == 1)
+ #endif
+ // WRITEME
+}
void WorldObjectModelRendererS3O::DrawModel(const CUnit* u)
{
diff --git a/rts/Rendering/Models/WorldObjectModelRenderer.h b/rts/Rendering/Models/WorldObjectModelRenderer.h
old mode 100644
new mode 100755
index 386da99..11a7644
--- a/rts/Rendering/Models/WorldObjectModelRenderer.h
+++ b/rts/Rendering/Models/WorldObjectModelRenderer.h
@@ -117,4 +117,11 @@ public:
void PopRenderState();
};
+class WorldObjectModelRendererASS: public IWorldObjectModelRenderer {
+public:
+ WorldObjectModelRendererASS(): IWorldObjectModelRenderer(MODELTYPE_ASS) {}
+ void PushRenderState();
+ void PopRenderState();
+};
+
#endif
diff --git a/rts/Rendering/ProjectileDrawer.cpp b/rts/Rendering/ProjectileDrawer.cpp
old mode 100644
new mode 100755
diff --git a/rts/Rendering/Textures/Bitmap.cpp b/rts/Rendering/Textures/Bitmap.cpp
old mode 100644
new mode 100755
index 2445c31..0e31ad6
--- a/rts/Rendering/Textures/Bitmap.cpp
+++ b/rts/Rendering/Textures/Bitmap.cpp
@@ -282,9 +282,9 @@ bool CBitmap::LoadGrayscale(const std::string& filename)
delete[] mem;
mem = new unsigned char[xsize * ysize];
memcpy(mem, ilGetData(), xsize * ysize);
-
+
ilDeleteImages(1, &ImageName);
-
+
return true;
}
@@ -738,6 +738,18 @@ void CBitmap::InvertColors()
}
+void CBitmap::InvertAlpha()
+{
+ if (type != BitmapTypeStandardRGBA) return; // Don't try to invert DDS
+ for (int y = 0; y < ysize; ++y) {
+ for (int x = 0; x < xsize; ++x) {
+ const int base = ((y * xsize) + x) * 4;
+ mem[base + 3] = 0xFF - mem[base + 3];
+ }
+ }
+}
+
+
void CBitmap::GrayScale()
{
if (type != BitmapTypeStandardRGBA) {
@@ -786,6 +798,7 @@ void CBitmap::Tint(const float tint[3])
void CBitmap::ReverseYAxis()
{
+ if (type != BitmapTypeStandardRGBA) return; // don't try to flip DDS
unsigned char* tmpLine = new unsigned char[channels * xsize];
for (int y=0; y < (ysize / 2); ++y) {
const int pixelLow = (((y ) * xsize) + 0) * channels;
diff --git a/rts/Rendering/Textures/Bitmap.h b/rts/Rendering/Textures/Bitmap.h
old mode 100644
new mode 100755
index 9b1577b..9d984f9
--- a/rts/Rendering/Textures/Bitmap.h
+++ b/rts/Rendering/Textures/Bitmap.h
@@ -83,6 +83,7 @@ public:
CBitmap CreateRescaled(int newx, int newy) const;
void ReverseYAxis();
void InvertColors();
+ void InvertAlpha();
void GrayScale();
void Tint(const float tint[3]);
};
diff --git a/rts/Rendering/Textures/S3OTextureHandler.cpp b/rts/Rendering/Textures/S3OTextureHandler.cpp
old mode 100644
new mode 100755
index 857406b..abb6a02
--- a/rts/Rendering/Textures/S3OTextureHandler.cpp
+++ b/rts/Rendering/Textures/S3OTextureHandler.cpp
@@ -20,6 +20,15 @@
#include "System/Exceptions.h"
#include "System/LogOutput.h"
+static CLogSubsystem LOG_TEXTURE("Texture");
+
+// The S3O texture handler uses two textures.
+// The first contains diffuse color (RGB) and teamcolor (A)
+// The second contains glow (R), reflectivity (G) and 1-bit Alpha (A).
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
CS3OTextureHandler* texturehandlerS3O = NULL;
@@ -52,6 +61,10 @@ void CS3OTextureHandler::Update() {
int CS3OTextureHandler::LoadS3OTextureNow(const S3DModel* model)
{
GML_STDMUTEX_LOCK(model); // LoadS3OTextureNow
+ logOutput.Print(LOG_TEXTURE, "Load S3O texture now (Flip Y Axis: %s, Invert Team Alpha: %s)",
+ model->flipTexY ? "yes" : "no",
+ model->invertTexAlpha ? "yes" : "no"
+ );
const string totalName = model->tex1 + model->tex2;
@@ -74,6 +87,8 @@ int CS3OTextureHandler::LoadS3OTextureNow(const S3DModel* model)
tex1bm.mem[2] = 0;
tex1bm.mem[3] = 255;
}
+ if (model->flipTexY) tex1bm.ReverseYAxis();
+ if (model->invertTexAlpha) tex1bm.InvertAlpha();
tex.num = s3oTextures.size();
tex.tex1 = tex1bm.CreateTexture(true);
@@ -92,6 +107,7 @@ int CS3OTextureHandler::LoadS3OTextureNow(const S3DModel* model)
tex2bm.mem[2] = 0; // unused
tex2bm.mem[3] = 255; // team-color
}
+ if (model->flipTexY) tex2bm.ReverseYAxis();
tex.tex2 = tex2bm.CreateTexture(true);
tex.tex2SizeX = tex2bm.xsize;
diff --git a/rts/Rendering/Textures/S3OTextureHandler.h b/rts/Rendering/Textures/S3OTextureHandler.h
old mode 100644
new mode 100755
diff --git a/rts/Rendering/UnitDrawer.cpp b/rts/Rendering/UnitDrawer.cpp
old mode 100644
new mode 100755
index 9dc973b..f6ca177
--- a/rts/Rendering/UnitDrawer.cpp
+++ b/rts/Rendering/UnitDrawer.cpp
@@ -519,7 +519,7 @@ void CUnitDrawer::DrawOpaqueUnits(int modelType, const CUnit* excludeUnit, bool
UnitSet::const_iterator unitSetIt;
for (unitBinIt = unitBin.begin(); unitBinIt != unitBin.end(); ++unitBinIt) {
- if (modelType == MODELTYPE_S3O || modelType == MODELTYPE_OBJ) {
+ if (modelType == MODELTYPE_S3O || modelType == MODELTYPE_OBJ || modelType == MODELTYPE_ASS) {
texturehandlerS3O->SetS3oTexture(unitBinIt->first);
}
@@ -779,13 +779,13 @@ inline void CUnitDrawer::DrawOpaqueUnitShadow(CUnit* unit) {
#define S3O_TEX(model) \
texturehandlerS3O->GetS3oTex(model->textureType)
#define PUSH_SHADOW_TEXTURE_STATE(model) \
- if (model->type == MODELTYPE_S3O || model->type == MODELTYPE_OBJ) { \
+ if (model->type == MODELTYPE_S3O || model->type == MODELTYPE_OBJ || model->type == MODELTYPE_ASS) { \
glActiveTexture(GL_TEXTURE0); \
glEnable(GL_TEXTURE_2D); \
glBindTexture(GL_TEXTURE_2D, S3O_TEX(model)->tex2); \
}
#define POP_SHADOW_TEXTURE_STATE(model) \
- if (model->type == MODELTYPE_S3O || model->type == MODELTYPE_OBJ) { \
+ if (model->type == MODELTYPE_S3O || model->type == MODELTYPE_OBJ || model->type == MODELTYPE_ASS) { \
glBindTexture(GL_TEXTURE_2D, 0); \
glDisable(GL_TEXTURE_2D); \
glActiveTexture(GL_TEXTURE0); \
@@ -1042,7 +1042,7 @@ void CUnitDrawer::DrawCloakedUnitsHelper(int modelType)
// cloaked units
for (UnitRenderBinIt it = unitBin.begin(); it != unitBin.end(); ++it) {
- if (modelType == MODELTYPE_S3O || modelType == MODELTYPE_OBJ) {
+ if (modelType == MODELTYPE_S3O || modelType == MODELTYPE_OBJ || modelType == MODELTYPE_ASS) {
texturehandlerS3O->SetS3oTexture(it->first);
}
@@ -1099,7 +1099,7 @@ inline void CUnitDrawer::DrawCloakedUnit(CUnit* unit, int modelType, bool drawGh
glTranslatef3(unit->pos);
glRotatef(unit->buildFacing * 90.0f, 0, 1, 0);
- if (modelType == MODELTYPE_S3O || modelType == MODELTYPE_OBJ) {
+ if (modelType == MODELTYPE_S3O || modelType == MODELTYPE_OBJ || modelType == MODELTYPE_ASS) {
// the units in liveGhostedBuildings[modelType] are not
// sorted by textureType, but we cannot merge them with
// cloakedModelRenderers[modelType] since they are not
@@ -1183,7 +1183,7 @@ void CUnitDrawer::DrawGhostedBuildings(int modelType)
glTranslatef3((*it)->pos);
glRotatef((*it)->facing * 90.0f, 0, 1, 0);
- if (modelType == MODELTYPE_S3O || modelType == MODELTYPE_OBJ)
+ if (modelType == MODELTYPE_S3O || modelType == MODELTYPE_OBJ || modelType == MODELTYPE_ASS)
texturehandlerS3O->SetS3oTexture((*it)->model->textureType);
SetTeamColour((*it)->team, cloakAlpha1);
@@ -1559,7 +1559,7 @@ void CUnitDrawer::DrawIndividual(CUnit* unit)
SetupForUnitDrawing();
opaqueModelRenderers[MDL_TYPE(unit)]->PushRenderState();
- if (MDL_TYPE(unit) == MODELTYPE_S3O || MDL_TYPE(unit) == MODELTYPE_OBJ) {
+ if (MDL_TYPE(unit) == MODELTYPE_S3O || MDL_TYPE(unit) == MODELTYPE_OBJ || MDL_TYPE(unit) == MODELTYPE_ASS) {
texturehandlerS3O->SetS3oTexture(TEX_TYPE(unit));
}
@@ -1599,7 +1599,8 @@ void CUnitDrawer::DrawBuildingSample(const UnitDef* unitdef, int side, float3 po
texturehandler3DO->Set3doAtlases();
} break;
case MODELTYPE_S3O:
- case MODELTYPE_OBJ: {
+ case MODELTYPE_OBJ:
+ case MODELTYPE_ASS: {
texturehandlerS3O->SetS3oTexture(model->textureType);
} break;
default: {
@@ -1987,7 +1988,7 @@ inline void CUnitDrawer::UpdateUnitIconState(CUnit* unit) {
#ifdef USE_GML
if (showHealthBars && !unit->noDraw &&
(unit->health < unit->maxHealth || unit->paralyzeDamage > 0.0f || unit->limExperience > 0.0f ||
- unit->beingBuilt || unit->stockpileWeapon || unit->group) &&
+ unit->beingBuilt || unit->stockpileWeapon || unit->group) &&
((unit->pos - camera->pos).SqLength() < (unitDrawDistSqr * 500.0f)))
drawStat.insert(unit);
#endif
diff --git a/rts/Sim/Misc/GlobalConstants.h b/rts/Sim/Misc/GlobalConstants.h
index 78c5305..6006a4e 100644
--- a/rts/Sim/Misc/GlobalConstants.h
+++ b/rts/Sim/Misc/GlobalConstants.h
@@ -39,6 +39,13 @@ const int UNIT_SLOWUPDATE_RATE = 16;
const int TEAM_SLOWUPDATE_RATE = 32;
/**
+ * @brief max view range
+ *
+ * Defines the maximum view range as 8000
+ */
+const int MAX_VIEW_RANGE = 8000;
+
+/**
* @brief max teams
*
* Defines the maximum number of teams
@@ -56,10 +63,9 @@ const int MAX_PLAYERS = 251;
/**
* @brief max units
*
- * Defines the absolute global maximum number of units allowed to exist in a game.
- * MUST be <= SHRT_MAX ((1 << ((sizeof(short) * 8) - 1)) - 1) because current net
- * code transmits unit ID's as signed shorts. The effective global unit limit is
- * stored in UnitHandler::maxUnits and is always clamped to this value.
+ * Defines the maximum number of untis that may be set as maximum for a game.
+ * The real maximum of the game is stored in uh->maxUnits,
+ * and may not be higher then this value.
*/
const int MAX_UNITS = 32000;
@@ -69,6 +75,13 @@ const int MAX_UNITS = 32000;
const int MAX_WEAPONS_PER_UNIT = 32;
/**
+ * @brief near plane
+ *
+ * Defines the near plane as 2.8f
+ */
+const float NEAR_PLANE = 2.8f;
+
+/**
* @brief randint max
*
* Defines the maximum random integer as 0x7fff
diff --git a/rts/Sim/Misc/Team.cpp b/rts/Sim/Misc/Team.cpp
index 407c17f..3b84cc6 100644
--- a/rts/Sim/Misc/Team.cpp
+++ b/rts/Sim/Misc/Team.cpp
@@ -27,52 +27,56 @@
CR_BIND(CTeam,);
CR_REG_METADATA(CTeam, (
- // from CTeamBase
- CR_MEMBER(leader),
- CR_MEMBER(color),
- CR_MEMBER(incomeMultiplier),
- CR_MEMBER(side),
- CR_MEMBER(startPos),
- CR_MEMBER(teamStartNum),
- CR_MEMBER(teamAllyteam),
- // CR_MEMBER(customValues),
- // from CTeam
- CR_MEMBER(teamNum),
- CR_MEMBER(isDead),
- CR_MEMBER(gaia),
- CR_MEMBER(origColor),
- CR_MEMBER(units),
- CR_MEMBER(metal),
- CR_MEMBER(energy),
- CR_MEMBER(metalPull),
- CR_MEMBER(prevMetalPull),
- CR_MEMBER(metalIncome),
- CR_MEMBER(prevMetalIncome),
- CR_MEMBER(metalExpense),
- CR_MEMBER(prevMetalExpense),
- CR_MEMBER(energyPull),
- CR_MEMBER(prevEnergyPull),
- CR_MEMBER(energyIncome),
- CR_MEMBER(prevEnergyIncome),
- CR_MEMBER(energyExpense),
- CR_MEMBER(prevEnergyExpense),
- CR_MEMBER(metalStorage),
- CR_MEMBER(energyStorage),
- CR_MEMBER(metalShare),
- CR_MEMBER(energyShare),
- CR_MEMBER(delayedMetalShare),
- CR_MEMBER(delayedEnergyShare),
- CR_MEMBER(metalSent),
- CR_MEMBER(metalReceived),
- CR_MEMBER(energySent),
- CR_MEMBER(energyReceived),
- //CR_MEMBER(currentStats),
- CR_MEMBER(nextHistoryEntry),
- //CR_MEMBER(statHistory),
- CR_MEMBER(modParams),
- CR_MEMBER(modParamsMap),
- CR_RESERVED(64)
-));
+// from CTeamBase
+ CR_MEMBER(leader),
+ CR_MEMBER(color),
+ CR_MEMBER(incomeMultiplier),
+ CR_MEMBER(side),
+ CR_MEMBER(startPos),
+ CR_MEMBER(teamStartNum),
+ CR_MEMBER(teamAllyteam),
+// CR_MEMBER(customValues),
+// from CTeam
+ CR_MEMBER(teamNum),
+ CR_MEMBER(isDead),
+ CR_MEMBER(gaia),
+ CR_MEMBER(origColor),
+ CR_MEMBER(units),
+ CR_MEMBER(metal),
+ CR_MEMBER(energy),
+ CR_MEMBER(metalPull),
+ CR_MEMBER(prevMetalPull),
+ CR_MEMBER(metalIncome),
+ CR_MEMBER(prevMetalIncome),
+ CR_MEMBER(metalExpense),
+ CR_MEMBER(prevMetalExpense),
+ CR_MEMBER(metalUpkeep),
+ CR_MEMBER(prevMetalUpkeep),
+ CR_MEMBER(energyPull),
+ CR_MEMBER(prevEnergyPull),
+ CR_MEMBER(energyIncome),
+ CR_MEMBER(prevEnergyIncome),
+ CR_MEMBER(energyExpense),
+ CR_MEMBER(prevEnergyExpense),
+ CR_MEMBER(energyUpkeep),
+ CR_MEMBER(prevEnergyUpkeep),
+ CR_MEMBER(metalStorage),
+ CR_MEMBER(energyStorage),
+ CR_MEMBER(metalShare),
+ CR_MEMBER(energyShare),
+ CR_MEMBER(delayedMetalShare),
+ CR_MEMBER(delayedEnergyShare),
+ CR_MEMBER(metalSent),
+ CR_MEMBER(metalReceived),
+ CR_MEMBER(energySent),
+ CR_MEMBER(energyReceived),
+ //CR_MEMBER(currentStats),
+ CR_MEMBER(nextHistoryEntry),
+ //CR_MEMBER(statHistory),
+ CR_MEMBER(modParams),
+ CR_MEMBER(modParamsMap),
+ CR_RESERVED(64)
+ ));
//////////////////////////////////////////////////////////////////////
@@ -88,9 +92,11 @@ CTeam::CTeam() :
metalPull(0.0f), prevMetalPull(0.0f),
metalIncome(0.0f), prevMetalIncome(0.0f),
metalExpense(0.0f), prevMetalExpense(0.0f),
+ metalUpkeep(0.0f), prevMetalUpkeep(0.0f),
energyPull(0.0f), prevEnergyPull(0.0f),
energyIncome(0.0f), prevEnergyIncome(0.0f),
energyExpense(0.0f), prevEnergyExpense(0.0f),
+ energyUpkeep(0.0f), prevEnergyUpkeep(0.0f),
metalStorage(1000000),
energyStorage(1000000),
metalShare(0.99f),
@@ -114,10 +120,14 @@ CTeam::CTeam() :
}
+CTeam::~CTeam()
+{
+}
+
bool CTeam::UseMetal(float amount)
{
- if (metal >= amount) {
+ if ((metal - (prevMetalUpkeep * 10)) >= amount) {
metal -= amount;
metalExpense += amount;
return true;
@@ -125,9 +135,10 @@ bool CTeam::UseMetal(float amount)
return false;
}
+
bool CTeam::UseEnergy(float amount)
{
- if (energy >= amount) {
+ if ((energy - (prevEnergyUpkeep * 10)) >= amount) {
energy -= amount;
energyExpense += amount;
return true;
@@ -136,6 +147,29 @@ bool CTeam::UseEnergy(float amount)
}
+bool CTeam::UseMetalUpkeep(float amount)
+{
+ if (metal >= amount) {
+ metal -= amount;
+ metalExpense += amount;
+ metalUpkeep += amount;
+ return true;
+ }
+ return false;
+}
+
+
+bool CTeam::UseEnergyUpkeep(float amount)
+{
+ if (energy >= amount) {
+ energy -= amount;
+ energyExpense += amount;
+ energyUpkeep += amount;
+ return true;
+ }
+ return false;
+}
+
void CTeam::AddMetal(float amount, bool useIncomeMultiplier)
{
@@ -143,24 +177,23 @@ void CTeam::AddMetal(float amount, bool useIncomeMultiplier)
metal += amount;
metalIncome += amount;
if (metal > metalStorage) {
- delayedMetalShare += (metal - metalStorage);
+ delayedMetalShare += metal - metalStorage;
metal = metalStorage;
}
}
+
void CTeam::AddEnergy(float amount, bool useIncomeMultiplier)
{
if (useIncomeMultiplier) { amount *= GetIncomeMultiplier(); }
energy += amount;
energyIncome += amount;
if (energy > energyStorage) {
- delayedEnergyShare += (energy - energyStorage);
+ delayedEnergyShare += energy - energyStorage;
energy = energyStorage;
}
}
-
-
void CTeam::GiveEverythingTo(const unsigned toTeam)
{
CTeam* target = teamHandler->Team(toTeam);
@@ -220,6 +253,10 @@ void CTeam::Died()
eventHandler.TeamDied(teamNum);
}
+void CTeam::StartposMessage(const float3& pos)
+{
+ startPos = pos;
+}
CTeam& CTeam::operator=(const TeamBase& base)
{
@@ -227,36 +264,43 @@ CTeam& CTeam::operator=(const TeamBase& base)
return *this;
}
-
-
-void CTeam::ResetResourceState()
+void CTeam::ResetFrameVariables()
{
- // reset all state variables that were
- // potentially modified during the last
- // <TEAM_SLOWUPDATE_RATE> frames
- prevMetalPull = metalPull; metalPull = 0.0f;
- prevMetalIncome = metalIncome; metalIncome = 0.0f;
- prevMetalExpense = metalExpense; metalExpense = 0.0f;
- prevEnergyPull = energyPull; energyPull = 0.0f;
- prevEnergyIncome = energyIncome; energyIncome = 0.0f;
- prevEnergyExpense = energyExpense; energyExpense = 0.0f;
-
- // reset the sharing accumulators
- metalSent = 0.0f; metalReceived = 0.0f;
- energySent = 0.0f; energyReceived = 0.0f;
+ prevMetalPull = metalPull;
+ prevMetalIncome = metalIncome;
+ prevMetalExpense = metalExpense;
+ prevMetalUpkeep = metalUpkeep;
+ prevEnergyPull = energyPull;
+ prevEnergyIncome = energyIncome;
+ prevEnergyExpense = energyExpense;
+ prevEnergyUpkeep = energyUpkeep;
+
+ metalPull = 0;
+ metalIncome = 0;
+ metalExpense = 0;
+ metalUpkeep = 0;
+ energyPull = 0;
+ energyIncome = 0;
+ energyExpense = 0;
+ energyUpkeep = 0;
+
+ metalSent = 0;
+ energySent = 0;
+ metalReceived = 0;
+ energyReceived = 0;
}
void CTeam::SlowUpdate()
{
- float eShare = 0.0f, mShare = 0.0f;
+ currentStats->metalProduced += prevMetalIncome;
+ currentStats->energyProduced += prevEnergyIncome;
+ currentStats->metalUsed += prevMetalUpkeep + prevMetalExpense;
+ currentStats->energyUsed += prevEnergyUpkeep + prevEnergyExpense;
- // calculate the total amount of resources that all
- // (allied) teams can collectively receive through
- // sharing
+ float eShare = 0.0f, mShare = 0.0f;
for (int a = 0; a < teamHandler->ActiveTeams(); ++a) {
- CTeam* team = teamHandler->Team(a);
-
if ((a != teamNum) && (teamHandler->AllyTeam(teamNum) == teamHandler->AllyTeam(a))) {
+ CTeam* team = teamHandler->Team(a);
if (team->isDead)
continue;
@@ -265,25 +309,21 @@ void CTeam::SlowUpdate()
}
}
+ metal += delayedMetalShare;
+ energy += delayedEnergyShare;
+ delayedMetalShare = 0;
+ delayedEnergyShare = 0;
- currentStats->metalProduced += prevMetalIncome;
- currentStats->energyProduced += prevEnergyIncome;
- currentStats->metalUsed += prevMetalExpense;
- currentStats->energyUsed += prevEnergyExpense;
-
- metal += delayedMetalShare; delayedMetalShare = 0.0f;
- energy += delayedEnergyShare; delayedEnergyShare = 0.0f;
-
-
- // calculate how much we can share in total (any and all excess resources)
const float eExcess = std::max(0.0f, energy - (energyStorage * energyShare));
const float mExcess = std::max(0.0f, metal - (metalStorage * metalShare));
float de = 0.0f, dm = 0.0f;
- if (eShare > 0.0f) { de = std::min(1.0f, eExcess / eShare); }
- if (mShare > 0.0f) { dm = std::min(1.0f, mExcess / mShare); }
-
- // now evenly distribute our excess resources among allied teams
+ if (eShare > 0.0f) {
+ de = std::min(1.0f, eExcess/eShare);
+ }
+ if (mShare > 0.0f) {
+ dm = std::min(1.0f, mExcess/mShare);
+ }
for (int a = 0; a < teamHandler->ActiveTeams(); ++a) {
if ((a != teamNum) && (teamHandler->AllyTeam(teamNum) == teamHandler->AllyTeam(a))) {
CTeam* team = teamHandler->Team(a);
@@ -291,19 +331,23 @@ void CTeam::SlowUpdate()
continue;
const float edif = std::max(0.0f, (team->energyStorage * 0.99f) - team->energy) * de;
- const float mdif = std::max(0.0f, (team->metalStorage * 0.99f) - team->metal) * dm;
+ energy -= edif;
+ energySent += edif;
+ currentStats->energySent += edif;
+ team->energy += edif;
+ team->energyReceived += edif;
+ team->currentStats->energyReceived += edif;
- energy -= edif; team->energy += edif;
- energySent += edif; team->energyReceived += edif;
- metal -= mdif; team->metal += mdif;
- metalSent += mdif; team->metalReceived += mdif;
-
- currentStats->energySent += edif; team->currentStats->energyReceived += edif;
- currentStats->metalSent += mdif; team->currentStats->metalReceived += mdif;
+ const float mdif = std::max(0.0f, (team->metalStorage * 0.99f) - team->metal) * dm;
+ metal -= mdif;
+ metalSent += mdif;
+ currentStats->metalSent += mdif;
+ team->metal += mdif;
+ team->metalReceived += mdif;
+ team->currentStats->metalReceived += mdif;
}
}
- // clamp resource levels to storage capacity
if (metal > metalStorage) {
currentStats->metalExcess += (metal - metalStorage);
metal = metalStorage;
@@ -325,10 +369,11 @@ void CTeam::SlowUpdate()
nextHistoryEntry = gs->frameNum + statsFrames;
currentStats->frame = nextHistoryEntry;
}
+
}
-void CTeam::AddUnit(CUnit* unit, AddType type)
+void CTeam::AddUnit(CUnit* unit,AddType type)
{
units.insert(unit);
switch (type) {
@@ -348,7 +393,7 @@ void CTeam::AddUnit(CUnit* unit, AddType type)
}
-void CTeam::RemoveUnit(CUnit* unit, RemoveType type)
+void CTeam::RemoveUnit(CUnit* unit,RemoveType type)
{
units.erase(unit);
switch (type) {
diff --git a/rts/Sim/Misc/Team.h b/rts/Sim/Misc/Team.h
index fdd6bcf..f390cbc 100644
--- a/rts/Sim/Misc/Team.h
+++ b/rts/Sim/Misc/Team.h
@@ -21,20 +21,28 @@ class CTeam : public TeamBase, private boost::noncopyable //! cannot allow shall
CR_DECLARE(CTeam);
public:
CTeam();
+ ~CTeam();
+public:
- void ResetResourceState();
+ /**
+ * This has to be called for every team before SlowUpdates start,
+ * otherwise values get overwritten.
+ */
+ void ResetFrameVariables();
void SlowUpdate();
void AddMetal(float amount, bool useIncomeMultiplier = true);
void AddEnergy(float amount, bool useIncomeMultiplier = true);
bool UseEnergy(float amount);
bool UseMetal(float amount);
+ bool UseEnergyUpkeep(float amount);
+ bool UseMetalUpkeep(float amount);
void GiveEverythingTo(const unsigned toTeam);
void Died();
- void StartposMessage(const float3& pos) { startPos = pos; }
+ void StartposMessage(const float3& pos);
CTeam& operator=(const TeamBase& base);
@@ -71,10 +79,12 @@ public:
float metalPull, prevMetalPull;
float metalIncome, prevMetalIncome;
float metalExpense, prevMetalExpense;
+ float metalUpkeep, prevMetalUpkeep;
float energyPull, prevEnergyPull;
float energyIncome, prevEnergyIncome;
float energyExpense, prevEnergyExpense;
+ float energyUpkeep, prevEnergyUpkeep;
SyncedFloat metalStorage, energyStorage;
diff --git a/rts/Sim/Misc/TeamHandler.cpp b/rts/Sim/Misc/TeamHandler.cpp
index 0bbbf99..04e5bd0 100644
--- a/rts/Sim/Misc/TeamHandler.cpp
+++ b/rts/Sim/Misc/TeamHandler.cpp
@@ -25,7 +25,7 @@ CR_REG_METADATA(CTeamHandler, (
));
-CTeamHandler* teamHandler = NULL;
+CTeamHandler* teamHandler;
CTeamHandler::CTeamHandler():
@@ -88,12 +88,12 @@ void CTeamHandler::LoadFromSetup(const CGameSetup* setup)
void CTeamHandler::GameFrame(int frameNum)
{
- if ((frameNum % TEAM_SLOWUPDATE_RATE) == 0) {
+ if (!(frameNum & (TEAM_SLOWUPDATE_RATE-1))) {
for (int a = 0; a < ActiveTeams(); ++a) {
- teams[a]->ResetResourceState();
+ Team(a)->ResetFrameVariables();
}
for (int a = 0; a < ActiveTeams(); ++a) {
- teams[a]->SlowUpdate();
+ Team(a)->SlowUpdate();
}
}
}
diff --git a/rts/Sim/MoveTypes/AAirMoveType.cpp b/rts/Sim/MoveTypes/AAirMoveType.cpp
index 5cabd4e..67943ce 100644
--- a/rts/Sim/MoveTypes/AAirMoveType.cpp
+++ b/rts/Sim/MoveTypes/AAirMoveType.cpp
@@ -39,9 +39,9 @@ AAirMoveType::AAirMoveType(CUnit* unit) :
wantedHeight(80.0f),
collide(true),
useSmoothMesh(false),
- autoLand(true),
lastColWarning(NULL),
lastColWarningType(0),
+ autoLand(true),
lastFuelUpdateFrame(0)
{
useHeading = false;
diff --git a/rts/Sim/MoveTypes/AirMoveType.cpp b/rts/Sim/MoveTypes/AirMoveType.cpp
index f0aade2..bc09cbf 100644
--- a/rts/Sim/MoveTypes/AirMoveType.cpp
+++ b/rts/Sim/MoveTypes/AirMoveType.cpp
@@ -1088,7 +1088,7 @@ void CAirMoveType::SetState(AAirMoveType::AircraftState state)
-void CAirMoveType::ImpulseAdded(const float3&)
+void CAirMoveType::ImpulseAdded(void)
{
if (aircraftState == AIRCRAFT_FLYING) {
owner->speed += owner->residualImpulse;
diff --git a/rts/Sim/MoveTypes/AirMoveType.h b/rts/Sim/MoveTypes/AirMoveType.h
index 2f70cab..bc3db18 100644
--- a/rts/Sim/MoveTypes/AirMoveType.h
+++ b/rts/Sim/MoveTypes/AirMoveType.h
@@ -32,7 +32,7 @@ public:
float engine, const float3& engineVector);
void SetState(AircraftState state);
void UpdateTakeOff(float wantedHeight);
- void ImpulseAdded(const float3&);
+ void ImpulseAdded();
float3 FindLandingPos() const;
void DependentDied(CObject* o);
diff --git a/rts/Sim/MoveTypes/GroundMoveType.cpp b/rts/Sim/MoveTypes/GroundMoveType.cpp
index 58e8670..984aa85 100644
--- a/rts/Sim/MoveTypes/GroundMoveType.cpp
+++ b/rts/Sim/MoveTypes/GroundMoveType.cpp
@@ -81,11 +81,12 @@ CR_REG_METADATA(CGroundMoveType, (
CR_MEMBER(canReverse),
CR_MEMBER(useMainHeading),
+ CR_MEMBER(skidRotSpeed),
+
CR_MEMBER(waypointDir),
CR_MEMBER(flatFrontDir),
CR_MEMBER(skidRotVector),
- CR_MEMBER(skidRotSpeed),
CR_MEMBER(skidRotSpeed2),
CR_MEMBER(skidRotPos2),
CR_ENUM_MEMBER(oldPhysState),
@@ -110,10 +111,10 @@ CGroundMoveType::CGroundMoveType(CUnit* owner):
maxReverseSpeed(0.0f),
wantedSpeed(0.0f),
currentSpeed(0.0f),
- requestedSpeed(0.0f),
deltaSpeed(0.0f),
deltaHeading(0),
+ flatFrontDir(0.0f, 0.0, 1.0f),
pathId(0),
goalRadius(0),
@@ -121,7 +122,15 @@ CGroundMoveType::CGroundMoveType(CUnit* owner):
nextWaypoint(ZeroVector),
atGoal(false),
haveFinalWaypoint(false),
+
+ requestedSpeed(0.0f),
currentDistanceToWaypoint(0),
+ pathRequestDelay(0),
+ numIdlingUpdates(0),
+ numIdlingSlowUpdates(0),
+
+ nextDeltaSpeedUpdate(0),
+ nextObstacleAvoidanceUpdate(0),
skidding(false),
flying(false),
@@ -130,22 +139,12 @@ CGroundMoveType::CGroundMoveType(CUnit* owner):
canReverse(owner->unitDef->rSpeed > 0.0f),
useMainHeading(false),
- skidRotVector(UpVector),
skidRotSpeed(0.0f),
+ skidRotVector(UpVector),
skidRotSpeed2(0.0f),
skidRotPos2(0.0f),
oldPhysState(CSolidObject::OnGround),
-
- flatFrontDir(0.0f, 0.0, 1.0f),
- mainHeadingPos(ZeroVector),
-
- nextDeltaSpeedUpdate(0),
- nextObstacleAvoidanceUpdate(0),
-
- pathRequestDelay(0),
-
- numIdlingUpdates(0),
- numIdlingSlowUpdates(0)
+ mainHeadingPos(0.0f, 0.0f, 0.0f)
{
if (owner) {
moveSquareX = owner->pos.x / MIN_WAYPOINT_DISTANCE;
@@ -560,17 +559,23 @@ void CGroundMoveType::ChangeHeading(short wantedHeading) {
tracefile << "unit " << owner->id << " changed heading to " << heading << " from " << _oldheading << " (wantedHeading: " << wantedHeading << ")\n";
#endif
- owner->SetDirectionFromHeading();
+ owner->frontdir = GetVectorFromHeading(heading);
+ if (owner->upright) {
+ owner->updir = UpVector;
+ owner->rightdir = owner->frontdir.cross(owner->updir);
+ } else {
+ owner->updir = ground->GetNormal(owner->pos.x, owner->pos.z);
+ owner->rightdir = owner->frontdir.cross(owner->updir);
+ owner->rightdir.Normalize();
+ owner->frontdir = owner->updir.cross(owner->rightdir);
+ }
flatFrontDir = owner->frontdir;
flatFrontDir.y = 0.0f;
flatFrontDir.Normalize();
}
-
-
-
-void CGroundMoveType::ImpulseAdded(const float3&)
+void CGroundMoveType::ImpulseAdded()
{
if (owner->beingBuilt || owner->unitDef->movedata->moveType == MoveData::Ship_Move)
return;
@@ -583,34 +588,25 @@ void CGroundMoveType::ImpulseAdded(const float3&)
impulse = ZeroVector;
}
- const float3& groundNormal = ground->GetNormal(owner->pos.x, owner->pos.z);
- const float groundImpulseScale = impulse.dot(groundNormal);
+ float3 groundNormal = ground->GetNormal(owner->pos.x, owner->pos.z);
+
+ if (impulse.dot(groundNormal) < 0)
+ impulse -= groundNormal * impulse.dot(groundNormal);
- if (groundImpulseScale < 0.0f)
- impulse -= (groundNormal * groundImpulseScale);
+ const float sqstrength = impulse.SqLength();
- if (impulse.SqLength() > 9.0f || groundImpulseScale > 0.3f) {
+ if (sqstrength > 9 || impulse.dot(groundNormal) > 0.3f) {
skidding = true;
speed += impulse;
impulse = ZeroVector;
- // FIXME: impulse should not cause a _random_ rotational component
skidRotSpeed += (gs->randFloat() - 0.5f) * 1500;
- skidRotSpeed2 = 0.0f;
- skidRotPos2 = 0.0f;
-
- float3 skidDir;
-
- if (speed.SqLength2D() >= 0.01f) {
- skidDir = speed;
- skidDir.y = 0.0f;
+ skidRotPos2 = 0;
+ skidRotSpeed2 = 0;
+ float3 skidDir(speed);
+ skidDir.y = 0;
skidDir.Normalize();
- } else {
- skidDir = owner->frontdir;
- }
-
skidRotVector = skidDir.cross(UpVector);
-
oldPhysState = owner->physicalState;
owner->physicalState = CSolidObject::Flying;
owner->moveType->useHeading = false;
@@ -690,8 +686,8 @@ void CGroundMoveType::UpdateSkid()
speed *= (speedf - speedReduction) / speedf;
}
- const float remTime = speedf / speedReduction - 1.0f;
- const float rp = floor(skidRotPos2 + skidRotSpeed2 * remTime + 0.5f);
+ float remTime = speedf / speedReduction - 1.0f;
+ float rp = floor(skidRotPos2 + skidRotSpeed2 * remTime + 0.5f);
skidRotSpeed2 = (remTime + 1.0f == 0.0f ) ? 0.0f : (rp - skidRotPos2) / (remTime + 1.0f);
@@ -720,7 +716,13 @@ void CGroundMoveType::UpdateSkid()
}
}
CalcSkidRot();
- owner->MoveMidPos(speed);
+
+ midPos += speed;
+ pos = midPos -
+ owner->frontdir * owner->relMidPos.z -
+ owner->updir * owner->relMidPos.y -
+ owner->rightdir * owner->relMidPos.x;
+ owner->midPos = midPos;
CheckCollisionSkid();
ASSERT_SYNCED_FLOAT3(owner->midPos);
@@ -733,17 +735,25 @@ void CGroundMoveType::UpdateControlledDrop()
SyncedFloat3& midPos = owner->midPos;
if (owner->falling) {
- speed.y += (mapInfo->map.gravity * owner->fallSpeed);
- speed.y = std::min(speed.y, 0.0f);
+ speed.y += mapInfo->map.gravity * owner->fallSpeed;
- owner->MoveMidPos(speed);
+ if (owner->speed.y > 0) //sometimes the dropped unit gets an upward force, still unsure where its coming from
+ owner->speed.y = 0;
- if (midPos.y < 0.0f)
- speed *= 0.90;
+ midPos += speed;
+ pos = midPos -
+ owner->frontdir * owner->relMidPos.z -
+ owner->updir * owner->relMidPos.y -
+ owner->rightdir * owner->relMidPos.x;
+
+ owner->midPos.y = owner->pos.y + owner->relMidPos.y;
+
+ if(midPos.y < 0)
+ speed*=0.90;
const float wh = GetGroundHeight(midPos);
- if (wh > (midPos.y - owner->relMidPos.y)) {
+ if (wh > midPos.y - owner->relMidPos.y) {
owner->falling = false;
midPos.y = wh + owner->relMidPos.y - speed.y * 0.8;
owner->script->Landed(); //stop parachute animation
@@ -781,8 +791,12 @@ void CGroundMoveType::CheckCollisionSkid()
const float impactSpeed = -owner->speed.dot(dif);
if (impactSpeed > 0.0f) {
- owner->MoveMidPos(dif * impactSpeed);
- owner->speed += ((dif * impactSpeed) * 1.8f);
+ midPos += dif * impactSpeed;
+ pos = midPos -
+ owner->frontdir * owner->relMidPos.z -
+ owner->updir * owner->relMidPos.y -
+ owner->rightdir * owner->relMidPos.x;
+ owner->speed += dif * (impactSpeed * 1.8f);
// damage the collider
if (impactSpeed > ownerUD->minCollisionSpeed && ownerUD->minCollisionSpeed >= 0) {
@@ -799,10 +813,17 @@ void CGroundMoveType::CheckCollisionSkid()
const float impactSpeed = (u->speed - owner->speed).dot(dif) * 0.5f;
if (impactSpeed > 0.0f) {
- owner->MoveMidPos(dif * (impactSpeed * (1 - part) * 2));
+ midPos += dif * (impactSpeed * (1 - part) * 2);
+ pos = midPos -
+ owner->frontdir * owner->relMidPos.z -
+ owner->updir * owner->relMidPos.y -
+ owner->rightdir * owner->relMidPos.x;
owner->speed += dif * (impactSpeed * (1 - part) * 2);
-
- u->MoveMidPos(dif * (impactSpeed * part * -2));
+ u->midPos -= dif * (impactSpeed * part * 2);
+ u->pos = u->midPos -
+ u->frontdir * u->relMidPos.z -
+ u->updir * u->relMidPos.y -
+ u->rightdir * u->relMidPos.x;
u->speed -= dif * (impactSpeed * part * 2);
if (CGroundMoveType* mt = dynamic_cast<CGroundMoveType*>(u->moveType)) {
@@ -845,8 +866,12 @@ void CGroundMoveType::CheckCollisionSkid()
const float impactSpeed = -owner->speed.dot(dif);
if (impactSpeed > 0.0f) {
- owner->MoveMidPos(dif * impactSpeed);
- owner->speed += ((dif * impactSpeed) * 1.8f);
+ midPos += dif * impactSpeed;
+ pos = midPos -
+ owner->frontdir * owner->relMidPos.z -
+ owner->updir * owner->relMidPos.y -
+ owner->rightdir * owner->relMidPos.x;
+ owner->speed += dif * (impactSpeed * 1.8f);
if (impactSpeed > ownerUD->minCollisionSpeed && ownerUD->minCollisionSpeed >= 0) {
owner->DoDamage(DamageArray(impactSpeed * owner->mass * 0.2f), 0, ZeroVector);
@@ -859,7 +884,18 @@ void CGroundMoveType::CheckCollisionSkid()
void CGroundMoveType::CalcSkidRot()
{
owner->heading += (short int) skidRotSpeed;
- owner->SetDirectionFromHeading();
+
+ owner->frontdir = GetVectorFromHeading(owner->heading);
+
+ if (owner->upright) {
+ owner->updir = UpVector;
+ owner->rightdir = owner->frontdir.cross(owner->updir);
+ } else {
+ owner->updir = ground->GetSmoothNormal(owner->pos.x, owner->pos.z);
+ owner->rightdir = owner->frontdir.cross(owner->updir);
+ owner->rightdir.Normalize();
+ owner->frontdir = owner->updir.cross(owner->rightdir);
+ }
skidRotPos2 += skidRotSpeed2;
@@ -868,25 +904,22 @@ void CGroundMoveType::CalcSkidRot()
float3 f1 = skidRotVector * skidRotVector.dot(owner->frontdir);
float3 f2 = owner->frontdir - f1;
+ f2 = f2 * cosp + f2.cross(skidRotVector) * sinp;
+ owner->frontdir = f1 + f2;
float3 r1 = skidRotVector * skidRotVector.dot(owner->rightdir);
float3 r2 = owner->rightdir - r1;
+ r2 = r2 * cosp + r2.cross(skidRotVector) * sinp;
+ owner->rightdir = r1 + r2;
float3 u1 = skidRotVector * skidRotVector.dot(owner->updir);
float3 u2 = owner->updir - u1;
-
- f2 = f2 * cosp + f2.cross(skidRotVector) * sinp;
- r2 = r2 * cosp + r2.cross(skidRotVector) * sinp;
u2 = u2 * cosp + u2.cross(skidRotVector) * sinp;
-
- owner->frontdir = f1 + f2;
- owner->rightdir = r1 + r2;
- owner->updir = u1 + u2;
+ owner->updir = u1 + u2;
}
-
/*
* Dynamic obstacle avoidance, helps the unit to
* follow the path even when it's not perfect.
diff --git a/rts/Sim/MoveTypes/GroundMoveType.h b/rts/Sim/MoveTypes/GroundMoveType.h
index 30ee478..ad8c805 100644
--- a/rts/Sim/MoveTypes/GroundMoveType.h
+++ b/rts/Sim/MoveTypes/GroundMoveType.h
@@ -29,7 +29,7 @@ public:
void SetMaxSpeed(float speed);
- void ImpulseAdded(const float3&);
+ void ImpulseAdded();
void KeepPointingTo(float3 pos, float distance, bool aggressive);
void KeepPointingTo(CUnit* unit, float distance, bool aggressive);
diff --git a/rts/Sim/MoveTypes/MoveType.h b/rts/Sim/MoveTypes/MoveType.h
index b89ff88..c47428c 100644
--- a/rts/Sim/MoveTypes/MoveType.h
+++ b/rts/Sim/MoveTypes/MoveType.h
@@ -23,7 +23,7 @@ public:
virtual void KeepPointingTo(float3 pos, float distance, bool aggressive) = 0;
virtual void KeepPointingTo(CUnit* unit, float distance, bool aggressive);
virtual void StopMoving() = 0;
- virtual void ImpulseAdded(const float3&) {}
+ virtual void ImpulseAdded(void) {}
virtual void ReservePad(CAirBaseHandler::LandingPad* lp);
virtual void SetGoal(const float3& pos);
diff --git a/rts/Sim/MoveTypes/ScriptMoveType.h b/rts/Sim/MoveTypes/ScriptMoveType.h
index 1195710..904fd91 100644
--- a/rts/Sim/MoveTypes/ScriptMoveType.h
+++ b/rts/Sim/MoveTypes/ScriptMoveType.h
@@ -34,6 +34,7 @@ class CScriptMoveType : public AMoveType
void KeepPointingTo(CUnit* unit, float distance, bool aggressive) {}
void StopMoving() {}
+ void ImpulseAdded() {}
void SetGoal(float3 pos) {}
void SetMaxSpeed(float speed) {}
void SetWantedMaxSpeed(float speed) {}
diff --git a/rts/Sim/Objects/SolidObject.cpp b/rts/Sim/Objects/SolidObject.cpp
index f3ec270..949f734 100644
--- a/rts/Sim/Objects/SolidObject.cpp
+++ b/rts/Sim/Objects/SolidObject.cpp
@@ -60,8 +60,8 @@ CSolidObject::CSolidObject():
isMoving(false),
isUnderWater(false),
isMarkedOnBlockingMap(false),
- speed(ZeroVector),
- residualImpulse(ZeroVector),
+ speed(0, 0, 0),
+ residualImpulse(0, 0, 0),
allyteam(0),
team(0),
mobility(NULL),
diff --git a/rts/Sim/Path/Default/PathEstimator.cpp b/rts/Sim/Path/Default/PathEstimator.cpp
index b612a2b..e64fb78 100644
--- a/rts/Sim/Path/Default/PathEstimator.cpp
+++ b/rts/Sim/Path/Default/PathEstimator.cpp
@@ -1,9 +1,6 @@
/* This file is part of the Spring engine (GPL v2 or later), see LICENSE.html */
#include "StdAfx.h"
-
-#include "lib/gml/gml.h" // FIXME: linux for some reason does not compile without this
-
#include "PathEstimator.h"
#include <fstream>
diff --git a/rts/Sim/Projectiles/Projectile.h b/rts/Sim/Projectiles/Projectile.h
index ab75359..b0385c1 100644
--- a/rts/Sim/Projectiles/Projectile.h
+++ b/rts/Sim/Projectiles/Projectile.h
@@ -3,7 +3,7 @@
#ifndef PROJECTILE_H
#define PROJECTILE_H
-#include "lib/gml/gml.h" // for GML_ENABLE_SIM
+#include "Rendering/GL/myGL.h"
#ifdef _MSC_VER
#pragma warning(disable:4291)
diff --git a/rts/Sim/Units/Unit.cpp b/rts/Sim/Units/Unit.cpp
index 7802b41..07ac36a 100644
--- a/rts/Sim/Units/Unit.cpp
+++ b/rts/Sim/Units/Unit.cpp
@@ -120,7 +120,6 @@ CUnit::CUnit() : CSolidObject(),
stunned(false),
useHighTrajectory(false),
dontUseWeapons(false),
- dontFire(false),
deathScriptFinished(false),
delayedWreckLevel(-1),
restTime(0),
@@ -201,6 +200,7 @@ CUnit::CUnit() : CSolidObject(),
commandShotCount(-1),
fireState(FIRESTATE_FIREATWILL),
moveState(MOVESTATE_MANEUVER),
+ dontFire(false),
activated(false),
crashing(false),
isDead(false),
@@ -233,10 +233,6 @@ CUnit::CUnit() : CSolidObject(),
myTrack(NULL),
lastFlareDrop(0),
currentFuel(0.0f),
- maxSpeed(0.0f),
- maxReverseSpeed(0.0f),
- alphaThreshold(0.1f),
- cegDamage(1),
luaDraw(false),
noDraw(false),
noSelect(false),
@@ -244,8 +240,12 @@ CUnit::CUnit() : CSolidObject(),
leaveTracks(false),
isIcon(false),
iconRadius(0.0f),
+ maxSpeed(0.0f),
+ maxReverseSpeed(0.0f),
lodCount(0),
- currentLOD(0)
+ currentLOD(0),
+ alphaThreshold(0.1f),
+ cegDamage(1)
#ifdef USE_GML
, lastDrawFrame(-30)
#endif
@@ -593,6 +593,45 @@ void CUnit::ForcedSpin(const float3& newDir)
ForcedMove(pos); // lazy, don't need to update the quadfield, etc...
}
+
+/*
+void CUnit::SetFront(const SyncedFloat3& newDir)
+{
+ frontdir = newDir;
+ frontdir.Normalize();
+ rightdir = frontdir.cross(updir);
+ rightdir.Normalize();
+ updir = rightdir.cross(frontdir);
+ updir.Normalize();
+ heading = GetHeadingFromVector(frontdir.x, frontdir.z);
+ UpdateMidPos();
+}
+
+void CUnit::SetUp(const SyncedFloat3& newDir)
+{
+ updir = newDir;
+ updir.Normalize();
+ frontdir = updir.cross(rightdir);
+ frontdir.Normalize();
+ rightdir = frontdir.cross(updir);
+ rightdir.Normalize();
+ heading = GetHeadingFromVector(frontdir.x, frontdir.z);
+ UpdateMidPos();
+}
+
+void CUnit::SetRight(const SyncedFloat3& newDir)
+{
+ rightdir = newDir;
+ rightdir.Normalize();
+ updir = rightdir.cross(frontdir);
+ updir.Normalize();
+ frontdir = updir.cross(rightdir);
+ frontdir.Normalize();
+ heading = GetHeadingFromVector(frontdir.x, frontdir.z);
+ UpdateMidPos();
+}
+*/
+
void CUnit::SetDirectionFromHeading()
{
if (GetTransporter() == NULL) {
@@ -619,14 +658,6 @@ void CUnit::UpdateMidPos()
(rightdir * relMidPos.x);
}
-void CUnit::MoveMidPos(const float3& deltaPos) {
- midPos += deltaPos;
- pos = midPos -
- (frontdir * relMidPos.z) -
- (updir * relMidPos.y) -
- (rightdir * relMidPos.x);
-}
-
void CUnit::Drop(const float3& parentPos, const float3& parentDir, CUnit* parent)
{
@@ -1054,21 +1085,18 @@ void CUnit::SlowUpdateWeapons() {
void CUnit::DoWaterDamage()
{
- if (mapInfo->water.damage <= 0.0f) {
- return;
- }
- if (!pos.IsInBounds()) {
- return;
- }
-
- const int px = pos.x / (SQUARE_SIZE * 2);
- const int pz = pos.z / (SQUARE_SIZE * 2);
- const bool isFloating = (physicalState == CSolidObject::Floating);
- const bool onGround = (physicalState == CSolidObject::OnGround);
- const bool isWaterSquare = (readmap->mipHeightmap[1][pz * gs->hmapx + px] <= 0.0f);
-
- if ((pos.y <= 0.0f) && isWaterSquare && (isFloating || onGround)) {
- DoDamage(DamageArray(mapInfo->water.damage), 0, ZeroVector, -1);
+ if (uh->waterDamage > 0.0f) {
+ if (pos.IsInBounds()) {
+ const int px = int(pos.x / (SQUARE_SIZE * 2));
+ const int pz = int(pos.z / (SQUARE_SIZE * 2));
+ const bool isFloating = (physicalState == CSolidObject::Floating);
+ const bool onGround = (physicalState == CSolidObject::OnGround);
+ const bool isWaterSquare = (readmap->mipHeightmap[1][pz * gs->hmapx + px] <= 0.0f);
+
+ if ((pos.y <= 0.0f) && isWaterSquare && (isFloating || onGround)) {
+ DoDamage(DamageArray(uh->waterDamage), 0, ZeroVector, -1);
+ }
+ }
}
}
@@ -1128,7 +1156,8 @@ void CUnit::DoDamage(const DamageArray& damages, CUnit* attacker, const float3&
damage = newDamage;
}
- AddImpulse((impulse * impulseMult) / mass);
+ residualImpulse += ((impulse * impulseMult) / mass);
+ moveType->ImpulseAdded();
if (paralyzeTime == 0) { // real damage
if (damage > 0.0f) {
@@ -1149,7 +1178,8 @@ void CUnit::DoDamage(const DamageArray& damages, CUnit* attacker, const float3&
stunned = false;
}
}
- } else { // paralyzation
+ }
+ else { // paralyzation
experienceMod *= 0.1f; // reduced experience
if (damage > 0.0f) {
// paralyzeDamage may not get higher than maxHealth * (paralyzeTime + 1),
@@ -1223,13 +1253,6 @@ void CUnit::Kill(const float3& impulse) {
DoDamage(da, NULL, impulse, -1);
}
-void CUnit::AddImpulse(const float3& addedImpulse) {
- residualImpulse += addedImpulse;
-
- if (addedImpulse.SqLength() >= 0.01f)
- moveType->ImpulseAdded(addedImpulse);
-}
-
/******************************************************************************/
diff --git a/rts/Sim/Units/Unit.h b/rts/Sim/Units/Unit.h
index 3aa74a0..31871cb 100644
--- a/rts/Sim/Units/Unit.h
+++ b/rts/Sim/Units/Unit.h
@@ -3,8 +3,6 @@
#ifndef UNIT_H
#define UNIT_H
-#include "lib/gml/gml.h" // for GML_ENABLE_SIM
-
#include <map>
#include <vector>
#include <string>
@@ -82,7 +80,6 @@ public:
const float3& impulse, int weaponId = -1);
virtual void DoWaterDamage();
virtual void Kill(const float3& impulse);
- virtual void AddImpulse(const float3&);
virtual void FinishedBuilding();
bool AttackGround(const float3& pos, bool wantDGun, bool fpsMode = false);
@@ -150,7 +147,6 @@ public:
void UpdateTerrainType();
void UpdateMidPos();
- void MoveMidPos(const float3&);
bool IsNeutral() const {
return neutral;
diff --git a/rts/Sim/Units/UnitHandler.cpp b/rts/Sim/Units/UnitHandler.cpp
index 2c8326e..ab14579 100644
--- a/rts/Sim/Units/UnitHandler.cpp
+++ b/rts/Sim/Units/UnitHandler.cpp
@@ -1,18 +1,20 @@
/* This file is part of the Spring engine (GPL v2 or later), see LICENSE.html */
#include "StdAfx.h"
-#include <cassert>
+#include <assert.h>
#include "mmgr.h"
#include "lib/gml/gml.h"
#include "UnitHandler.h"
#include "Unit.h"
#include "UnitDefHandler.h"
-#include "CommandAI/BuilderCAI.h"
+#include "UnitLoader.h"
#include "CommandAI/Command.h"
+#include "CommandAI/BuilderCAI.h"
#include "Game/GameSetup.h"
#include "Lua/LuaUnsyncedCtrl.h"
#include "Map/Ground.h"
+#include "Map/MapInfo.h"
#include "Map/ReadMap.h"
#include "Sim/Features/Feature.h"
#include "Sim/Features/FeatureDef.h"
@@ -27,6 +29,7 @@
#include "System/LogOutput.h"
#include "System/TimeProfiler.h"
#include "System/myMath.h"
+#include "System/LoadSave/LoadSaveInterface.h"
#include "System/Sync/SyncTracer.h"
#include "System/creg/STL_Deque.h"
#include "System/creg/STL_List.h"
@@ -39,24 +42,29 @@ using std::max;
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
-CUnitHandler* uh = NULL;
+CUnitHandler* uh;
-CR_BIND(CUnitHandler, );
+CR_BIND(CUnitHandler, (true));
CR_REG_METADATA(CUnitHandler, (
CR_MEMBER(activeUnits),
CR_MEMBER(units),
- CR_MEMBER(freeUnitIDs),
- CR_MEMBER(maxUnits),
- CR_MEMBER(maxUnitsPerTeam),
+ CR_MEMBER(freeIDs),
+ CR_MEMBER(waterDamage),
+ CR_MEMBER(unitsPerTeam),
CR_MEMBER(maxUnitRadius),
- CR_MEMBER(unitsToBeRemoved),
+ CR_MEMBER(toBeRemoved),
CR_MEMBER(morphUnitToFeature),
+// CR_MEMBER(toBeRemoved),
CR_MEMBER(builderCAIs),
CR_MEMBER(unitsByDefs),
CR_POSTLOAD(PostLoad),
CR_SERIALIZER(Serialize)
-));
+ ));
+
+void CUnitHandler::Serialize(creg::ISerializer& s)
+{
+}
void CUnitHandler::PostLoad()
@@ -66,55 +74,38 @@ void CUnitHandler::PostLoad()
}
-CUnitHandler::CUnitHandler()
+CUnitHandler::CUnitHandler(bool serializing)
:
maxUnitRadius(0.0f),
morphUnitToFeature(true)
{
- assert(teamHandler->ActiveTeams() > 0);
-
- // note: the number of active teams can change at run-time, so
- // the team unit limit should be recalculated whenever one dies
- // or spawns (but would get complicated)
- maxUnits = std::min(gameSetup->maxUnits * teamHandler->ActiveTeams(), MAX_UNITS);
- maxUnitsPerTeam = maxUnits / teamHandler->ActiveTeams();
-
- // ensure each team can make at least one unit
- assert(maxUnits >= teamHandler->ActiveTeams());
- assert(maxUnitsPerTeam >= 1);
-
- units.resize(maxUnits, NULL);
- unitsByDefs.resize(teamHandler->ActiveTeams(), std::vector<CUnitSet>(unitDefHandler->unitDefs.size()));
+ const size_t maxUnitsTemp = std::min(gameSetup->maxUnits * teamHandler->ActiveTeams(), MAX_UNITS);
+ units.resize(maxUnitsTemp);
+ unitsPerTeam = maxUnitsTemp / teamHandler->ActiveTeams() - 5;
+
+ freeIDs.reserve(units.size()-1);
+ for (size_t a = 1; a < units.size(); a++) {
+ freeIDs.push_back(a);
+ units[a] = NULL;
+ }
+ units[0] = NULL;
- {
- std::vector<unsigned int> freeIDs(units.size());
+ slowUpdateIterator = activeUnits.end();
- // id's are used as indices, so they must lie in [0, units.size() - 1]
- // (furthermore all id's are treated equally, none have special status)
- for (unsigned int id = 0; id < units.size(); id++) {
- freeIDs[id] = id;
- }
+ waterDamage = mapInfo->water.damage;
- // randomize the unit ID's so that Lua widgets can not
- // easily determine enemy unit counts from ID's alone
- // (shuffle twice for good measure)
- SyncedRNG rng;
+ if (!serializing) {
+ airBaseHandler = new CAirBaseHandler;
- std::random_shuffle(freeIDs.begin(), freeIDs.end(), rng);
- std::random_shuffle(freeIDs.begin(), freeIDs.end(), rng);
- std::copy(freeIDs.begin(), freeIDs.end(), std::front_inserter(freeUnitIDs));
+ unitsByDefs.resize(teamHandler->ActiveTeams(), std::vector<CUnitSet>(unitDefHandler->unitDefs.size()));
}
-
- slowUpdateIterator = activeUnits.end();
- airBaseHandler = new CAirBaseHandler();
}
CUnitHandler::~CUnitHandler()
{
for (std::list<CUnit*>::iterator usi = activeUnits.begin(); usi != activeUnits.end(); ++usi) {
- // ~CUnit dereferences featureHandler which is destroyed already
- (*usi)->delayedWreckLevel = -1;
+ (*usi)->delayedWreckLevel = -1; // dont create wreckages since featureHandler may be destroyed already
delete (*usi);
}
@@ -122,44 +113,40 @@ CUnitHandler::~CUnitHandler()
}
-bool CUnitHandler::AddUnit(CUnit *unit)
+int CUnitHandler::AddUnit(CUnit *unit)
{
- if (freeUnitIDs.empty()) {
- // should be unreachable (all code that goes through
- // UnitLoader::LoadUnit --> Unit::PreInit checks the
- // unit limit first)
- assert(false);
- return false;
- }
-
- unit->id = freeUnitIDs.front();
- units[unit->id] = unit;
-
+ int num = (int)(gs->randFloat()) * ((int)activeUnits.size() - 1);
std::list<CUnit*>::iterator ui = activeUnits.begin();
-
- if (ui != activeUnits.end()) {
- // randomize this to make the slow-update order random (good if one
- // builds say many buildings at once and then many mobile ones etc)
- const unsigned int insertionPos = gs->randFloat() * activeUnits.size();
-
- for (unsigned int n = 0; n < insertionPos; ++n) {
- ++ui;
- }
+ for (int a = 0; a < num;++a) {
+ ++ui;
}
+ // randomize this to make the order in slowupdate random (good if one
+ // builds say many buildings at once and then many mobile ones etc)
activeUnits.insert(ui, unit);
- freeUnitIDs.pop_front();
+ // randomize the unitID assignment so that lua widgets can
+ // not easily determine enemy unit counts from unitIDs alone
+ assert(!freeIDs.empty());
+ const unsigned int freeSlot = gs->randInt() % freeIDs.size();
+ const unsigned int freeMax = freeIDs.size() - 1;
+ unit->id = freeIDs[freeSlot]; // set the unit ID
+ freeIDs[freeSlot] = freeIDs[freeMax];
+ freeIDs.resize(freeMax);
+
+ units[unit->id] = unit;
teamHandler->Team(unit->team)->AddUnit(unit, CTeam::AddBuilt);
unitsByDefs[unit->team][unit->unitDef->id].insert(unit);
maxUnitRadius = max(unit->radius, maxUnitRadius);
- return true;
+
+ return unit->id;
}
+
void CUnitHandler::DeleteUnit(CUnit* unit)
{
- unitsToBeRemoved.push_back(unit);
+ toBeRemoved.push_back(unit);
(eventBatchHandler->GetUnitCreatedDestroyedBatch()).dequeue_synced(unit);
}
@@ -187,12 +174,13 @@ void CUnitHandler::DeleteUnitNow(CUnit* delUnit)
activeUnits.erase(usi);
units[delUnit->id] = 0;
- freeUnitIDs.push_back(delUnit->id);
+ freeIDs.push_back(delUnit->id);
teamHandler->Team(delTeam)->RemoveUnit(delUnit, CTeam::RemoveDied);
unitsByDefs[delTeam][delType].erase(delUnit);
delete delUnit;
+
break;
}
}
@@ -215,7 +203,7 @@ void CUnitHandler::Update()
{
GML_STDMUTEX_LOCK(runit); // Update
- if (!unitsToBeRemoved.empty()) {
+ if (!toBeRemoved.empty()) {
GML_RECMUTEX_LOCK(unit); // Update - for anti-deadlock purposes.
GML_RECMUTEX_LOCK(sel); // Update - unit is removed from selectedUnits in ~CObject, which is too late.
GML_RECMUTEX_LOCK(quad); // Update - make sure unit does not get partially deleted before before being removed from the quadfield
@@ -223,9 +211,9 @@ void CUnitHandler::Update()
eventHandler.DeleteSyncedUnits();
- while (!unitsToBeRemoved.empty()) {
- CUnit* delUnit = unitsToBeRemoved.back();
- unitsToBeRemoved.pop_back();
+ while (!toBeRemoved.empty()) {
+ CUnit* delUnit = toBeRemoved.back();
+ toBeRemoved.pop_back();
DeleteUnitNow(delUnit);
}
@@ -237,7 +225,7 @@ void CUnitHandler::Update()
GML_UPDATE_TICKS();
{
- SCOPED_TIMER("Unit::MoveType::Update");
+ SCOPED_TIMER("Unit Movetype update");
std::list<CUnit*>::iterator usi;
for (usi = activeUnits.begin(); usi != activeUnits.end(); ++usi) {
CUnit* unit = *usi;
@@ -252,7 +240,7 @@ void CUnitHandler::Update()
}
{
- SCOPED_TIMER("Unit::Update");
+ SCOPED_TIMER("Unit update");
std::list<CUnit*>::iterator usi;
for (usi = activeUnits.begin(); usi != activeUnits.end(); ++usi) {
CUnit* unit = *usi;
@@ -272,7 +260,7 @@ void CUnitHandler::Update()
}
{
- SCOPED_TIMER("Unit::SlowUpdate");
+ SCOPED_TIMER("Unit slow update");
if (!(gs->frameNum & (UNIT_SLOWUPDATE_RATE - 1))) {
slowUpdateIterator = activeUnits.begin();
}
@@ -285,10 +273,10 @@ void CUnitHandler::Update()
}
-float CUnitHandler::GetBuildHeight(const float3& pos, const UnitDef* unitdef)
+float CUnitHandler::GetBuildHeight(float3 pos, const UnitDef* unitdef)
{
- float minh = -5000.0f;
- float maxh = 5000.0f;
+ float minh=-5000;
+ float maxh=5000;
int numBorder=0;
float borderh=0;
const float* heightmap=readmap->GetHeightmap();
@@ -477,9 +465,10 @@ void CUnitHandler::AddBuilderCAI(CBuilderCAI* b)
{
GML_STDMUTEX_LOCK(cai); // AddBuilderCAI
- builderCAIs.insert(builderCAIs.end(), b);
+ builderCAIs.insert(builderCAIs.end(),b);
}
+
void CUnitHandler::RemoveBuilderCAI(CBuilderCAI* b)
{
GML_STDMUTEX_LOCK(cai); // RemoveBuilderCAI
@@ -488,51 +477,46 @@ void CUnitHandler::RemoveBuilderCAI(CBuilderCAI* b)
}
+void CUnitHandler::LoadSaveUnits(CLoadSaveInterface* file, bool loading)
+{
+}
+
/**
* Returns a build Command that intersects the ray described by pos and dir from
* the command queues of the units 'units' on team number 'team'.
* @brief returns a build Command that intersects the ray described by pos and dir
- * @return the build Command, or a Command with id 0 if none is found
+ * @return the build Command, or a Command wiht id 0 if none is found
*/
-Command CUnitHandler::GetBuildCommand(const float3& pos, const float3& dir) {
+Command CUnitHandler::GetBuildCommand(float3 pos, float3 dir){
float3 tempF1 = pos;
GML_STDMUTEX_LOCK(cai); // GetBuildCommand
CCommandQueue::iterator ci;
- for (std::list<CUnit*>::const_iterator ui = activeUnits.begin(); ui != activeUnits.end(); ++ui) {
- const CUnit* unit = *ui;
-
- if (unit->team != gu->myTeam) {
- continue;
- }
-
- ci = unit->commandAI->commandQue.begin();
-
- for (; ci != unit->commandAI->commandQue.end(); ++ci) {
- const Command& cmd = *ci;
-
- if (cmd.id < 0 && cmd.params.size() >= 3) {
- BuildInfo bi(cmd);
- tempF1 = pos + dir * ((bi.pos.y - pos.y) / dir.y) - bi.pos;
-
- if (bi.def && (bi.GetXSize() / 2) * SQUARE_SIZE > fabs(tempF1.x) && (bi.GetZSize() / 2) * SQUARE_SIZE > fabs(tempF1.z)) {
- return cmd;
+ for(std::list<CUnit*>::iterator ui = this->activeUnits.begin(); ui != this->activeUnits.end(); ++ui){
+ if((*ui)->team == gu->myTeam){
+ ci = (*ui)->commandAI->commandQue.begin();
+ for(; ci != (*ui)->commandAI->commandQue.end(); ++ci){
+ if((*ci).id < 0 && (*ci).params.size() >= 3){
+ BuildInfo bi(*ci);
+ tempF1 = pos + dir*((bi.pos.y - pos.y)/dir.y) - bi.pos;
+ if(bi.def && bi.GetXSize()/2*SQUARE_SIZE > fabs(tempF1.x) && bi.GetZSize()/2*SQUARE_SIZE > fabs(tempF1.z)){
+ return (*ci);
+ }
}
}
}
}
-
Command c;
- c.id = CMD_STOP;
+ c.id = 0;
return c;
}
bool CUnitHandler::CanBuildUnit(const UnitDef* unitdef, int team)
{
- if (teamHandler->Team(team)->units.size() >= maxUnitsPerTeam) {
+ if (teamHandler->Team(team)->units.size() >= unitsPerTeam) {
return false;
}
if (unitsByDefs[team][unitdef->id].size() >= unitdef->maxThisUnit) {
diff --git a/rts/Sim/Units/UnitHandler.h b/rts/Sim/Units/UnitHandler.h
index 0f348d7..407f4c7 100644
--- a/rts/Sim/Units/UnitHandler.h
+++ b/rts/Sim/Units/UnitHandler.h
@@ -24,15 +24,14 @@ class CUnitHandler
CR_DECLARE(CUnitHandler)
public:
- CUnitHandler();
- ~CUnitHandler();
-
void Update();
void DeleteUnit(CUnit* unit);
void DeleteUnitNow(CUnit* unit);
- bool AddUnit(CUnit* unit);
- void Serialize(creg::ISerializer& s) {}
+ int AddUnit(CUnit* unit);
+ CUnitHandler(bool serializing=false);
+ void Serialize(creg::ISerializer& s);
void PostLoad();
+ virtual ~CUnitHandler();
///< test if a unit can be built at specified position
///< return values for the following is
@@ -56,12 +55,20 @@ public:
void AddBuilderCAI(CBuilderCAI*);
void RemoveBuilderCAI(CBuilderCAI*);
- float GetBuildHeight(const float3& pos, const UnitDef* unitdef);
+ float GetBuildHeight(float3 pos, const UnitDef* unitdef);
+
+ void LoadSaveUnits(CLoadSaveInterface* file, bool loading);
+ Command GetBuildCommand(float3 pos, float3 dir);
- Command GetBuildCommand(const float3& pos, const float3& dir);
+ int MaxUnitsPerTeam() const
+ {
+ return unitsPerTeam;
+ };
- unsigned int MaxUnitsPerTeam() const { return maxUnitsPerTeam; }
- unsigned int MaxUnits() const { return maxUnits; }
+ size_t MaxUnits() const
+ {
+ return units.size();
+ };
// note: negative ID's are implicitly converted
@@ -72,19 +79,23 @@ public:
std::vector< std::vector<CUnitSet> > unitsByDefs; ///< units sorted by team and unitDef
std::list<CUnit*> activeUnits; ///< used to get all active units
+ std::vector<int> freeIDs;
std::vector<CUnit*> units; ///< used to get units from IDs (0 if not created)
+
+ std::vector<CUnit*> toBeRemoved; ///< units that will be removed at start of next update
+
+ std::list<CUnit*>::iterator slowUpdateIterator;
+
std::list<CBuilderCAI*> builderCAIs;
+ float waterDamage;
+
float maxUnitRadius; ///< largest radius seen so far
+
bool morphUnitToFeature;
private:
- std::list<unsigned int> freeUnitIDs;
- std::vector<CUnit*> unitsToBeRemoved; ///< units that will be removed at start of next update
- std::list<CUnit*>::iterator slowUpdateIterator;
-
- unsigned int maxUnits;
- unsigned int maxUnitsPerTeam;
+ int unitsPerTeam;
};
extern CUnitHandler* uh;
diff --git a/rts/Sim/Units/UnitLoader.cpp b/rts/Sim/Units/UnitLoader.cpp
index 47210de..fa95845 100644
--- a/rts/Sim/Units/UnitLoader.cpp
+++ b/rts/Sim/Units/UnitLoader.cpp
@@ -315,8 +315,8 @@ void CUnitLoader::GiveUnits(const std::vector<std::string>& args, int team)
}
if (objectName == "all") {
- unsigned int numRequestedUnits = unitDefHandler->unitDefs.size() - 1; /// defid=0 is not valid
- unsigned int currentNumUnits = teamHandler->Team(team)->units.size();
+ int numRequestedUnits = unitDefHandler->unitDefs.size() - 1; /// defid=0 is not valid
+ int currentNumUnits = teamHandler->Team(team)->units.size();
// make sure team unit-limit is not exceeded
if ((currentNumUnits + numRequestedUnits) > uh->MaxUnitsPerTeam()) {
@@ -345,14 +345,11 @@ void CUnitLoader::GiveUnits(const std::vector<std::string>& args, int team)
}
}
} else {
- unsigned int numRequestedUnits = amount;
- unsigned int currentNumUnits = teamHandler->Team(team)->units.size();
+ int numRequestedUnits = amount;
+ int currentNumUnits = teamHandler->Team(team)->units.size();
if (currentNumUnits >= uh->MaxUnitsPerTeam()) {
- logOutput.Print(
- "[%s] unable to give more units to team %d (current: %u, team limit: %u, global limit: %u)",
- __FUNCTION__, team, currentNumUnits, uh->MaxUnitsPerTeam(), uh->MaxUnits()
- );
+ logOutput.Print("[%s] unable to give more units to team %d (current: %d, max: %d)", __FUNCTION__, team, currentNumUnits, uh->MaxUnits());
return;
}
diff --git a/rts/Sim/Units/UnitTypes/TransportUnit.cpp b/rts/Sim/Units/UnitTypes/TransportUnit.cpp
index 72faaa3..470d6f9 100644
--- a/rts/Sim/Units/UnitTypes/TransportUnit.cpp
+++ b/rts/Sim/Units/UnitTypes/TransportUnit.cpp
@@ -77,19 +77,16 @@ void CTransportUnit::Update()
if (unitDef->holdSteady) {
// slave transportee orientation to piece
if (ti->piece >= 0) {
- const CMatrix44f& transMat = GetTransformMatrix(true);
const CMatrix44f& pieceMat = script->GetPieceMatrix(ti->piece);
- const CMatrix44f slaveMat = transMat.Mul(pieceMat);
-
- SyncedFloat3& xdir = transportee->rightdir;
- SyncedFloat3& ydir = transportee->updir;
- SyncedFloat3& zdir = transportee->frontdir;
-
- zdir.x = slaveMat[8]; zdir.y = slaveMat[9]; zdir.z = slaveMat[10];
- xdir.x = slaveMat[0]; xdir.y = slaveMat[1]; xdir.z = slaveMat[ 2];
- ydir.x = slaveMat[4]; ydir.y = slaveMat[5]; ydir.z = slaveMat[ 6];
-
- transportee->heading = GetHeadingFromVector(zdir.x, zdir.z);
+ const float3 pieceDir =
+ frontdir * pieceMat[10] +
+ updir * pieceMat[ 6] +
+ rightdir * pieceMat[ 2];
+
+ transportee->heading = GetHeadingFromVector(pieceDir.x, pieceDir.z);
+ transportee->frontdir = pieceDir;
+ transportee->rightdir = transportee->frontdir.cross(UpVector);
+ transportee->updir = transportee->rightdir.cross(transportee->frontdir);
}
} else {
// slave transportee orientation to body
diff --git a/rts/Sim/Weapons/Weapon.cpp b/rts/Sim/Weapons/Weapon.cpp
index bc60b64..aa7bf15 100644
--- a/rts/Sim/Weapons/Weapon.cpp
+++ b/rts/Sim/Weapons/Weapon.cpp
@@ -474,7 +474,7 @@ bool CWeapon::AttackGround(float3 pos, bool userTarget)
return false;
if (targetUnit) {
DeleteDeathDependence(targetUnit);
- targetUnit = NULL;
+ targetUnit=0;
}
haveUserTarget = userTarget;
@@ -531,7 +531,7 @@ bool CWeapon::AttackUnit(CUnit* unit, bool userTarget)
if (targetUnit) {
DeleteDeathDependence(targetUnit);
- targetUnit = NULL;
+ targetUnit = 0;
}
haveUserTarget = userTarget;
@@ -549,7 +549,7 @@ void CWeapon::HoldFire()
{
if (targetUnit) {
DeleteDeathDependence(targetUnit);
- targetUnit = NULL;
+ targetUnit = 0;
}
targetType = Target_None;
haveUserTarget = false;
@@ -668,7 +668,7 @@ void CWeapon::SlowUpdate(bool noAutoTargetOverride)
// use targets from the thing we are slaved to
if (targetUnit) {
DeleteDeathDependence(targetUnit);
- targetUnit = NULL;
+ targetUnit = 0;
}
targetType = Target_None;
@@ -698,34 +698,22 @@ void CWeapon::SlowUpdate(bool noAutoTargetOverride)
lastTargetRetry = gs->frameNum;
std::multimap<float, CUnit*> targets;
- std::multimap<float, CUnit*>::const_iterator nextTargetIt;
- std::multimap<float, CUnit*>::const_iterator lastTargetIt;
-
helper->GenerateWeaponTargets(this, targetUnit, targets);
- if (!targets.empty())
- lastTargetIt = --targets.end();
+ for (std::multimap<float, CUnit*>::const_iterator ti = targets.begin(); ti != targets.end(); ++ti) {
+ CUnit* nextTarget = ti->second;
- for (nextTargetIt = targets.begin(); nextTargetIt != targets.end(); ++nextTargetIt) {
- CUnit* nextTargetUnit = nextTargetIt->second;
-
- if (nextTargetUnit->neutral && (owner->fireState <= FIRESTATE_FIREATWILL)) {
+ if (nextTarget->neutral && (owner->fireState <= FIRESTATE_FIREATWILL)) {
continue;
}
-
- // when only one target is available, <nextTarget> can equal <targetUnit>
- // and we want to attack whether it is in our bad target category or not
- // (if only bad targets are available and this is the last, just pick it)
- if (nextTargetUnit != targetUnit && (nextTargetUnit->category & badTargetCategory)) {
- if (nextTargetIt != lastTargetIt) {
- continue;
- }
+ if (targetUnit && (nextTarget->category & badTargetCategory)) {
+ continue;
}
- const float weaponLead = weaponDef->targetMoveError * GAME_SPEED * nextTargetUnit->speed.Length();
+ const float weaponLead = weaponDef->targetMoveError * GAME_SPEED * nextTarget->speed.Length();
const float weaponError = weaponLead * (1.0f - owner->limExperience);
- float3 nextTargetPos = nextTargetUnit->midPos + (errorVector * weaponError);
+ float3 nextTargetPos = nextTarget->midPos + (errorVector * weaponError);
const float appHeight = ground->GetApproximateHeight(nextTargetPos.x, nextTargetPos.z) + 2.0f;
@@ -733,13 +721,13 @@ void CWeapon::SlowUpdate(bool noAutoTargetOverride)
nextTargetPos.y = appHeight;
}
- if (TryTarget(nextTargetPos, false, nextTargetUnit)) {
+ if (TryTarget(nextTargetPos, false, nextTarget)) {
if (targetUnit) {
DeleteDeathDependence(targetUnit);
}
targetType = Target_Unit;
- targetUnit = nextTargetUnit;
+ targetUnit = nextTarget;
targetPos = nextTargetPos;
AddDeathDependence(targetUnit);
@@ -755,7 +743,7 @@ void CWeapon::SlowUpdate(bool noAutoTargetOverride)
}
} else {
// if we can't target anything, try switching aim point
- if (useWeaponPosForAim == 1) {
+ if (useWeaponPosForAim && (useWeaponPosForAim == 1)) {
useWeaponPosForAim = 0;
} else {
useWeaponPosForAim = 1;
Relationships