wagic

ActionElement.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

ActionLayer.cpp

At Z's request, fixed Issue 184, ExtraCost types with targets such as Siege-Gang Commander/Drowner of secrets combined with targeted abilities bug.

2010-12-06 06:49:36 +00:00

ActionStack.cpp

added abilities=split second

2011-02-03 00:04:11 +00:00

AIMomirPlayer.cpp

Erwan

2011-02-12 16:31:07 +00:00

AIPlayer.cpp

reverted latest change

2011-02-14 09:35:43 +00:00

AIStats.cpp

- Moved the card collection out of the GameApp class to clean up the dependencies

2011-02-06 11:35:40 +00:00

AllAbilities.cpp

Erwan

2011-02-13 08:01:13 +00:00

CardDescriptor.cpp

added

2011-02-02 18:22:08 +00:00

CardDisplay.cpp

Fixed a crash occuring when trying to select card with the mouse in an empty list

2010-12-02 20:35:42 +00:00

CardEffect.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

CardGui.cpp

Resuming on my threading support work with the card caching mechanism. This change unfortunately touches quite a few files, but I needed to get it out of the way before things got out of hand: one significant hurdle is the assumed lifetime of a JQuad pointer. In a single threaded model, the life time of the pointer is clear: you fetch it into the cache, the cache makes room, you use the pointer immediately. In a multithreaded context however, it's unsafe, as the drawing thread can request a few JQuads, and the cache operating on a separate thread can potentially bounce a JQuad out of the cache before the draw routine is done using it, which ends up in an access violation when you attempt to draw using an invalidated quad pointer. To prevent this, the bulk of this change swaps out the use of naked JQuad* pointers in the code with a JQuadPtr, which is basically a typedef to a boost shared_ptr<JQuad>.

2011-02-01 10:37:21 +00:00

CardPrimitive.cpp

more fixes to the review

2011-01-22 17:14:41 +00:00

CardSelector.cpp

Revert changes to CardSelector. This wasn't meant to be part of my previous check in, another case of AnkhSVN selecting a file automatically for submission when it was in a different changelist. Sorry!

2010-12-18 03:47:52 +00:00

CardSelectorSingleton.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

Closest.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

Counters.cpp

bug fixs, added colon to "damage" parsing so we can finally not worry about "damage" wanting to build a ability. it now has to look for "damage:" which makes it more consistent with how we made the other abilities. did the same with lifeset however no bug there.

2010-12-04 12:32:33 +00:00

Credits.cpp

- Moved the card collection out of the GameApp class to clean up the dependencies

2011-02-06 11:35:40 +00:00

Damage.cpp

added

2011-02-02 18:22:08 +00:00

DamagerDamaged.cpp

Another change that looks bigger than it is: changed out the global extern WResourceManager to a real singleton. This means that it's no longer being init'ed at static initialization time, and we can debug construction/destruction properly; it's also safer in a multithreaded context.

2010-12-01 08:22:17 +00:00

DeckDataWrapper.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

DeckEditorMenu.cpp

moved the translator init code earlier; added some translation support for the code of r2517 and r2907; updated some Chinese translation.

2011-01-31 14:21:46 +00:00

DeckManager.cpp

reimplemented mana color display for deck selection. This is now totally controlled by

2011-02-10 17:19:11 +00:00

DeckMenu.cpp

reimplemented mana color display for deck selection. This is now totally controlled by

2011-02-10 17:19:11 +00:00

DeckMenuItem.cpp

Resuming on my threading support work with the card caching mechanism. This change unfortunately touches quite a few files, but I needed to get it out of the way before things got out of hand: one significant hurdle is the assumed lifetime of a JQuad pointer. In a single threaded model, the life time of the pointer is clear: you fetch it into the cache, the cache makes room, you use the pointer immediately. In a multithreaded context however, it's unsafe, as the drawing thread can request a few JQuads, and the cache operating on a separate thread can potentially bounce a JQuad out of the cache before the draw routine is done using it, which ends up in an access violation when you attempt to draw using an invalidated quad pointer. To prevent this, the bulk of this change swaps out the use of naked JQuad* pointers in the code with a JQuadPtr, which is basically a typedef to a boost shared_ptr<JQuad>.

2011-02-01 10:37:21 +00:00

DeckMetaData.cpp

reverted latest change

2011-02-14 09:35:43 +00:00

DeckStats.cpp

reimplemented mana color display for deck selection. This is now totally controlled by

2011-02-10 17:19:11 +00:00

DuelLayers.cpp

fix and completely reworked affinity AGAIN.

2011-02-12 15:06:28 +00:00

Effects.cpp

J :

2009-06-15 01:01:57 +00:00

ExtraCost.cpp

Erwan

2011-01-23 06:59:00 +00:00

GameApp.cpp

- Moved the card collection out of the GameApp class to clean up the dependencies

2011-02-06 11:35:40 +00:00

GameLauncher.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

GameObserver.cpp

Erwan

2011-02-13 11:23:51 +00:00

GameOptions.cpp

- Moved the card collection out of the GameApp class to clean up the dependencies

2011-02-06 11:35:40 +00:00

GameState.cpp

* Added new options parameter. "SaveDetailedDeckInfo". This will force the system to save all

2011-01-31 10:04:18 +00:00

GameStateAwards.cpp

- Moved the card collection out of the GameApp class to clean up the dependencies

2011-02-06 11:35:40 +00:00

GameStateDeckViewer.cpp

added empty string check when save and quiting from the deck editor.

2011-02-08 06:30:18 +00:00

GameStateDuel.cpp

reimplemented mana color display for deck selection. This is now totally controlled by

2011-02-10 17:19:11 +00:00

GameStateMenu.cpp

Erwan

2011-02-12 16:31:07 +00:00

GameStateOptions.cpp

im forced to do this commit in whole instead of parts as originally planned, and before my beta test period of the changes is complete BECAUSE there are people doing "clean up" and the MASSIVE amount of conflicts i have to resolve from it is WAY too much for me to take on after nearly 200 hours of coding this patch. i cant seem to get enough respect to have people hold off on "clean up" so this brings me to being forced to do a full commit before playtest period is done, so they can go ahead with there *super important* clean up.

2011-01-21 20:18:56 +00:00

GameStateShop.cpp

- Moved the card collection out of the GameApp class to clean up the dependencies

2011-02-06 11:35:40 +00:00

GameStateStory.cpp

Added a debug helper override class for ifstream - this normally washes out to std::ifstream. If #define TRACK_FILE_USAGE_STATS is enabled, it derives from ifstream, but additionally tracks each time we create an instance for a given file name & counts each hit in a map, and dump the statistics on shutdown. This is to help track how often we open up certain files, since i/o is costly on the psp.

2011-01-11 10:11:15 +00:00

GameStateTransitions.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

GuiAvatars.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

GuiBackground.cpp

Resuming on my threading support work with the card caching mechanism. This change unfortunately touches quite a few files, but I needed to get it out of the way before things got out of hand: one significant hurdle is the assumed lifetime of a JQuad pointer. In a single threaded model, the life time of the pointer is clear: you fetch it into the cache, the cache makes room, you use the pointer immediately. In a multithreaded context however, it's unsafe, as the drawing thread can request a few JQuads, and the cache operating on a separate thread can potentially bounce a JQuad out of the cache before the draw routine is done using it, which ends up in an access violation when you attempt to draw using an invalidated quad pointer. To prevent this, the bulk of this change swaps out the use of naked JQuad* pointers in the code with a JQuadPtr, which is basically a typedef to a boost shared_ptr<JQuad>.

2011-02-01 10:37:21 +00:00

GuiCardsController.cpp

Enabled precompiled headers for the build. This cuts the win compile time in debug by at least half on my laptop; on the psp compile, it shaves it down by ~ 45 seconds. I only did a cursory inspection of what to add to PrecompiledHeader.h, there's probably more that we can throw in there for more incremental speed improvements.

2010-10-24 05:55:24 +00:00

GuiCombat.cpp

Resuming on my threading support work with the card caching mechanism. This change unfortunately touches quite a few files, but I needed to get it out of the way before things got out of hand: one significant hurdle is the assumed lifetime of a JQuad pointer. In a single threaded model, the life time of the pointer is clear: you fetch it into the cache, the cache makes room, you use the pointer immediately. In a multithreaded context however, it's unsafe, as the drawing thread can request a few JQuads, and the cache operating on a separate thread can potentially bounce a JQuad out of the cache before the draw routine is done using it, which ends up in an access violation when you attempt to draw using an invalidated quad pointer. To prevent this, the bulk of this change swaps out the use of naked JQuad* pointers in the code with a JQuadPtr, which is basically a typedef to a boost shared_ptr<JQuad>.

2011-02-01 10:37:21 +00:00

GuiFrame.cpp

Resuming on my threading support work with the card caching mechanism. This change unfortunately touches quite a few files, but I needed to get it out of the way before things got out of hand: one significant hurdle is the assumed lifetime of a JQuad pointer. In a single threaded model, the life time of the pointer is clear: you fetch it into the cache, the cache makes room, you use the pointer immediately. In a multithreaded context however, it's unsafe, as the drawing thread can request a few JQuads, and the cache operating on a separate thread can potentially bounce a JQuad out of the cache before the draw routine is done using it, which ends up in an access violation when you attempt to draw using an invalidated quad pointer. To prevent this, the bulk of this change swaps out the use of naked JQuad* pointers in the code with a JQuadPtr, which is basically a typedef to a boost shared_ptr<JQuad>.

2011-02-01 10:37:21 +00:00

GuiHand.cpp

Resuming on my threading support work with the card caching mechanism. This change unfortunately touches quite a few files, but I needed to get it out of the way before things got out of hand: one significant hurdle is the assumed lifetime of a JQuad pointer. In a single threaded model, the life time of the pointer is clear: you fetch it into the cache, the cache makes room, you use the pointer immediately. In a multithreaded context however, it's unsafe, as the drawing thread can request a few JQuads, and the cache operating on a separate thread can potentially bounce a JQuad out of the cache before the draw routine is done using it, which ends up in an access violation when you attempt to draw using an invalidated quad pointer. To prevent this, the bulk of this change swaps out the use of naked JQuad* pointers in the code with a JQuadPtr, which is basically a typedef to a boost shared_ptr<JQuad>.

2011-02-01 10:37:21 +00:00

GuiLayers.cpp

Additional fix to go along with r2834 - the previous fix revealed an ugly interdependency between CardView and MTGCardInstance. Neither object owns the other, but they each have a pointer reference to each other, which is a recipe for disaster if not managed correctly. I had fixed half of the problem, where the status of a CardView being destroyed wasn't reflected in the MTGCardInstance; meanwhile, it introduced another problem where if the MTGCardInstance was destroyed first, the CardView would crash when trying to do the cleanup.

2010-12-16 21:17:18 +00:00

GuiMana.cpp

Resuming on my threading support work with the card caching mechanism. This change unfortunately touches quite a few files, but I needed to get it out of the way before things got out of hand: one significant hurdle is the assumed lifetime of a JQuad pointer. In a single threaded model, the life time of the pointer is clear: you fetch it into the cache, the cache makes room, you use the pointer immediately. In a multithreaded context however, it's unsafe, as the drawing thread can request a few JQuads, and the cache operating on a separate thread can potentially bounce a JQuad out of the cache before the draw routine is done using it, which ends up in an access violation when you attempt to draw using an invalidated quad pointer. To prevent this, the bulk of this change swaps out the use of naked JQuad* pointers in the code with a JQuadPtr, which is basically a typedef to a boost shared_ptr<JQuad>.

2011-02-01 10:37:21 +00:00

GuiMessageBox.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

GuiPhaseBar.cpp

Resuming on my threading support work with the card caching mechanism. This change unfortunately touches quite a few files, but I needed to get it out of the way before things got out of hand: one significant hurdle is the assumed lifetime of a JQuad pointer. In a single threaded model, the life time of the pointer is clear: you fetch it into the cache, the cache makes room, you use the pointer immediately. In a multithreaded context however, it's unsafe, as the drawing thread can request a few JQuads, and the cache operating on a separate thread can potentially bounce a JQuad out of the cache before the draw routine is done using it, which ends up in an access violation when you attempt to draw using an invalidated quad pointer. To prevent this, the bulk of this change swaps out the use of naked JQuad* pointers in the code with a JQuadPtr, which is basically a typedef to a boost shared_ptr<JQuad>.

2011-02-01 10:37:21 +00:00

GuiPlay.cpp

Refactored Z's last change slightly, eliminated code duplication.

2011-02-05 21:30:28 +00:00

GuiStatic.cpp

Resuming on my threading support work with the card caching mechanism. This change unfortunately touches quite a few files, but I needed to get it out of the way before things got out of hand: one significant hurdle is the assumed lifetime of a JQuad pointer. In a single threaded model, the life time of the pointer is clear: you fetch it into the cache, the cache makes room, you use the pointer immediately. In a multithreaded context however, it's unsafe, as the drawing thread can request a few JQuads, and the cache operating on a separate thread can potentially bounce a JQuad out of the cache before the draw routine is done using it, which ends up in an access violation when you attempt to draw using an invalidated quad pointer. To prevent this, the bulk of this change swaps out the use of naked JQuad* pointers in the code with a JQuadPtr, which is basically a typedef to a boost shared_ptr<JQuad>.

2011-02-01 10:37:21 +00:00

ManaCost.cpp

fixed a mem leak I introduced in last update

2011-02-10 00:18:52 +00:00

ManaCostHybrid.cpp

updated ManaCost copy constructor to do a true deep copy.

2011-02-09 20:42:19 +00:00

MenuItem.cpp

Another change that looks bigger than it is: changed out the global extern WResourceManager to a real singleton. This means that it's no longer being init'ed at static initialization time, and we can debug construction/destruction properly; it's also safer in a multithreaded context.

2010-12-01 08:22:17 +00:00

MTGAbility.cpp

Erwan

2011-02-13 11:23:51 +00:00

MTGardInstance.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

MTGCard.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

MTGCardInstance.cpp

i subjected poor changelings to planeswalker legend rule lol.

2011-02-07 15:37:21 +00:00

MTGDeck.cpp

reverted latest change

2011-02-14 09:35:43 +00:00

MTGDefinitions.cpp

Erwan

2011-02-13 11:23:51 +00:00

MTGGamePhase.cpp

Forcing LF as the line ending style through SVN properties. No actual code changes here.

2011-01-28 06:00:51 +00:00

MTGGameZones.cpp

reverted latest change

2011-02-14 09:35:43 +00:00

MTGPack.cpp

- Moved the card collection out of the GameApp class to clean up the dependencies

2011-02-06 11:35:40 +00:00

MTGRules.cpp

Erwan

2011-02-13 11:23:51 +00:00

MTGSpellStack.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

Navigator.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

OptionItem.cpp

- Moved the card collection out of the GameApp class to clean up the dependencies

2011-02-06 11:35:40 +00:00

PhaseRing.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

Player.cpp

Erwan

2011-02-13 11:23:51 +00:00

PlayerData.cpp

Added a debug helper override class for ifstream - this normally washes out to std::ifstream. If #define TRACK_FILE_USAGE_STATS is enabled, it derives from ifstream, but additionally tracks each time we create an instance for a given file name & counts each hit in a map, and dump the statistics on shutdown. This is to help track how often we open up certain files, since i/o is costly on the psp.

2011-01-11 10:11:15 +00:00

PlayGuiObject.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

PlayGuiObjectController.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

PlayRestrictions.cpp

Erwan

2011-02-12 16:31:07 +00:00

Pos.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

PrecompiledHeader.cpp

Added newline to end-of-file

2011-01-08 12:24:39 +00:00

PriceList.cpp

Added a debug helper override class for ifstream - this normally washes out to std::ifstream. If #define TRACK_FILE_USAGE_STATS is enabled, it derives from ifstream, but additionally tracks each time we create an instance for a given file name & counts each hit in a map, and dump the statistics on shutdown. This is to help track how often we open up certain files, since i/o is costly on the psp.

2011-01-11 10:11:15 +00:00

ReplacementEffects.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

Rules.cpp

yeah im stupid

2011-02-06 15:22:15 +00:00

SimpleMenu.cpp

Resuming on my threading support work with the card caching mechanism. This change unfortunately touches quite a few files, but I needed to get it out of the way before things got out of hand: one significant hurdle is the assumed lifetime of a JQuad pointer. In a single threaded model, the life time of the pointer is clear: you fetch it into the cache, the cache makes room, you use the pointer immediately. In a multithreaded context however, it's unsafe, as the drawing thread can request a few JQuads, and the cache operating on a separate thread can potentially bounce a JQuad out of the cache before the draw routine is done using it, which ends up in an access violation when you attempt to draw using an invalidated quad pointer. To prevent this, the bulk of this change swaps out the use of naked JQuad* pointers in the code with a JQuadPtr, which is basically a typedef to a boost shared_ptr<JQuad>.

2011-02-01 10:37:21 +00:00

SimpleMenuItem.cpp

Another change that looks bigger than it is: changed out the global extern WResourceManager to a real singleton. This means that it's no longer being init'ed at static initialization time, and we can debug construction/destruction properly; it's also safer in a multithreaded context.

2010-12-01 08:22:17 +00:00

SimplePad.cpp

Another change that looks bigger than it is: changed out the global extern WResourceManager to a real singleton. This means that it's no longer being init'ed at static initialization time, and we can debug construction/destruction properly; it's also safer in a multithreaded context.

2010-12-01 08:22:17 +00:00

SimplePopup.cpp

Resuming on my threading support work with the card caching mechanism. This change unfortunately touches quite a few files, but I needed to get it out of the way before things got out of hand: one significant hurdle is the assumed lifetime of a JQuad pointer. In a single threaded model, the life time of the pointer is clear: you fetch it into the cache, the cache makes room, you use the pointer immediately. In a multithreaded context however, it's unsafe, as the drawing thread can request a few JQuads, and the cache operating on a separate thread can potentially bounce a JQuad out of the cache before the draw routine is done using it, which ends up in an access violation when you attempt to draw using an invalidated quad pointer. To prevent this, the bulk of this change swaps out the use of naked JQuad* pointers in the code with a JQuadPtr, which is basically a typedef to a boost shared_ptr<JQuad>.

2011-02-01 10:37:21 +00:00

StoryFlow.cpp

- Moved the card collection out of the GameApp class to clean up the dependencies

2011-02-06 11:35:40 +00:00

StyleManager.cpp

- Moved the card collection out of the GameApp class to clean up the dependencies

2011-02-06 11:35:40 +00:00

Subtypes.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

TargetChooser.cpp

combined nbzone increment and zone assignment into one statement.

2011-02-13 13:25:41 +00:00

TargetsList.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

Tasks.cpp

Added a debug helper override class for ifstream - this normally washes out to std::ifstream. If #define TRACK_FILE_USAGE_STATS is enabled, it derives from ifstream, but additionally tracks each time we create an instance for a given file name & counts each hit in a map, and dump the statistics on shutdown. This is to help track how often we open up certain files, since i/o is costly on the psp.

2011-01-11 10:11:15 +00:00

testfeatures.c

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

TestSuiteAI.cpp

Erwan

2011-02-12 16:31:07 +00:00

TextScroller.cpp

Added newline to end-of-file

2011-01-08 12:24:39 +00:00

ThisDescriptor.cpp

added

2011-02-02 18:22:08 +00:00

Token.cpp

im forced to do this commit in whole instead of parts as originally planned, and before my beta test period of the changes is complete BECAUSE there are people doing "clean up" and the MASSIVE amount of conflicts i have to resolve from it is WAY too much for me to take on after nearly 200 hours of coding this patch. i cant seem to get enough respect to have people hold off on "clean up" so this brings me to being forced to do a full commit before playtest period is done, so they can go ahead with there *super important* clean up.

2011-01-21 20:18:56 +00:00

Translate.cpp

Added a debug helper override class for ifstream - this normally washes out to std::ifstream. If #define TRACK_FILE_USAGE_STATS is enabled, it derives from ifstream, but additionally tracks each time we create an instance for a given file name & counts each hit in a map, and dump the statistics on shutdown. This is to help track how often we open up certain files, since i/o is costly on the psp.

2011-01-11 10:11:15 +00:00

TranslateKeys.cpp

Resuming on my threading support work with the card caching mechanism. This change unfortunately touches quite a few files, but I needed to get it out of the way before things got out of hand: one significant hurdle is the assumed lifetime of a JQuad pointer. In a single threaded model, the life time of the pointer is clear: you fetch it into the cache, the cache makes room, you use the pointer immediately. In a multithreaded context however, it's unsafe, as the drawing thread can request a few JQuads, and the cache operating on a separate thread can potentially bounce a JQuad out of the cache before the draw routine is done using it, which ends up in an access violation when you attempt to draw using an invalidated quad pointer. To prevent this, the bulk of this change swaps out the use of naked JQuad* pointers in the code with a JQuadPtr, which is basically a typedef to a boost shared_ptr<JQuad>.

2011-02-01 10:37:21 +00:00

Trash.cpp

reformatting code according to guidelines defined at

2010-11-16 00:55:16 +00:00

utils.cpp

A simpler way to allow trim() to work with temporary strings.

2011-02-05 06:42:53 +00:00

WCachedResource.cpp

Resuming on my threading support work with the card caching mechanism. This change unfortunately touches quite a few files, but I needed to get it out of the way before things got out of hand: one significant hurdle is the assumed lifetime of a JQuad pointer. In a single threaded model, the life time of the pointer is clear: you fetch it into the cache, the cache makes room, you use the pointer immediately. In a multithreaded context however, it's unsafe, as the drawing thread can request a few JQuads, and the cache operating on a separate thread can potentially bounce a JQuad out of the cache before the draw routine is done using it, which ends up in an access violation when you attempt to draw using an invalidated quad pointer. To prevent this, the bulk of this change swaps out the use of naked JQuad* pointers in the code with a JQuadPtr, which is basically a typedef to a boost shared_ptr<JQuad>.

2011-02-01 10:37:21 +00:00

WDataSrc.cpp

- Moved the card collection out of the GameApp class to clean up the dependencies

2011-02-06 11:35:40 +00:00

WEvent.cpp

3 things here, found my targets returns for @vampired we're screwy, which explained why doc didnt add 3 of the possible cards for it...corrected that but i need to rename the varibles which i will do at a later time, not in this patch..

2011-02-03 14:17:25 +00:00

WFilter.cpp

altered condition to srcLenth -1 and not "srcLength - 2"

2011-02-14 06:54:28 +00:00

WFont.cpp

Resuming on my threading support work with the card caching mechanism. This change unfortunately touches quite a few files, but I needed to get it out of the way before things got out of hand: one significant hurdle is the assumed lifetime of a JQuad pointer. In a single threaded model, the life time of the pointer is clear: you fetch it into the cache, the cache makes room, you use the pointer immediately. In a multithreaded context however, it's unsafe, as the drawing thread can request a few JQuads, and the cache operating on a separate thread can potentially bounce a JQuad out of the cache before the draw routine is done using it, which ends up in an access violation when you attempt to draw using an invalidated quad pointer. To prevent this, the bulk of this change swaps out the use of naked JQuad* pointers in the code with a JQuadPtr, which is basically a typedef to a boost shared_ptr<JQuad>.

2011-02-01 10:37:21 +00:00

WGui.cpp

Resuming on my threading support work with the card caching mechanism. This change unfortunately touches quite a few files, but I needed to get it out of the way before things got out of hand: one significant hurdle is the assumed lifetime of a JQuad pointer. In a single threaded model, the life time of the pointer is clear: you fetch it into the cache, the cache makes room, you use the pointer immediately. In a multithreaded context however, it's unsafe, as the drawing thread can request a few JQuads, and the cache operating on a separate thread can potentially bounce a JQuad out of the cache before the draw routine is done using it, which ends up in an access violation when you attempt to draw using an invalidated quad pointer. To prevent this, the bulk of this change swaps out the use of naked JQuad* pointers in the code with a JQuadPtr, which is basically a typedef to a boost shared_ptr<JQuad>.

2011-02-01 10:37:21 +00:00

WResourceManager.cpp

Resuming on my threading support work with the card caching mechanism. This change unfortunately touches quite a few files, but I needed to get it out of the way before things got out of hand: one significant hurdle is the assumed lifetime of a JQuad pointer. In a single threaded model, the life time of the pointer is clear: you fetch it into the cache, the cache makes room, you use the pointer immediately. In a multithreaded context however, it's unsafe, as the drawing thread can request a few JQuads, and the cache operating on a separate thread can potentially bounce a JQuad out of the cache before the draw routine is done using it, which ends up in an access violation when you attempt to draw using an invalidated quad pointer. To prevent this, the bulk of this change swaps out the use of naked JQuad* pointers in the code with a JQuadPtr, which is basically a typedef to a boost shared_ptr<JQuad>.

2011-02-01 10:37:21 +00:00