Backups/GTASource
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c971d568a112e5bec2e45ab389375b07c6914a6e
GTASource/game/frontend/MiniMapRenderThread.cpp
expvintl 419f2e4752 init
2025-02-23 17:40:52 +08:00

8605 lines
277 KiB
C++
Raw Blame History

#include "MiniMapRenderThread.h"
// rage:
#include "grcore/allocscope.h"
#include "grcore/quads.h"
#include "scaleform/scaleform.h"
#include "grcore/light.h"
#if DEVICE_EQAA
#include "grcore/fastquad.h"
#endif
// framework:
#include "fwsys/gameskeleton.h"
#include "fwsys/timer.h"
#include "fwmaths/Rect.h"
// game:
#include "camera/viewports/Viewport.h"
#include "Control/gps.h"
#include "debug/DebugScene.h"
#include "frontend/CMapMenu.h"
#include "frontend/ui_channel.h"
#include "frontend/Map/BlipEnums.h"
#include "frontend/Scaleform/ScaleformMgr.h"
#include "Network/Live/livemanager.h"
#include "profile/group.h"
#include "renderer/postprocessFX.h"
#include "renderer/rendertargets.h"
#include "renderer/sprite2d.h"
#include "scene/world/GameWorldHeightMap.h"
#include "script/script.h"
#include "script/script_hud.h"
#include "system/companion.h"
#include "text/TextConversion.h"
#include "timecycle/TimeCycleConfig.h"
RAGE_DEFINE_CHANNEL(supertile)
#define supertileAssertf(cond,fmt,...) RAGE_ASSERTF(supertile,cond,fmt,##__VA_ARGS__)
#define supertileVerifyf(cond,fmt,...) RAGE_VERIFYF(supertile,cond,fmt,##__VA_ARGS__)
#define supertileWarningf(fmt,...) RAGE_WARNINGF(supertile,fmt,##__VA_ARGS__)
#define supertileDisplayf(fmt,...) RAGE_DISPLAYF(supertile,fmt,##__VA_ARGS__)
#define supertileDebugf1(fmt,...) RAGE_DEBUGF1(supertile,fmt,##__VA_ARGS__)
#define supertileDebugf2(fmt,...) RAGE_DEBUGF2(supertile,fmt,##__VA_ARGS__)
#define supertileDebugf3(fmt,...) RAGE_DEBUGF3(supertile,fmt,##__VA_ARGS__)
#define BLIP_LAYER_PATH "_level0.asRootContainer.asBlipLayerContainer.asBlipContainer.blipLayer"
#define MINIMAP_INITIAL_SCALE (533.333333333333f)
#define MINIMAP_TILE_WIDTH (MINIMAP_WORLD_SIZE_X / MINIMAP_WORLD_TILE_SIZE_X)
#define MINIMAP_TILE_HEIGHT (MINIMAP_WORLD_SIZE_Y / MINIMAP_WORLD_TILE_SIZE_Y)
#define DISABLE_HUD_FOR_CONTENT_CONTROLLED_BUILD 0
#define __DEBUG_SUPERTILES (0) // slightly optimises the supertiles
//
// we move the content of the bigmap internally so that the movie doesnt need to be moved off the edge of the screen to align with the minimap
//
#define __BIGMAP_INTERNAL_ADJUSTMENT_BLIP_RANGE (0.18f) // blip range offset
#define __BIGMAP_INTERNAL_ADJUSTMENT_CONTAINERS (34.0f) // amount to move the containers
#if DEBUG_DRAW && __BANK
// because these are processed on subrender threads, we have to queue them up to the UT... to then queue back onto the RT
struct debugVolume
{
debugVolume() : bCollides(false), type(DVVT_Sphere) {};
debugVolume(const spdSphere& sphere, Color32 color, bool bCollides_ = false) : asSphere(sphere), bCollides(bCollides_), objColor(color), type(DVVT_Sphere) {};
debugVolume(const spdOrientedBB& BB, Color32 color, bool bCollides_ = false) : asBB(BB), bCollides(bCollides_), objColor(color), type(DVVT_OBB) {};
debugVolume(Vec3V_In pt1, Vec3V_In pt2, Color32 color, Color32 color2, bool bCollides_ = false) : asLinePoint1(pt1), asLinePoint2(pt2), bCollides(bCollides_), objColor(color), objColor2(color2), type(DVVT_Line) {};
debugVolume& operator=(const debugVolume& b)
{
type = b.type;
objColor = b.objColor;
objColor2 = b.objColor2;
bCollides = b.bCollides;
switch(type)
{
case DVVT_Sphere:
asSphere = b.asSphere;
break;
case DVVT_OBB:
asBB = b.asBB;
break;
case DVVT_Line:
asLinePoint1 = b.asLinePoint1;
asLinePoint2 = b.asLinePoint2;
break;
}
return *this;
}
enum volType {
DVVT_Sphere,
DVVT_OBB,
DVVT_Line
};
volType type;
// union { // durango's being a jerk about this. So we'll get object bloat
spdSphere asSphere;
spdOrientedBB asBB;
Vec3V asLinePoint1;
Vec3V asLinePoint2;
// };
Color32 objColor;
Color32 objColor2;
bool bCollides;
};
static CDblBuf<atArray<debugVolume>> s_DebugDrawVolumes;
bool CMiniMap_RenderThread::sm_bDrawCollisionVolumes;
void CMiniMap_RenderThread::RenderDebugVolumesOnUT()
{
if(!sm_bDrawCollisionVolumes)
return;
for( int i=0; i < s_DebugDrawVolumes.GetUpdateBuf().GetCount(); ++i )
{
debugVolume& vol = s_DebugDrawVolumes.GetUpdateBuf()[i];
switch(vol.type)
{
case debugVolume::DVVT_OBB:
{
Mat34V mat(vol.asBB.m_localToWorld);
grcDebugDraw::BoxOriented(vol.asBB.m_localBox.GetMin(), vol.asBB.m_localBox.GetMax(), mat, vol.objColor, vol.bCollides);
break;
}
case debugVolume::DVVT_Line:
grcDebugDraw::Line(vol.asLinePoint1, vol.asLinePoint2, vol.objColor, vol.objColor2);
break;
case debugVolume::DVVT_Sphere:
grcDebugDraw::Sphere(vol.asSphere.GetCenter(), vol.asSphere.GetRadiusf(), vol.objColor, vol.bCollides, 1,24);
break;
}
}
s_DebugDrawVolumes.GetUpdateBuf().Reset();
}
#endif // DEBUG_DRAW && BANK
//
// depth settings on movies:
//
enum
{
MOVIE_DEPTH_ROOT_CONTAINER = 1,
MOVIE_DEPTH_ROOT_BLIP_CONTAINER,
MOVIE_DEPTH_MAP,
MOVIE_DEPTH_FREEWAY,
MOVIE_DEPTH_INTERIOR,
MOVIE_DEPTH_GOLF_COURSE,
MOVIE_DEPTH_BITMAP,
MOVIE_DEPTH_TILES,
MOVIE_DEPTH_TERRITORY,
MOVIE_DEPTH_RADIUS,
MOVIE_DEPTH_STEALTH,
MOVIE_DEPTH_ALTIMETER_DISPLAY,
MOVIE_DEPTH_RUNWAY,
MOVIE_DEPTH_GPS,
MOVIE_DEPTH_MASK = MOVIE_DEPTH_GPS+GPS_NUM_SLOTS, // allow a gap here for the slots
MOVIE_DEPTH_HEALTH,
MOVIE_DEPTH_BLIPS_3D,
MOVIE_DEPTH_BLIPS_2D,
MOVIE_DEPTH_TEST_BLIP_3D,
MOVIE_DEPTH_CROSSHAIR,
MAX_MOVIE_DEPTHS
};
//
// depth of the blip and its children/siblings
//
enum
{
BLIP_DEPTH_OUTLINE_INDICATOR = 1, // outline blip
BLIP_DEPTH_FRIEND_INDICATOR, // friend_blip
BLIP_DEPTH_CREW_INDICATOR, // crew blip
BLIP_DEPTH_MAIN_BLIP, // main_blip
BLIP_DEPTH_DIRECTION_INDICATOR, // direction_blip
BLIP_DEPTH_NUMBER, // number
BLIP_DEPTH_TICK, // tick
BLIP_DEPTH_SALE_ICON, // for sale blip
BLIP_DEPTH_HIGHER_LOWER, // higher/lower blip
MAX_BLIP_DEPTH_VALUES
};
#if !__FINAL
PARAM(minimap3d, "[code] 3D minimap");
PARAM(minimapRound, "[code] Round 2D minimap");
XPARAM(logMinimapTransitions);
#endif
#if __DEV
extern u32 iTimeTaken;
#endif // __DEV
#if __BANK
extern bool bDisplayInteriorInfoToLog;
extern bool bDebug3DBlips;
// extern float ms_fTilesAroundPlayer;
// extern Vector2 ms_vTilesAroundPlayer;
static Vector2 vGameScreenPos(0,0);
extern float fDebugTiltValue;
extern float fDebugOffsetValue;
extern bool noUIAA;
extern bool noUIAAOnBitMap;
bool CMiniMap_RenderThread::sm_bDebugMaskDisplay = false;
u8 CMiniMap_RenderThread::sm_uDebugMaskAlpha = 50;
#endif // __BANK
BankFloat CMiniMap_RenderThread::sm_fMultiheadEdgeFeatherPct = 0.012f;
extern float fFreewayDisplayZ;
#define MINIMAP_VISIBLE_TILES_NORTH (0) // these are the range of tiles which we will want to display (we ignore tiles outside this area as its unused as its just blank "sea" areas
#define MINIMAP_VISIBLE_TILES_SOUTH (53)
#define MINIMAP_VISIBLE_TILES_EAST (47)
#define MINIMAP_VISIBLE_TILES_WEST (0)
#define WEAPON_BLIP_NAME ("radar_weapon_") // i need to make these exposed to code really instead of this hack, but it will do for now since the bug is well overdue!
#define HOOP_BLIP_NAME ("radar_ai") // for bug 1027418
// BankFloat
extern float ALTIMETER_GROUND_LEVEL_FUDGE_FACTOR;
extern float ALTIMETER_TICK_PIXEL_HEIGHT;
extern float MINIMAP_GPS_DISPLAY_LIMIT;
extern float MAP_BLIP_ROUND_THRESHOLD;
bool bMiniMap3D = true;
bool bMiniMapSquare = true;
// Static member variables
atArray<sConesAttachedToBlips> CMiniMap_RenderThread::ms_ConesAttachedToBlips;
sMiniMapRenderStateStruct CMiniMap_RenderThread::ms_MiniMapRenderState;
// Blend States used when rendering the minimap
grcBlendStateHandle CMiniMap_RenderThread::ms_StandardMiniMapRenderBlendStateHandle = grcStateBlock::BS_Invalid;
grcBlendStateHandle CMiniMap_RenderThread::ms_ClearAlphaMiniMapRenderBlendStateHandle = grcStateBlock::BS_Invalid;
grcBlendStateHandle CMiniMap_RenderThread::ms_CopyAAMiniMapRenderBlendStateHandle = grcStateBlock::BS_Invalid;
grcSamplerStateHandle CMiniMap_RenderThread::ms_MinimapBitmapSamplerStateHandle = grcStateBlock::SS_Invalid;
grcRasterizerStateHandle CMiniMap_RenderThread::ms_MinimapBitmapRasterizerStateHandle = grcStateBlock::RS_Invalid;
#if __DEV
grcSamplerStateHandle CMiniMap_RenderThread::ms_MinimapBitmapSamplerStateNearestHandle = grcStateBlock::SS_Invalid;
#endif
#if ENABLE_FOG_OF_WAR
grcBlendStateHandle CMiniMap_RenderThread::ms_MinimapFoWBlendStateHandle = grcStateBlock::BS_Invalid;
#if __D3D11
bool CMiniMap_RenderThread::ms_bUpdateFogOfWarData= false;
#endif // __D3D11
#endif
float CMiniMap_RenderThread::ms_MiniMapAlpha = 1.0f;
EXT_PF_PAGE(MiniMap);
PF_GROUP(MiniMapRenderThread);
PF_LINK(MiniMap, MiniMapRenderThread);
PF_TIMER(UpdateIndividualBlip, MiniMapRenderThread);
PF_TIMER(AddBlipToStage, MiniMapRenderThread);
PF_TIMER(RemoveBlipFromStage, MiniMapRenderThread);
#if ENABLE_FOG_OF_WAR
float FoWPrevX = 0.0f;
float FoWPrevY = 0.0f;
u32 FowLastFrameRead = 0;
bank_s32 fowTileSize = 16;
bank_s32 fowFrameCount = 33;
#if __BANK
bool DebugDrawFOW = false;
float DebugFOWX1 = 0.6f;
float DebugFOWY1 = 0.5f;
float DebugFOWX2 = 0.8f;
float DebugFOWY2 = 0.85f;
int Fow_WorldX = -3447;
int Fow_WorldY = -7722;
int Fow_WorldW = 7647;
int Fow_WorldH = 11368;
#endif // __BANK
Color32 fowColor(64,64,64,64); // PS3's using a signed blend because lum8
Color32 fowBleepColor(64,64,64,64);
bank_s32 bleepCount = 2;
bank_float fowColorSizeX = 2.5f;
bank_float fowColorSizeY = 2.5f;
bank_float fowBlipColorSizeX = 1.75f;
bank_float fowBlipColorSizeY = 1.75f;
bank_float moveStep = 0.25f;
#if RSG_PC
static int g_curFOWClearGPUCount = 0;
static int g_curFOWRevealGPUCount = 0;
#endif
#endif // ENABLE_FOG_OF_WAR
s32 CMiniMap_RenderThread::ms_iMovieId[MAX_MINIMAP_MOVIE_LAYERS];
Vector2 CMiniMap_RenderThread::ms_vOriginalStageSize;
Vector2 CMiniMap_RenderThread::ms_vStageSize;
CDblBuf<GMatrix3D> CMiniMap_RenderThread::ms_LocalToScreen;
GFxValue CMiniMap_RenderThread::asBitmap;
GFxValue *CMiniMap_RenderThread::pRenderedBlipObject[MAX_NUM_BLIPS];
atFixedBitSet<MAX_NUM_BLIPS> CMiniMap_RenderThread::bBlipIsOn3dLayer;
GFxValue CMiniMap_RenderThread::ms_asRootContainer[MAX_MINIMAP_ROOT_LAYERS];
GFxValue CMiniMap_RenderThread::ms_asBaseLayerContainer[MAX_MINIMAP_LAYERS];
GFxValue CMiniMap_RenderThread::ms_asBaseOverlay3D[MAX_MINIMAP_LAYERS];
GFxValue CMiniMap_RenderThread::ms_asMapContainerMc;
GFxValue CMiniMap_RenderThread::ms_asBlipContainerMc;
GFxValue CMiniMap_RenderThread::ms_asGpsLayer[GPS_NUM_SLOTS];
GFxValue CMiniMap_RenderThread::ms_asMapObject;
GFxValue CMiniMap_RenderThread::ms_asBlipLayer3D;
GFxValue CMiniMap_RenderThread::ms_asInteriorMc;
GFxValue CMiniMap_RenderThread::ms_asInteriorMovie;
GFxValue CMiniMap_RenderThread::ms_asGolfCourseMc;
GFxValue CMiniMap_RenderThread::ms_asGolfCourseMovie;
GFxValue CMiniMap_RenderThread::ms_asGolfCourseHole;
GFxValue CMiniMap_RenderThread::ms_asTileLayerContainer;
GFxValue CMiniMap_RenderThread::ms_asBitmapLayerContainer;
GFxValue CMiniMap_RenderThread::ms_asFreewayMovieClip;
CMiniMap_RenderThread::AltimeterDisplay CMiniMap_RenderThread::ms_Altimeter;
#if __STREAMED_SUPERTILE_FILES
CSupertiles CMiniMap_RenderThread::ms_Supertiles;
#endif // __STREAMED_SUPERTILE_FILES
sMiniMapInterior CMiniMap_RenderThread::ms_PreviousInterior;
s32 CMiniMap_RenderThread::ms_iPreviousGolfCourse = GOLF_COURSE_OFF;
s32 CMiniMap_RenderThread::ms_iInteriorMovieId = -1;
bool CMiniMap_RenderThread::ms_bInteriorMovieIdFullySetup = false;
bool CMiniMap_RenderThread::ms_bInteriorWasSetOnPerFrame = false;
s32 CMiniMap_RenderThread::ms_iGolfCourseMovieId = -1;
bool CMiniMap_RenderThread::ms_bRunwayBlipsAreDisplaying = false;
bool CMiniMap_RenderThread::ms_bRemoveInteriorMovie = false;
bool CMiniMap_RenderThread::ms_bStreamInteriorMovie = false;
bool CMiniMap_RenderThread::ms_bRemoveGolfCourseMovie = false;
bool CMiniMap_RenderThread::ms_bStreamGolfCourseMovie = false;
bank_bool CMiniMap_RenderThread::ms_bUseTexturedAlphaAllMovies = false;
bank_bool CMiniMap_RenderThread::ms_bUseTextureAlphaBaseMovie = true;
grcTexture *CMiniMap_RenderThread::ms_MaskTextureSm = NULL;
grcTexture *CMiniMap_RenderThread::ms_MaskTextureLg = NULL;
grcTexture *CMiniMap_RenderThread::ms_MaskTextureCnCSm = NULL;
grcTexture *CMiniMap_RenderThread::ms_MaskTextureCnCLg = NULL;
float CMiniMap_RenderThread::ms_fBlipMapRange = 1.0f;
float CMiniMap_RenderThread::ms_fBlipMapAngle = 0.0f;
#if RSG_PC
CMiniMap_RenderThread::extraquad CMiniMap_RenderThread::ms_quads[MAX_FOW_TARGETS*(MAX_FOG_SCRIPT_REVEALS + 1)];
bool CMiniMap_RenderThread::ms_gotQuads = false;
int CMiniMap_RenderThread::ms_iMultiGPUCount = 0;
#endif
#if __STREAMED_SUPERTILE_FILES
// ****************************** CSupertile ******************************
void CSupertile::Init(u32 Row, u32 Column)
{
m_SupertileRow = Row;
m_SupertileColumn = Column;
m_bStreamThisSupertile = false;
m_bRemoveThisSupertile = false;
m_bPreviousValueOfShouldBeLoaded = false;
m_bFullyLoaded = false;
Remove(); // Resets everything
}
void CSupertile::Shutdown(unsigned shutdownMode)
{
if (CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on UT
{
sfAssertf(0, "CSupertile::Shutdown can only be called on the UpdateThread!");
return;
}
if (shutdownMode == SHUTDOWN_SESSION)
{
supertileDebugf3("CSupertile::Shutdown releasing drawable %d", m_dwdRequest.GetRequestId().Get());
Remove();
m_bFullyLoaded = false;
m_bStreamThisSupertile = false;
m_bRemoveThisSupertile = false;
m_bPreviousValueOfShouldBeLoaded = false;
}
}
void CSupertile::Remove()
{
m_Background = NULL;
m_Sea = NULL;
for(int i = 0; i < HEIGHT_OF_DWD_SUPERTILE; i++)
{
for(int j = 0; j < WIDTH_OF_DWD_SUPERTILE; j++)
{
m_Foregrounds[i][j] = NULL;
}
}
m_dwdRequest.ClearRequiredFlags(STRFLAG_DONTDELETE);
m_dwdRequest.ClearMyRequestFlags(STRFLAG_DONTDELETE);
m_dwdRequest.DelayedRelease();
}
void CSupertile::Update(bool bShouldBeLoaded, GFxValue & UNUSED_PARAM(TileLayerContainer))
{
if (m_bPreviousValueOfShouldBeLoaded != bShouldBeLoaded)
{
if (bShouldBeLoaded)
{
m_bStreamThisSupertile = true;
}
else
{
m_bRemoveThisSupertile = true;
}
m_bPreviousValueOfShouldBeLoaded = bShouldBeLoaded;
}
}
bool g_RenderMinimapSea = false;
bool g_RenderMinimap = true;
Color32 g_MinimapSeaColor(56, 74, 80, 0xff); // for 1884099
void CSupertile::Render(int pass)
{
Matrix34 FlattenZ;
FlattenZ.MakeScale(1.0f, 1.0f, 0.1f);
FlattenZ.d.Zero();
if (m_bFullyLoaded && m_dwdRequest.IsValid())
{
if (pass == 0)
{
PPU_ONLY(grcEffect::SetEdgeViewportCullEnable(false));
bool vectorSeaAllowed = g_RenderMinimapSea;
#if __BANK
if (CMiniMap_RenderThread::IsInPauseMap())
{
vectorSeaAllowed = vectorSeaAllowed || CMiniMap::DrawVectorSeaPaused(); // normally false, allow switching on
}
else
{
vectorSeaAllowed = vectorSeaAllowed && CMiniMap::DrawVectorSeaMinimap(); // normally true, allow switching off
}
#endif
if (m_Sea && vectorSeaAllowed)
{
m_Sea->Draw(FlattenZ, 0xFFFFFFFF, 0);
}
if (m_Background)
{
m_Background->Draw(FlattenZ, 0xFFFFFFFF, 0);
}
PPU_ONLY(grcEffect::SetEdgeViewportCullEnable(true));
}
else
{
for(int row = 0; row < HEIGHT_OF_DWD_SUPERTILE; row++)
{
for(int col = 0; col < WIDTH_OF_DWD_SUPERTILE; col++)
{
if (m_Foregrounds[row][col])
{
m_Foregrounds[row][col]->Draw(FlattenZ, 0xFFFFFFFF, 0);
}
}
}
}
}
#if __BANK
if (pass == 1 && CMiniMap::DebugDrawTiles())
{
spdRect superRect = CSupertiles::GetSuperTileWorldSpaceBounds(m_SupertileRow, m_SupertileColumn);
Vec2V superCorners[4];
superRect.GetCorners(superCorners);
grcColor(Color_black);
grcBegin(drawLineStrip, 5);
grcVertex2f(superCorners[0]);
grcVertex2f(superCorners[1]);
grcVertex2f(superCorners[2]);
grcVertex2f(superCorners[3]);
grcVertex2f(superCorners[0]);
grcEnd();
Vec2V center = Average(superCorners[0], superCorners[1]);
Vector3 center3(center.GetXf(), center.GetYf(), 0.0f);
char label[64];
if (m_bFullyLoaded)
{
for(int row = 0; row < HEIGHT_OF_DWD_SUPERTILE; row++)
{
for(int col = 0; col < WIDTH_OF_DWD_SUPERTILE; col++)
{
spdRect rect = CSupertiles::GetMiniTileWorldSpaceBounds(m_SupertileRow, m_SupertileColumn, row, col);
Vec2V corners[4];
rect.GetCorners(corners);
grcColor(m_Foregrounds[row][col] == NULL ? Color_blue : Color_red);
grcBegin(drawLineStrip, 8);
grcVertex2f(corners[0]);
grcVertex2f(corners[1]);
grcVertex2f(corners[2]);
grcVertex2f(corners[3]);
grcVertex2f(corners[0]);
grcVertex2f(corners[2]);
grcVertex2f(corners[1]);
grcVertex2f(corners[3]);
grcEnd();
}
}
formatf(label, g_DwdStore.GetName(strLocalIndex(m_dwdRequest.GetRequestId())));
}
else
{
formatf(label, "r%d, c%d", m_SupertileRow, m_SupertileColumn);
}
grcDrawLabel(center3, label, true);
}
#endif
}
void CSupertile::RenderFoW()
{
#if ENABLE_FOG_OF_WAR
spdRect superRect = CSupertiles::GetSuperTileWorldSpaceBounds(m_SupertileRow, m_SupertileColumn);
Vec2V superCorners[4];
superRect.GetCorners(superCorners);
grcColor(Color32(0xff,0xff,0xff,0xff));
Vec2V superCornersUVs[4];
for(int i=0;i<4;i++)
{
Vector2 coords = CMiniMap_RenderThread::WorldToFowCoord(superCorners[i].GetXf(), superCorners[i].GetYf());
superCornersUVs[i].SetX(coords.x);
superCornersUVs[i].SetY(coords.y);
}
grcDrawMode drawMode = drawQuads;
#if __D3D11
drawMode = drawTriStrip;
#endif
grcBegin(drawMode, 4);
grcTexCoord2f(superCornersUVs[0]);
grcVertex2f(superCorners[0]);
grcTexCoord2f(superCornersUVs[1]);
grcVertex2f(superCorners[1]);
#if __D3D11
grcTexCoord2f(superCornersUVs[3]);
grcVertex2f(superCorners[3]);
grcTexCoord2f(superCornersUVs[2]);
grcVertex2f(superCorners[2]);
#else
grcTexCoord2f(superCornersUVs[2]);
grcVertex2f(superCorners[2]);
grcTexCoord2f(superCornersUVs[3]);
grcVertex2f(superCorners[3]);
#endif
grcEnd();
#endif // ENABLE_FOG_OF_WAR
}
void CSupertile::RenderIslandFoW()
{
#if ENABLE_FOG_OF_WAR
static dev_float ms_IslandWorldX = 2700; // TODO: customize these via overrides in GetSuperTileWorldSpaceBounds()
static dev_float ms_IslandWorldY = -3150;
static dev_float ms_IslandWorldW = 4000;
static dev_float ms_IslandWorldH = 4000;
//float superWidth = CMiniMap::sm_Tunables.Tiles.vMiniMapWorldSize.x / (float)(NUMBER_OF_SUPERTILE_COLUMNS);
//float superHeight = CMiniMap::sm_Tunables.Tiles.vMiniMapWorldSize.y / (float)(NUMBER_OF_SUPERTILE_ROWS);
//Vec2V superStart(CMiniMap::sm_Tunables.Tiles.vMiniMapWorldStart.x + superWidth * col, CMiniMap::sm_Tunables.Tiles.vMiniMapWorldStart.y - superHeight * row);
//Vec2V superEnd(CMiniMap::sm_Tunables.Tiles.vMiniMapWorldStart.x + superWidth * (col+1), CMiniMap::sm_Tunables.Tiles.vMiniMapWorldStart.y - superHeight * (row+1));
Vec2V superStart(ms_IslandWorldX, ms_IslandWorldY);
Vec2V superEnd(ms_IslandWorldX + ms_IslandWorldW, ms_IslandWorldY - ms_IslandWorldH);
spdRect superRect(Min(superStart, superEnd), Max(superStart, superEnd));
Vec2V superCorners[4];
superRect.GetCorners(superCorners);
grcColor(Color32(0xff,0xff,0xff,0xff));
Vec2V superCornersUVs[4];
for(int i=0;i<4;i++)
{
Vector2 coords = CMiniMap_RenderThread::WorldToFowCoord(superCorners[i].GetXf(), superCorners[i].GetYf());
superCornersUVs[i].SetX(coords.x);
superCornersUVs[i].SetY(coords.y);
}
grcDrawMode drawMode = drawQuads;
#if __D3D11
drawMode = drawTriStrip;
#endif
grcBegin(drawMode, 4);
grcTexCoord2f(superCornersUVs[0]);
grcVertex2f(superCorners[0]);
grcTexCoord2f(superCornersUVs[1]);
grcVertex2f(superCorners[1]);
#if __D3D11
grcTexCoord2f(superCornersUVs[3]);
grcVertex2f(superCorners[3]);
grcTexCoord2f(superCornersUVs[2]);
grcVertex2f(superCorners[2]);
#else
grcTexCoord2f(superCornersUVs[2]);
grcVertex2f(superCorners[2]);
grcTexCoord2f(superCornersUVs[3]);
grcVertex2f(superCorners[3]);
#endif
grcEnd();
#endif // ENABLE_FOG_OF_WAR
}
void CSupertile::ProcessAtEndOfFrame(s32 UNUSED_PARAM(iParentMovieId))
{
if (m_bRemoveThisSupertile)
{
supertileDebugf3("CSupertile::ProcessAtEndOfFrame releasing %d", m_dwdRequest.GetRequestId().Get());
m_bRemoveThisSupertile = false;
m_bFullyLoaded = false;
Remove();
}
else if (m_bStreamThisSupertile)
{
char cSupertileName[20];
formatf(cSupertileName, "minimap_%u_%u", m_SupertileColumn, m_SupertileRow);
supertileDebugf3("CSupertile::ProcessAtEndOfFrame streaming supertile %s", cSupertileName);
strLocalIndex slot = g_DwdStore.FindSlot(cSupertileName);
if (slot.Get() >= 0)
{
supertileDebugf3("CSupertile::ProcessAtEndOfFrame requesting drawable %s %d", cSupertileName, slot.Get());
m_dwdRequest.Request(slot, g_DwdStore.GetStreamingModuleId(), STRFLAG_FORCE_LOAD | STRFLAG_PRIORITY_LOAD | STRFLAG_DONTDELETE );
}
m_bStreamThisSupertile = false;
}
else
{
// Poll for load completion
bool wasLoaded = m_bFullyLoaded;
m_bFullyLoaded = m_dwdRequest.HasLoaded();
if (m_bFullyLoaded)
{
m_dwdRequest.ClearRequiredFlags(STRFLAG_DONTDELETE); // ref counting takes over now
}
if (m_bPreviousValueOfShouldBeLoaded && !wasLoaded && m_bFullyLoaded) // if it's supposed to be loaded, and it just became loaded
{
Dwd* dict = g_DwdStore.Get(strLocalIndex(m_dwdRequest.GetRequestId()));
supertileAssertf(dict, "Invalid dict?!");
char bkgName[32];
formatf(bkgName, "supertile_back_%d_%d", m_SupertileColumn, m_SupertileRow);
m_Background = dict->LookupLocal(bkgName);
char seaName[32];
formatf(seaName, "supertile_sea_%d_%d", m_SupertileColumn, m_SupertileRow);
m_Sea = dict->LookupLocal(seaName);
for(int i = 0; i < HEIGHT_OF_DWD_SUPERTILE; i++)
{
for(int j = 0; j < WIDTH_OF_DWD_SUPERTILE; j++)
{
char minitileName[64];
formatf(minitileName, "supertile_fore_%d_%d_tile_%d_%d", m_SupertileColumn, m_SupertileRow, j, i);
m_Foregrounds[i][j] = dict->LookupLocal(minitileName);
}
}
}
}
}
void CSupertile::HandleIsLoadedCallback(const GFxValue& /*gfxVal*/)
{
}
// ****************************** CSupertiles ******************************
void CSupertiles::Init(unsigned initMode)
{
if(initMode == INIT_CORE)
{
for (u32 row = 0; row < NUMBER_OF_SUPERTILE_ROWS; row++)
{
for (u32 column = 0; column < NUMBER_OF_SUPERTILE_COLUMNS; column++)
{
m_Supertiles[row][column].Init(row, column);
}
}
}
else if (initMode == INIT_SESSION)
{
m_PreviousTopTile = -1;
m_PreviousBottomTile = -1;
m_PreviousLeftTile = -1;
m_PreviousRightTile = -1;
}
}
void CSupertiles::Shutdown(unsigned shutdownMode)
{
if (CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on UT
{
sfAssertf(0, "CSupertiles::Shutdown can only be called on the UpdateThread!");
return;
}
if (shutdownMode == SHUTDOWN_SESSION)
{
CScaleformMgr::AutoLock lockFore(CMiniMap::GetMovieId(MINIMAP_MOVIE_FOREGROUND));
CScaleformMgr::AutoLock lockBack(CMiniMap::GetMovieId(MINIMAP_MOVIE_BACKGROUND));
for (u32 row = 0; row < NUMBER_OF_SUPERTILE_ROWS; row++)
{
for (u32 column = 0; column < NUMBER_OF_SUPERTILE_COLUMNS; column++)
{
m_Supertiles[row][column].Shutdown(SHUTDOWN_SESSION);
}
}
}
}
bool CSupertiles::Update(const Vector2 &vCurrentTile, const Vector2 &vTilesAroundPlayer, GFxValue &TileLayerContainer, bool bBitmapOnly)
{
#define MAX_TILES_TO_ATTACH_PER_UPDATE (10)
#define MAX_TILES_TO_DETACH_PER_UPDATE (10)
// Get x,y of top left and bottom right supertiles for current
s32 CurrentTopTile = rage::Max((s32)(floorf(vCurrentTile.y - vTilesAroundPlayer.y)), MINIMAP_VISIBLE_TILES_NORTH);
s32 CurrentBottomTile = rage::Min((s32)(ceilf(vCurrentTile.y + vTilesAroundPlayer.y)), MINIMAP_VISIBLE_TILES_SOUTH);
s32 CurrentLeftTile = rage::Max((s32)(floorf(vCurrentTile.x - vTilesAroundPlayer.x)), MINIMAP_VISIBLE_TILES_WEST);
s32 CurrentRightTile = rage::Min((s32)(ceilf(vCurrentTile.x + vTilesAroundPlayer.x)), MINIMAP_VISIBLE_TILES_EAST);
// once all tiles have been detached, store the current tile we now are starting to attach...
m_PreviousTopTile = CurrentTopTile;
m_PreviousBottomTile = CurrentBottomTile;
m_PreviousLeftTile = CurrentLeftTile;
m_PreviousRightTile = CurrentRightTile;
// Deal with loading/unloading the supertiles
{
s32 CurrentTopSupertile = CurrentTopTile/HEIGHT_OF_SUPERTILE;
s32 CurrentBottomSupertile = CurrentBottomTile/HEIGHT_OF_SUPERTILE;
s32 CurrentLeftSupertile = CurrentLeftTile/WIDTH_OF_SUPERTILE;
s32 CurrentRightSupertile = CurrentRightTile/WIDTH_OF_SUPERTILE;
for (s32 supertile_row = 0; supertile_row < NUMBER_OF_SUPERTILE_ROWS; supertile_row++)
{
for (s32 supertile_column = 0; supertile_column < NUMBER_OF_SUPERTILE_COLUMNS; supertile_column++)
{
bool bIsInVisibleRange = false;
if (!bBitmapOnly)
{
if ( (supertile_row >= CurrentTopSupertile) && (supertile_row <= CurrentBottomSupertile) ) // Change to < maybe
{
if ( (supertile_column >= CurrentLeftSupertile) && (supertile_column <= CurrentRightSupertile) ) // Change to < maybe
{
bIsInVisibleRange = true;
}
}
}
m_Supertiles[supertile_row][supertile_column].Update(bIsInVisibleRange, TileLayerContainer);
}
}
}
return true;
}
void CSupertiles::ProcessAtEndOfFrame(s32 iParentMovieId)
{
if (CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on UT
{
sfAssertf(0, "CSupertiles::ProcessAtEndOfFrame can only be called on the UpdateThread!");
return;
}
for (u32 row = 0; row < NUMBER_OF_SUPERTILE_ROWS; row++)
{
for (u32 column = 0; column < NUMBER_OF_SUPERTILE_COLUMNS; column++)
{
m_Supertiles[row][column].ProcessAtEndOfFrame(iParentMovieId);
}
}
}
void CSupertiles::HandleIsLoadedCallback(s32 Row, s32 Column, const GFxValue &gfxVal)
{
if (Verifyf((Row >= 0) && (Row < NUMBER_OF_SUPERTILE_ROWS), "CSupertiles::HandleIsLoadedCallback - Row %d is out of range", Row))
{
if (Verifyf((Column >= 0) && (Column < NUMBER_OF_SUPERTILE_COLUMNS), "CSupertiles::HandleIsLoadedCallback - Column %d is out of range", Column))
{
m_Supertiles[Row][Column].HandleIsLoadedCallback(gfxVal);
}
}
}
spdRect CSupertiles::GetMiniTileWorldSpaceBounds(s32 superTileRow, s32 superTileCol, s32 tileRow, s32 tileColumn)
{
spdRect superBounds = GetSuperTileWorldSpaceBounds(superTileRow, superTileCol);
Vec2V superMin = superBounds.GetMin();
Vec2V superMax = superBounds.GetMax();
Vec2V superSize = superMax - superMin;
Vec2V miniSize = superSize / Vec2V((float)WIDTH_OF_DWD_SUPERTILE, (float)(HEIGHT_OF_DWD_SUPERTILE));
Vec2V miniStart = AddScaled(superMin, miniSize, Vec2V((float)tileColumn, (float)(HEIGHT_OF_DWD_SUPERTILE - (tileRow))));
Vec2V miniEnd = AddScaled(superMin, miniSize, Vec2V((float)(tileColumn+1), (float)(HEIGHT_OF_DWD_SUPERTILE - (tileRow+1))));
return spdRect(miniStart, miniEnd);
}
spdRect CSupertiles::GetSuperTileWorldSpaceBounds(s32 row, s32 col)
{
float superWidth = CMiniMap::sm_Tunables.Tiles.vMiniMapWorldSize.x / (float)(NUMBER_OF_SUPERTILE_COLUMNS);
float superHeight = CMiniMap::sm_Tunables.Tiles.vMiniMapWorldSize.y / (float)(NUMBER_OF_SUPERTILE_ROWS);
Vec2V superStart(CMiniMap::sm_Tunables.Tiles.vMiniMapWorldStart.x + superWidth * col, CMiniMap::sm_Tunables.Tiles.vMiniMapWorldStart.y - superHeight * row);
Vec2V superEnd(CMiniMap::sm_Tunables.Tiles.vMiniMapWorldStart.x + superWidth * (col+1), CMiniMap::sm_Tunables.Tiles.vMiniMapWorldStart.y - superHeight * (row+1));
return spdRect(Min(superStart, superEnd), Max(superStart, superEnd));
}
void CSupertiles::Render()
{
for(int layer = 0; layer < 2; layer++)
{
// TODO - based on camera orientation, draw in one of 8 directions to do back-to-front rendering
for(int row = 0; row < NUMBER_OF_SUPERTILE_ROWS; row++)
{
for(int col = 0; col < NUMBER_OF_SUPERTILE_COLUMNS; col++)
{
m_Supertiles[row][col].Render(layer);
}
}
}
}
void CSupertiles::RenderFoW()
{
for(int row = 0; row < NUMBER_OF_SUPERTILE_ROWS; row++)
{
for(int col = 0; col < NUMBER_OF_SUPERTILE_COLUMNS; col++)
{
m_Supertiles[row][col].RenderFoW();
}
}
}
#endif // __STREAMED_SUPERTILE_FILES
#if SUPPORT_MULTI_MONITOR
class MultiMonitorHudHelper
{
sMiniMapRenderStateStruct *m_State;
Vector2 m_vPosition;
Vector2 m_vSize;
Vector2 m_vMaskPosition;
Vector2 m_vMaskSize;
Vector2 m_vBlurPosition;
Vector2 m_vBlurSize;
MultiMonitorHudHelper(const MultiMonitorHudHelper&);
void operator= (const MultiMonitorHudHelper&);
public:
static void TransformPos(const GridMonitor& mon, Vector2 *v)
{
v->x = (mon.uLeft + mon.getWidth() * v->x) / GRCDEVICE.GetWidth();
v->y = (mon.uTop + mon.getHeight() * v->y) / GRCDEVICE.GetHeight();
}
static void TransformSize(const GridMonitor& mon, Vector2 *v)
{
v->x = mon.getWidth() * v->x / GRCDEVICE.GetWidth();
v->y = mon.getHeight() * v->y / GRCDEVICE.GetHeight();
}
MultiMonitorHudHelper(sMiniMapRenderStateStruct *state)
: m_State(state)
, m_vPosition(state->m_vCurrentMiniMapPosition)
, m_vSize(state->m_vCurrentMiniMapSize)
, m_vMaskPosition(state->m_vCurrentMiniMapMaskPosition)
, m_vMaskSize(state->m_vCurrentMiniMapMaskSize)
, m_vBlurPosition(state->m_vCurrentMiniMapBlurPosition)
, m_vBlurSize(state->m_vCurrentMiniMapBlurSize)
{
const GridMonitor &mon = GRCDEVICE.GetMonitorConfig().getLandscapeMonitor();
TransformPos (mon, &state->m_vCurrentMiniMapPosition);
TransformSize(mon, &state->m_vCurrentMiniMapSize);
TransformPos (mon, &state->m_vCurrentMiniMapMaskPosition);
TransformSize(mon, &state->m_vCurrentMiniMapMaskSize);
TransformPos (mon, &state->m_vCurrentMiniMapBlurPosition);
TransformSize(mon, &state->m_vCurrentMiniMapBlurSize);
}
~MultiMonitorHudHelper()
{
m_State->m_vCurrentMiniMapPosition = m_vPosition;
m_State->m_vCurrentMiniMapSize = m_vSize;
m_State->m_vCurrentMiniMapMaskPosition = m_vMaskPosition;
m_State->m_vCurrentMiniMapMaskSize = m_vMaskSize;
m_State->m_vCurrentMiniMapBlurPosition = m_vBlurPosition;
m_State->m_vCurrentMiniMapBlurSize = m_vBlurSize;
}
};
#endif //SUPPORT_MULTI_MONITOR
void CMiniMap_RenderThread::Init(unsigned initMode)
{
if(initMode == INIT_CORE)
{
grcBlendStateDesc bsd;
bsd.BlendRTDesc[0].RenderTargetWriteMask = grcRSV::COLORWRITEENABLE_ALPHA;
ms_ClearAlphaMiniMapRenderBlendStateHandle = grcStateBlock::CreateBlendState(bsd);
// stateblock for standard minimap render
bsd.BlendRTDesc[0].RenderTargetWriteMask = grcRSV::COLORWRITEENABLE_RGB;
bsd.BlendRTDesc[0].BlendEnable = true;
bsd.BlendRTDesc[0].SrcBlend = grcRSV::BLEND_ONE;
bsd.BlendRTDesc[0].DestBlend = grcRSV::BLEND_INVSRCALPHA;
bsd.BlendRTDesc[0].BlendOp = grcRSV::BLENDOP_ADD;
ms_StandardMiniMapRenderBlendStateHandle = grcStateBlock::CreateBlendState(bsd);
grcSamplerStateDesc ssd;
ssd.AddressU = grcSSV::TADDRESS_CLAMP;
ssd.AddressV = grcSSV::TADDRESS_CLAMP;
ms_MinimapBitmapSamplerStateHandle = grcStateBlock::CreateSamplerState(ssd);
#if __DEV
ssd.Filter = grcSSV::FILTER_MIN_MAG_MIP_POINT;
ms_MinimapBitmapSamplerStateNearestHandle = grcStateBlock::CreateSamplerState(ssd);
#endif
grcRasterizerStateDesc rsd;
rsd.CullMode = grcRSV::CULL_NONE;
ms_MinimapBitmapRasterizerStateHandle = grcStateBlock::CreateRasterizerState(rsd);
#if ENABLE_FOG_OF_WAR
bsd.BlendRTDesc[0].RenderTargetWriteMask = grcRSV::COLORWRITEENABLE_ALPHA;
bsd.BlendRTDesc[0].BlendEnable = true;
bsd.BlendRTDesc[0].SrcBlend = grcRSV::BLEND_ONE;
bsd.BlendRTDesc[0].DestBlend = grcRSV::BLEND_ONE;
bsd.BlendRTDesc[0].BlendOp = grcRSV::BLENDOP_MIN;
bsd.BlendRTDesc[0].SrcBlendAlpha = grcRSV::BLEND_ONE;
bsd.BlendRTDesc[0].DestBlendAlpha = grcRSV::BLEND_ONE;
bsd.BlendRTDesc[0].BlendOpAlpha = grcRSV::BLENDOP_MIN;
ms_MinimapFoWBlendStateHandle = grcStateBlock::CreateBlendState(bsd);
#endif // ENABLE_FOG_OF_WAR
// stateblock for copying the fully composited minimap with AA to the UI buffer
bsd.BlendRTDesc[0].RenderTargetWriteMask = grcRSV::COLORWRITEENABLE_ALL;
bsd.BlendRTDesc[0].BlendEnable = true;
bsd.BlendRTDesc[0].SrcBlend = grcRSV::BLEND_ONE;
bsd.BlendRTDesc[0].DestBlend = grcRSV::BLEND_ZERO;
bsd.BlendRTDesc[0].BlendOp = grcRSV::BLENDOP_ADD;
bsd.BlendRTDesc[0].SrcBlendAlpha = grcRSV::BLEND_ZERO;
bsd.BlendRTDesc[0].DestBlendAlpha = grcRSV::BLEND_ONE;
bsd.BlendRTDesc[0].BlendOpAlpha = grcRSV::BLENDOP_ADD;
ms_CopyAAMiniMapRenderBlendStateHandle = grcStateBlock::CreateBlendState(bsd);
for (s32 i = 0; i < MAX_MINIMAP_MOVIE_LAYERS; i++)
{
ms_iMovieId[i] = -1;
}
#if !__FINAL
if (PARAM_minimapRound.Get())
{
bMiniMapSquare = false;
bMiniMap3D = false;
}
if (PARAM_minimap3d.Get())
{
bMiniMap3D = true;
}
#endif // !__FINAL
}
else if(initMode == INIT_SESSION)
{
ms_bRunwayBlipsAreDisplaying = false; // Will the runway movie be hidden when a new session is started?
ms_asInteriorMc.SetUndefined();
ms_asInteriorMovie.SetUndefined();
ms_asGolfCourseMc.SetUndefined();
ms_asGolfCourseMovie.SetUndefined();
ms_asGolfCourseHole.SetUndefined();
ms_PreviousInterior.Clear();
ms_iPreviousGolfCourse = GOLF_COURSE_OFF;
ms_iInteriorMovieId = -1;
ms_bInteriorMovieIdFullySetup = false;
ms_bInteriorWasSetOnPerFrame = false;
ms_iGolfCourseMovieId = -1;
#if ENABLE_FOG_OF_WAR
FowLastFrameRead = 0;
#endif // ENABLE_FOG_OF_WAR
// initialise all blips:
for (s32 iCount = 0; iCount < MAX_NUM_BLIPS; iCount++)
{
pRenderedBlipObject[iCount] = NULL;
}
s32 txdSlot = CShaderLib::GetTxdId();
CMiniMap_RenderThread::ms_MaskTextureSm = g_TxdStore.Get(strLocalIndex(txdSlot))->Lookup(ATSTRINGHASH("RadarMaskSm", 0x6dd9a16));
CMiniMap_RenderThread::ms_MaskTextureLg = g_TxdStore.Get(strLocalIndex(txdSlot))->Lookup(ATSTRINGHASH("RadarMaskLg", 0x91a810f0));
//CMiniMap_RenderThread::ms_MaskTextureCnCSm = g_TxdStore.Get(strLocalIndex(txdSlot))->Lookup(ATSTRINGHASH("RadarMaskCnCSm", 0xEC1F6E28));
//AssertMsg(CMiniMap_RenderThread::ms_MaskTextureCnCSm, "RadarMaskCnCSm not found!");
//CMiniMap_RenderThread::ms_MaskTextureCnCLg = g_TxdStore.Get(strLocalIndex(txdSlot))->Lookup(ATSTRINGHASH("RadarMaskCnCLg", 0x1AD26689));
//AssertMsg(CMiniMap_RenderThread::ms_MaskTextureCnCLg, "RadarMaskCnCLg not found!");
#if RSG_PC
ms_gotQuads = false;
for (int i = 0; i < MAX_FOW_TARGETS*(MAX_FOG_SCRIPT_REVEALS + 1); i++)
{
ms_quads[i].flags = 0x7;
}
#endif
}
#if __STREAMED_SUPERTILE_FILES
ms_Supertiles.Init(initMode);
#endif // __STREAMED_SUPERTILE_FILES
}
void CMiniMap_RenderThread::Shutdown(unsigned shutdownMode)
{
if (shutdownMode == SHUTDOWN_CORE)
{
}
else if (shutdownMode == SHUTDOWN_SESSION)
{
CScaleformMgr::AutoLock lockFore(CMiniMap::GetMovieId(MINIMAP_MOVIE_FOREGROUND));
CScaleformMgr::AutoLock lockBack(CMiniMap::GetMovieId(MINIMAP_MOVIE_BACKGROUND));
// remove any additional minimap movies we have loaded in
RemoveInterior();
HandleInteriorAtEndOfFrame(); // actually request the removal of the movie - fixes 1617703
RemoveGolfCourse(true);
HandleGolfCourseAtEndOfFrame(); // actually request the removal of the movie - fixes 1617703
for (int loop = 0; loop < ms_ConesAttachedToBlips.GetCount(); loop++)
{
RemoveConeFromBlipOnStage(ms_ConesAttachedToBlips[loop].m_iActualIdOfBlip);
}
ms_ConesAttachedToBlips.Reset();
CMiniMap_RenderThread::ms_MaskTextureSm = NULL;
CMiniMap_RenderThread::ms_MaskTextureLg = NULL;
CMiniMap_RenderThread::ms_MaskTextureCnCSm = NULL;
CMiniMap_RenderThread::ms_MaskTextureCnCLg = NULL;
}
#if __STREAMED_SUPERTILE_FILES
ms_Supertiles.Shutdown(shutdownMode);
#endif // __STREAMED_SUPERTILE_FILES
}
void CMiniMap_RenderThread::SetMiniMapRenderState(const sMiniMapRenderStateStruct &newRenderState)
{
// copy over the structure
sysMemCpy(&ms_MiniMapRenderState, &newRenderState, sizeof(sMiniMapRenderStateStruct));
}
void CMiniMap_RenderThread::PrepareForRendering()
{
UpdateStatesWithActionScriptOnRT();
if (ms_MiniMapRenderState.m_bShouldProcessMiniMap) // if in pause map and not in map screen then don't render
{
UpdateWithActionScriptOnRT(((!ms_MiniMapRenderState.m_bShouldRenderMiniMap) || ms_MiniMapRenderState.m_CurrentGolfMap != GOLF_COURSE_OFF), false);
}
else
{
// continue to update the tiles even though its not rendered since we need them to appear as soon as possible
// so if they can be streaming and attaching in the background whilst the minimap isnt getting rendered, all the better
// otherwise they stream in as soon as the minimap pops on screen and you see the LOD for a second or so
UpdateTiles(false);
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::SetLocalStageSize()
// PURPOSE: gets the stage size and stores it locally in code
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::SetLocalStageSize()
{
GFxMovieView* pView = CScaleformMgr::GetMovieView(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND]);
if (uiVerifyf(pView, "CMiniMap_RenderThread: no movieview to get stage size from at init"))
{
ms_vOriginalStageSize = Vector2(pView->GetMovieDef()->GetWidth(), pView->GetMovieDef()->GetHeight()); // store the stage size
ms_vStageSize = ms_vOriginalStageSize;
}
else
{
ms_vStageSize = Vector2(0,0); // it will be buggered!
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::CreateRoot()
// PURPOSE: sets up the main root layer
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::CreateRoot(s32 iId)
{
switch (iId)
{
case MINIMAP_MOVIE_BACKGROUND:
{
GFxValue asMovieObject1 = CScaleformMgr::GetActionScriptObjectFromRoot(ms_iMovieId[MINIMAP_MOVIE_BACKGROUND]);
asMovieObject1.CreateEmptyMovieClip(&ms_asRootContainer[MINIMAP_ROOT_MAP_TRANSPARENT], "asRootContainer", MOVIE_DEPTH_ROOT_CONTAINER);
break;
}
case MINIMAP_MOVIE_FOREGROUND:
{
GFxValue asMovieObject2 = CScaleformMgr::GetActionScriptObjectFromRoot(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND]);
asMovieObject2.CreateEmptyMovieClip(&ms_asRootContainer[MINIMAP_ROOT_LAYER_MASKED], "asRootContainer", MOVIE_DEPTH_ROOT_CONTAINER);
GFxValue asMovieObject3 = CScaleformMgr::GetActionScriptObjectFromRoot(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND]);
asMovieObject3.CreateEmptyMovieClip(&ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED], "asRootContainerBlips", MOVIE_DEPTH_ROOT_BLIP_CONTAINER);
break;
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::RemoveRoot()
// PURPOSE: removes the main root layer
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::RemoveRoot(s32 iId)
{
switch (iId)
{
case MINIMAP_MOVIE_BACKGROUND:
{
if (ms_asRootContainer[MINIMAP_ROOT_MAP_TRANSPARENT].IsDefined())
{
ms_asRootContainer[MINIMAP_ROOT_MAP_TRANSPARENT].Invoke("removeMovieClip");
ms_asRootContainer[MINIMAP_ROOT_MAP_TRANSPARENT].SetUndefined();
}
break;
}
case MINIMAP_MOVIE_FOREGROUND:
{
if (ms_asRootContainer[MINIMAP_ROOT_LAYER_MASKED].IsDefined())
{
ms_asRootContainer[MINIMAP_ROOT_LAYER_MASKED].Invoke("removeMovieClip");
ms_asRootContainer[MINIMAP_ROOT_LAYER_MASKED].SetUndefined();
}
if (ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED].IsDefined())
{
ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED].Invoke("removeMovieClip");
ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED].SetUndefined();
}
break;
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::CreateTerritoryContainer
// PURPOSE: creates a container for the territory and passes info to actionscript
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::CreateTerritoryContainer()
{
GFxValue asTerritoryContainer;
ms_asBaseOverlay3D[MINIMAP_LAYER_FOREGROUND].CreateEmptyMovieClip(&asTerritoryContainer, "asTerritory3D", MOVIE_DEPTH_TERRITORY);
GFxValue::DisplayInfo info;
info.SetScale(MINIMAP_INITIAL_SCALE, MINIMAP_INITIAL_SCALE);
asTerritoryContainer.SetDisplayInfo(info);
if (uiVerifyf(asTerritoryContainer.IsDisplayObject(), "MiniMap: 'asTerritoryContainer' is not a display object at init"))
{
if (CScaleformMgr::BeginMethod(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND], SF_BASE_CLASS_MINIMAP, "REGISTER_TERRITORY"))
{
CScaleformMgr::AddParamGfxValue(asTerritoryContainer);
CScaleformMgr::EndMethod(true); // this is instant as we are initialising the minimap here
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::RemoveTerritoryContainer
// PURPOSE: removes the containers
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::RemoveTerritoryContainer()
{
GFxValue asTerritoryContainer;
if (ms_asBaseOverlay3D[MINIMAP_LAYER_FOREGROUND].GFxValue::GetMember("asTerritory3D", &asTerritoryContainer))
{
asTerritoryContainer.Invoke("removeMovieClip");
asTerritoryContainer.SetUndefined();
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::CreateHealthArmourContainer
// PURPOSE: creates a container for the health and armour
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::CreateHealthArmourContainer()
{
GFxValue asHealthContainer;
ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED].CreateEmptyMovieClip(&asHealthContainer, "asHealthContainer", MOVIE_DEPTH_HEALTH);
if (uiVerifyf(asHealthContainer.IsDisplayObject(), "MiniMap: 'asHealthContainer' is not a display object at init"))
{
if (CScaleformMgr::BeginMethod(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND], SF_BASE_CLASS_MINIMAP, "REGISTER_HEALTH_ARMOUR"))
{
CScaleformMgr::AddParamGfxValue(asHealthContainer);
CScaleformMgr::EndMethod(true); // this is instant as we are initialising the minimap here
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::RemoveHealthArmourContainer
// PURPOSE: removes the containers
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::RemoveHealthArmourContainer()
{
GFxValue asHealthContainer;
if (ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED].GFxValue::GetMember("asHealthContainer", &asHealthContainer))
{
asHealthContainer.Invoke("removeMovieClip"); // remove the mask movie
asHealthContainer.SetUndefined();
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::CreateAltimeter
// PURPOSE: creates altimeter and hides it (it gets set to visible later when needed)
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::CreateAltimeter()
{
if(ms_asRootContainer[MINIMAP_ROOT_LAYER_MASKED].CreateEmptyMovieClip(&ms_Altimeter.m_asContainerMc, "altimeterOffset", MOVIE_DEPTH_ALTIMETER_DISPLAY ) )
{
int iDepth = 1;
ms_Altimeter.m_asContainerMc.AttachMovie(&ms_Altimeter.m_asGaugeMc, "altimeterVertical", "asAltimeterVertical", iDepth++);
ms_Altimeter.m_asContainerMc.AttachMovie(&ms_Altimeter.m_asRollMc, "altimeterHorizontal", "asAltimeterHorizontal", iDepth++);
}
GFxValue::DisplayInfo info;
info.SetPosition((ms_vStageSize.x * 0.5f), (ms_vStageSize.y * 0.5f));// + MINIMAP_VEHICLE_OFFSET);
info.SetVisible(false);
ms_Altimeter.m_asContainerMc.SetDisplayInfo(info);
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::RemoveAltimeter
// PURPOSE: removes anything the altimeter has set up in AS
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::RemoveAltimeter()
{
if (ms_Altimeter.m_asGaugeMc.IsDefined())
{
ms_Altimeter.m_asGaugeMc.Invoke("removeMovieClip");
ms_Altimeter.m_asGaugeMc.SetUndefined();
}
if (ms_Altimeter.m_asRollMc.IsDefined())
{
ms_Altimeter.m_asRollMc.Invoke("removeMovieClip");
ms_Altimeter.m_asRollMc.SetUndefined();
}
if (ms_Altimeter.m_asContainerMc.IsDefined())
{
ms_Altimeter.m_asContainerMc.Invoke("removeMovieClip");
ms_Altimeter.m_asContainerMc.SetUndefined();
}
}
void CMiniMap_RenderThread::CreateFreeway()
{
const char *pFreewayComponentsString = "roads_overlay";
GFxValue asFreewayLayerContainer;
if (ms_asBaseOverlay3D[MINIMAP_LAYER_BACKGROUND].CreateEmptyMovieClip(&asFreewayLayerContainer, "asFreewayLayer", MOVIE_DEPTH_FREEWAY))
{
if (asFreewayLayerContainer.GFxValue::AttachMovie(&ms_asFreewayMovieClip, pFreewayComponentsString, pFreewayComponentsString, 1))
{
GFxValue::DisplayInfo freewayDisplayInfo;
freewayDisplayInfo.SetVisible(true);
freewayDisplayInfo.SetPosition(0.0f, 0.0f);
freewayDisplayInfo.SetScale(100.0f, 100.0f); // MINIMAP_INITIAL_SCALE / 100.0f, MINIMAP_INITIAL_SCALE / 100.0f);
ms_asFreewayMovieClip.SetDisplayInfo(freewayDisplayInfo);
}
}
}
void CMiniMap_RenderThread::RemoveFreeway()
{
if (ms_asFreewayMovieClip.IsDefined())
{
ms_asFreewayMovieClip.Invoke("removeMovieClip");
ms_asFreewayMovieClip.SetUndefined();
}
GFxValue asFreewayLayerContainer;
if (ms_asBaseOverlay3D[MINIMAP_LAYER_BACKGROUND].GFxValue::GetMember("asFreewayLayer", &asFreewayLayerContainer))
{
asFreewayLayerContainer.Invoke("removeMovieClip");
asFreewayLayerContainer.SetUndefined();
}
}
void CMiniMap_RenderThread::UpdateFreeway()
{
GFxValue::DisplayInfo freewayDisplayInfo;
#if __BANK
freewayDisplayInfo.SetPosition(CMiniMap::sm_Tunables.Overlay.vPos.x, CMiniMap::sm_Tunables.Overlay.vPos.y);
freewayDisplayInfo.SetScale(CMiniMap::sm_Tunables.Overlay.vScale.x, CMiniMap::sm_Tunables.Overlay.vScale.y);
#endif // __BANK
if (ms_MiniMapRenderState.m_vCentrePosition.z > CMiniMap::sm_Tunables.Overlay.fDisplayZ)
{
freewayDisplayInfo.SetVisible(true);
}
else
{
freewayDisplayInfo.SetVisible(false);
}
ms_asFreewayMovieClip.SetDisplayInfo(freewayDisplayInfo);
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::CreateCrosshair
// PURPOSE: creates a crosshair and hides it (it gets set to visible later when needed)
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::CreateCrosshair()
{
GFxValue asCrosshairMc;
ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED].GFxValue::AttachMovie(&asCrosshairMc, "crosshair", "asCrosshair", MOVIE_DEPTH_CROSSHAIR);
GFxValue::DisplayInfo info;
info.SetVisible(false);
asCrosshairMc.SetDisplayInfo(info);
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::CreateMapContainers
// PURPOSE: creates a container for the vector map
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::CreateMapContainers()
{
if (ms_asRootContainer[MINIMAP_ROOT_MAP_TRANSPARENT].CreateEmptyMovieClip(&ms_asBaseLayerContainer[MINIMAP_LAYER_BACKGROUND], "asMapContainer", MOVIE_DEPTH_MAP))
{
ms_asBaseLayerContainer[MINIMAP_LAYER_BACKGROUND].GFxValue::AttachMovie(&ms_asMapContainerMc, "mapContainer", "asMapContainer", 1);
}
if (ms_asRootContainer[MINIMAP_ROOT_LAYER_MASKED].CreateEmptyMovieClip(&ms_asBaseLayerContainer[MINIMAP_LAYER_FOREGROUND], "asBlipLayerContainer", MOVIE_DEPTH_BLIPS_3D))
{
ms_asBaseLayerContainer[MINIMAP_LAYER_FOREGROUND].GFxValue::AttachMovie(&ms_asBlipContainerMc, "blipContainer", "asBlipContainer", 1);
}
if (ms_asMapContainerMc.CreateEmptyMovieClip(&ms_asBaseOverlay3D[MINIMAP_LAYER_BACKGROUND], "asBackgroundOverlay3D", MOVIE_DEPTH_GPS)) //
{
GFxValue asInteriorLayer, asGolfCourseLayer;
ms_asBaseOverlay3D[MINIMAP_LAYER_BACKGROUND].CreateEmptyMovieClip(&asInteriorLayer, "asInteriorLayer", MOVIE_DEPTH_INTERIOR);
ms_asBaseOverlay3D[MINIMAP_LAYER_BACKGROUND].CreateEmptyMovieClip(&asGolfCourseLayer, "asGolfCourseLayer", MOVIE_DEPTH_GOLF_COURSE);
}
if (ms_asBlipContainerMc.CreateEmptyMovieClip(&ms_asBaseOverlay3D[MINIMAP_LAYER_FOREGROUND], "asForegroundOverlay3D", MOVIE_DEPTH_GPS)) //
{
for (s32 iLayerCount = 0; iLayerCount < GPS_NUM_SLOTS; iLayerCount++)
{
char cLayerName[20];
formatf(cLayerName, "asGpsLayer%d", iLayerCount, NELEM(cLayerName));
ms_asBaseOverlay3D[MINIMAP_LAYER_FOREGROUND].CreateEmptyMovieClip(&ms_asGpsLayer[iLayerCount], cLayerName, MOVIE_DEPTH_GPS+iLayerCount);
// init the route layers as invisible:
GFxValue::DisplayInfo info;
info.SetVisible(false);
ms_asGpsLayer[iLayerCount].SetDisplayInfo(info);
}
GFxValue asRadiusBlipLayer;
ms_asBaseOverlay3D[MINIMAP_LAYER_FOREGROUND].CreateEmptyMovieClip(&asRadiusBlipLayer, "asRadiusBlipLayer", MOVIE_DEPTH_RADIUS);
GFxValue asSonarBlipLayer;
ms_asBaseOverlay3D[MINIMAP_LAYER_FOREGROUND].CreateEmptyMovieClip(&asSonarBlipLayer, "asSonarBlipLayer", MOVIE_DEPTH_STEALTH);
}
if (ms_asBaseLayerContainer[MINIMAP_LAYER_BACKGROUND].GFxValue::HasMember("asMapContainer") &&
ms_asMapContainerMc.GFxValue::HasMember("map"))
{
ms_asMapContainerMc.GFxValue::GetMember("map", &ms_asMapObject);
ms_asBlipContainerMc.GFxValue::GetMember("blipLayer", &ms_asBlipLayer3D);
GFxValue::DisplayInfo info;
info.SetScale(MINIMAP_INITIAL_SCALE, MINIMAP_INITIAL_SCALE);
ms_asMapObject.SetDisplayInfo(info);
if (ms_asMapContainerMc.GFxValue::HasMember("sea"))
{
GFxValue seaMap;
ms_asMapContainerMc.GFxValue::GetMember("sea", &seaMap);
info.SetVisible(false);
seaMap.SetDisplayInfo(info);
}
g_RenderMinimapSea = true;
}
else
{
uiAssertf(0, "MiniMap: One or more required movieclips are not set up in ActionScript");
}
GFxValue::DisplayInfo info;
info.SetPosition((ms_vStageSize.x * 0.5f), (ms_vStageSize.y * 0.5f));
ms_asBaseLayerContainer[MINIMAP_LAYER_BACKGROUND].SetDisplayInfo(info);
ms_asBaseLayerContainer[MINIMAP_LAYER_FOREGROUND].SetDisplayInfo(info);
info.Clear(); // default the initial zoom value to exterior on-foot
info.SetScale(CMiniMap::sm_Tunables.Camera.fExteriorFootZoom, CMiniMap::sm_Tunables.Camera.fExteriorFootZoom);
ms_asMapContainerMc.SetDisplayInfo(info);
ms_asBlipContainerMc.SetDisplayInfo(info);
// blip 2d layer:
GFxValue asBlipLayer2D;
ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED].CreateEmptyMovieClip(&asBlipLayer2D, "asBlipLayer2D", MOVIE_DEPTH_BLIPS_2D);
GFxValue asMapObjectBackground;
ms_asMapContainerMc.GFxValue::GetMember("map", &asMapObjectBackground);
if (uiVerifyf(asMapObjectBackground.GFxValue::HasMember("main_map"), "MiniMap: 'main_map' does not exist in 'map'"))
{
GFxValue mainMap;
asMapObjectBackground.GFxValue::GetMember("main_map", &mainMap);
GFxValue asMapLayerGfx;
mainMap.GFxValue::GetMember("map_layer", &asMapLayerGfx);
asMapLayerGfx.CreateEmptyMovieClip(&ms_asTileLayerContainer, "asTileLayer", MOVIE_DEPTH_TILES);
asMapLayerGfx.CreateEmptyMovieClip(&ms_asBitmapLayerContainer, "asBitmapLayer", MOVIE_DEPTH_BITMAP);
//
// we need to scale the tiles down - not 100% sure why, it used to be done in Actionscript, triggered by MINIMAP_INITIALISED
// which we no longer call, so I do it here myself. It may have something to do with AA fixes Eddie may of done but he
// isnt here right now to ask...
//
GFxValue::DisplayInfo CurrInfo;
// For drawable minimap:
CurrInfo.SetVisible(false);
ms_asTileLayerContainer.SetDisplayInfo(CurrInfo);
ms_asBitmapLayerContainer.SetDisplayInfo(CurrInfo);
if (CScaleformMgr::BeginMethod(ms_iMovieId[MINIMAP_MOVIE_BACKGROUND], SF_BASE_CLASS_MINIMAP, "REGISTER_MAP_LAYER"))
{
CScaleformMgr::AddParamGfxValue(ms_asBitmapLayerContainer);
CScaleformMgr::EndMethod(true); // this is instant as we are initialising the minimap here
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::RemoveMapContainers
// PURPOSE: removes a container for the vector map
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::RemoveMapContainers()
{
GFxValue asInteriorLayer, asGolfCourseLayer, asRadiusBlipLayer, asSonarBlipLayer, asBlipLayer2D;
if (ms_asBaseOverlay3D[MINIMAP_LAYER_BACKGROUND].GFxValue::GetMember("asInteriorLayer", &asInteriorLayer))
{
asInteriorLayer.Invoke("removeMovieClip");
}
if (ms_asBaseOverlay3D[MINIMAP_LAYER_BACKGROUND].GFxValue::GetMember("asGolfCourseLayer", &asGolfCourseLayer))
{
asGolfCourseLayer.Invoke("removeMovieClip");
}
if (ms_asBaseOverlay3D[MINIMAP_LAYER_FOREGROUND].GFxValue::GetMember("asRadiusBlipLayer", &asRadiusBlipLayer))
{
asRadiusBlipLayer.Invoke("removeMovieClip");
}
if (ms_asBaseOverlay3D[MINIMAP_LAYER_FOREGROUND].GFxValue::GetMember("asSonarBlipLayer", &asSonarBlipLayer))
{
asSonarBlipLayer.Invoke("removeMovieClip");
}
if (ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED].GFxValue::GetMember("asBlipLayer2D", &asBlipLayer2D))
{
asBlipLayer2D.Invoke("removeMovieClip");
}
for (s32 iLayerCount = 0; iLayerCount < GPS_NUM_SLOTS; iLayerCount++)
{
if (ms_asGpsLayer[iLayerCount].IsDefined())
{
ms_asGpsLayer[iLayerCount].Invoke("removeMovieClip");
ms_asGpsLayer[iLayerCount].SetUndefined();
}
}
if (ms_asMapObject.IsDefined())
{
ms_asMapObject.Invoke("removeMovieClip");
ms_asMapObject.SetUndefined();
}
if (ms_asBlipLayer3D.IsDefined())
{
ms_asBlipLayer3D.Invoke("removeMovieClip");
ms_asBlipLayer3D.SetUndefined();
}
if (ms_asBlipContainerMc.IsDefined())
{
ms_asBlipContainerMc.Invoke("removeMovieClip");
ms_asBlipContainerMc.SetUndefined();
}
if (ms_asMapContainerMc.IsDefined())
{
ms_asMapContainerMc.Invoke("removeMovieClip");
ms_asMapContainerMc.SetUndefined();
}
if (ms_asTileLayerContainer.IsDefined())
{
ms_asTileLayerContainer.Invoke("removeMovieClip");
ms_asTileLayerContainer.SetUndefined();
}
if (ms_asBitmapLayerContainer.IsDefined())
{
ms_asBitmapLayerContainer.Invoke("removeMovieClip");
ms_asBitmapLayerContainer.SetUndefined();
}
if (ms_asBaseOverlay3D[MINIMAP_LAYER_FOREGROUND].IsDefined())
{
ms_asBaseOverlay3D[MINIMAP_LAYER_FOREGROUND].Invoke("removeMovieClip");
ms_asBaseOverlay3D[MINIMAP_LAYER_FOREGROUND].SetUndefined();
}
if (ms_asBaseOverlay3D[MINIMAP_LAYER_BACKGROUND].IsDefined())
{
ms_asBaseOverlay3D[MINIMAP_LAYER_BACKGROUND].Invoke("removeMovieClip");
ms_asBaseOverlay3D[MINIMAP_LAYER_BACKGROUND].SetUndefined();
}
if (ms_asBaseLayerContainer[MINIMAP_LAYER_BACKGROUND].IsDefined())
{
ms_asBaseLayerContainer[MINIMAP_LAYER_BACKGROUND].Invoke("removeMovieClip");
ms_asBaseLayerContainer[MINIMAP_LAYER_BACKGROUND].SetUndefined();
}
if (ms_asBaseLayerContainer[MINIMAP_LAYER_FOREGROUND].IsDefined())
{
ms_asBaseLayerContainer[MINIMAP_LAYER_FOREGROUND].Invoke("removeMovieClip");
ms_asBaseLayerContainer[MINIMAP_LAYER_FOREGROUND].SetUndefined();
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::SetMaskOnLayer
// PURPOSE: sets or unsets the mask on a layer
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::SetMaskOnLayer(bool bSet, s32 iLayer)
{
GFxValue args[1];
// either way, delete what's here
GFxValue asMask;
if (ms_asRootContainer[iLayer].HasMember("asMask"))
{
ms_asRootContainer[iLayer].GetMember("asMask", &asMask);
args[0].SetNull(); // set argument to AS as NULL
ms_asRootContainer[iLayer].Invoke("setMask", NULL, args, 1);
asMask.Invoke("removeMovieClip"); // remove the mask movie
asMask.SetUndefined();
}
if (bSet)
{
// create the mask:
GFxValue asMaskMc;
ms_asRootContainer[iLayer].CreateEmptyMovieClip(&asMask, "asMask", MOVIE_DEPTH_MASK);
GFxValue::DisplayInfo dispInfo;
// we're drawing the mask directly in SF, to make it tons easier to tune.
// the way this works, in theory, is:
// 1. Determine the aspect ratio the minimap is in natively
// 2. adjust away the offsets of the on-screen map (ie, the tunings are also in screen space)
// 3. scale the dimensions from 'screen space' to 'map space' (using the ratio from step 1)
// 4. draw the mask and set it on the appropriate layers
// because the map is drawn stretched and scaled from its original size, this series of convolutions is required to get it look right
// at all resolutions
Vector2 maskPos( ms_MiniMapRenderState.m_vCurrentMiniMapMaskPosition );
Vector2 maskSize( ms_MiniMapRenderState.m_vCurrentMiniMapMaskSize );
float fMapRatio = ms_vOriginalStageSize.x / ms_vOriginalStageSize.y;
const float fScaler = fMapRatio/CHudTools::GetAspectRatio();
maskPos.x -= ms_MiniMapRenderState.m_vCurrentMiniMapPosition.x; maskPos.y -= ms_MiniMapRenderState.m_vCurrentMiniMapPosition.y;
maskSize.x /= ms_MiniMapRenderState.m_vCurrentMiniMapSize.x; maskSize.y /= ms_MiniMapRenderState.m_vCurrentMiniMapSize.y;
maskPos.x *= ms_vOriginalStageSize.x/fScaler; maskPos.y *= ms_vOriginalStageSize.y;
maskSize.x *= ms_vOriginalStageSize.x/fScaler; maskSize.y *= ms_vOriginalStageSize.y;
GFxValue args[2];
u8 alpha = BANK_ONLY( sm_bDebugMaskDisplay ? sm_uDebugMaskAlpha : ) 100;
#define INVOKE(func, val1, val2); { args[0].SetNumber(val1); args[1].SetNumber(val2); asMask.Invoke(func, NULL, args,2); }
INVOKE("beginFill", 0x00FFFFFF, alpha); // white, full alpha
INVOKE("moveTo", maskPos.x, maskPos.y);
INVOKE("lineTo", maskPos.x+maskSize.x, maskPos.y);
INVOKE("lineTo", maskPos.x+maskSize.x, maskPos.y+maskSize.y);
INVOKE("lineTo", maskPos.x, maskPos.y+maskSize.y);
INVOKE("lineTo", maskPos.x, maskPos.y);
asMask.Invoke("endFill");
#if __BANK
if( sm_bDebugMaskDisplay )
{
static float thickness = 1;
static int color = 0x00FF00FF; // a nice purple
static int alpha = 50;
GFxValue args3[3];
args3[0].SetNumber(thickness);
args3[1].SetNumber(color);
args3[2].SetNumber(alpha); // alpha
asMask.Invoke("lineStyle", NULL, args3, 3);
INVOKE("moveTo", maskPos.x, maskPos.y);
INVOKE("lineTo", maskPos.x+maskSize.x, maskPos.y);
INVOKE("lineTo", maskPos.x+maskSize.x, maskPos.y+maskSize.y);
INVOKE("lineTo", maskPos.x, maskPos.y+maskSize.y);
INVOKE("lineTo", maskPos.x, maskPos.y);
}
else
#endif
{
args[0] = asMask; // set the arguments to AS at the mask
ms_asRootContainer[iLayer].Invoke("setMask", NULL, args, 1);
}
}
else
{
#if !__FINAL
if(CMiniMap_Common::OutputDebugTransitions())
{
uiDisplayf("MINIMAP_TRANSITION: CMiniMap_RenderThread::SetMaskOnLayer. turned off mask(RT)");
}
#endif
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::SetMask
// PURPOSE: create and enable or disable a mask on the minimap
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::SetMask(bool bSet)
{
for (s32 i = 0; i < MAX_MINIMAP_MOVIE_LAYERS; i++)
{
if (ms_iMovieId[i] == -1)
continue;
//s32 iLayer;
if (i == MINIMAP_MOVIE_FOREGROUND)
{
SetMaskOnLayer(bSet, MINIMAP_ROOT_LAYER_MASKED);
if (bSet)
{
if (ms_MiniMapRenderState.m_bIsInPauseMap && !CPauseMenu::IsNavigatingContent())
{
SetMaskOnLayer(true, MINIMAP_ROOT_LAYER_UNMASKED);
}
else
{
SetMaskOnLayer(false, MINIMAP_ROOT_LAYER_UNMASKED);
}
}
else
{
SetMaskOnLayer(false, MINIMAP_ROOT_LAYER_UNMASKED);
}
}
else
{
SetMaskOnLayer(bSet, MINIMAP_ROOT_MAP_TRANSPARENT);
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::SetupContainers()
// PURPOSE: sets up each ActionScript container
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::SetupContainers()
{
if (ms_iMovieId[MINIMAP_MOVIE_BACKGROUND] == -1 || ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
{
uiAssertf(0, "MiniMap: Minimap.gfx is not active yet - Minimap is unlikely to continue!");
return;
}
SetLocalStageSize();
CreateRoot(MINIMAP_MOVIE_BACKGROUND);
CreateRoot(MINIMAP_MOVIE_FOREGROUND);
CreateHealthArmourContainer();
CreateMapContainers();
CreateAltimeter();
CreateCrosshair();
// CreateRunway();
CreateFreeway();
CreateTerritoryContainer();
#if __DEV
if (!VerifyComponents())
{
uiAssertf(0, "MiniMap: Minimap.gfx is missing some vital components. Minimap is likely to be unstable!");
}
#endif // _DEV
SetMask(true);
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::RemoveContainers()
// PURPOSE: removes the containers setup inside SetupContainers
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::RemoveContainers()
{
if (ms_iMovieId[MINIMAP_MOVIE_BACKGROUND] == -1 || ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
{
uiAssertf(0, "MiniMap: Minimap.gfx is not active - Minimap is unlikely to continue!");
return;
}
// remove in reverse order of that we created them
SetMask(false);
RemoveTerritoryContainer();
RemoveFreeway();
RemoveAltimeter();
RemoveMapContainers();
RemoveHealthArmourContainer();
RemoveRoot(MINIMAP_MOVIE_BACKGROUND);
RemoveRoot(MINIMAP_MOVIE_FOREGROUND);
}
#if __DEV
/////////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::VerifyComponents()
// PURPOSE: this method checks some components on the movie at initialisation that we
// assume are there from now on to avoid having to check every time. This
// will only fail if there is a problem on the Actionscript side.
/////////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::VerifyComponents()
{
GFxValue asMovieObject = CScaleformMgr::GetActionScriptObjectFromRoot(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND]);
if ( ms_asMapObject.HasMember("main_map") )
{
return true;
}
return false;
}
#endif // __DEV
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::AddSonarBlipToStage
// PURPOSE: creates a self-removing "sonar" stealth blip. We do not need to keep
// track of these as these blips self-remove via ActionScript
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::AddSonarBlipToStage(sSonarBlipStructRT *pSonarBlip)
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::AddSonarBlipToStage can only be called on the RenderThread!");
return;
}
// if sonar layer is currently invisible, do not add any new sonar blips
GFxValue asSonarBlipLayer;
if (!ms_asBaseOverlay3D[MINIMAP_LAYER_FOREGROUND].GetMember("asSonarBlipLayer", &asSonarBlipLayer))
{
return;
}
GFxValue::DisplayInfo SonarLayerDisplayInfo;
asSonarBlipLayer.GetDisplayInfo(&SonarLayerDisplayInfo);
if (!SonarLayerDisplayInfo.GetVisible())
{
return;
}
char cRefName[MAX_BLIP_NAME_SIZE+10];
formatf(cRefName, "stealth_blip_%d", pSonarBlip->iId, NELEM(cRefName));
const char* cSonarBlipName = "stealth_blip_sonar_fill";
GFxValue asSonarBlipMc;
asSonarBlipLayer.GetMember(cRefName, &asSonarBlipMc);
if (!asSonarBlipMc.IsUndefined()) // sonar blip exists, so just set the frame back to 1
{
#define __BIGGEST_VISUAL_FRAME_NUM (1)
asSonarBlipMc.GotoAndPlay(__BIGGEST_VISUAL_FRAME_NUM);
}
else // sonar blip doesnt exist at all, so add it
{
if (pSonarBlip->iFramesAlive == 0)
{
asSonarBlipLayer.GFxValue::AttachMovie(&asSonarBlipMc, cSonarBlipName, cRefName, pSonarBlip->iId);
uiDisplayf("MiniMap: SONAR_BLIP - Attaching new sonar blip %s %s %d", cSonarBlipName, cRefName, pSonarBlip->iId);
}
}
// set it to the correct (latest) properties
if (!asSonarBlipMc.IsUndefined()) // sonar blip doesnt exist at all, so add it
{
GFxValue::DisplayInfo info;
info.SetPosition((pSonarBlip->vPos.x), -(pSonarBlip->vPos.y));
if (pSonarBlip->iFramesAlive == 0)
{
info.SetScale(pSonarBlip->fSize, pSonarBlip->fSize);
CRGBA blipColour = CHudColour::GetRGBA(pSonarBlip->iHudColour);
asSonarBlipMc.SetColorTransform(blipColour);
GFxValue::DisplayInfo dispInfo;
dispInfo.SetAlpha((float)blipColour.GetAlphaf() * 100.0f);
asSonarBlipMc.SetDisplayInfo(dispInfo);
uiDisplayf("MiniMap: SONAR_BLIP - Setting as new blip - %s %s %d - pos:%0.2f,%0.2f - size:%0.2f - alpha:%0.2f", cSonarBlipName, cRefName, pSonarBlip->iId, pSonarBlip->vPos.x, pSonarBlip->vPos.y, pSonarBlip->fSize, (float)blipColour.GetAlphaf() * 100.0f);
}
asSonarBlipMc.SetDisplayInfo(info);
}
}
void CMiniMap_RenderThread::SetupGolfCourseLayout()
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::SetupGolfCourseLayout can only be called on the RenderThread!");
return;
}
GFxValue asHealthContainer;
if (uiVerifyf(ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED].GetMember("asHealthContainer", &asHealthContainer), "CMiniMap_RenderThread: 'asHealthContainer' cannot be found when switching to golfcoursemap"))
{
if (uiVerifyf(asHealthContainer.IsDisplayObject(), "CMiniMap_RenderThread: 'asHealthContainer' is not a display object when switching to golfcourse"))
{
GFxValue::DisplayInfo healthContainerDisplayInfo;
healthContainerDisplayInfo.SetVisible(false);
asHealthContainer.SetDisplayInfo(healthContainerDisplayInfo);
}
}
UpdateSea(false);
GFxValue::DisplayInfo info;
info.SetVisible(false);
ms_asMapObject.SetDisplayInfo(info);
g_RenderMinimap = false;
SetMask(false);
for (s32 i = 0; i < MAX_MINIMAP_MOVIE_LAYERS; i++)
{
CScaleformMgr::ChangeMovieParams(ms_iMovieId[i], ms_MiniMapRenderState.m_vCurrentMiniMapPosition, ms_MiniMapRenderState.m_vCurrentMiniMapSize, GFxMovieView::SM_ExactFit);
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateGPSDisplay
// PURPOSE: updates the minimap with any gps display
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateGPSDisplay()
{
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return;
CGps::UpdateGpsOnMiniMapOnRT();
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateWithActionScriptOnRT
// PURPOSE: updates on the RenderThread as we alter ActionScript on the movie itself
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateWithActionScriptOnRT(bool bTransition, bool bClearTiles)
{
if (!ms_MiniMapRenderState.m_bIsActive)
return;
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::UpdateWithActionScriptOnRT can only be called on the RenderThread!");
return;
}
UpdateInterior();
UpdateMapPositionAndScale(bTransition);
UpdateMapVisibility();
UpdateAltimeter();
UpdateSonarSweep();
UpdateFreeway();
UpdateTiles(bClearTiles);
UpdateGolfCourse();
UpdateGPSDisplay();
GFxValue asCrosshairMc;
if (ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED].GetMember("asCrosshair", &asCrosshairMc))
{
GFxValue::DisplayInfo newDisplayInfo;
newDisplayInfo.SetVisible(ms_MiniMapRenderState.bDrawCrosshair);
asCrosshairMc.SetDisplayInfo(newDisplayInfo);
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateStatesWithActionScriptOnRT
// PURPOSE: switches minimap state (on the RT)
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateStatesWithActionScriptOnRT()
{
if (!ms_MiniMapRenderState.m_bIsActive)
return;
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::UpdateStatesWithActionScriptOnRT can only be called on the RenderThread!");
return;
}
switch (ms_MiniMapRenderState.m_MinimapModeState)
{
case MINIMAP_MODE_STATE_SETUP_FOR_MINIMAP:
{
// MinimapModeState = MINIMAP_MODE_STATE_NONE; // Graeme - Can't clear this on the RenderThread. I'm relying on it being cleared at the end of CMiniMap::UpdateStatesOnUT()
#if !__FINAL
if(CMiniMap_Common::OutputDebugTransitions())
uiDisplayf("MINIMAP_TRANSITION: CMiniMap_RenderThread::UpdateStatesWithActionScriptOnRT. Received MINIMAP_MODE_STATE_SETUP_FOR_MINIMAP(%d) before processed (RT)", ms_MiniMapRenderState.m_MinimapModeState);
#endif
SetupForMiniMap();
ms_MiniMapRenderState.m_MinimapModeState = MINIMAP_MODE_STATE_SETUP_FOR_MINIMAP_HAS_BEEN_PROCESSED_BY_RENDER_THREAD;
break;
}
case MINIMAP_MODE_STATE_SETUP_FOR_BIGMAP:
{
// MinimapModeState = MINIMAP_MODE_STATE_NONE; // Graeme - Can't clear this on the RenderThread. I'm relying on it being cleared at the end of CMiniMap::UpdateStatesOnUT()
#if !__FINAL
if(CMiniMap_Common::OutputDebugTransitions())
uiDisplayf("MINIMAP_TRANSITION: CMiniMap_RenderThread::UpdateStatesWithActionScriptOnRT. Received MINIMAP_MODE_STATE_SETUP_FOR_BIGMAP(%d) before processed (RT)", ms_MiniMapRenderState.m_MinimapModeState);
#endif
SetupForBigMap();
ms_MiniMapRenderState.m_MinimapModeState = MINIMAP_MODE_STATE_SETUP_FOR_BIGMAP_HAS_BEEN_PROCESSED_BY_RENDER_THREAD;
break;
}
case MINIMAP_MODE_STATE_SETUP_FOR_PAUSEMAP:
{
// MinimapModeState = MINIMAP_MODE_STATE_NONE; // Graeme - Can't clear this on the RenderThread. I'm relying on it being cleared at the end of CMiniMap::UpdateStatesOnUT()
#if !__FINAL
if(CMiniMap_Common::OutputDebugTransitions())
uiDisplayf("MINIMAP_TRANSITION: CMiniMap_RenderThread::UpdateStatesWithActionScriptOnRT. Received MINIMAP_MODE_STATE_SETUP_FOR_PAUSEMAP(%d) before processed (RT)", ms_MiniMapRenderState.m_MinimapModeState);
#endif
SetupForPauseMenu(true);
ms_MiniMapRenderState.m_MinimapModeState = MINIMAP_MODE_STATE_SETUP_FOR_PAUSEMAP_HAS_BEEN_PROCESSED_BY_RENDER_THREAD;
break;
}
case MINIMAP_MODE_STATE_SETUP_FOR_CUSTOMMAP:
{
#if !__FINAL
if(CMiniMap_Common::OutputDebugTransitions())
uiDisplayf("MINIMAP_TRANSITION: CMiniMap_RenderThread::UpdateStatesWithActionScriptOnRT. Received MINIMAP_MODE_STATE_SETUP_FOR_CUSTOMMAP(%d) before processed (RT)", ms_MiniMapRenderState.m_MinimapModeState);
#endif
// MinimapModeState = MINIMAP_MODE_STATE_NONE; // Graeme - Can't clear this on the RenderThread. I'm relying on it being cleared at the end of CMiniMap::UpdateStatesOnUT()
SetupForPauseMenu(false);
ms_MiniMapRenderState.m_MinimapModeState = MINIMAP_MODE_STATE_SETUP_FOR_CUSTOMMAP_HAS_BEEN_PROCESSED_BY_RENDER_THREAD;
break;
}
case MINIMAP_MODE_STATE_SETUP_FOR_GOLFMAP:
{
#if !__FINAL
if(CMiniMap_Common::OutputDebugTransitions())
uiDisplayf("MINIMAP_TRANSITION: CMiniMap_RenderThread::UpdateStatesWithActionScriptOnRT. Received MINIMAP_MODE_STATE_SETUP_FOR_GOLFMAP(%d) before processed (RT)", ms_MiniMapRenderState.m_MinimapModeState);
#endif
// MinimapModeState = MINIMAP_MODE_STATE_NONE; // Graeme - Can't clear this on the RenderThread. I'm relying on it being cleared at the end of CMiniMap::UpdateStatesOnUT()
SetupForMiniMap();
ms_MiniMapRenderState.m_MinimapModeState = MINIMAP_MODE_STATE_SETUP_FOR_GOLFMAP_HAS_BEEN_PROCESSED_BY_RENDER_THREAD;
break;
}
default:
{
// nothing
break;
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::ClearMatrix
// PURPOSE: clears the matrix3d when going from 3D to 2D view
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::ClearMatrix()
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::ClearMatrix can only be called on the RenderThread!");
return;
}
GFxValue nullValue;
nullValue.SetNull();
ms_asBaseLayerContainer[MINIMAP_LAYER_BACKGROUND].SetMember("_matrix3d", nullValue);
ms_asBaseLayerContainer[MINIMAP_LAYER_FOREGROUND].SetMember("_matrix3d", nullValue);
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateMapPositionAndScale
// PURPOSE: update position and scale of the map
/////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::UpdateMapPositionAndScale(bool bForceInstantRangeChange)
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::UpdateMapPositionAndScale can only be called on the RenderThread!");
return true;
}
bool bValuesChanged = false;
bool bInstantChanges = bForceInstantRangeChange;
if (ms_MiniMapRenderState.m_bIsInBigMap || ms_MiniMapRenderState.m_bInsideReappearance)
{
bInstantChanges = true; // always instant changes if in bigmap
}
const float fTimeAdjustment = fwTimer::GetSystemTimeStep();
//
// Tilt
//
GFxValue::DisplayInfo infoTilt;
bValuesChanged = false;
ms_asBaseLayerContainer[MINIMAP_LAYER_FOREGROUND].GetDisplayInfo(&infoTilt);
float fNewPosY = (ms_vStageSize.y * 0.5f) + ms_MiniMapRenderState.m_fOffset;
float fCurrentAngle = (float)infoTilt.GetXRotation();
if (infoTilt.GetY() != fNewPosY)
{
infoTilt.SetY(fNewPosY);
bValuesChanged = true;
}
if (ms_MiniMapRenderState.m_bIsInPauseMap || bInstantChanges)
{
if (infoTilt.GetXRotation() != ms_MiniMapRenderState.m_fAngle)
{
infoTilt.SetXRotation(ms_MiniMapRenderState.m_fAngle);
bValuesChanged = true;
}
}
else
{
#define ANGLE_ADJUSTER (6.0f*30.0f) // 6 degrees every update * 30 to compensate for legacy frame-based tunings
float fCurrAngle = fCurrentAngle;
Approach(fCurrAngle, ms_MiniMapRenderState.m_fAngle, ANGLE_ADJUSTER, fTimeAdjustment);
infoTilt.SetXRotation(fCurrAngle);
}
//if (bValuesChanged)
{
ms_asBaseLayerContainer[MINIMAP_LAYER_BACKGROUND].SetDisplayInfo(infoTilt);
ms_asBaseLayerContainer[MINIMAP_LAYER_FOREGROUND].SetDisplayInfo(infoTilt);
if (infoTilt.GetXRotation() == 0.0f && fCurrentAngle != 0.0f) // if new angle is 0.0f and old was not 0.0f then clear matrix
{
ClearMatrix();
}
}
//
// end of Tilt
//
//
// Position
//
GFxValue::DisplayInfo CurrInfo;
ms_asMapObject.GetDisplayInfo(&CurrInfo);
if ((float)CurrInfo.GetX() != -ms_MiniMapRenderState.m_vMiniMapPosition.x || (float)CurrInfo.GetY() != ms_MiniMapRenderState.m_vMiniMapPosition.y)
{
GFxValue::DisplayInfo infoPosition;
infoPosition.SetPosition(-ms_MiniMapRenderState.m_vMiniMapPosition.x, ms_MiniMapRenderState.m_vMiniMapPosition.y);
ms_asMapObject.SetDisplayInfo(infoPosition);
ms_asBlipLayer3D.SetDisplayInfo(infoPosition);
ms_asBaseOverlay3D[MINIMAP_LAYER_BACKGROUND].SetDisplayInfo(infoPosition);
ms_asBaseOverlay3D[MINIMAP_LAYER_FOREGROUND].SetDisplayInfo(infoPosition);
}
//
// End of Position
//
//
// Range and Rotation
//
GFxValue::DisplayInfo infoRangeRotation;
ms_asMapContainerMc.GetDisplayInfo(&CurrInfo);
float fCurrRange = (float)CurrInfo.GetXScale();
bValuesChanged = false;
if ( (fCurrRange != ms_MiniMapRenderState.m_fMiniMapRange) )
{
float fThisRange = ms_MiniMapRenderState.m_fMiniMapRange;
if (( ms_MiniMapRenderState.m_bIsInPauseMap || (ms_MiniMapRenderState.m_bIsInCustomMap && !ms_MiniMapRenderState.m_bLockedToDistanceZoom)) || bInstantChanges)
{
// if in pausemap and we zoom, redraw the gps so we can scale it accordingly
CGps::ForceUpdateOfGpsOnMiniMap();
infoRangeRotation.SetScale(fThisRange, fThisRange);
bValuesChanged = true;
}
else
{
#define RANGE_SCALER (0.07f*30.0f) // *30 to compensate for legacy frame-based tunings
if( fCurrRange != fThisRange )
{
float fRangeAdjuster = (RANGE_SCALER * fCurrRange);
Approach(fCurrRange, fThisRange, fRangeAdjuster, fTimeAdjustment);
infoRangeRotation.SetScale(fCurrRange, fCurrRange);
bValuesChanged = true;
}
}
}
if ((s32)CurrInfo.GetRotation() != ms_MiniMapRenderState.m_iRotation)
{
infoRangeRotation.SetRotation(ms_MiniMapRenderState.m_iRotation);
bValuesChanged = true;
}
if (bValuesChanged)
{
ms_asMapContainerMc.SetDisplayInfo(infoRangeRotation);
ms_asBlipContainerMc.SetDisplayInfo(infoRangeRotation);
}
//
// end of Range and Rotation
//
GFxMovieView* pView = CScaleformMgr::GetMovieView(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND]);
if (pView)
{
pView->FindLocalToScreenMatrix(BLIP_LAYER_PATH, ms_LocalToScreen.GetRenderBuf());
}
ms_fBlipMapRange = fCurrRange;
ms_fBlipMapAngle = ms_MiniMapRenderState.m_fAngle;
return (bValuesChanged);
}
// bool CMiniMap_RenderThread::IsFlagSet(CBlipComplex *pBlip, const s32 iQueryFlag)
// {
// if (uiVerifyf(pBlip, "CMiniMap_RenderThread::IsFlagSet - Blip not valid!"))
// {
// return ((pBlip->iFlags & iQueryFlag) ? true : false);
// }
//
// return false;
// }
Vector3 CMiniMap_RenderThread::GetBlipPositionValue(const CBlipComplex *pBlip)
{
return pBlip->vPosition;
}
const Vector3& CMiniMap_RenderThread::GetBlipPositionConstRef(const CBlipComplex *pBlip)
{
return pBlip->vPosition;
}
// This seems to be the same as GetBlipPositionValue
Vector3 CMiniMap_RenderThread::GetBlipPositionValueOnStage(const CBlipComplex *pBlip)
{
if (uiVerifyf(pBlip, "Blip doesnt exist!"))
{
return pBlip->vPosition;
}
return ORIGIN;
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::CheckForHeight()
// PURPOSE: Returns whether the blip is higher or lower than the player
// (expressed as -1, 0, 1)
/////////////////////////////////////////////////////////////////////////////////////
s32 CMiniMap_RenderThread::CheckForHeight(CBlipComplex *pBlip)
{
#define METRES_TO_CHECK_ABOVE_BELOW_BLIP_EXTENDED (10.0f)
#define METRES_TO_CHECK_ABOVE_BELOW_BLIP_STANDARD (2.0f)
#define METRES_TO_CHECK_ABOVE_BELOW_BLIP_SHORT (1.0f)
if (pBlip)
{
float fMetresToCheck = METRES_TO_CHECK_ABOVE_BELOW_BLIP_STANDARD;
if (CMiniMap::IsFlagSet(pBlip, BLIP_FLAG_USE_EXTENDED_HEIGHT_THRESHOLD) || ms_MiniMapRenderState.bInPlaneOrHeli)
{
fMetresToCheck = METRES_TO_CHECK_ABOVE_BELOW_BLIP_EXTENDED;
}
else if (CMiniMap::IsFlagSet(pBlip, BLIP_FLAG_USE_SHORT_HEIGHT_THRESHOLD))
{
fMetresToCheck = METRES_TO_CHECK_ABOVE_BELOW_BLIP_SHORT;
}
float fBlipHeight = GetBlipPositionValue(pBlip).z;
float fPlayerHeight = ms_MiniMapRenderState.m_vCentrePosition.z;
if (fPlayerHeight < fBlipHeight-fMetresToCheck)
{
return -1; // lower
}
else if (fPlayerHeight > fBlipHeight+fMetresToCheck)
{
return 1; // higher
}
}
return 0; // level
}
void CMiniMap_RenderThread::GetMiniMapCoordinatesForCone(float inputX, float inputY, float fMapRange, float &outputX, float &outputY)
{
if ( (ms_MiniMapRenderState.m_fPlayerVehicleSpeed == 0.0f) && (fMapRange < MAP_BLIP_ROUND_THRESHOLD) )
{
outputX = floor(inputX+0.5f);
outputY = floor(-inputY+0.5f);
}
else
{
outputX = inputX;
outputY = -inputY;
}
}
void DrawCone(GFxValue &coneValue, float fStartAzimuthAngle, float fEndAzimuthAngle, float fFocusRange)
{
GFxValue args[2];
Vector3 line(0.0f, fFocusRange, 0.0f);
line.RotateZ(fStartAzimuthAngle);
// Draw line from ped
args[0].SetNumber(0.0f);
args[1].SetNumber(0.0f);
coneValue.Invoke("moveTo", NULL, args, 2);
args[0].SetNumber(line.x);
args[1].SetNumber(-line.y);
coneValue.Invoke("lineTo", NULL, args, 2);
// End of draw line from ped
// Draw arc
float fAngle = fStartAzimuthAngle;
static float ANGLE_RENDER_DIFF = PI/32.0f;
while( fAngle < fEndAzimuthAngle )
{
float fNextAngle = Min(fAngle + ANGLE_RENDER_DIFF, fEndAzimuthAngle);
Vector3 line2(0.0f, fFocusRange, 0.0f);
line2.RotateZ(fNextAngle);
args[0].SetNumber(line2.x);
args[1].SetNumber(-line2.y);
coneValue.Invoke("lineTo", NULL, args, 2);
fAngle = fNextAngle;
}
// Draw line back from end of cone to origin
args[0].SetNumber(0.0f);
args[1].SetNumber(0.0f);
coneValue.Invoke("lineTo", NULL, args, 2);
}
void CMiniMap_RenderThread::DrawConeForBlip(GFxValue &coneValue, CBlipCone &blipCone)
{
GFxValue::DisplayInfo infoForNewlyCreatedCone;
GFxValue args[5];
float aAsimuthAngles[MAX_CONE_ANGLES] = { blipCone.GetVisualFieldMinAzimuthAngle(), -blipCone.GetGazeAngle(),
blipCone.GetGazeAngle(), blipCone.GetVisualFieldMaxAzimuthAngle() };
// Calculate the peripheral and focus ranges to render
// float fPeripheralRange = blipCone.GetPeripheralRange();
float fFocusRange = blipCone.GetFocusRange();
args[0].SetNumber(0); // thickness - 0=thinnest, 255=thickest
args[3].SetBoolean(false); // pixelHinting
args[4].SetString("normal"); // noScale - "normal" is the default, try "none"
#if __BANK
if (CMiniMap::GetDrawActualRangeCone())
{
// Set colour and alpha of debug cone
args[1].SetNumber(0xff0000);
args[2].SetNumber(100);
coneValue.Invoke("lineStyle", NULL, args, 5);
// Draw debug cone. This shows the actual perception range i.e. before FocusRangeMultiplier is applied
DrawCone(coneValue, aAsimuthAngles[1], aAsimuthAngles[2], fFocusRange);
}
#endif // __BANK
// Set colour and alpha of real cone
CRGBA color = CHudColour::GetRGBA(blipCone.GetColor());
s32 fillColour = color.GetRed() << 16;
fillColour |= color.GetGreen() << 8;
fillColour |= color.GetBlue();
s32 coneAlpha = CMiniMap_Common::ALPHA_OF_POLICE_PERCEPTION_CONES;
#if __BANK
if (CMiniMap::GetOverrideConeColour())
{ // This isn't really thread-safe. Hopefully, it doesn't matter too much since it's debug code.
fillColour = CMiniMap::GetConeColourRed() << 16;
fillColour |= CMiniMap::GetConeColourGreen() << 8;
fillColour |= CMiniMap::GetConeColourBlue();
coneAlpha = CMiniMap::GetConeColourAlpha();
}
#endif // __BANK
args[1].SetNumber(fillColour);
args[2].SetNumber(coneAlpha);
coneValue.Invoke("lineStyle", NULL, args, 5);
#if __BANK
fFocusRange *= CMiniMap::GetConeFocusRangeMultiplier();
#else
fFocusRange *= 1.05f;
#endif // __BANK
// Graeme - I'm not drawing the peripheral cones here - maybe I'll need to add them back in later.
// In the past when I was drawing them, they were so small that I couldn't actually see them on the radar.
args[0].SetNumber(fillColour);
args[1].SetNumber(coneAlpha);
coneValue.Invoke("beginFill", NULL, args, 2);
DrawCone(coneValue, aAsimuthAngles[1], aAsimuthAngles[2], fFocusRange);
// float fStartAzimuthAngle = aAsimuthAngles[1];
// float fEndAzimuthAngle = aAsimuthAngles[2];
coneValue.Invoke("endFill", NULL, args, 0);
infoForNewlyCreatedCone.SetVisible(true);
coneValue.SetDisplayInfo(infoForNewlyCreatedCone);
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::AddOrUpdateConeToBlipOnStage
// PURPOSE: adds a directional code to the blip on the stage
// idea is to mimic what CPedPerception::DrawVisualField() does here
// but in Scaleform
/////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::AddOrUpdateConeToBlipOnStage(CBlipCone &blipCone)
{
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return false;
GFxValue::DisplayInfo currentDisplayInfoMc;
ms_asMapContainerMc.GetDisplayInfo(&currentDisplayInfoMc);
float fMapRange = (float)currentDisplayInfoMc.GetXScale();
GFxValue coneValue;
bool bConeNeedsToBeDrawn = false;
char cRefName[MAX_BLIP_NAME_SIZE];
s32 iActualId = blipCone.GetActualId();
formatf(cRefName, "cone_%d", iActualId, NELEM(cRefName));
bool bHasConeAttached = ms_asBlipLayer3D.GFxValue::HasMember(cRefName);
if (!bHasConeAttached)
{
ms_asBlipLayer3D.CreateEmptyMovieClip(&coneValue, cRefName, iActualId);
if (!coneValue.IsUndefined())
{
sConesAttachedToBlips dataForNewCone;
dataForNewCone.m_iActualIdOfBlip = iActualId;
dataForNewCone.m_bConeShouldBeRemovedFromStage = false;
ms_ConesAttachedToBlips.PushAndGrow(dataForNewCone);
bConeNeedsToBeDrawn = true;
uiDebugf2("[PEDCONES] Creating cone for Blip Actual %i", iActualId);
}
else
{
uiErrorf("[PEDCONES] Failed to create cone for Blip Actual %i (no empty movie clip)", iActualId);
}
}
else
{
ms_asBlipLayer3D.GFxValue::GetMember(cRefName, &coneValue);
const s32 arraySize = ms_ConesAttachedToBlips.GetCount();
s32 coneLoop = 0;
bool bFound = false;
while ( (coneLoop < arraySize) && !bFound)
{
if (ms_ConesAttachedToBlips[coneLoop].m_iActualIdOfBlip == iActualId)
{
ms_ConesAttachedToBlips[coneLoop].m_bConeShouldBeRemovedFromStage = false;
bFound = true;
}
coneLoop++;
}
uiAssertf(bFound, "CMiniMap_RenderThread::AddOrUpdateConeToBlipOnStage - didn't find cone with ActualId of %d in the ms_ConesAttachedToBlips array", iActualId);
if (blipCone.GetForceRedraw())
{
if (uiVerifyf(coneValue.IsDisplayObject(), "CMiniMap_RenderThread::AddOrUpdateConeToBlipOnStage - cone is not a display object"))
{
coneValue.Invoke("clear");
}
bConeNeedsToBeDrawn = true;
}
}
if (!coneValue.IsUndefined())
{
if (bConeNeedsToBeDrawn)
{
DrawConeForBlip(coneValue, blipCone);
uiDebugf2("[PEDCONES] Drawing a ped cone for Blip %i with Alpha %i, Focus Range %f, Gaze Angle %f, Pos <<%.2f, %.2f>>"
, iActualId, blipCone.GetAlpha(), blipCone.GetFocusRange(), blipCone.GetGazeAngle(), blipCone.GetPosX(), blipCone.GetPosY());
}
GFxValue::DisplayInfo info;
// ensure the cone is positioned at the coords of the blip but on the 3d layer
float fPositionOnMiniMapX = 0.0f;
float fPositionOnMiniMapY = 0.0f;
GetMiniMapCoordinatesForCone(blipCone.GetPosX(), blipCone.GetPosY(), fMapRange, fPositionOnMiniMapX, fPositionOnMiniMapY);
info.SetPosition(fPositionOnMiniMapX, fPositionOnMiniMapY);
float fBlipRotation = -(blipCone.GetRotation() * RtoD); // get blip rotation
info.SetRotation(fBlipRotation);
info.SetAlpha(100.0f * (float)blipCone.GetAlpha()/255.0f);
coneValue.SetDisplayInfo(info);
return true;
}
return false;
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateVisualDataSettings
// PURPOSE: Load visual settings tune data.
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateVisualDataSettings()
{
Assertf(g_visualSettings.GetIsLoaded(), "visual settings aren't loaded");
ms_MiniMapAlpha = g_visualSettings.Get("UI.minimap.alpha", 1.0f);
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::RemoveConeFromBlipOnStage
// PURPOSE: removes the cone
/////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::RemoveConeFromBlipOnStage(s32 iActualIdOfBlip)
{
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return false;
char cRefName[MAX_BLIP_NAME_SIZE+10];
formatf(cRefName, "cone_%d", iActualIdOfBlip, NELEM(cRefName));
bool bHasConeAttached = ms_asBlipLayer3D.GFxValue::HasMember(cRefName);
if (bHasConeAttached) // already got higher blip attached, so remove this 1st
{
GFxValue pCone;
ms_asBlipLayer3D.GFxValue::GetMember(cRefName, &pCone);
if (pCone.IsDisplayObject())
{
pCone.Invoke("removeMovieClip");
return true;
}
}
return false;
}
void CMiniMap_RenderThread::ResetBlipConeFlags()
{
const s32 arraySize = ms_ConesAttachedToBlips.GetCount();
for (s32 coneLoop = 0; coneLoop < arraySize; coneLoop++)
{
ms_ConesAttachedToBlips[coneLoop].m_bConeShouldBeRemovedFromStage = true;
}
}
void CMiniMap_RenderThread::RemoveUnusedBlipConesFromStage()
{
const s32 sizeOfArray = ms_ConesAttachedToBlips.GetCount();
s32 coneLoop = sizeOfArray - 1;
while (coneLoop >= 0)
{
if (ms_ConesAttachedToBlips[coneLoop].m_bConeShouldBeRemovedFromStage)
{
uiDebugf2("[PEDCONES] Removing unused cone from Blip Actual %i", ms_ConesAttachedToBlips[coneLoop].m_iActualIdOfBlip);
RemoveConeFromBlipOnStage(ms_ConesAttachedToBlips[coneLoop].m_iActualIdOfBlip);
ms_ConesAttachedToBlips.Delete(coneLoop);
}
coneLoop--;
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::ShouldBlipHeightIndicatorFlash
// PURPOSE: decides whether this blip height indicator should flash - bug 948610
/////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::ShouldBlipHeightIndicatorFlash(CBlipComplex *pBlip)
{
if (!pBlip)
return true;
switch(GetBlipObjectNameId(pBlip))
{
// always flash health or armour (1665263)
case RADAR_TRACE_WEAPON_HEALTH:
case RADAR_TRACE_WEAPON_ARMOUR:
// exceptional list continues
// should PROBABLY be based on if the blip is a 'circle', and if it uses the override AI_BLIP instead of the normal higher/lower
case RADAR_TRACE_HOT_PROPERTY:
case RADAR_TRACE_KING_OF_THE_CASTLE:
case RADAR_TRACE_DEAD_DROP:
case RADAR_TRACE_SM_CARGO:
case RADAR_TRACE_SM_HANGAR:
case RADAR_TRACE_NHP_BAG:
case RADAR_TRACE_BAT_CARGO:
case RADAR_TRACE_TEMP_1:
case RADAR_TRACE_BAT_ASSASSINATE:
return true;
default:
break;
}
eBLIP_COLOURS blipColour = GetBlipColourValue(pBlip);
bool bReturnValue = false;
switch (blipColour)
{
case BLIP_COLOUR_BLUE:
case BLIP_COLOUR_GREEN:
case BLIP_COLOUR_YELLOW:
case BLIP_COLOUR_RED:
case BLIP_COLOUR_FRIENDLY:
{
//uiDisplayf("BLIP '%s' WILL NOT FLASH", CMiniMap::GetBlipNameValue(pBlip));
bReturnValue = false;
break;
}
default:
{
//uiDisplayf("BLIP '%s' WILL FLASH", CMiniMap::GetBlipNameValue(pBlip));
bReturnValue = true;
}
}
return (bReturnValue);
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::ShouldBlipUseWeaponTypeArrows
// PURPOSE: should the blip be overridden with a specific type of up/down arrow
/////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::ShouldBlipUseWeaponTypeArrows(CBlipComplex const *pBlip)
{
if (pBlip)
{
BlipLinkage const c_blipId = GetBlipObjectNameId(pBlip);
return ((!strncmp(WEAPON_BLIP_NAME, GetBlipObjectName(pBlip), NELEM(WEAPON_BLIP_NAME)-1)) ||
c_blipId == RADAR_TRACE_TESTOSTERONE ||
c_blipId == RADAR_TRACE_PICKUP_BEAST ||
c_blipId == RADAR_TRACE_PICKUP_ZONED ||
c_blipId == RADAR_TRACE_PICKUP_RANDOM ||
c_blipId == RADAR_TRACE_PICKUP_SLOW_TIME ||
c_blipId == RADAR_TRACE_PICKUP_SWAP ||
c_blipId == RADAR_TRACE_PICKUP_THERMAL ||
c_blipId == RADAR_TRACE_PICKUP_WEED ||
c_blipId == RADAR_TRACE_WEAPON_RAILGUN ||
c_blipId == RADAR_TRACE_BALL ||
c_blipId == RADAR_TRACE_HIDDEN ||
c_blipId == RADAR_TRACE_ROCKETS ||
c_blipId == RADAR_TRACE_BOOST ||
c_blipId == RADAR_TRACE_PICKUP_GHOST ||
c_blipId == RADAR_TRACE_PICKUP_ARMOURED ||
c_blipId == RADAR_TRACE_PICKUP_ACCELERATOR ||
c_blipId == RADAR_TRACE_PICKUP_SWAP ||
c_blipId == RADAR_TRACE_PICKUP_DETONATOR ||
c_blipId == RADAR_TRACE_PICKUP_BOMB ||
c_blipId == RADAR_TRACE_PICKUP_JUMP ||
c_blipId == RADAR_TRACE_PICKUP_DEADLINE ||
c_blipId == RADAR_TRACE_PICKUP_REPAIR ||
c_blipId == RADAR_TRACE_PICKUP_ROCKET_BOOST ||
c_blipId == RADAR_TRACE_PICKUP_HOMING_ROCKET ||
c_blipId == RADAR_TRACE_PICKUP_MACHINEGUN ||
c_blipId == RADAR_TRACE_PICKUP_PARACHUTE ||
c_blipId == RADAR_TRACE_PICKUP_TIME_5 ||
c_blipId == RADAR_TRACE_PICKUP_TIME_10 ||
c_blipId == RADAR_TRACE_PICKUP_TIME_15 ||
c_blipId == RADAR_TRACE_PICKUP_TIME_20 ||
c_blipId == RADAR_TRACE_PICKUP_TIME_30 ||
c_blipId == RADAR_TRACE_CONTRABAND ||
c_blipId == RADAR_TRACE_PICKUP_DTB_HEALTH ||
c_blipId == RADAR_TRACE_PICKUP_DTB_BOMB_INCREASE ||
c_blipId == RADAR_TRACE_PICKUP_DTB_BOMB_DECREASE ||
c_blipId == RADAR_TRACE_PICKUP_DTB_BLAST_INCREASE ||
c_blipId == RADAR_TRACE_PICKUP_DTB_BLAST_DECREASE);
}
return false;
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::ShouldBlipUseAiTypeArrows
// PURPOSE: should the blip be overridden with a specific type of up/down arrow
/////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::ShouldBlipUseAiTypeArrows(CBlipComplex const *pBlip)
{
if (pBlip)
{
BlipLinkage const c_blipId = GetBlipObjectNameId(pBlip);
return (c_blipId == RADAR_TRACE_CAPTURE_THE_FLAG ||
c_blipId == RADAR_TRACE_CAPTURE_THE_USAFLAG ||
c_blipId == RADAR_TRACE_LEVEL_INSIDE ||
c_blipId == RADAR_TRACE_PLAYER_KING ||
c_blipId == RADAR_TRACE_BOUNTY_HIT_INSIDE); // fix for 1723248 & 1772239
}
return false;
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::AddHigherLowerBlip
// PURPOSE: adds the higher/lower blip onto the blip that is on the stage
/////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::AddHigherLowerBlip(GFxValue *pBlipGfx, CBlipComplex *pBlip, s32 iHighLowBlipId)
{
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return false;
if (!pBlipGfx)
return false;
if (!pBlipGfx->IsDisplayObject())
return false;
if (!pBlip)
return false;
GFxValue higherBlip;
GFxValue lowerBlip;
pBlipGfx->GFxValue::GetMember("higher_blip",&higherBlip);
pBlipGfx->GFxValue::GetMember("lower_blip",&lowerBlip);
GFxValue* pRecolourThis = nullptr;
if (iHighLowBlipId == -1) // lower
{
RemoveHigherLowerBlip(pBlipGfx, 1); // remove the higher one
if (!lowerBlip.IsDisplayObject())
{
const char* pHigherLowerName = NULL;
if (GetBlipObjectNameId(pBlip) == RADAR_TRACE_BOUNTY_HIT) // new stuff doesnt require these higher/lower blips to be in the enum but means we need to use their names here
{
pHigherLowerName = "radar_bounty_hit_higher";
}
else
{
s32 iLowerBlipNameId = BLIP_LEVEL+iHighLowBlipId;
if (ShouldBlipUseWeaponTypeArrows(pBlip))
{
iLowerBlipNameId = BLIP_WEAPON_HIGHER;
}
else if (ShouldBlipUseAiTypeArrows(pBlip))
{
iLowerBlipNameId = BLIP_AI_HIGHER;
}
else if (!strcmp(HOOP_BLIP_NAME, GetBlipObjectName(pBlip)))
{
iLowerBlipNameId = BLIP_AI_HIGHER;
}
pHigherLowerName = CMiniMap_Common::GetBlipName(iLowerBlipNameId);
}
pBlipGfx->GFxValue::AttachMovie(&lowerBlip, pHigherLowerName, "lower_blip", BLIP_DEPTH_HIGHER_LOWER);
pRecolourThis = &lowerBlip;
}
else if( CMiniMap::IsFlagSet(pBlip,BLIP_FLAG_VALUE_CHANGED_COLOUR) )
{
pRecolourThis = &lowerBlip;
}
}
else if (iHighLowBlipId == 1) // higher
{
RemoveHigherLowerBlip(pBlipGfx, -1); // remove the lower one
if (!higherBlip.IsDisplayObject())
{
const char* pHigherLowerName = NULL;
if (GetBlipObjectNameId(pBlip) == RADAR_TRACE_BOUNTY_HIT) // new stuff doesnt require these higher/lower blips to be in the enum but means we need to use their names here
{
pHigherLowerName = "radar_bounty_hit_lower";
}
else
{
s32 iHigherBlipNameId = BLIP_LEVEL+iHighLowBlipId;
if (ShouldBlipUseWeaponTypeArrows(pBlip))
{
iHigherBlipNameId = BLIP_WEAPON_LOWER;
}
else if (ShouldBlipUseAiTypeArrows(pBlip))
{
iHigherBlipNameId = BLIP_AI_LOWER;
}
else if (!strcmp(HOOP_BLIP_NAME, GetBlipObjectName(pBlip)))
{
iHigherBlipNameId = BLIP_AI_LOWER;
}
pHigherLowerName = CMiniMap_Common::GetBlipName(iHigherBlipNameId);
}
pBlipGfx->GFxValue::AttachMovie(&higherBlip, pHigherLowerName, "higher_blip", BLIP_DEPTH_HIGHER_LOWER);
pRecolourThis = &higherBlip;
}
else if( CMiniMap::IsFlagSet(pBlip,BLIP_FLAG_VALUE_CHANGED_COLOUR) )
{
pRecolourThis = &higherBlip;
}
}
else
{
uiAssertf(0, "CMiniMap_RenderThread: Invalid height value");
return false;
}
if( pRecolourThis != nullptr )
{
// apply colour onto the blip whether we created it this time or we got it from before
if (pRecolourThis->IsDisplayObject())
{
// since this is based on color, we should check it here too
if (!ShouldBlipHeightIndicatorFlash(pBlip))
{
pRecolourThis->GotoAndStop(1); // stop on frame 1 as we don't want to flash these (bug 948610)
}
CRGBA blipColour;
if (GetBlipObjectNameId(pBlip) == RADAR_TRACE_WEAPON_HEALTH || GetBlipObjectNameId(pBlip) == RADAR_TRACE_WEAPON_ARMOUR)
{
// health/armour blip height indicator should be white
blipColour = CHudColour::GetRGBA(HUD_COLOUR_WHITE);
}
else
{
// other blips should be same colour as the main blip
blipColour = CMiniMap_Common::GetColourFromBlipSettings(GetBlipColourValue(pBlip), CMiniMap::IsFlagSet(pBlip,BLIP_FLAG_BRIGHTNESS));
}
pRecolourThis->SetColorTransform(blipColour);
GFxValue::DisplayInfo dispInfo;
s32 iMainBlipAlpha = GetBlipAlphaValue(pBlip);
dispInfo.SetAlpha((float)((iMainBlipAlpha / 255.0f) * 100.0f));
pRecolourThis->SetDisplayInfo(dispInfo);
}
}
return true;
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::RemoveHigherLowerBlip
// PURPOSE: removes the higher/lower blip
/////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::RemoveHigherLowerBlip(GFxValue *pBlipGfx, int iHigherOrLower /* = 0 */)
{
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return false;
if (!pBlipGfx)
return false;
if (!pBlipGfx->IsDisplayObject())
return false;
// if iHigherOrLower is -1, we wanna remove ONLY the lower blip
// if it's 1, remove ONLY the higher blip
// otherwise, remove any (but for some reason not both...?)
GFxValue pHeightBlip;
if ( (iHigherOrLower == 0 || iHigherOrLower == 1) && pBlipGfx->GFxValue::GetMember("higher_blip", &pHeightBlip))
{
if (pHeightBlip.IsDisplayObject())
{
pHeightBlip.Invoke("removeMovieClip");
}
// some of the height blips may selectively have hidden the main blip
// so we'll unhide it just in case
GFxValue mainBlip;
if( pBlipGfx->GetMember("main_blip", &mainBlip) )
{
GFxValue::DisplayInfo di;
di.SetVisible(true);
mainBlip.SetDisplayInfo(di);
}
return true;
}
if ((iHigherOrLower == 0 || iHigherOrLower == -1) && pBlipGfx->GFxValue::GetMember("lower_blip", &pHeightBlip))
{
if (pHeightBlip.IsDisplayObject())
{
pHeightBlip.Invoke("removeMovieClip");
}
// some of the height blips may selectively have hidden the main blip
// so we'll unhide it just in case
GFxValue mainBlip;
if( pBlipGfx->GetMember("main_blip", &mainBlip) )
{
GFxValue::DisplayInfo di;
di.SetVisible(true);
mainBlip.SetDisplayInfo(di);
}
return true;
}
return false;
}
/*void CMiniMap_RenderThread::SetFlag(CBlipComplex *pBlip, const int flag)
{
pBlip->iFlags |= flag;
}
void CMiniMap_RenderThread::UnsetFlag(CBlipComplex *pBlip, const int flag)
{
if(IsFlagSet(pBlip, flag))
{
pBlip->iFlags &= ~flag;
}
}*/
bool CMiniMap_RenderThread::GetIsInsideInterior()
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::GetIsInsideInterior can only be called on the RenderThread!");
return false;
}
return ms_MiniMapRenderState.bInsideInterior;
}
s32 CMiniMap_RenderThread::DetermineBlipStageDepth(CBlipComplex* pBlip)
{
eBLIP_PRIORITY priority = GetBlipPriorityValue(pBlip);
if( CMiniMap::IsFlagSet(pBlip, BLIP_FLAG_HOVERED_ON_PAUSEMAP) )
priority = BLIP_PRIORITY_ONTOP_OF_EVERYTHING; // so they will always float to the top, as they DO have the player hovering directly over them, after all
return ( s32(priority) * MAX_NUM_BLIPS) + pBlip->m_iActualId; // fix for 1564035 (and possibly some priority issues too)
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::AddBlipToStage
// PURPOSE: creates the GFxValue object as the blip is now active on the stage
/////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::AddBlipToStage(CBlipComplex *pBlip)
{
PF_FUNC(AddBlipToStage);
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return false;
if (!pBlip)
return false;
s32 iActualId = pBlip->m_iActualId;
if (iActualId == -1)
{
uiAssertf(0, "CMiniMap_RenderThread::AddBlipToStage - iActualId of blip is -1");
return false;
}
const char* pBlipName = GetBlipObjectName(pBlip);
s32 iStageDepth = DetermineBlipStageDepth(pBlip);
uiAssertf(pRenderedBlipObject[iActualId] == NULL, "CMiniMap_RenderThread::AddBlipToStage - pRenderedBlipObject in slot %d should be NULL at the beginning of this function", iActualId);
// create the actual blip:
pRenderedBlipObject[iActualId] = rage_new GFxValue;
GFxValue *pGfxValue = pRenderedBlipObject[iActualId];
GFxValue asLayerForBlip;
if(GetIsPlacedOn3dMap(pBlip))
{
// override area blips' 3D linkage
// on RDR we do this for RADIUS blips too, but don't want to rock the boat here
if( GetBlipTypeValue(pBlip) == BLIP_TYPE_AREA )
pBlipName = CMiniMap_Common::GetBlipName(BLIP_AREA);
if (!ms_asBaseOverlay3D[MINIMAP_LAYER_FOREGROUND].GetMember("asRadiusBlipLayer", &asLayerForBlip))
{
uiAssertf(0, "CMiniMap_RenderThread::AddBlipToStage - cannot find 'asRadiusBlipLayer'");
return false;
}
}
else
{
if( GetBlipTypeValue(pBlip) == BLIP_TYPE_AREA && CMiniMap::IsFlagSet(pBlip, BLIP_FLAG_SHORTRANGE) )
pBlipName = CMiniMap_Common::GetBlipName(RADAR_TRACE_EDGE_POINTER);
if (!ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED].GetMember("asBlipLayer2D", &asLayerForBlip))
{
uiAssertf(0, "CMiniMap_RenderThread::AddBlipToStage - cannot find 'asBlipLayer2D'");
return false;
}
}
if (!asLayerForBlip.IsUndefined())
{
char cRefName[MAX_BLIP_NAME_SIZE+10];
formatf(cRefName, "%s_%d", pBlipName, iActualId, NELEM(cRefName));
if (asLayerForBlip.CreateEmptyMovieClip(pGfxValue, cRefName, iStageDepth))
{
GFxValue asTheBlip;
if (pGfxValue->AttachMovie(&asTheBlip, pBlipName, "main_blip", BLIP_DEPTH_MAIN_BLIP))
{
// re-init various flags:
CMiniMap::SetFlag(pBlip, BLIP_FLAG_VALUE_CHANGED_COLOUR);
CMiniMap::SetFlag(pBlip, BLIP_FLAG_VALUE_CHANGED_TICK);
CMiniMap::SetFlag(pBlip, BLIP_FLAG_VALUE_CHANGED_GOLD_TICK);
CMiniMap::SetFlag(pBlip, BLIP_FLAG_VALUE_CHANGED_FOR_SALE);
CMiniMap::SetFlag(pBlip, BLIP_FLAG_VALUE_CHANGED_PULSE);
CMiniMap::SetFlag(pBlip, BLIP_FLAG_VALUE_CHANGED_OUTLINE_INDICATOR);
CMiniMap::SetFlag(pBlip, BLIP_FLAG_VALUE_CHANGED_FRIEND_INDICATOR);
CMiniMap::SetFlag(pBlip, BLIP_FLAG_VALUE_CHANGED_CREW_INDICATOR);
// re-init the number (if any)
CMiniMap::SetFlag(pBlip,BLIP_FLAG_VALUE_SET_NUMBER);
// re-init the flash:
if (CMiniMap::IsFlagSet(pBlip,BLIP_FLAG_FLASHING))
{
CMiniMap::UnsetFlag(pBlip, BLIP_FLAG_FLASHING); // unset so when we setup the flash again it starts it flashing
CMiniMap::SetFlag(pBlip, BLIP_FLAG_VALUE_CHANGED_FLASH);
}
#if __BANK
if (ms_MiniMapRenderState.m_bDisplayAllBlipNames)
{
CMiniMap::SetFlag(pBlip, BLIP_FLAG_VALUE_SET_LABEL);
}
else
{
if (CMiniMap::GetBlipDebugNumberValue(pBlip) != -1)
{
CMiniMap::SetFlag(pBlip, BLIP_FLAG_VALUE_SET_LABEL);
}
}
#endif // __BANK
uiDebugf1("CMiniMap_RenderThread: Added blip %d %s with priority %d, pos %0.2f,%0.2f onto stage at depth %d", pBlip->m_iUniqueId, GetBlipObjectName(pBlip), (s32)GetBlipPriorityValue(pBlip), GetBlipPositionValueOnStage(pBlip).x, GetBlipPositionValueOnStage(pBlip).y, iStageDepth);
return true;
}
}
}
return false;
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::GetBlipNameValue
// PURPOSE: gets the text name value to be shown on screen
/////////////////////////////////////////////////////////////////////////////////////
const char* CMiniMap_RenderThread::GetBlipNameValue(const CBlipComplex *pBlip)
{
return pBlip->cLocName.GetStr();
}
#if __BANK
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::LabelBlipOnStage
// PURPOSE: calls invoke on the ActionScript object to colour a blip
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::LabelBlipOnStage(GFxValue *pBlipGfx, CBlipComplex *pBlip, bool bOnOff)
{
uiAssertf(pBlip && pBlipGfx, "blip doesnt exist");
if (pBlip && pBlipGfx && pBlipGfx->IsDisplayObject())
{
if (GetBlipObjectNameId(pBlip) != BLIP_NORTH)
{
s8 iBlipNumber = -1;
iBlipNumber = CMiniMap::GetBlipDebugNumberValue(pBlip);
if (bOnOff)
{
if (CScaleformMgr::BeginMethod(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND], SF_BASE_CLASS_MINIMAP, "SET_BLIP_LABEL"))
{
CScaleformMgr::AddParamGfxValue(*pBlipGfx);
if (iBlipNumber == -1)
{
CScaleformMgr::AddParamString(GetBlipNameValue(pBlip));
}
else
{
char cBlipString[5];
formatf(cBlipString, "%d", CMiniMap::GetBlipDebugNumberValue(pBlip), NELEM(cBlipString));
CScaleformMgr::AddParamString(cBlipString);
}
// Pass Scaleform the correct counter-scale for the text label it is about to create
GFxValue::DisplayInfo blipDisplayInfo;
pBlipGfx->GetDisplayInfo(&blipDisplayInfo);
CScaleformMgr::AddParamFloat(GetBlipScalerValue(pBlip) / blipDisplayInfo.GetXScale() * 100);
CScaleformMgr::EndMethod();
}
}
else
{
if (CScaleformMgr::BeginMethod(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND], SF_BASE_CLASS_MINIMAP, "REMOVE_BLIP_LABEL"))
{
CScaleformMgr::AddParamGfxValue(*pBlipGfx);
CScaleformMgr::EndMethod();
}
}
}
}
else
{
uiAssertf(0, "CMiniMap_RenderThread: Tried to label a blip on the stage that is no longer is a display object!");
}
}
#endif // __BANK
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::NumberBlipOnStage
// PURPOSE: displays a number ontop of a blip on the stage
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::NumberBlipOnStage(GFxValue *pBlipGfx, CBlipComplex *pBlip)
{
if( uiVerifyf(pBlip, "Tried to display a number on a blip using a null blip pointer.") &&
uiVerifyf(pBlipGfx, "Tried to display a number on a blip that doesn't have a main_blip component.") &&
uiVerifyf(pBlipGfx->IsDisplayObject(), "Tried to display a number on a blip that is no longer is a display object!"))
{
s8 iNumberToDisplay = CMiniMap::GetBlipNumberValue(pBlip);
if (iNumberToDisplay == -1)
{
if (pBlipGfx->GFxValue::HasMember("blipTextField"))
{
GFxValue pNumberClip;
pBlipGfx->GFxValue::GetMember("blipTextField", &pNumberClip);
if (pNumberClip.IsDisplayObject())
{
pNumberClip.Invoke("removeMovieClip");
}
}
return;
}
if (iNumberToDisplay >= 0)
{
GFxValue gfxBlipTextFieldMc;
pBlipGfx->GFxValue::AttachMovie(&gfxBlipTextFieldMc, "blipTextField", "blipTextField", BLIP_DEPTH_NUMBER);
if (uiVerifyf(!gfxBlipTextFieldMc.IsUndefined(), "CMiniMap_RenderThread::NumberBlipOnStage - 'blipTextField' doesnt exist in Actionscript or is undefined"))
{
GFxValue gfxBlipTextField;
if (uiVerifyf(gfxBlipTextFieldMc.GFxValue::GetMember("numberTF", &gfxBlipTextField), "CMiniMap_RenderThread::NumberBlipOnStage - 'numberTF' doesnt exist in Actionscript"))
{
char cTextFieldString[5];
formatf(cTextFieldString, "%d", iNumberToDisplay, NELEM(cTextFieldString));
gfxBlipTextField.SetText(cTextFieldString);
}
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::PulseBlipOnStage
// PURPOSE: pulses a blip on the stage
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::PulseBlipOnStage(GFxValue *pBlipGfx, CBlipComplex *pBlip)
{
#define __PULSE_FRAME_NUM (2)
if (pBlip && pBlipGfx && pBlipGfx->IsDisplayObject())
{
//uiDebugf1("CMiniMap_RenderThread: Pulsing blip %d %s", pBlip->m_iUniqueId, GetBlipObjectName(pBlip));
s32 iCurrentFrame = 1;
GFxValue currentFrameGfx;
if (pBlipGfx->GFxValue::HasMember("_currentframe"))
{
pBlipGfx->GFxValue::GetMember("_currentframe", &currentFrameGfx);
if (currentFrameGfx.IsNumber())
{
iCurrentFrame = (s32)currentFrameGfx.GetNumber();
}
}
else
{
uiAssertf(0, "CMiniMap_RenderThread: _currentframe is not a member of blip %s", GetBlipObjectName(pBlip));
}
if (iCurrentFrame < __PULSE_FRAME_NUM)
{
if (!pBlipGfx->GotoAndPlay(__PULSE_FRAME_NUM))
{
uiAssertf(0, "CMiniMap_RenderThread: Pulse blip didnt work on blip %s", GetBlipObjectName(pBlip));
}
}
}
else
{
uiAssertf(0, "CMiniMap_RenderThread: Tried to pulse a blip on the stage that is no longer is a display object!");
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateTickBlipOnStage
// PURPOSE: adds or removes a "tick" icon on a blip on the stage
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateTickBlipOnStage(GFxValue *pBlipGfx, CBlipComplex *pBlip)
{
UpdateBlipSecondaryIconOnStage(pBlipGfx, pBlip, BLIP_FLAG_SHOW_TICK, "radar_completed", "tick_blip", BLIP_DEPTH_TICK);
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateGoldTickBlipOnStage
// PURPOSE: adds or removes a golden "tick" icon on a blip on the stage
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateGoldTickBlipOnStage(GFxValue *pBlipGfx, CBlipComplex *pBlip)
{
UpdateBlipSecondaryIconOnStage(pBlipGfx, pBlip, BLIP_FLAG_SHOW_GOLD_TICK, "radar_completed", "tick_blip", BLIP_DEPTH_TICK);
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateSaleBlipOnStage
// PURPOSE: adds or removes a "for sale" icon on a blip on the stage
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateForSaleBlipOnStage(GFxValue *pBlipGfx, CBlipComplex *pBlip)
{
UpdateBlipSecondaryIconOnStage(pBlipGfx, pBlip, BLIP_FLAG_SHOW_FOR_SALE, "radar_for_sale", "sale_blip", BLIP_DEPTH_SALE_ICON);
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateBlipSecondaryIconOnStage
// PURPOSE: adds or removes a secondary icon on a blip on the stage
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateBlipSecondaryIconOnStage(GFxValue *pBlipGfx, CBlipComplex *pBlip, eBLIP_PROPERTY_FLAGS iconFlag, const char* symbolName, const char* instanceName, int displayDepth)
{
if (pBlip && pBlipGfx && pBlipGfx->IsDisplayObject())
{
bool bHasIconAttached = pBlipGfx->GFxValue::HasMember(instanceName);
if (!CMiniMap::IsFlagSet(pBlip, iconFlag))
{
const bool c_checkmarkIcon = displayDepth == BLIP_DEPTH_TICK ;
const bool c_shouldRemove = c_checkmarkIcon ? !CMiniMap::IsFlagSet(pBlip, BLIP_FLAG_SHOW_TICK) && !CMiniMap::IsFlagSet(pBlip, BLIP_FLAG_SHOW_GOLD_TICK) : true;
// remove the icon if it is there
if (bHasIconAttached && c_shouldRemove) // already got higher blip attached, so remove this 1st
{
GFxValue pIcon;
pBlipGfx->GFxValue::GetMember(instanceName, &pIcon);
if (pIcon.IsDisplayObject())
{
pIcon.Invoke("removeMovieClip");
}
}
}
else
{
// add a tick blip if its not there already
if (!bHasIconAttached)
{
GFxValue tempValue;
if(uiVerifyf(pBlipGfx->GFxValue::AttachMovie(&tempValue, symbolName, instanceName, displayDepth), "Failed to attach secondary blip icon movieclip (symbolName = %s)", symbolName))
{
CRGBA blipColour = iconFlag == BLIP_FLAG_SHOW_GOLD_TICK ? CHudColour::GetRGBA(HUD_COLOUR_GOLD) : CHudColour::GetRGBA(HUD_COLOUR_GREEN);
tempValue.SetColorTransform(blipColour);
GFxValue::DisplayInfo dispInfo;
dispInfo.SetAlpha((float)blipColour.GetAlphaf() * 100.0f);
tempValue.SetDisplayInfo(dispInfo);
}
}
}
}
else
{
uiAssertf(0, "CMiniMap_RenderThread: Tried to update %s on a blip on the stage that is no longer is a display object!", instanceName);
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateHeadingIndicatorOnBlipOnStage
// PURPOSE: adds or removes and rotates a heading indicator onto the blip
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateHeadingIndicatorOnBlipOnStage(GFxValue *pBlipGfx, CBlipComplex *pBlip, s32 iMapRotation)
{
if (pBlip && pBlipGfx && pBlipGfx->IsDisplayObject())
{
GFxValue pAttachmentBlip;
bool bHasAttachmentBlip = pBlipGfx->GFxValue::GetMember("direction_blip", &pAttachmentBlip);
if (!CMiniMap::IsFlagSet(pBlip,BLIP_FLAG_SHOW_HEADING_INDICATOR))
{
//
// remove the direction blip if it is there
//
if (bHasAttachmentBlip) // already got higher blip attached, so remove this 1st
{
if (pAttachmentBlip.IsDisplayObject())
{
pAttachmentBlip.Invoke("removeMovieClip");
}
bHasAttachmentBlip = false;
}
}
else
{
//
// add the direction blip if its not there already
//
if (!bHasAttachmentBlip)
{
pBlipGfx->GFxValue::AttachMovie(&pAttachmentBlip, "radar_pointer", "direction_blip", BLIP_DEPTH_DIRECTION_INDICATOR);
bHasAttachmentBlip = true;
}
}
if (bHasAttachmentBlip)
{
if (pAttachmentBlip.IsDisplayObject())
{
// then update its rotation based on entity heading
float fBlipRotation = -CMiniMap::GetBlipDirectionValue(pBlip);
fBlipRotation -= iMapRotation;
// ensure the value is between 0 and 359 degrees
fBlipRotation = CMiniMap_Common::WrapBlipRotation(fBlipRotation);
GFxValue::DisplayInfo rotationInfo;
rotationInfo.SetRotation(fBlipRotation);
// copy the alpha from the main blip:
s32 const c_mainBlipAlpha = GetBlipAlphaValue(pBlip);
rotationInfo.SetAlpha((float)((c_mainBlipAlpha / 255.0f) * 100.0f));
pAttachmentBlip.SetDisplayInfo(rotationInfo); // apply the rotation to the "direction" only
}
}
}
else
{
uiAssertf(0, "CMiniMap_RenderThread: Tried to update a headingIndicator on a blip on the stage that is no longer is a display object!");
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateOutlineIndicatorOnBlipOnStage
// PURPOSE: adds or removes an outline indicator blip
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateOutlineIndicatorOnBlipOnStage(GFxValue *pBlipGfx, CBlipComplex *pBlip)
{
if (pBlip && pBlipGfx && pBlipGfx->IsDisplayObject())
{
GFxValue pAttachmentBlip;
bool bHasAttachmentBlip = pBlipGfx->GFxValue::GetMember("outline_blip", &pAttachmentBlip);
if (!CMiniMap::IsFlagSet(pBlip,BLIP_FLAG_SHOW_OUTLINE_INDICATOR))
{
//
// remove the outline blip if it is there
//
if (bHasAttachmentBlip) // already got higher blip attached, so remove this 1st
{
if (pAttachmentBlip.IsDisplayObject())
{
pAttachmentBlip.Invoke("removeMovieClip");
}
}
}
else
{
//
// add the outline blip if its not there already
//
if (!bHasAttachmentBlip)
{
const char* pAttachmentBlipName = NULL;
if (GetBlipObjectNameId(pBlip) == RADAR_TRACE_CAPTURE_THE_FLAG)
{
// suitcase outline:
pAttachmentBlipName = "radar_capture_the_flag_outline";
}
else if (GetBlipObjectNameId(pBlip) == RADAR_TRACE_CAPTURE_THE_USAFLAG)
{
// usa flag outline:
pAttachmentBlipName = "radar_capture_the_useflag_outline";
}
else
{
// standard circle outline:
pAttachmentBlipName = "RADAR_MP_FRIEND"; // not "really" friend anymore ;-) confusing I know, last minute requests etc etc
}
pBlipGfx->GFxValue::AttachMovie(&pAttachmentBlip, pAttachmentBlipName, "outline_blip", BLIP_DEPTH_OUTLINE_INDICATOR);
}
// apply colour onto the blip whether we created it this time or we got it from before
if (pAttachmentBlip.IsDisplayObject())
{
CRGBA blipColour = GetBlipSecondaryColourValue(pBlip);
pAttachmentBlip.SetColorTransform(blipColour);
GFxValue::DisplayInfo dispInfo;
s32 iMainBlipAlpha = GetBlipAlphaValue(pBlip); // fix for 1584520 - use alpha of the main blip (as the friend indicator needs to fade out when they fade the blip)
dispInfo.SetAlpha((float)((iMainBlipAlpha / 255.0f) * 100.0f));
pAttachmentBlip.SetDisplayInfo(dispInfo);
}
}
}
else
{
uiAssertf(0, "CMiniMap_RenderThread: Tried to update an outline blip on a blip on the stage that is no longer is a display object!");
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateFriendIndicatorOnBlipOnStage
// PURPOSE: adds or removes an outline indicator blip
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateFriendIndicatorOnBlipOnStage(GFxValue *pBlipGfx, CBlipComplex *pBlip)
{
if (pBlip && pBlipGfx && pBlipGfx->IsDisplayObject())
{
GFxValue pAttachmentBlip;
bool bHasAttachmentBlip = pBlipGfx->GFxValue::GetMember("friend_blip", &pAttachmentBlip);
if (!CMiniMap::IsFlagSet(pBlip,BLIP_FLAG_SHOW_FRIEND_INDICATOR))
{
//
// remove the direction blip if it is there
//
if (bHasAttachmentBlip) // already got higher blip attached, so remove this 1st
{
if (pAttachmentBlip.IsDisplayObject())
{
pAttachmentBlip.Invoke("removeMovieClip");
}
}
}
else
{
//
// add the direction blip if its not there already
//
if (!bHasAttachmentBlip)
{
pBlipGfx->GFxValue::AttachMovie(&pAttachmentBlip, "radar_mp_friendlies", "friend_blip", BLIP_DEPTH_FRIEND_INDICATOR);
}
// apply colour onto the blip whether we created it this time or we got it from before
if (pAttachmentBlip.IsDisplayObject())
{
CRGBA blipColour = CHudColour::GetRGBA(HUD_COLOUR_FRIENDLY);
pAttachmentBlip.SetColorTransform(blipColour);
GFxValue::DisplayInfo dispInfo;
s32 iMainBlipAlpha = GetBlipAlphaValue(pBlip); // fix for 1584520 - use alpha of the main blip (as the friend indicator needs to fade out when they fade the blip)
dispInfo.SetAlpha((float)((iMainBlipAlpha / 255.0f) * 100.0f));
pAttachmentBlip.SetDisplayInfo(dispInfo);
}
}
}
else
{
uiAssertf(0, "CMiniMap_RenderThread: Tried to update a friend indicator on a blip on the stage that is no longer is a display object!");
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateCrewIndicatorOnBlipOnStage
// PURPOSE: adds or removes an outline indicator blip
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateCrewIndicatorOnBlipOnStage(GFxValue *pBlipGfx, CBlipComplex *pBlip)
{
if (pBlip && pBlipGfx && pBlipGfx->IsDisplayObject())
{
GFxValue pAttachmentBlip;
bool bHasAttachmentBlip = pBlipGfx->GFxValue::GetMember("crew_blip", &pAttachmentBlip);
if (!CMiniMap::IsFlagSet(pBlip,BLIP_FLAG_SHOW_CREW_INDICATOR))
{
//
// remove the direction blip if it is there
//
if (bHasAttachmentBlip) // already got higher blip attached, so remove this 1st
{
if (pAttachmentBlip.IsDisplayObject())
{
pAttachmentBlip.Invoke("removeMovieClip");
}
}
}
else
{
//
// add the direction blip if its not there already
//
if (!bHasAttachmentBlip)
{
pBlipGfx->GFxValue::AttachMovie(&pAttachmentBlip, "radar_mp_crew", "crew_blip", BLIP_DEPTH_CREW_INDICATOR);
}
// apply colour onto the blip whether we created it this time or we got it from before
if (pAttachmentBlip.IsDisplayObject())
{
CRGBA blipColour = GetBlipSecondaryColourValue(pBlip);
pAttachmentBlip.SetColorTransform(blipColour);
GFxValue::DisplayInfo dispInfo;
s32 iMainBlipAlpha = GetBlipAlphaValue(pBlip); // fix for 1584520 - use alpha of the main blip (as the friend indicator needs to fade out when they fade the blip)
dispInfo.SetAlpha((float)((iMainBlipAlpha / 255.0f) * 100.0f));
pAttachmentBlip.SetDisplayInfo(dispInfo);
}
}
}
else
{
uiAssertf(0, "CMiniMap_RenderThread: Tried to update a crew indicator on a blip on the stage that is no longer is a display object!");
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::FadeOutDistantBlipOnStage
// PURPOSE: fades out a blip as it gets further out into the distance
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::FadeOutDistantBlipOnStage(GFxValue *pBlipGfx, s32 iDisplayAlpha)
{
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return;
if (pBlipGfx && pBlipGfx->IsDisplayObject())
{
GFxValue::DisplayInfo currentAlphaDisplayInfo;
pBlipGfx->GetDisplayInfo(&currentAlphaDisplayInfo);
if (currentAlphaDisplayInfo.GetAlpha() != iDisplayAlpha)
{
currentAlphaDisplayInfo.SetAlpha(iDisplayAlpha);
pBlipGfx->SetDisplayInfo(currentAlphaDisplayInfo);
}
}
else
{
uiAssertf(0, "CMiniMap_RenderThread: Tried to set alpha on the stage that is no longer is a display object!");
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::ColourBlipOnStage
// PURPOSE: calls invoke on the ActionScript object to colour a blip
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::ColourBlipOnStage(GFxValue *pBlipGfx, CBlipComplex *pBlip)
{
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return;
if (pBlip && pBlipGfx && pBlipGfx->IsDisplayObject())
{
GFxValue pMainBlip;
if (pBlipGfx->GFxValue::GetMember("main_blip", &pMainBlip))
{
if (pMainBlip.IsDisplayObject())
{
CRGBA blipColour;
if (GetBlipColourValue(pBlip) != BLIP_COLOUR_USE_COLOUR32)
{
blipColour = CMiniMap_Common::GetColourFromBlipSettings(GetBlipColourValue(pBlip), CMiniMap::IsFlagSet(pBlip,BLIP_FLAG_BRIGHTNESS));
if (GetBlipAlphaValue(pBlip) != 255)
{
blipColour.SetAlpha(GetBlipAlphaValue(pBlip)); // use individual alpha settings
}
}
else
{
blipColour = GetBlipSecondaryColourValue(pBlip); // use actual RGBA value
}
// with the alpha, we set it on the blip container movieclip so it sets the alpha for all its children aswell
GFxValue::DisplayInfo currentDisplayInfo;
float fAlpha = blipColour.GetAlphaf() * 100;
Assertf(CMiniMap::IsFlagSet(pBlip,BLIP_FLAG_UPDATE_ALPHA_ONLY) || CMiniMap::IsFlagSet(pBlip,BLIP_FLAG_VALUE_CHANGED_COLOUR), "CMiniMap_RenderThread::ColourBlipOnStage - expected either the CHANGED_COLOUR or the UPDATE_ALPHA_ONLY flag to be set");
currentDisplayInfo.SetAlpha(fAlpha);
pBlipGfx->SetDisplayInfo(currentDisplayInfo);
if (CMiniMap::IsFlagSet(pBlip,BLIP_FLAG_VALUE_CHANGED_COLOUR))
{
// we set the colour on the "main_blip" only - as we only want to colour the blip iself (and any children) and not its siblings
pMainBlip.SetColorTransform(blipColour);
}
if (CMiniMap::IsFlagSet(pBlip,BLIP_FLAG_VALUE_CHANGED_COLOUR) || CMiniMap::IsFlagSet(pBlip,BLIP_FLAG_UPDATE_ALPHA_ONLY))
{
GFxValue::DisplayInfo dispInfo;
dispInfo.SetAlpha((float)blipColour.GetAlphaf() * 100.0f);
pMainBlip.SetDisplayInfo(dispInfo);
}
// need to copy the alpha value of the blip onto the higher/lower blip
bool bHasHigherBlipAttached = pBlipGfx->GFxValue::HasMember("higher_blip");
bool bHasLowerBlipAttached = pBlipGfx->GFxValue::HasMember("lower_blip");
GFxValue pHeightBlip;
if (bHasHigherBlipAttached)
{
pBlipGfx->GFxValue::GetMember("higher_blip", &pHeightBlip);
}
else if (bHasLowerBlipAttached)
{
pBlipGfx->GFxValue::GetMember("lower_blip", &pHeightBlip);
}
if (pHeightBlip.IsDisplayObject())
{
// copy the alpha from the main blip:
GFxValue::DisplayInfo heightBlipDisplayInfo;
heightBlipDisplayInfo.SetAlpha(fAlpha);
pHeightBlip.SetDisplayInfo(heightBlipDisplayInfo);
}
}
}
}
else
{
uiAssertf(0, "CMiniMap_RenderThread: Tried to colour a blip on the stage that is no longer is a display object!");
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::FlashBlipOnStage
// PURPOSE: calls invoke on the ActionScript object to flash/stop flashing a blip
/////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::FlashBlipOnStage(GFxValue *pBlipGfx, CBlipComplex *pBlip)
{
if (pBlip && pBlipGfx && pBlipGfx->IsDisplayObject())
{
if (!CMiniMap::IsFlagSet(pBlip, BLIP_FLAG_FLASHING))
{
float fTimeInSeconds = ( (float)GetBlipFlashInterval(pBlip) / 1000.0f ); // convert ms into seconds to pass to ActionScript
if (CScaleformMgr::BeginMethod(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND], SF_BASE_CLASS_MINIMAP, "START_BLIP_FLASHING"))
{
CScaleformMgr::AddParamGfxValue(*pBlipGfx);
CScaleformMgr::AddParamFloat(fTimeInSeconds);
CScaleformMgr::EndMethod();
}
}
else
{
if (CScaleformMgr::BeginMethod(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND], SF_BASE_CLASS_MINIMAP, "STOP_BLIP_FLASHING"))
{
CScaleformMgr::AddParamGfxValue(*pBlipGfx);
CScaleformMgr::EndMethod();
}
}
return true;
}
else
{
uiAssertf(0, "CMiniMap_RenderThread: Tried to flash a blip on the stage that is no longer is a display object!");
}
return false;
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::GetBlipGfxValue
// PURPOSE: returns the gfxvalue used for this slot (in the render)
/////////////////////////////////////////////////////////////////////////////////////
GFxValue* CMiniMap_RenderThread::GetBlipGfxValue(const CBlipComplex *pBlip)
{
if (pBlip)
{
if (pBlip->m_iActualId != -1)
{
uiAssertf((pBlip->m_iActualId >= 0) && (pBlip->m_iActualId < MAX_NUM_BLIPS), "CMiniMap_RenderThread::GetBlipGfxValue()...Accessing bad blip!");
return pRenderedBlipObject[pBlip->m_iActualId];
}
}
return NULL;
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::SetBlipGfxValue
// PURPOSE: sets the gfx value of the blip
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::SetBlipGfxValue(const CBlipComplex *pBlip, GFxValue *pParam)
{
if (pBlip)
{
if (pBlip->m_iActualId != -1)
{
pRenderedBlipObject[pBlip->m_iActualId] = pParam;
}
}
}
bool CMiniMap_RenderThread::GetIsPlacedOn3dMap(const CBlipComplex* pBlip)
{
if (pBlip && pBlip->m_iActualId != -1)
{
uiAssertf((pBlip->m_iActualId >= 0) && (pBlip->m_iActualId < MAX_NUM_BLIPS), "CMiniMap_RenderThread::GetIsPlacedOn3dMap()...Accessing bad blip!");
return bBlipIsOn3dLayer.IsSet(pBlip->m_iActualId);
}
return false;
}
void CMiniMap_RenderThread::SetIsPlacedOn3dMap(const CBlipComplex* pBlip, bool bOnMap)
{
if (pBlip && pBlip->m_iActualId != -1)
{
bBlipIsOn3dLayer.Set(pBlip->m_iActualId, bOnMap);
}
}
#define BLIP_SIZE_MINIMAP_GOLF_COURSE (45.0f)
#define BLIP_SIZE_MINIMAP (100.0f)
#define BLIP_SIZE_PAUSEMENU_MAP (24.0f)
#define BLIP_SIZE_PAUSEMENU_MAP_HOVERED (30.0f)
#define BLIP_SIZE_BIGMAP (45.0f)
#define BLIP_SIZE_GALLERYMAP (45.0f)
float CMiniMap_RenderThread::GetBlipScalerValue(const CBlipComplex* pBlip, bool bCareAboutType /* = true */)
{
float fBlipScaler = BLIP_SIZE_MINIMAP;
if ( bCareAboutType && (GetBlipTypeValue(pBlip) == BLIP_TYPE_RADIUS || GetBlipTypeValue(pBlip) == BLIP_TYPE_AREA))
{
fBlipScaler = 2.0f;
}
else if (ms_MiniMapRenderState.m_bIsInPauseMap)
{
fBlipScaler = BLIP_SIZE_PAUSEMENU_MAP;
if( CMiniMap::IsFlagSet(pBlip, BLIP_FLAG_HOVERED_ON_PAUSEMAP) )
fBlipScaler = BLIP_SIZE_PAUSEMENU_MAP_HOVERED;
}
else if (ms_MiniMapRenderState.m_bIsInBigMap)
{
fBlipScaler = BLIP_SIZE_BIGMAP;
}
else if (ms_MiniMapRenderState.m_bIsInCustomMap)
{
fBlipScaler = BLIP_SIZE_GALLERYMAP;
}
else if (ms_MiniMapRenderState.m_CurrentGolfMap != GOLF_COURSE_OFF)
{
fBlipScaler = BLIP_SIZE_MINIMAP_GOLF_COURSE;
}
return fBlipScaler;
}
bool CMiniMap_RenderThread::DoesRenderedBlipExist(s32 BlipIndex)
{
if (uiVerifyf((BlipIndex >= 0) && (BlipIndex < MAX_NUM_BLIPS), "CMiniMap_RenderThread::DoesRenderedBlipExist - blip index is out of range"))
{
return (pRenderedBlipObject[BlipIndex] != NULL);
}
return false;
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::RemoveBlipFromStage
// PURPOSE: removes the GFxValue object if the blip leaves the stage
/////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::RemoveBlipFromStage(CBlipComplex *pBlip, bool bFromUpdateThreadInShutdownSession)
{
PF_FUNC(RemoveBlipFromStage);
if (bFromUpdateThreadInShutdownSession)
{
if (CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on UT
{
sfAssertf(0, "CMiniMap_RenderThread::RemoveBlipFromStage has been called with the special-case flag bFromUpdateThreadInShutdownSession so it's expected to be called on the UpdateThread");
return false;
}
}
else
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::RemoveBlipFromStage can only be called on the RenderThread!");
return false;
}
}
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return false;
if (!pBlip)
return false;
uiDebugf1("CMiniMap_RenderThread: Removed blip %d %s from stage", pBlip->m_iUniqueId, GetBlipObjectName(pBlip));
GFxValue *pGfxValue = GetBlipGfxValue(pBlip);
if (pGfxValue)
{
if (pGfxValue->IsDisplayObject())
{
//
// at this point, we need to ensure we call some "stop" methods on actionscript so it call cleans up nicely in the tweener:
//
if (CMiniMap::IsFlagSet(pBlip, BLIP_FLAG_FLASHING))
{
if (CScaleformMgr::BeginMethod(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND], SF_BASE_CLASS_MINIMAP, "STOP_BLIP_FLASHING"))
{
CScaleformMgr::AddParamGfxValue(*pGfxValue);
CScaleformMgr::EndMethod(bFromUpdateThreadInShutdownSession);
}
}
if(CMiniMap::IsFlagSet(pBlip, BLIP_FLAG_SHOW_HEIGHT))
{
RemoveHigherLowerBlip(pGfxValue, 0);
}
//
// finally, remove the blip:
//
pGfxValue->Invoke("removeMovieClip");
pGfxValue->SetUndefined();
delete (pGfxValue);
CScaleformMgr::ForceCollectGarbage(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND]); // perform garbage collection once the blip has been removed
}
else
{
uiAssertf(0, "MiniMap: Tried to remove a blip from the stage that is no longer is a display object!");
}
SetBlipGfxValue(pBlip, NULL);
}
return true;
}
void CMiniMap_RenderThread::RenderToFoW(CBlipComplex * FOG_OF_WAR_ONLY(pBlip))
{
#if ENABLE_FOG_OF_WAR
Vector2 coords = WorldToFowCoord(pBlip->vPosition.x, pBlip->vPosition.y);
float fowWidth = (float)CMiniMap_Common::GetFogOfWarRT()->GetWidth();
float fowHeight = (float)CMiniMap_Common::GetFogOfWarRT()->GetHeight();
const float aspectRatio = CMiniMap::AreFowCustomWorldExtentsEnabled()?
(CMiniMap::GetFowCustomWorldH() / CMiniMap::GetFowCustomWorldW()) :
(CMiniMap::sm_Tunables.FogOfWar.fWorldH / CMiniMap::sm_Tunables.FogOfWar.fWorldW);
float xDelta = (fowBlipColorSizeX/fowWidth)*aspectRatio;
float yDelta = (fowBlipColorSizeY/fowHeight);
grcBindTexture(CShaderLib::LookupTexture("FoW"));
for(int i=0;i<bleepCount;i++)
{
grcDrawSingleQuadf(coords.x-xDelta,coords.y-yDelta,coords.x+xDelta,coords.y+yDelta, 0.0f, 0.0f , 0.0f , 1.0f , 1.0f , fowBleepColor);
}
#endif // ENABLE_FOG_OF_WAR
}
#define SCALEFORM_SCALE_VALUE (100.0f) // flash uses 100 as a base scale value instead of the sane 1.0.
#define ADJUST_SCALEFORM_SCALAR(scalar) (SCALEFORM_SCALE_VALUE/scalar) // a scalar of 50 means 2x 'zoom'
#define SCALEFORM_SCALE_TO_PERCENT(scalar) (scalar/SCALEFORM_SCALE_VALUE) // a scalar of 50 means 50% (.5)
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateIndividualBlip
// PURPOSE: updates an individual blip
/////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::UpdateIndividualBlip(CBlipComplex *pBlip, s32 iMapRotation, bool bRangeCheckOnly)
{
PF_FUNC(UpdateIndividualBlip);
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::UpdateIndividualBlip can only be called on the RenderThread!");
return false;
}
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return false;
if (!pBlip)
return false;
iMapRotation = -ms_MiniMapRenderState.m_iRotation;
Vector2 vMapCentrePosition(ms_MiniMapRenderState.m_vCentrePosition.x, ms_MiniMapRenderState.m_vCentrePosition.y);
CMiniMap::BlipFlagBitset flags(false);
CMiniMap::GetAllFlags(flags, pBlip);
if (!bRangeCheckOnly)
{
if (flags.IsSet(BLIP_FLAG_VALUE_REMOVE_FROM_STAGE))
{
RemoveBlipFromStage(pBlip, false);
return false;
}
if (flags.IsSet(BLIP_FLAG_VALUE_REINIT_STAGE))
{
ReInitBlipOnStage(pBlip);
CMiniMap::GetAllFlags(flags, pBlip); // Flags may have changed, get new ones
}
}
//
// update this individual blip
//
Vec3f vBlipPos(RCC_VEC3F(GetBlipPositionConstRef(pBlip))); // Stay out of the vector registers
Vector2 vNewBlipPos = Vector2(vBlipPos.GetX(), -vBlipPos.GetY());
const eBLIP_DISPLAY_TYPE c_blipDisplayType = GetBlipDisplayValue(pBlip);
bool bOnEdgeOfRadar = false;
bool bOnRadar = true;
bool bOn3dMap = GetBlipTypeValue(pBlip) == BLIP_TYPE_AREA || GetBlipTypeValue(pBlip) == BLIP_TYPE_RADIUS;
//
// depending on the display value of this blip, we need to decide whether to have this displayed on
// the current map (either in the pausemap or on the ingame minimap)
//
// no POI when in golf (bug 1319054) or creator (1702753)
if (GetBlipObjectNameId(pBlip) == RADAR_TRACE_POI)
{
if ( (ms_MiniMapRenderState.m_CurrentGolfMap != GOLF_COURSE_OFF) ||
(ms_MiniMapRenderState.bInCreator) )
{
bOnRadar = false;
}
}
// fix for 1690613 - no mission creator blips should be shown when script are hiding the exterior map
// except sometimes
if ((c_blipDisplayType != BLIP_DISPLAY_BOTH) &&
(flags.IsSet(BLIP_FLAG_MISSION_CREATOR)) &&
((ms_MiniMapRenderState.m_bIsInPauseMap && ms_MiniMapRenderState.bInsideInterior) ||
((!ms_MiniMapRenderState.m_bShowMainMap) && (!ms_MiniMapRenderState.m_bShowPrologueMap) && (!ms_MiniMapRenderState.m_bShowIslandMap))))
{
bOnRadar = false;
}
// probably dont want to do this now this has been changed to high and low detail - but design is sketchy, leaving out to begin with
/*if (bOnRadar && ((!CMiniMap::GetBlipVisibilityHighDetail()) && (flags.IsSet(BLIP_FLAG_HIGH_DETAIL))) ) // 1190959 wants legend blips hidden on minimap too
{
bOnRadar = false;
}*/
// if minimap is not being rendered, then lets not add any blips to the stage, rather lets remove them (optimisation to help fix 1708020)
if ( (!ms_MiniMapRenderState.m_bShouldRenderMiniMap) && // minimap isnt getting rendered
(!ms_MiniMapRenderState.m_bIsInPauseMap) && // and we are not in the pausemap
(!ms_MiniMapRenderState.m_bIsInCustomMap)) // and we are not in a custom map
{
bOnRadar = false;
}
if (bOnRadar)
{
//
// if in-game minimap:
//
if (!ms_MiniMapRenderState.m_bIsInPauseMap && !ms_MiniMapRenderState.m_bIsInCustomMap)
{
if (ms_MiniMapRenderState.m_bIsInCustomMap)
{
if (c_blipDisplayType != BLIP_DISPLAY_CUSTOM_MAP_ONLY)
{
bOnRadar = false;
}
}
else
{
if (c_blipDisplayType == BLIP_DISPLAY_PAUSEMAP ||
c_blipDisplayType == BLIP_DISPLAY_MARKERONLY ||
c_blipDisplayType == BLIP_DISPLAY_NEITHER)
{
bOnRadar = false;
}
if (ms_MiniMapRenderState.m_bIsInBigMap)
{
if (c_blipDisplayType == BLIP_DISPLAY_MINIMAP)
{
bOnRadar = false;
}
if (!ms_MiniMapRenderState.m_bBigMapFullZoom)
{
if (c_blipDisplayType == BLIP_DISPLAY_BIGMAP_FULL_ONLY)
{
bOnRadar = false;
}
}
}
else
{
if (c_blipDisplayType == BLIP_DISPLAY_BIGMAP_FULL_ONLY)
{
bOnRadar = false;
}
}
}
}
else if (ms_MiniMapRenderState.m_bIsInCustomMap)
{
if (c_blipDisplayType != BLIP_DISPLAY_CUSTOM_MAP_ONLY && c_blipDisplayType != BLIP_DISPLAY_BLIPONLY)
bOnRadar = false;
else
bOnRadar = true;
}
else
//
// frontend map:
//
{
if (((CMiniMap::GetBlipVisibilityHighDetail()) && (!flags.IsSet(BLIP_FLAG_HIGH_DETAIL))) ||
c_blipDisplayType == BLIP_DISPLAY_MINIMAP ||
c_blipDisplayType == BLIP_DISPLAY_MINIMAP_OR_BIGMAP ||
c_blipDisplayType == BLIP_DISPLAY_MARKERONLY ||
c_blipDisplayType == BLIP_DISPLAY_BIGMAP_FULL_ONLY ||
c_blipDisplayType == BLIP_DISPLAY_NEITHER)
{
bOnRadar = false;
}
if ( (bOnRadar && ms_MiniMapRenderState.bInsideInterior) && (!ms_MiniMapRenderState.m_Interior.vBoundMin.IsZero()) && (!ms_MiniMapRenderState.m_Interior.vBoundMax.IsZero()) )
{
if (GetBlipTypeValue(pBlip) == BLIP_TYPE_COORDS)
{
if (vBlipPos.GetX() < ms_MiniMapRenderState.m_Interior.vBoundMin.x ||
vBlipPos.GetX() > ms_MiniMapRenderState.m_Interior.vBoundMax.x ||
vBlipPos.GetY() < ms_MiniMapRenderState.m_Interior.vBoundMin.y ||
vBlipPos.GetY() > ms_MiniMapRenderState.m_Interior.vBoundMax.y)
{
bOnRadar = false;
}
}
}
}
}
Vector2 vNewBlipPosInMiniMap(0,0);
bool bBlipWithin15mOfPlayer = true;
s32 iDisplayAlpha = 100;
int iQuadrant = -1; // used solely for edgey blips
if (bOnRadar)
{
/* if (asBlipTestObject.IsDisplayObject())
{
GFxValue::DisplayInfo displayInfo;
if ( (!ms_MiniMapRenderState.m_bIsInPauseMap) && (pLocalPlayer && (!pLocalPlayer->GetVehiclePedInside())) && (GetRange() < MAP_BLIP_ROUND_THRESHOLD) )
{
displayInfo.SetPosition(floor(vNewBlipPos.x+0.5f), floor(vNewBlipPos.y+0.5f));
}
else
{
displayInfo.SetPosition(vNewBlipPos.x, vNewBlipPos.y);
}
asBlipTestObject.SetDisplayInfo(displayInfo);
}*/
//
// check the position of the blip in "2D space"
//
GPointF blipPoint, screenPoint;
//
// because of the way scaleform returns the screen position of the 3D blip, we need to limit the range so we only ever check coords
// that are close to the edge of the minimap ring. We first work out the height of the blip onscreen in 3D space not relative to the
// current rotation of the map, then from that we scale the distance we check for. This means the range that is checked against is
// further away if you can see further away into the distance, but the range is less if the blip is at the bottom of the minimap and
// there isnt a lot of map visible.
//
bool bAdjustPosForDistance = true;
if( GetBlipTypeValue(pBlip) == BLIP_TYPE_AREA )
{
// Extended area checks necessary for Square blips (and radius blips, if we did this [which we don't for V])
// Only take into account distance adjustments if the area is outside the bounds of the map
// If we run these calculations for area blips within map bounds, the area position glitches about
// when the center extends outside of the map
bAdjustPosForDistance = IsAreaBlipOutsideMapBounds(*pBlip);
}
if ( (!ms_MiniMapRenderState.m_bIsInPauseMap && !ms_MiniMapRenderState.m_bIsInCustomMap) && (ms_MiniMapRenderState.m_CurrentGolfMap == GOLF_COURSE_OFF) &&
bAdjustPosForDistance)
{
if (GetBlipTypeValue(pBlip) != BLIP_TYPE_RADIUS /*&& GetBlipTypeValue(pBlip) != BLIP_TYPE_AREA*/)
{
Vector2 vTestBlipForDistance(Vector2(vBlipPos.GetX(), vBlipPos.GetY())-vMapCentrePosition);
float fMaxDistance = 0.0f;
// do we need to re-adjust the range based on a 3D view....?
if (ms_fBlipMapAngle != 0.0f) // if we have an angle
{
// work out the angle of the blip relative to the centre blip:
float fAngle = atan2(vMapCentrePosition.y - vBlipPos.GetY(), vMapCentrePosition.x - vBlipPos.GetX());
if (fAngle < 0)
fAngle += (2*PI);
fAngle = ((fAngle * RtoD) - 270.0f) + (float)iMapRotation;
// ensure its between 0 to 360 degrees
fAngle = rage::Wrap(fAngle, 0.0f, 360.0f);
// work out the max distance we want to check for based on how much range is visible (may also want to add 3D angle in here too)
fMaxDistance = MINIMAP_DISTANCE_SCALER_3D * (MIN_MINIMAP_RANGE/ms_fBlipMapRange); // more zoomed out you are, the less we need to restrict the check
if (fAngle > 180.0f)
fAngle = 180.0f-(fAngle-180.0f); // get a 0 to 180 degree range across the top to bottom of the minimap, regardless of which side of the minimap the blip is on
float fHeightScaler = Max(0.15f, 1.0f-(fAngle / 180.0f)); // convert that to 0-1 space
if (fHeightScaler > 0.5f) // if the blip is high up on the minimap then its in the area that is more visible, so gradually give it more range
{
fHeightScaler *= (1.0f+((fHeightScaler-0.5f)*MINIMAP_HEIGHT_SCALER));
}
fMaxDistance *= fHeightScaler; // apply the scaler to the max distance
}
else // ... or a 2D view?
{
fMaxDistance = MINIMAP_DISTANCE_SCALER_2D * (MIN_MINIMAP_RANGE/ms_fBlipMapRange);
}
float fDistance = vTestBlipForDistance.Mag(); // get the distance
if (fDistance > 15.0f) // check to see if its 15m
{
bBlipWithin15mOfPlayer = false;
}
if (fDistance > fMaxDistance)
{
float fScale = fMaxDistance / fDistance;
vTestBlipForDistance.x *= fScale;
vTestBlipForDistance.y *= fScale;
vNewBlipPos = Vector2(vTestBlipForDistance.x + vMapCentrePosition.x, -(vTestBlipForDistance.y + vMapCentrePosition.y));
}
}
}
blipPoint.x = vNewBlipPos.x;
blipPoint.y = vNewBlipPos.y;
Vector2 vPosInMiniMap(0,0);
ms_LocalToScreen.GetRenderBuf().Transform(&screenPoint, blipPoint, true);
#if SUPPORT_MULTI_MONITOR
// ms_LocalToScreen is built from the scaleform viewport, which is already adjusted for multihead
// other values here are not aware yet, hence we transform it back into the original space
const GridMonitor &mon = GRCDEVICE.GetMonitorConfig().getLandscapeMonitor();
screenPoint.x = SCREEN_WIDTH * (screenPoint.x - mon.uLeft) / mon.getWidth();
screenPoint.y = SCREEN_HEIGHT * (screenPoint.y - mon.uTop) / mon.getHeight();
#endif //SUPPORT_MULTI_MONITOR
#if 0 // Sanity check the new transform code
{
GFxMovieView* pView = CScaleformMgr::GetMovieView(ms_iMovieId);
GPointF oldScreenPoint;
if (pView && pView->TranslateLocalToScreen(BLIP_LAYER_PATH, blipPoint, &oldScreenPoint))
{
Assertf(oldScreenPoint.DistanceSquared(screenPoint) < 0.001f, "FindLocalToScreen didn't work!");
}
}
#endif
// if(...) was removed
{
// convert "screen space" to "minimap space":
vPosInMiniMap = Vector2(screenPoint.x / SCREEN_WIDTH, screenPoint.y / SCREEN_HEIGHT);
/*#if __BANK
if (bDebug3DBlips)
{
if (CMiniMap::GetUniqueBlipUsed(pBlip) == CMiniMap::GetUniqueCentreBlipId())
{
vGameScreenPos = vPosInMiniMap;
}
}
#endif // __BANK*/
if ( (!ms_MiniMapRenderState.m_bIsInPauseMap) && (ms_MiniMapRenderState.m_CurrentGolfMap != GOLF_COURSE_OFF) )
{
vPosInMiniMap.x -= ms_MiniMapRenderState.m_vCurrentMiniMapPosition.x;
vPosInMiniMap.y -= ms_MiniMapRenderState.m_vCurrentMiniMapPosition.y;
// work out if the blip is in the range of the visible map on the screen (the stage):
if (vPosInMiniMap.x >= 0.0f && vPosInMiniMap.y >= 0.0f &&
vPosInMiniMap.x <= ms_MiniMapRenderState.m_vCurrentMiniMapSize.x && vPosInMiniMap.y <= ms_MiniMapRenderState.m_vCurrentMiniMapSize.y)
{
vPosInMiniMap.x = (vPosInMiniMap.x / ms_MiniMapRenderState.m_vCurrentMiniMapSize.x) * ms_vStageSize.x; // reposition into "stage space"
vPosInMiniMap.y = (vPosInMiniMap.y / ms_MiniMapRenderState.m_vCurrentMiniMapSize.y) * ms_vStageSize.y;
}
else
{
bOnRadar = false;
}
}
else
{
vPosInMiniMap.x -= ms_MiniMapRenderState.m_vCurrentMiniMapPosition.x;
vPosInMiniMap.y -= ms_MiniMapRenderState.m_vCurrentMiniMapPosition.y;
vPosInMiniMap.x /= ms_MiniMapRenderState.m_vCurrentMiniMapSize.x;
vPosInMiniMap.y /= ms_MiniMapRenderState.m_vCurrentMiniMapSize.y;
}
vNewBlipPosInMiniMap = Vector2(vPosInMiniMap.x - 0.5f, vPosInMiniMap.y - 0.5f);
/*#if __BANK // cant access GetActiveWaypointId() anympore from RT
if (bDebug3DBlips)
{
if (CMiniMap::GetUniqueBlipUsed(pBlip) == CMiniMap::GetUniqueCentreBlipId())
{
Displayf("Debug blip pos - %d (%d) - %0.2f,%0.2f vorig %0.2f,%0.2f", CMiniMap::GetUniqueBlipUsed(pBlip), CMiniMap::GetActualBlipUsed(pBlip), vNewBlipPosInMiniMap.x, vNewBlipPosInMiniMap.y, vBlipPos.x, vBlipPos.y);
}
}
#endif // __BANK*/
// BIG NASTY SORTA HACK
// Counter-scale area blips so they don't appear too big on the screen
// because script is currently using these to spoof a line
// if we ever need them to be an ACTUAL area, this won't work
if( GetBlipTypeValue(pBlip) == BLIP_TYPE_AREA && pBlip->vScale.y <= 5.0f )// assumption, if it's kinda small, always counterscale
{
GFxValue::DisplayInfo infoRangeRotation;
ms_asMapContainerMc.GetDisplayInfo(&infoRangeRotation);
float fCurrRange = ADJUST_SCALEFORM_SCALAR((float)infoRangeRotation.GetXScale());
pBlip->vScale.y = Min(pBlip->vScale.y, fCurrRange * pBlip->vScale.y);
// we could scale the values entirely, but it looks really weird very zoomed out, so we'll just prevent it from getting too fat
}
// we now have the 2D blip position in the minimap space
// check the range so we can lock blips to the edge of the radar in the 2D space:
if ( (ms_MiniMapRenderState.m_bIsInPauseMap) || (ms_MiniMapRenderState.m_CurrentGolfMap == GOLF_COURSE_OFF) )
{
#define MAX_2D_RADAR_DISTANCE_RADIUS_CIRCLE (0.39f)
#define MAX_2D_RADAR_DISTANCE_RADIUS_SQUARE (0.8f)
float fMaxDistance = MAX_2D_RADAR_DISTANCE_RADIUS_CIRCLE;
if (bMiniMapSquare)
{
fMaxDistance = MAX_2D_RADAR_DISTANCE_RADIUS_SQUARE;
}
float f2DDistance = vNewBlipPosInMiniMap.Mag();
if (GetBlipTypeValue(pBlip) != BLIP_TYPE_RADIUS && GetBlipTypeValue(pBlip) != BLIP_TYPE_AREA)
{
if (f2DDistance > fMaxDistance)
{
// if these are short range blips and isnt flashing then dont lock to the edge (they dissapear off the radar)
if (flags.IsSet(BLIP_FLAG_SHORTRANGE) && ( (flags.IsClear(BLIP_FLAG_FLASHING)) && (flags.IsClear(BLIP_FLAG_VALUE_CHANGED_FLASH)) ))
{
if (!bMiniMapSquare)
{
bOnRadar = false;
}
}
float fScale = fMaxDistance / f2DDistance;
vNewBlipPosInMiniMap.x *= fScale;
vNewBlipPosInMiniMap.y *= fScale;
if (!bMiniMapSquare)
{
bOnEdgeOfRadar = true;
}
}
}
if (bMiniMapSquare)
{
float fCentreOffsetX = 0.0f;
Vector2 vMax2dRadarDistanceSquare(0.459f, 0.42f);
if (ms_MiniMapRenderState.m_bIsInPauseMap)
{
vMax2dRadarDistanceSquare = Vector2(0.5f, 0.5f);
}
else if (ms_MiniMapRenderState.m_bIsInCustomMap)
{
float x = 0.225000009f;
float y = 0.5972222f;
vMax2dRadarDistanceSquare = Vector2(x, y);
}
else if (ms_MiniMapRenderState.m_bIsInBigMap)
{
fCentreOffsetX = __BIGMAP_INTERNAL_ADJUSTMENT_BLIP_RANGE;
vMax2dRadarDistanceSquare = Vector2(0.305f, 0.448f);
}
if( GetBlipTypeValue(pBlip) != BLIP_TYPE_RADIUS && (GetBlipTypeValue(pBlip) != BLIP_TYPE_AREA || flags.IsClear(BLIP_FLAG_SHORTRANGE)) )
{
if (vNewBlipPosInMiniMap.x > vMax2dRadarDistanceSquare.x-fCentreOffsetX)
{
iQuadrant = 0;
vNewBlipPosInMiniMap.x = vMax2dRadarDistanceSquare.x-fCentreOffsetX;
bOnEdgeOfRadar = true;
}
if (vNewBlipPosInMiniMap.y > vMax2dRadarDistanceSquare.y)
{
iQuadrant = 1;
vNewBlipPosInMiniMap.y = vMax2dRadarDistanceSquare.y;
bOnEdgeOfRadar = true;
}
if (vNewBlipPosInMiniMap.x < -(vMax2dRadarDistanceSquare.x+fCentreOffsetX))
{
iQuadrant = 2;
vNewBlipPosInMiniMap.x = -(vMax2dRadarDistanceSquare.x+fCentreOffsetX);
bOnEdgeOfRadar = true;
}
if (vNewBlipPosInMiniMap.y < -vMax2dRadarDistanceSquare.y)
{
iQuadrant = 3;
vNewBlipPosInMiniMap.y = -vMax2dRadarDistanceSquare.y;
bOnEdgeOfRadar = true;
}
if( GetBlipTypeValue(pBlip) == BLIP_TYPE_AREA )
{
// Extended area checks necessary for Square blips (and radius blips, if we did this [which we don't for V])
bOnEdgeOfRadar = IsAreaBlipOutsideMapBounds(*pBlip);
}
// if these are short range blips and isnt flashing then dont lock to the edge (they dissapear off the radar)
if (bOnEdgeOfRadar)
{
if (ms_MiniMapRenderState.m_bIsInPauseMap || ms_MiniMapRenderState.m_bIsInCustomMap)
{
bOnRadar = false;
}
else
{
if (flags.IsSet(BLIP_FLAG_SHORTRANGE) && (flags.IsClear(BLIP_FLAG_FLASHING)) && (flags.IsClear(BLIP_FLAG_VALUE_CHANGED_FLASH)))
{
bOnRadar = false;
}
}
//blips on the edge cannot be drawn in the 3d format because they override vNewBlipPosInMiniMap
bOn3dMap = false;
}
// fade out short range blips when in 3D mode and on standard minimap: (fixes todo 1166607)
if ( (!ms_MiniMapRenderState.m_bIsInPauseMap) && (!ms_MiniMapRenderState.m_bIsInBigMap) && (!ms_MiniMapRenderState.m_bIsInCustomMap) && (ms_MiniMapRenderState.m_fAngle != 0.0f) )
{
if ( (bOnRadar) && (flags.IsSet(BLIP_FLAG_SHORTRANGE)) && (flags.IsClear(BLIP_FLAG_FLASHING)) && (flags.IsClear(BLIP_FLAG_ROUTE)) && (flags.IsClear(BLIP_FLAG_VALUE_CHANGED_FLASH)) )
{
if (vNewBlipPosInMiniMap.y < -0.4f)
{
bOnRadar = false;
}
else if (vNewBlipPosInMiniMap.y < -0.3f)
{
iDisplayAlpha = (s32)floor((0.4f-(-vNewBlipPosInMiniMap.y)) * 1000.0f);
}
}
}
}
}
// set the 2D blip final position:
vNewBlipPosInMiniMap.x *= ms_vStageSize.x;
vNewBlipPosInMiniMap.y *= ms_vStageSize.y;
vNewBlipPosInMiniMap.x += (ms_vStageSize.x * 0.5f);
vNewBlipPosInMiniMap.y += (ms_vStageSize.y * 0.5f);
}
}
}
//
// now we know if we are visible or not on the minimap, we can return
//
if (bRangeCheckOnly)
{
return (bOnEdgeOfRadar);
}
const bool bLayerChanged = bOn3dMap!=GetIsPlacedOn3dMap(pBlip);
//layer changed? refresh stage
if( bLayerChanged )
{
SetIsPlacedOn3dMap(pBlip, bOn3dMap);
ReInitBlipOnStage(pBlip);
CMiniMap::GetAllFlags(flags, pBlip); // Flags may have changed, get new ones
}
GFxValue *pGfxValue = GetBlipGfxValue(pBlip);
if (bOnRadar)
{
if (!pGfxValue)
{
if (AddBlipToStage(pBlip)) // add object to stage
{
pGfxValue = GetBlipGfxValue(pBlip);
CMiniMap::GetAllFlags(flags, pBlip); // Flags may have changed, get the new ones
}
}
}
else
{
if (pGfxValue)
{
if (RemoveBlipFromStage(pBlip, false)) // remove object from stage
{
return false; // we have now removed the blip so exit out early
}
}
}
if (bOnRadar && pGfxValue)
{
//
// update the blip if it is on the stage:
//
uiAssertf(pGfxValue->IsDisplayObject(), "CMiniMap_RenderThread: Blip is not display object!");
float fBlipRotation = -(GetBlipDirectionValue(pBlip)); // get blip rotation
if (fBlipRotation == -DEFAULT_BLIP_ROTATION) // if blip has no rotation...
{
if (bOn3dMap)
{
fBlipRotation = static_cast<float>(iMapRotation); // ... then counter rotate by the map rotation to keep it upright
}
}
// 3D blips don't get rotated
else if(!bOn3dMap)
{
fBlipRotation -= iMapRotation;
}
// ensure the value is between 0 and 359 degrees (Note: This actually wraps between 0 and 360)
fBlipRotation = rage::Wrap(fBlipRotation, 0.0f, 360.0f);
// 3D, edge-shrunked blips disregard their rotation, and instead put it on a quadrant
if( bOnEdgeOfRadar && GetBlipTypeValue(pBlip) == BLIP_TYPE_AREA && flags.IsClear(BLIP_FLAG_SHORTRANGE))
{
fBlipRotation = 90.0f * (iQuadrant+1);
}
/*
if (CMiniMap::GetUniqueBlipUsed(pBlip) == CMiniMap::GetUniqueCentreBlipId())
{
Displayf("new centre blip rot: %d (map %d) blip orig %d", iBlipRotation, iMapRotation, GetBlipDirectionValue(pBlip));
}
*/
GFxValue pMainBlip;
if (pGfxValue->GFxValue::GetMember("main_blip", &pMainBlip))
{
// 3D blips don't rotate their sub blip, they need to rotate the parent object
// otherwise 2D shapes get weird (this may come up for other blips too)
if(!GetIsPlacedOn3dMap(pBlip) && flags.IsClear(BLIP_FLAG_SHOW_HEADING_INDICATOR))
{
if (pMainBlip.IsDisplayObject())
{
GFxValue::DisplayInfo rotationInfo;
rotationInfo.SetRotation(fBlipRotation);
pMainBlip.SetDisplayInfo(rotationInfo); // apply the rotation to the "main_blip" only
}
}
}
GFxValue::DisplayInfo info;
if (GetIsPlacedOn3dMap(pBlip))
{
// need to rotate 3D blips' main blip instead of the subblip above
info.SetRotation(fBlipRotation);
// fMapRange was computed in the first "if (bOnRadar)" block
if (ms_fBlipMapRange < MAP_BLIP_ROUND_THRESHOLD)
{
info.SetPosition(floor(vNewBlipPos.x+0.5f), floor(vNewBlipPos.y+0.5f));
}
else
{
info.SetPosition(vNewBlipPos.x, vNewBlipPos.y);
}
}
else
{
info.SetPosition(vNewBlipPosInMiniMap.x, vNewBlipPosInMiniMap.y);
}
Vector2 vBlipFinalSize;
float fBlipScaler = GetBlipScalerValue(pBlip);
if(GetBlipTypeValue(pBlip) == BLIP_TYPE_AREA )
{
if (bOnEdgeOfRadar)
{
//minimized radius edge blips shouldn't inherit alpha
// and this is OKAY to do, because all the blips are currently copied to be rendered
// so the original's data is untouched
pBlip->iAlpha = 0xFF;
fBlipScaler = GetBlipScalerValue(pBlip, false);
vBlipFinalSize.Set( fBlipScaler, fBlipScaler); // if on the edge, shrink it to match what others look like
}
else
{
vBlipFinalSize.Set( GetBlipScaleValue(pBlip) );
}
}
else if (GetBlipTypeValue(pBlip) == BLIP_TYPE_RADIUS)
{
vBlipFinalSize.Set( GetBlipScaleValue(pBlip) * 2.0f ); // radius needs to be diameter for SetScale
}
else
{
vBlipFinalSize.Set( GetBlipScaleValue(pBlip) * fBlipScaler );
// if blip is a player blip then reduce to 50% on edge of minimap
// if blip is considered "dead" then 50% size
if ((flags.IsSet(BLIP_FLAG_DEAD)) ||
(bOnEdgeOfRadar && flags.IsSet(BLIP_FLAG_MINIMISE_ON_EDGE)))
{
vBlipFinalSize *= 0.5f;
}
}
if (GetBlipObjectNameId(pBlip) == BLIP_LEVEL && !bOn3dMap)
{
vBlipFinalSize *= 0.8f; // these blips are always 80% of the original size
}
info.SetScale(vBlipFinalSize.x, vBlipFinalSize.y);
if(pGfxValue->GFxValue::HasMember("textLabel"))
{
GFxValue gfxTextLabel;
if (pGfxValue->GFxValue::GetMember("textLabel", &gfxTextLabel))
{
// Counter-scale text label so the size remains consistent
GFxValue::DisplayInfo textLabelInfo;
float fTextLabelScale = fBlipScaler / vBlipFinalSize.x * 100;
textLabelInfo.SetScale(fTextLabelScale, fTextLabelScale);
gfxTextLabel.SetDisplayInfo(textLabelInfo);
}
}
pGfxValue->SetDisplayInfo(info); // apply the changes
if (flags.IsSet(BLIP_FLAG_UPDATE_STAGE_DEPTH))
{
GFxValue newDepth;
newDepth.SetNumber( DetermineBlipStageDepth(pBlip) );
pGfxValue->Invoke("swapDepths", nullptr, &newDepth, 1);
}
//
// now check for anything that requires an invoke (a flag must be checked before invoking):
//
if (flags.IsSet(BLIP_FLAG_VALUE_CHANGED_COLOUR) || flags.IsSet(BLIP_FLAG_UPDATE_ALPHA_ONLY) )
{
ColourBlipOnStage(pGfxValue, pBlip);
}
//if (flags.IsSet(BLIP_FLAG_SHOW_HEADING_INDICATOR))
{
UpdateHeadingIndicatorOnBlipOnStage(pGfxValue, pBlip, iMapRotation);
}
if (flags.IsSet(BLIP_FLAG_VALUE_CHANGED_OUTLINE_INDICATOR))
{
UpdateOutlineIndicatorOnBlipOnStage(pGfxValue, pBlip);
}
if (flags.IsSet(BLIP_FLAG_VALUE_CHANGED_FRIEND_INDICATOR))
{
UpdateFriendIndicatorOnBlipOnStage(pGfxValue, pBlip);
}
if (flags.IsSet(BLIP_FLAG_VALUE_CHANGED_CREW_INDICATOR))
{
UpdateCrewIndicatorOnBlipOnStage(pGfxValue, pBlip);
}
if (flags.IsSet(BLIP_FLAG_VALUE_CHANGED_TICK))
{
UpdateTickBlipOnStage(pGfxValue, pBlip);
}
if( flags.IsSet(BLIP_FLAG_VALUE_CHANGED_GOLD_TICK))
{
UpdateGoldTickBlipOnStage(pGfxValue, pBlip);
}
if (flags.IsSet(BLIP_FLAG_VALUE_CHANGED_FOR_SALE))
{
UpdateForSaleBlipOnStage(pGfxValue, pBlip);
}
if (flags.IsSet(BLIP_FLAG_VALUE_CHANGED_PULSE))
{
PulseBlipOnStage(&pMainBlip, pBlip);
}
if (flags.IsSet(BLIP_FLAG_VALUE_CHANGED_FLASH))
{
FlashBlipOnStage(pGfxValue, pBlip);
}
#if __BANK
if (flags.IsSet(BLIP_FLAG_VALUE_SET_LABEL))
{
LabelBlipOnStage(pGfxValue, pBlip, true);
}
if (flags.IsSet(BLIP_FLAG_VALUE_REMOVE_LABEL))
{
LabelBlipOnStage(pGfxValue, pBlip, false);
}
#endif // __BANK
if (flags.IsSet(BLIP_FLAG_VALUE_SET_NUMBER))
{
NumberBlipOnStage(&pMainBlip, pBlip);
}
FadeOutDistantBlipOnStage(pGfxValue, iDisplayAlpha);
if (GetBlipCategoryValue(pBlip) == BLIP_CATEGORY_PLAYER) // only blips that are in the player category
{
ProcessPlayerNameDisplayOnBlip(pGfxValue, pBlip, bOnEdgeOfRadar);
}
//
// check for changing the height display of a blip:
//
if (flags.IsSet(BLIP_FLAG_SHOW_HEIGHT))
{
bool bShowHeight = false;
s32 iBlipHeight = 0;
if (GetBlipTypeValue(pBlip) != BLIP_TYPE_RADIUS && GetBlipTypeValue(pBlip) != BLIP_TYPE_AREA)
{
if ( (bOnRadar) && (!ms_MiniMapRenderState.m_bIsInPauseMap)/* && (!ms_MiniMapRenderState.m_bIsInBigMap)*/) // bug 623508 requests no height shown in pausemenu map
{
if (CMiniMap::IsFlagSet(pBlip, BLIP_FLAG_USE_HEIGHT_ON_EDGE))
{
bShowHeight = true;
}
else
{
// we only show the height indicator if the blip is inside the radar area or the player is in a vehicle that has a large change of height (ie a plane), or inside an interior
if ((!bOnEdgeOfRadar) || (ms_MiniMapRenderState.bInsideInterior))
{
// always show height if inside the radar area
bShowHeight = true;
}
else
{
// check if in a plane/heli
if (ms_MiniMapRenderState.bInPlaneOrHeli || ms_MiniMapRenderState.bIsInParachute) // fix for 1430446
{
bShowHeight = true;
}
}
}
}
}
// if its a weapon blip then only show it if its within 15m (for bug 980784)
if (bShowHeight) // only if we are already wanting to show height
{
if (!strncmp(WEAPON_BLIP_NAME, GetBlipObjectName(pBlip), NELEM(WEAPON_BLIP_NAME)-1))
{
bShowHeight = bBlipWithin15mOfPlayer;
}
}
if (bShowHeight) // height indicator only happens when the blip is inside the radar ring
{
iBlipHeight = CheckForHeight(pBlip); // whether this blip is above, below, level to the player
}
if (iBlipHeight != 0)
{
AddHigherLowerBlip(pGfxValue, pBlip, iBlipHeight);
}
else
{
RemoveHigherLowerBlip(pGfxValue);
}
}
else if (flags.IsSet(BLIP_FLAG_VALUE_TURNED_OFF_SHOW_HEIGHT))
{
RemoveHigherLowerBlip(pGfxValue);
flags.Set(BLIP_FLAG_VALUE_TURNED_OFF_SHOW_HEIGHT, false);
}
}
return true;
}
// Returns whether the area blip is outside of minimap bounds
bool CMiniMap_RenderThread::IsAreaBlipOutsideMapBounds(const CBlipComplex& rBlip)
{
// NOTE: Unlike on RDR, all the world positions had to be inverted
// Not sure why, but... didn't work otherwise.
// construct box also in world space, which is easy
ScalarV boxRotate( ScalarVFromF32(GetBlipDirectionValue(&rBlip) * DtoR) );
Mat34V boxLocalRotate;
// translation inverted so the box can transform stuff into its local space
// Removed the - from the positions....I don't know why they were in there but it didn't work with them....B*2173220
Mat34VFromZAxisAngle( boxLocalRotate, boxRotate, Vec3V(-GetBlipPositionConstRef(&rBlip).x, -GetBlipPositionConstRef(&rBlip).y, 0.0f) );
const float boxHeight = 0.0f;
const float fRadarSizeScalarForEdgeBlips = 0.95f; // give it a LITTLE bit of gimme room, so we don't have tiny pixels hanging out off screen
const float diameterScalar = 0.5f * fRadarSizeScalarForEdgeBlips;
const Vec3V vBoxHalfDims(GetBlipScaleValue(&rBlip).x*diameterScalar, GetBlipScaleValue(&rBlip).y*diameterScalar, boxHeight);
const spdAABB aabb(-vBoxHalfDims, vBoxHalfDims);
const spdOrientedBB oriRect( aabb, boxLocalRotate );
ScalarV mapRotate( ScalarVFromF32(ms_MiniMapRenderState.m_iRotation * DtoR) );
#if SUPPORT_MULTI_MONITOR
MultiMonitorHudHelper helper(&ms_MiniMapRenderState);
#endif // SUPPORT_MULTI_MONITOR
Vec3V mapPosition(ms_MiniMapRenderState.m_vMiniMapPosition.x, ms_MiniMapRenderState.m_vMiniMapPosition.y, 0.0f);
Vec3V offsetInWorld(0.0f, ADJUST_SCALEFORM_SCALAR(ms_MiniMapRenderState.m_fMiniMapRange) * ms_MiniMapRenderState.m_fOffset, 0.0f);
Vec3V offsetRotated( RotateAboutZAxis( offsetInWorld, mapRotate ) );
mapPosition += offsetRotated;
Mat34V mapLocalRotate;
Mat34VFromZAxisAngle( mapLocalRotate, mapRotate, -mapPosition );
GFxValue curXTilt;
if( ms_asBaseLayerContainer[MINIMAP_LAYER_FOREGROUND].GetMember("_xrotation", &curXTilt) )
{
Mat34VRotateLocalX(mapLocalRotate, ScalarVFromF32( float(-curXTilt.GetNumber()) * DtoR ) );
}
// We need this in 'world' units. The map is 1:1 pixels to meters, so if we found out how big the map is in pixels, we're all set!
//
// lifted from SetMaskOnLayer, because we need how it clips this to match
Vector2 maskSize( ms_MiniMapRenderState.m_vCurrentMiniMapMaskSize );
float fMapRatio = ms_vOriginalStageSize.x / ms_vOriginalStageSize.y;
const float fScaler = fMapRatio/CHudTools::GetAspectRatio();
maskSize.x /= ms_MiniMapRenderState.m_vCurrentMiniMapSize.x; maskSize.y /= ms_MiniMapRenderState.m_vCurrentMiniMapSize.y;
maskSize.x *= ms_vOriginalStageSize.x/fScaler; maskSize.y *= ms_vOriginalStageSize.y;
// then, now that we have it in 'map meters', we just adjust it by the scalar to see how big the area is in world meters!
const Vec3V vMapHalfDims( ADJUST_SCALEFORM_SCALAR(ms_MiniMapRenderState.m_fMiniMapRange) * maskSize.x * 0.5f
, ADJUST_SCALEFORM_SCALAR(ms_MiniMapRenderState.m_fMiniMapRange) * maskSize.y * 0.5f
, 1000.0f ); // fake a frustum by picking a rather large (?) value
const spdAABB mapAABB(-vMapHalfDims, vMapHalfDims);
const spdOrientedBB mapRect( mapAABB, mapLocalRotate );
bool bOnEdgeOfRadar = !oriRect.IntersectsOrientedBB(mapRect);
#if DEBUG_DRAW && __BANK
// if this the first one, push the minimap's settings
if( CMiniMap_RenderThread::sm_bDrawCollisionVolumes )
{
if( s_DebugDrawVolumes.GetRenderBuf().empty() )
s_DebugDrawVolumes.GetRenderBuf().PushAndGrow(debugVolume(mapRect, Color_WhiteSmoke), 4);
Color32 blipColor = CMiniMap_Common::GetColourFromBlipSettings(GetBlipColourValue(&rBlip), CMiniMap::IsFlagSet(&rBlip,BLIP_FLAG_BRIGHTNESS));
s_DebugDrawVolumes.GetRenderBuf().PushAndGrow(debugVolume(oriRect, blipColor, !bOnEdgeOfRadar), 4);
}
#endif
return bOnEdgeOfRadar;
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::ProcessPlayerNameDisplayOnBlip
// PURPOSE: whether to attach or remove the player name display on a blip
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::ProcessPlayerNameDisplayOnBlip(GFxValue *pBlipGfx, CBlipComplex *pBlip, bool bOnEdgeOfRadar)
{
if (!pBlip) // safeguard against invalid blips
{
return;
}
//
// check to see if we need to display the blip name against the blip (ie player blips)
//
bool bSetBlipLabelThisFrame = false;
bool bRemoveBlipLabelThisFrame = false;
bool bHasNameBeenAttachedPreviously = false;
if (pBlipGfx)
{
bHasNameBeenAttachedPreviously = pBlipGfx->GFxValue::HasMember("textLabel");
}
if ( (ms_MiniMapRenderState.m_bDisplayPlayerNames) && (!ms_MiniMapRenderState.m_bIsInPauseMap) && (ms_MiniMapRenderState.m_bIsInBigMap) )
{
if (bHasNameBeenAttachedPreviously)
{
if (!bOnEdgeOfRadar)
{
if (!IsBlipNameTagWithinBounds(pBlipGfx, pBlip))
{
bRemoveBlipLabelThisFrame = true;
}
}
else
{
bRemoveBlipLabelThisFrame = true;
}
}
else
{
if (!bOnEdgeOfRadar) // if within the zone, not already attached then flag to add
{
bSetBlipLabelThisFrame = true;
}
}
}
else
{
bRemoveBlipLabelThisFrame = bHasNameBeenAttachedPreviously; // if no longer needing names at all, then flag to remove it it has been previously added
}
if (pBlipGfx)
{
// if flagged to be added, then invoke scaleform
if (bSetBlipLabelThisFrame)
{
if (CScaleformMgr::BeginMethod(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND], SF_BASE_CLASS_MINIMAP, "SET_BLIP_LABEL"))
{
CScaleformMgr::AddParamGfxValue(*pBlipGfx);
CScaleformMgr::AddParamString(GetBlipNameValue(pBlip));
GFxValue::DisplayInfo blipDisplayInfo;
pBlipGfx->GetDisplayInfo(&blipDisplayInfo);
CScaleformMgr::AddParamFloat(GetBlipScalerValue(pBlip) / blipDisplayInfo.GetXScale() * 100);
CScaleformMgr::EndMethod();
}
if (!IsBlipNameTagWithinBounds(pBlipGfx, pBlip))
{
if (CScaleformMgr::BeginMethod(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND], SF_BASE_CLASS_MINIMAP, "REMOVE_BLIP_LABEL"))
{
CScaleformMgr::AddParamGfxValue(*pBlipGfx);
CScaleformMgr::EndMethod();
}
}
}
// if flagged to be removed, then invoke scaleform
if (bRemoveBlipLabelThisFrame)
{
if (CScaleformMgr::BeginMethod(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND], SF_BASE_CLASS_MINIMAP, "REMOVE_BLIP_LABEL"))
{
CScaleformMgr::AddParamGfxValue(*pBlipGfx);
CScaleformMgr::EndMethod();
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::IsBlipNameTagWithinBounds
// PURPOSE: is the blip name tag within the bounds of the minimap zone
/////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::IsBlipNameTagWithinBounds(GFxValue *pBlipGfx, CBlipComplex *pBlip)
{
if ( (!pBlip) || (!pBlipGfx) )
return false;
GFxValue::DisplayInfo displayInfo;
pBlipGfx->GetDisplayInfo(&displayInfo);
Vector2 vPosOnStage = Vector2((float)displayInfo.GetX(), (float)displayInfo.GetY());
GFxValue gfxTextLabel;
if (pBlipGfx->GFxValue::GetMember("textLabel", &gfxTextLabel))
{
GFxValue gfxTextLabelBG;
if (gfxTextLabel.GetMember("bg", &gfxTextLabelBG))
{
float fNameLength = 0.0f;
GFxValue nameTagWidth;
gfxTextLabelBG.GetMember("_width", &nameTagWidth);
if(nameTagWidth.IsDefined())
{
#define GAP_BETWEEN_BLIP_AND_BORDER (20.0f)
// need to convert from "actionscript space" to the minimap scaled space:
fNameLength = static_cast<float>(( (nameTagWidth.GetNumber() + GAP_BETWEEN_BLIP_AND_BORDER) / (float)ACTIONSCRIPT_STAGE_SIZE_X) * MINIMAP_INITIAL_SCALE);
// deal with adjusting this length to the correct scaled side:
fNameLength *= GetBlipScaleValue(pBlip).x; // scale for blip scaling
if (GetBlipObjectNameId(pBlip) == BLIP_LEVEL)
{
fNameLength *= 0.8f; // these blips are always 80% of the original size
}
}
// these values match the position in the AS stage where the name shouldnt display
if ((vPosOnStage.x-fNameLength) < 8.0f || // check if within bounds
vPosOnStage.y < 17.0f ||
vPosOnStage.x > 112.0f ||
vPosOnStage.y > 119.0f)
{
return false;
}
else
{
return true; // within bounds
}
}
}
return false;
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::ReInitBlipOnStage
// PURPOSE: re-initialises the blips that are currently on the stage
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::ReInitBlipOnStage(CBlipComplex *pBlip)
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::ReInitBlipOnStage can only be called on the RenderThread!");
return;
}
if (pBlip)
{
if (GetBlipGfxValue(pBlip))
{
if (RemoveBlipFromStage(pBlip, false))
{
AddBlipToStage(pBlip);
}
else
{
uiAssertf(0, "CMiniMap_RenderThread: Reinit blip on stage couldnt complete!");
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateAltimeter
// PURPOSE: updates the altimeter
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateAltimeter()
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::UpdateAltimeter can only be called on the RenderThread!");
return;
}
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return;
// bool bSwitchOff = true;
bool bDrawAltimeter = (ms_MiniMapRenderState.m_AltimeterMode != ALTIMETER_OFF);
if( bDrawAltimeter )
{
// remember that -Y is UP, so the TOP is actually the lower value
// whereas the bottom is a higher value
const float fHeight = (ms_MiniMapRenderState.m_vCentrePosition.z + ALTIMETER_GROUND_LEVEL_FUDGE_FACTOR);
//
// Background
//
const float fFloorLevel = ms_MiniMapRenderState.m_fMinAltimeterHeight;
const float fCeilingLevel = ms_MiniMapRenderState.m_fMaxAltimeterHeight;
const float fPercent = ms_MiniMapRenderState.m_AltimeterMode == ALTIMETER_SWIMMING ? rage::Range(fHeight, fCeilingLevel, fFloorLevel) : rage::Range(fHeight, fFloorLevel, fCeilingLevel);
GFxValue::DisplayInfo infoGauge;
const float fPercentPixels = (fPercent - 0.5f) * ALTIMETER_TICK_PIXEL_HEIGHT;// 0.5f to adjust for the registration point being centered
infoGauge.SetY( fPercentPixels );
ms_Altimeter.m_asGaugeMc.SetDisplayInfo(infoGauge);
GFxValue altimeter_colour_mc;
if (ms_Altimeter.m_asGaugeMc.GFxValue::GetMember("altimeter_colour", &altimeter_colour_mc))
{
GFxValue::DisplayInfo visibilityDisplayInfo;
visibilityDisplayInfo.SetVisible(ms_MiniMapRenderState.m_bColourAltimeter);
altimeter_colour_mc.SetDisplayInfo(visibilityDisplayInfo);
GFxValue ColorArg[1];
GFxValue result;
ColorArg[0].SetNumber((int)(ms_MiniMapRenderState.m_AltimeterColor));
altimeter_colour_mc.Invoke("Recolor", &result, ColorArg, COUNTOF(ColorArg));
}
//
// asAltimeterRoll:
//
GFxValue::DisplayInfo infoRoll;
infoRoll.SetVisible( ms_MiniMapRenderState.m_AltimeterMode != ALTIMETER_OFF );
infoRoll.SetRotation(ms_MiniMapRenderState.fRoll * RtoD);
ms_Altimeter.m_asRollMc.SetDisplayInfo(infoRoll);
}
// determine visibility for the whole shebang
{
GFxValue::DisplayInfo drawInfo;
drawInfo.SetVisible(bDrawAltimeter);
drawInfo.SetPosition((ms_vStageSize.x * 0.5f), (ms_vStageSize.y * 0.5f) + ms_MiniMapRenderState.m_fOffset);
ms_Altimeter.m_asContainerMc.SetDisplayInfo(drawInfo);
}
// Show/Hide all four runways
if( ms_MiniMapRenderState.bInPlaneOrHeli != ms_bRunwayBlipsAreDisplaying )
{
ms_bRunwayBlipsAreDisplaying = ms_MiniMapRenderState.bInPlaneOrHeli;
if (CScaleformMgr::BeginMethod(ms_iMovieId[MINIMAP_MOVIE_BACKGROUND], SF_BASE_CLASS_MINIMAP, "SHOW_AIRCRAFT_COMPONENTS"))
{
CScaleformMgr::AddParamBool(ms_bRunwayBlipsAreDisplaying);
CScaleformMgr::EndMethod();
}
}
}
void CMiniMap_RenderThread::UpdateSonarSweep()
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::UpdateSonarSweep can only be called on the RenderThread!");
return;
}
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return;
if(ms_MiniMapRenderState.m_bShowSonarSweep)
{
const bool bHideSonarSweep = ms_MiniMapRenderState.m_bIsInBigMap;
const bool bShowSonarSweep = ms_MiniMapRenderState.m_bShowSonarSweep && !bHideSonarSweep;
if (CScaleformMgr::BeginMethod(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND], SF_BASE_CLASS_MINIMAP, "SHOW_SONAR_SWEEP"))
{
CScaleformMgr::AddParamBool(bShowSonarSweep);
CScaleformMgr::EndMethod();
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateMapVisibility
// PURPOSE: makes sure the prologue map is displayed instead of the standard one
// when script set it, or the main map is turned off
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateMapVisibility()
{
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return;
GFxValue mainMap;
GFxValue::DisplayInfo currentMainMapDisplayInfo;
ms_asMapObject.GFxValue::GetMember("main_map", &mainMap);
mainMap.GetDisplayInfo(&currentMainMapDisplayInfo);
// show/hide the prologue map:
if (ms_MiniMapRenderState.m_bShowPrologueMap)
{
#if COMPANION_APP
CCompanionData::GetInstance()->SetMapDisplay(eMapDisplay::MAP_DISPLAY_PROLOGUE);
#endif // COMPANION_APP
}
// show/hide the island map:
if (ms_MiniMapRenderState.m_bShowIslandMap)
{
#if COMPANION_APP
CCompanionData::GetInstance()->SetMapDisplay(eMapDisplay::MAP_DISPLAY_ISLAND);
#endif // COMPANION_APP
}
//
// show/hide the main map:
//
if (ms_MiniMapRenderState.m_bShowMainMap)
{
#if COMPANION_APP
CCompanionData::GetInstance()->SetMapDisplay(eMapDisplay::MAP_DISPLAY_NORMAL);
#endif // COMPANION_APP
if (!currentMainMapDisplayInfo.GetVisible())
{
GFxValue::DisplayInfo newDisplayInfo;
newDisplayInfo.SetVisible(true);
mainMap.SetDisplayInfo(newDisplayInfo);
g_RenderMinimap = true;
if ( (!ms_MiniMapRenderState.m_bIsInPauseMap) && (!ms_MiniMapRenderState.m_bIsInCustomMap) )
{
g_RenderMinimapSea = true;
}
}
}
else
{
if (currentMainMapDisplayInfo.GetVisible())
{
GFxValue::DisplayInfo newDisplayInfo;
newDisplayInfo.SetVisible(false);
mainMap.SetDisplayInfo(newDisplayInfo);
g_RenderMinimap = false;
g_RenderMinimapSea = false;
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::CheckIncomingFunctions
// PURPOSE: checks for incoming functions from ActionScript
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::CheckIncomingFunctions(atHashWithStringBank methodName, const GFxValue* args)
{
// INTERIOR_IS_LOADED
if (methodName == ATSTRINGHASH("INTERIOR_IS_LOADED",0xad2c4c8))
{
if (ms_asInteriorMc.IsDisplayObject()) // ignore this until its been invoked with LoadMovie - where ms_asInteriorMc is attached
{
ms_asInteriorMovie = args[1];
}
return;
}
// GOLF_COURSE_IS_LOADED
if (methodName == ATSTRINGHASH("GOLF_COURSE_IS_LOADED",0x9a61c818))
{
if (ms_asGolfCourseMc.IsDisplayObject()) // ignore this until its been invoked with LoadMovie - where ms_asGolfCourseMc is attached
{
ms_asGolfCourseMovie = args[1];
}
return;
}
#if __STREAMED_SUPERTILE_FILES
if (methodName == ATSTRINGHASH("SUPERTILE_IS_LOADED",0xc72454db))
{
ms_Supertiles.HandleIsLoadedCallback((s32)args[1].GetNumber(), (s32)args[2].GetNumber(), args[3]);
return;
}
#endif // __STREAMED_SUPERTILE_FILES
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::RemoveInterior
// PURPOSE: creates the GFxValue object as the interior is now active on the stage
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::RemoveInterior()
{
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return;
ms_bInteriorMovieIdFullySetup = false;
ms_bInteriorWasSetOnPerFrame = false;
if (ms_asInteriorMc.IsDisplayObject())
{
ms_asInteriorMc.Invoke("removeMovieClip");
}
ms_asInteriorMc.SetUndefined();
ms_asInteriorMovie.SetUndefined();
ms_PreviousInterior.iLevel = sMiniMapInterior::INVALID_LEVEL;
if (ms_iInteriorMovieId != -1)
{
ms_bRemoveInteriorMovie = true;
}
uiDebugf1("MiniMap: Interior removed from stage");
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateInterior
// PURPOSE: updates the minimap with any information interiors/exteriors
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateInterior()
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
uiAssertf(0, "CMiniMap_RenderThread::UpdateInterior can only be called on the RenderThread!");
return;
}
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return;
if (ms_PreviousInterior.ResolveDifferentHash(ms_MiniMapRenderState.m_Interior))
{
if (ms_MiniMapRenderState.m_Interior.uHash != 0)
{
#if __BANK && __DEV
if (bDisplayInteriorInfoToLog)
{
Displayf("Interior info for minimap is: %u (%d)", ms_MiniMapRenderState.m_Interior.uHash, ms_MiniMapRenderState.m_Interior.uHash);
}
#endif // __BANK && __DEV
RemoveInterior();
ms_bStreamInteriorMovie = true;
}
else
{
RemoveInterior();
}
}
if (ms_bStreamInteriorMovie || ms_bRemoveInteriorMovie)
return;
GFxValue asInteriorLayer;
if (!ms_asBaseOverlay3D[MINIMAP_LAYER_BACKGROUND].GetMember("asInteriorLayer", &asInteriorLayer))
{
uiAssertf(0, "CMiniMap_RenderThread::UpdateInterior cannot find member 'asInteriorLayer'");
return;
}
//
// no interior map should be shown when not in an interior:
//
GFxValue::DisplayInfo displayInfo;
asInteriorLayer.GetDisplayInfo(&displayInfo);
if (ms_MiniMapRenderState.m_Interior.uHash == 0 || ms_MiniMapRenderState.m_bHideInteriorMap)
{
// hide
if (displayInfo.GetVisible())
{
GFxValue::DisplayInfo newInteriorDisplayInfo;
newInteriorDisplayInfo.SetVisible(false);
asInteriorLayer.SetDisplayInfo(newInteriorDisplayInfo);
}
}
else
{
// show
if (!displayInfo.GetVisible())
{
GFxValue::DisplayInfo newInteriorDisplayInfo;
newInteriorDisplayInfo.SetVisible(true);
asInteriorLayer.SetDisplayInfo(newInteriorDisplayInfo);
}
}
if (CScaleformMgr::IsMovieActive(ms_iInteriorMovieId))
{
if ((!ms_asInteriorMovie.IsDisplayObject()) || (ms_asInteriorMovie.IsDisplayObject() && (!ms_asInteriorMovie.HasMember("interior"))))
{
char cHashName[20];
formatf(cHashName, "INT%u", ms_MiniMapRenderState.m_Interior.uHash, NELEM(cHashName));
if (ms_asInteriorMc.IsUndefined())
{
// invoke the load here
GFxValue result, params[1];
params[0].SetString(cHashName);
asInteriorLayer.CreateEmptyMovieClip(&ms_asInteriorMc, "INTERIOR_LINK", MOVIE_DEPTH_INTERIOR);
ms_asInteriorMc.Invoke("loadMovie", &result, params, 1);
}
if (ms_asInteriorMc.IsDisplayObject())
{
if (ms_asInteriorMovie.IsDisplayObject())
{
if (ms_asInteriorMovie.GotoAndStop(cHashName))
{
if (ms_asInteriorMovie.HasMember("interior"))
{
Vector3 vPos(0,0,0);
float fRot = 0.0f;
#if __BANK
if (!ms_MiniMapRenderState.m_bHasDebugInterior)
#endif // __BANK
{
// get current interior rotation and position:
vPos = ms_MiniMapRenderState.m_Interior.vPos;
fRot = ms_MiniMapRenderState.m_Interior.fRot;
}
// set the position:
GFxValue::DisplayInfo currentDisplayInfo;
currentDisplayInfo.SetPosition((vPos.x), -(vPos.y));
currentDisplayInfo.SetRotation(fRot);
if (ms_MiniMapRenderState.m_bShowPrologueMap) // fix for 986642
{
currentDisplayInfo.SetScale(400.0f, 400.0f);
}
else if (ms_MiniMapRenderState.m_bShowIslandMap)
{
currentDisplayInfo.SetScale(100.0f, 100.0f);
}
else
{
currentDisplayInfo.SetScale(100.0f, 100.0f);
}
ms_asInteriorMovie.SetDisplayInfo(currentDisplayInfo);
ms_bInteriorMovieIdFullySetup = true;
uiDebugf1("CMiniMap_RenderThread: Interior %s added to stage", cHashName);
}
else
{
uiDebugf1("CMiniMap_RenderThread: Interior data for %s is invalid - unable to set up Interior on stage (probably movieclip is missing member 'interior')", cHashName);
RemoveInterior(); // remove anything that was setup
return;
}
}
else
{
uiDebugf1("CMiniMap_RenderThread: Interior %s is invalid - probably doesnt exist (gotoandstop(%s) failed)", cHashName, cHashName);
}
}
}
}
//
// make current level in the interior visible and hide the previous interior level:
//
if (ms_asInteriorMovie.IsDisplayObject() && ms_asInteriorMovie.HasMember("interior"))
{
GFxValue theinterior;
ms_asInteriorMovie.GetMember("interior", &theinterior);
s32 iCurrentInteriorLevel = ms_MiniMapRenderState.m_Interior.iLevel;
s32 iPreviousInteriorLevel = ms_PreviousInterior.iLevel;
if(ms_PreviousInterior.ResolveDifferentOrientation(ms_MiniMapRenderState.m_Interior))
{
GFxValue::DisplayInfo currentDisplayInfo;
currentDisplayInfo.SetPosition(ms_MiniMapRenderState.m_Interior.vPos.x, -(ms_MiniMapRenderState.m_Interior.vPos.y));
currentDisplayInfo.SetRotation(ms_MiniMapRenderState.m_Interior.fRot);
ms_asInteriorMovie.SetDisplayInfo(currentDisplayInfo);
}
if( ms_PreviousInterior.ResolveDifferentLevels(ms_MiniMapRenderState.m_Interior) )
{
char cCurrentLevelString[50];
if (iCurrentInteriorLevel >= 0)
formatf(cCurrentLevelString, "level_%d", iCurrentInteriorLevel, NELEM(cCurrentLevelString));
else
formatf(cCurrentLevelString, "level_u%d", -iCurrentInteriorLevel, NELEM(cCurrentLevelString));
if (ms_PreviousInterior.iLevel != sMiniMapInterior::INVALID_LEVEL) // if we have a previous level
{
char cPreviousLevelString[50];
if (iPreviousInteriorLevel >= 0)
formatf(cPreviousLevelString, "level_%d", iPreviousInteriorLevel, NELEM(cPreviousLevelString));
else
formatf(cPreviousLevelString, "level_u%d", -iPreviousInteriorLevel, NELEM(cPreviousLevelString));
if (theinterior.HasMember(cPreviousLevelString))
{
GFxValue thisLevel;
theinterior.GFxValue::GetMember(cPreviousLevelString, &thisLevel);
GFxValue::DisplayInfo info;
info.SetAlpha(0);
thisLevel.SetDisplayInfo(info);
uiDebugf1("CMiniMap_RenderThread: Removed interior '%s'", cPreviousLevelString);
}
#if __DEV
else
{
uiDebugf1("CMiniMap_RenderThread: Tried to remove interior '%s' but it doesnt exist", cPreviousLevelString);
}
#endif // __DEV
}
if (theinterior.HasMember(cCurrentLevelString))
{
GFxValue thisLevel;
theinterior.GFxValue::GetMember(cCurrentLevelString, &thisLevel);
GFxValue::DisplayInfo info;
info.SetAlpha(100);
thisLevel.SetDisplayInfo(info);
uiDebugf1("CMiniMap_RenderThread: Activated interior '%s'", cCurrentLevelString);
}
#if __DEV
else
{
uiDebugf1("CMiniMap_RenderThread: Tried to activate interior '%s' but it doesnt exist", cCurrentLevelString);
}
#endif // __DEV
}
}
}
}
void CMiniMap_RenderThread::HandleInteriorAtEndOfFrame()
{
if (CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on UT
{
sfAssertf(0, "CMiniMap_RenderThread::HandleInteriorsAtEndOfFrame can only be called on the UpdateThread!");
return;
}
//
// removal/stream of interior movie
//
if (ms_bRemoveInteriorMovie || ms_bStreamInteriorMovie)
{
if (ms_iInteriorMovieId != -1)
{
if (CScaleformMgr::IsMovieActive(ms_iInteriorMovieId))
{
CScaleformMgr::RequestRemoveMovie(ms_iInteriorMovieId);
}
ms_iInteriorMovieId = -1;
}
ms_bRemoveInteriorMovie = false;
}
if (ms_bStreamInteriorMovie)
{
char cInteriorFilename[64];
formatf(cInteriorFilename, "INT%u", ms_MiniMapRenderState.m_Interior.uHash, NELEM(cInteriorFilename));
if (CScaleformMgr::DoesMovieExistInImage(cInteriorFilename))
{
ms_bInteriorWasSetOnPerFrame = CScriptHud::FakeInterior.bActive;
ms_iInteriorMovieId = CScaleformMgr::CreateMovie(cInteriorFilename, Vector2(0.0f, 0.0f), Vector2(1.0f, 1.0f), true, -1, -1, false);
}
else
{
uiDebugf1("CMiniMap: Interior %s is invalid - movie doesnt exist in RPF", cInteriorFilename);
}
ms_bStreamInteriorMovie = false;
}
CMiniMap_Common::SetInteriorMovieActive(ms_iInteriorMovieId != -1 && ms_bInteriorMovieIdFullySetup); // flag the interior movie as on/off
}
void CMiniMap_RenderThread::ProcessAtEndOfFrame()
{
#if __STREAMED_SUPERTILE_FILES
ms_Supertiles.ProcessAtEndOfFrame(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND]);
#endif // __STREAMED_SUPERTILE_FILES
HandleInteriorAtEndOfFrame();
HandleGolfCourseAtEndOfFrame();
}
bool CMiniMap_RenderThread::HasRenderThreadProcessedThisMinimapModeState(eSETUP_STATE StateToCheck)
{
switch (StateToCheck)
{
case MINIMAP_MODE_STATE_NONE :
return false;
case MINIMAP_MODE_STATE_SETUP_FOR_MINIMAP :
if (MINIMAP_MODE_STATE_SETUP_FOR_MINIMAP_HAS_BEEN_PROCESSED_BY_RENDER_THREAD == ms_MiniMapRenderState.m_MinimapModeState)
{
#if !__FINAL
if(CMiniMap_Common::OutputDebugTransitions())
uiDisplayf("MINIMAP_TRANSITION: CMiniMap_RenderThread::HasRenderThreadProcessedThisMinimapModeState. Processed MINIMAP_MODE_STATE_SETUP_FOR_MINIMAP(%d) this frame (RT)", StateToCheck);
#endif
return true;
}
break;
case MINIMAP_MODE_STATE_SETUP_FOR_PAUSEMAP :
if (MINIMAP_MODE_STATE_SETUP_FOR_PAUSEMAP_HAS_BEEN_PROCESSED_BY_RENDER_THREAD == ms_MiniMapRenderState.m_MinimapModeState)
{
#if !__FINAL
if(CMiniMap_Common::OutputDebugTransitions())
uiDisplayf("MINIMAP_TRANSITION: CMiniMap_RenderThread::HasRenderThreadProcessedThisMinimapModeState. Processed MINIMAP_MODE_STATE_SETUP_FOR_PAUSEMAP(%d) this frame (RT)", StateToCheck);
#endif
return true;
}
break;
case MINIMAP_MODE_STATE_SETUP_FOR_BIGMAP :
if (MINIMAP_MODE_STATE_SETUP_FOR_BIGMAP_HAS_BEEN_PROCESSED_BY_RENDER_THREAD == ms_MiniMapRenderState.m_MinimapModeState)
{
#if !__FINAL
if(CMiniMap_Common::OutputDebugTransitions())
uiDisplayf("MINIMAP_TRANSITION: CMiniMap_RenderThread::HasRenderThreadProcessedThisMinimapModeState. Processed MINIMAP_MODE_STATE_SETUP_FOR_BIGMAP(%d) this frame (RT)", StateToCheck);
#endif
return true;
}
break;
case MINIMAP_MODE_STATE_SETUP_FOR_CUSTOMMAP :
if (MINIMAP_MODE_STATE_SETUP_FOR_CUSTOMMAP_HAS_BEEN_PROCESSED_BY_RENDER_THREAD == ms_MiniMapRenderState.m_MinimapModeState)
{
#if !__FINAL
if(CMiniMap_Common::OutputDebugTransitions())
uiDisplayf("MINIMAP_TRANSITION: CMiniMap_RenderThread::HasRenderThreadProcessedThisMinimapModeState. Processed MINIMAP_MODE_STATE_SETUP_FOR_CUSTOMMAP(%d) this frame (RT)", StateToCheck);
#endif
return true;
}
break;
case MINIMAP_MODE_STATE_SETUP_FOR_GOLFMAP :
if (MINIMAP_MODE_STATE_SETUP_FOR_GOLFMAP_HAS_BEEN_PROCESSED_BY_RENDER_THREAD == ms_MiniMapRenderState.m_MinimapModeState)
{
#if !__FINAL
if(CMiniMap_Common::OutputDebugTransitions())
uiDisplayf("MINIMAP_TRANSITION: CMiniMap_RenderThread::HasRenderThreadProcessedThisMinimapModeState. Processed MINIMAP_MODE_STATE_SETUP_FOR_GOLFMAP(%d) this frame (RT)", StateToCheck);
#endif
return true;
}
break;
default :
Assertf(0, "CMiniMap_RenderThread::HasRenderThreadProcessedThisMinimapModeState - setup state %d not handled by this function", StateToCheck);
break;
}
return false;
}
bool CMiniMap_RenderThread::IsInGameMiniMapDisplaying()
{
return ms_MiniMapRenderState.m_bShouldRenderMiniMap &&
( ms_MiniMapRenderState.m_bIsInBigMap ||
(!ms_MiniMapRenderState.m_bIsInCustomMap && !ms_MiniMapRenderState.m_bIsInPauseMap) );
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateTiles
// PURPOSE: switches on/off tiles based on current player position
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateTiles(bool bClearAll)
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::UpdateTiles can only be called on the RenderThread!");
return;
}
Vector2 vTilesAroundPlayer;
bool bBitmapOnly = false;
if (bClearAll)
{
bBitmapOnly = true;
vTilesAroundPlayer = Vector2(0.0f, 0.0f);
}
else
{
bBitmapOnly = ms_MiniMapRenderState.m_bBitmapOnly;
vTilesAroundPlayer = ms_MiniMapRenderState.m_vTilesAroundPlayer;
}
Vector2 vCurrentTile = ms_MiniMapRenderState.m_vCentreTileForPlayer;
bool bAllTilesAreVisible = ms_Supertiles.Update(vCurrentTile, vTilesAroundPlayer, ms_asTileLayerContainer, bBitmapOnly);
bool bBitmapVisible = false;
#if __STREAMED_SUPERTILE_FILES
if ( (ms_MiniMapRenderState.m_bIsInPauseMap) && (!ms_MiniMapRenderState.bInsideInterior) )
{
if (!bAllTilesAreVisible)
{
bBitmapVisible = (ms_MiniMapRenderState.m_fMiniMapRange < 22.0f); // only have bitmap if we are zoomed out enough
}
else
{
bBitmapVisible = (ms_MiniMapRenderState.m_fMiniMapRange < 8.0f);
}
}
else
{
bBitmapVisible = true;
}
// turn bitmap on/off as desired
static bool bPreviouslyVisible = !bBitmapVisible;
if (bPreviouslyVisible != bBitmapVisible)
{
bPreviouslyVisible = bBitmapVisible;
GFxValue txd_mc;
if (uiVerifyf(ms_asBitmapLayerContainer.GFxValue::GetMember("TXD_MC", &txd_mc), "cannot find 'TXD_MC' member"))
{
GFxValue::DisplayInfo bitmapDisplayInfo;
if (bBitmapVisible)
bitmapDisplayInfo.SetVisible(true);
else
bitmapDisplayInfo.SetVisible(false);
txd_mc.SetDisplayInfo(bitmapDisplayInfo);
}
}
#else // __STREAMED_SUPERTILE_FILES
static Vector2 vPreviousTile(-1.0f,-1.0f);
static Vector2 vPreviousTilesAroundPlayer = vTilesAroundPlayer;
// if tile player is on hasnt changed and the amount of tiles to display hasnt changed, then no point in processing any further
if ( (!bClearAll) && (vPreviousTile == vCurrentTile && vPreviousTilesAroundPlayer == vTilesAroundPlayer) )
{
return;
}
char cLinkageName[30];
Vector2 vTile;
#if __DEV
s32 iDebugTileSwap = 0;
#endif // __DEV
if ( (vPreviousTile.x != -1.0f && vPreviousTile.y != -1.0f) || (vPreviousTilesAroundPlayer != vTilesAroundPlayer) )
{
for (vTile.x = vPreviousTile.x - vPreviousTilesAroundPlayer.x; vTile.x <= vPreviousTile.x + vPreviousTilesAroundPlayer.x; vTile.x++)
{
if (vTile.x < 0.0f || vTile.x > MINIMAP_WORLD_TILE_SIZE_X) // ignore tiles out of the map bounds
continue;
for (vTile.y = vPreviousTile.y - vPreviousTilesAroundPlayer.y; vTile.y <= vPreviousTile.y + vPreviousTilesAroundPlayer.y; vTile.y++)
{
if (vTile.y < 0.0f || vTile.y > MINIMAP_WORLD_TILE_SIZE_Y) // ignore tiles out of the map bounds
continue;
formatf(cLinkageName, "MAP_high_r%d_col%d", (s32)vTile.y, (s32)vTile.x, NELEM(cLinkageName));
if (vPreviousTile != vCurrentTile && vTile == vPreviousTile)
{
// Displayf("REMOVING TILE (centre) %s", cLinkageName);
}
else
{
// no need to turn off tiles that we still want to display this time round
if ((!bBitmapOnly) &&
vTile.x >= vCurrentTile.x - vTilesAroundPlayer.x &&
vTile.x <= vCurrentTile.x + vTilesAroundPlayer.x &&
vTile.y >= vCurrentTile.y - vTilesAroundPlayer.y &&
vTile.y <= vCurrentTile.y + vTilesAroundPlayer.y)
{
continue;
}
// Displayf("REMOVING TILE %s", cLinkageName);
}
if (ms_asTileLayerContainer.HasMember(cLinkageName))
{
GFxValue tile;
ms_asTileLayerContainer.GFxValue::GetMember(cLinkageName, &tile);
if (tile.IsDisplayObject())
{
tile.Invoke("removeMovieClip");
#if __DEV
// uiDebugf1("REMOVING TILE %s %d", cLinkageName, iDebugTileSwap);
iDebugTileSwap++;
#endif // __DEV
}
}
}
}
}
if (!bBitmapOnly)
{
for (vTile.x = vCurrentTile.x - vTilesAroundPlayer.x; vTile.x <= vCurrentTile.x + vTilesAroundPlayer.x; vTile.x++)
{
if (vTile.x < 0.0f || vTile.x > MINIMAP_WORLD_TILE_SIZE_X) // ignore tiles out of the map bounds
continue;
for (vTile.y = vCurrentTile.y - vTilesAroundPlayer.y; vTile.y <= vCurrentTile.y + vTilesAroundPlayer.y; vTile.y++)
{
if (vTile.y < 0.0f || vTile.y > MINIMAP_WORLD_TILE_SIZE_Y) // ignore tiles out of the map bounds
continue;
formatf(cLinkageName, "MAP_high_r%d_col%d", (s32)vTile.y, (s32)vTile.x, NELEM(cLinkageName));
if (vTile != vCurrentTile)
{
// no need to turn on tiles that we already know are active from last time
if (vTile != vPreviousTile &&
vTile.x >= vPreviousTile.x - vPreviousTilesAroundPlayer.x &&
vTile.x <= vPreviousTile.x + vPreviousTilesAroundPlayer.x &&
vTile.y >= vPreviousTile.y - vPreviousTilesAroundPlayer.y &&
vTile.y <= vPreviousTile.y + vPreviousTilesAroundPlayer.y)
{
continue;
}
}
if (!ms_asTileLayerContainer.HasMember(cLinkageName))
{
GFxValue tile;
static s32 iTileDepth = 1;
if (iTileDepth > (MINIMAP_WORLD_TILE_SIZE_X * MINIMAP_WORLD_TILE_SIZE_Y) + 1 )
{
iTileDepth = 1; // wrap around back to depth 1
}
else
{
iTileDepth++;
}
// #if __DEV
// uiDebugf1("TRYING TO ADD TILE %s (%0.0f %0.0f)", cLinkageName, vTile.x, vTile.y);
// #endif // __DEV
if (vTile.x >= MINIMAP_VISIBLE_TILES_WEST && vTile.y >= MINIMAP_VISIBLE_TILES_NORTH && vTile.x <= MINIMAP_VISIBLE_TILES_EAST && vTile.y <= MINIMAP_VISIBLE_TILES_SOUTH)
{
if (ms_asTileLayerContainer.GFxValue::AttachMovie(&tile, cLinkageName, cLinkageName, iTileDepth))
{
Vector2 vWorldTilePosition((vTile.x * MINIMAP_TILE_WIDTH) - (MINIMAP_WORLD_SIZE_X * 0.5f), ((MINIMAP_WORLD_TILE_SIZE_Y-vTile.y) * MINIMAP_TILE_HEIGHT) - (MINIMAP_WORLD_SIZE_Y * 0.5f));
GFxValue::DisplayInfo tileDisplayInfo;
tileDisplayInfo.SetPosition(vWorldTilePosition.x, -vWorldTilePosition.y);
tile.SetDisplayInfo(tileDisplayInfo);
#if __DEV
// uiDebugf1("ADDED TILE %s (%0.2f,%0.2f) %d %d", cLinkageName, vWorldTilePosition.x,vWorldTilePosition.y, iDebugTileSwap, iTileDepth);
iDebugTileSwap++;
#endif // __DEV
}
}
}
}
}
}
#if __DEV
// uiDebugf1("Had to change %d tiles this frame", iDebugTileSwap);
#endif // __DEV
vPreviousTile = vCurrentTile;
vPreviousTilesAroundPlayer = vTilesAroundPlayer;
#endif // __STREAMED_SUPERTILE_FILES
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::RemoveGolfCourse
// PURPOSE:
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::RemoveGolfCourse(bool bFromUpdateThreadInShutdownSession)
{
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return;
if (ms_asGolfCourseMc.IsDisplayObject())
{
ms_asGolfCourseMc.Invoke("removeMovieClip");
}
ms_asGolfCourseMc.SetUndefined();
ms_asGolfCourseMovie.SetUndefined();
ms_asGolfCourseHole.SetUndefined();
// remove the movie gfx
if (ms_iGolfCourseMovieId != -1)
{
ms_bRemoveGolfCourseMovie = true;
}
if (!bFromUpdateThreadInShutdownSession && !ms_MiniMapRenderState.m_bIsInPauseMap && !ms_MiniMapRenderState.m_bIsInCustomMap)
{
// Graeme - I'm not sure if this will work. MinimapModeState on the Update Thread is cleared every frame
// Can I call SetupForMiniMap() directly here?
// ms_MiniMapRenderState.m_MinimapModeState = MINIMAP_MODE_STATE_SETUP_FOR_MINIMAP;
SetupForMiniMap();
}
uiDebugf1("MiniMap: golf course removed from stage");
}
void CMiniMap_RenderThread::UpdateSea(bool bOn)
{
// turn the sea on/off
if (ms_asMapContainerMc.GFxValue::HasMember("sea"))
{
GFxValue seaMap;
ms_asMapContainerMc.GFxValue::GetMember("sea", &seaMap);
GFxValue::DisplayInfo info;
info.SetVisible(false);
seaMap.SetDisplayInfo(info);
}
g_RenderMinimapSea = bOn;
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::UpdateGolfCourse
// PURPOSE: updates the minimap with any information golf courses
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::UpdateGolfCourse()
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::UpdateGolfCourse can only be called on the RenderThread!");
return;
}
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return;
eGOLF_COURSE_HOLES iCurrentGolfCourse = ms_MiniMapRenderState.m_CurrentGolfMap;
if (ms_iPreviousGolfCourse != iCurrentGolfCourse)
{
UpdateSea(iCurrentGolfCourse == GOLF_COURSE_OFF && !ms_MiniMapRenderState.m_bIsInPauseMap && !ms_MiniMapRenderState.m_bIsInCustomMap);
if (iCurrentGolfCourse != GOLF_COURSE_OFF)
{
if (ms_iPreviousGolfCourse != GOLF_COURSE_OFF)
{
ms_iPreviousGolfCourse = iCurrentGolfCourse;
RemoveGolfCourse(false);
}
ms_iPreviousGolfCourse = iCurrentGolfCourse;
ms_bStreamGolfCourseMovie = true;
}
else
{
ms_iPreviousGolfCourse = iCurrentGolfCourse;
RemoveGolfCourse(false);
}
}
if (ms_bStreamGolfCourseMovie || ms_bRemoveGolfCourseMovie)
return;
if (ms_iGolfCourseMovieId != -1)
{
if (CScaleformMgr::IsMovieActive(ms_iGolfCourseMovieId))
{
if ((!ms_asGolfCourseMovie.IsDisplayObject()) || (ms_asGolfCourseMovie.IsDisplayObject() && (ms_asGolfCourseHole.IsUndefined())))
{
if (ms_asGolfCourseMc.IsUndefined())
{
// invoke the load here
GFxValue result, asGolfCourseLayer, params[1];
params[0].SetString("golf_courses");
if (uiVerifyf(ms_asBaseOverlay3D[MINIMAP_LAYER_BACKGROUND].GetMember("asGolfCourseLayer", &asGolfCourseLayer), "cannot find 'asGolfCourseLayer' member"))
{
asGolfCourseLayer.CreateEmptyMovieClip(&ms_asGolfCourseMc, "GOLF_LINK", MOVIE_DEPTH_INTERIOR);
ms_asGolfCourseMc.Invoke("loadMovie", &result, params, 1);
ms_asGolfCourseHole.SetUndefined();
}
}
if (ms_asGolfCourseMc.IsDisplayObject())
{
if (ms_asGolfCourseMovie.IsDisplayObject())
{
eGOLF_COURSE_HOLES iCurrentGolfCourse = ms_MiniMapRenderState.m_CurrentGolfMap;
char cHashName[20];
if (iCurrentGolfCourse == GOLF_COURSE_HOLE_ALL)
{
formatf(cHashName, "hole_all");
}
else
{
formatf(cHashName, "hole_%u", iCurrentGolfCourse);
}
if (ms_asGolfCourseMovie.HasMember("golf_course"))
{
ms_asGolfCourseMovie.GetMember("golf_course", &ms_asGolfCourseHole);
ms_asGolfCourseHole.GotoAndStop(cHashName);
Vector2 vPos(-1170.0f, 50.0f);
// set the position:
GFxValue::DisplayInfo currentDisplayInfo;
currentDisplayInfo.SetPosition((vPos.x), -(vPos.y));
ms_asGolfCourseMovie.SetDisplayInfo(currentDisplayInfo);
if(!ms_MiniMapRenderState.m_bIsInPauseMap && !ms_MiniMapRenderState.m_bIsInCustomMap)
SetupGolfCourseLayout();
uiDebugf1("CMiniMap_RenderThread: golf course %s added to stage", cHashName);
}
else
{
uiDebugf1("CMiniMap_RenderThread: golf course data for %s is invalid - unable to set up golf course on stage", cHashName);
RemoveGolfCourse(false); // remove anything that was setup
ms_iPreviousGolfCourse = GOLF_COURSE_OFF;
}
}
else
{
uiDebugf1("CMiniMap_RenderThread: golf course movie is invalid!");
}
}
}
}
}
}
void CMiniMap_RenderThread::HandleGolfCourseAtEndOfFrame()
{
if (CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on UT
{
sfAssertf(0, "CMiniMap_RenderThread::HandleGolfCourseAtEndOfFrame can only be called on the UpdateThread!");
return;
}
//
// removal/stream of golf course movie
//
if (ms_bRemoveGolfCourseMovie || ms_bStreamGolfCourseMovie)
{
if (ms_iGolfCourseMovieId != -1)
{
if (CScaleformMgr::IsMovieActive(ms_iGolfCourseMovieId))
{
CScaleformMgr::RequestRemoveMovie(ms_iGolfCourseMovieId);
}
ms_iGolfCourseMovieId = -1;
}
ms_bRemoveGolfCourseMovie = false;
}
if (ms_bStreamGolfCourseMovie)
{
ms_iGolfCourseMovieId = CScaleformMgr::CreateMovie(ms_MiniMapRenderState.m_CurrentMiniMapFilename, Vector2(0.0f, 0.0f), Vector2(1.0f, 1.0f), true, -1, -1, false);
ms_bStreamGolfCourseMovie = false;
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::RenderNavPath
// PURPOSE: renders the nav path onto the minimap. This only needs to be called once
// as it adds the route on but doesnt need to be set every frame
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::RenderNavPath(s32 iRouteNum, s32 iNumPoints, Vector3 *vPoints, rage::Color32 colour, float fOffsetX, float fOffsetY, bool bClipFirstLine, float fClipX, float fClipY, float fRoadWidthMiniMap, float fRoadWidthPauseMap)
{
// DMP
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::RenderNavPath can only be called on the RenderThread!");
return;
}
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return;
static float PAUSE_MAP_INITIAL_SCALER = 0.01f;
// only render the route once its invisible:
GFxValue::DisplayInfo info;
ms_asGpsLayer[iRouteNum].GetDisplayInfo(&info);
if (info.GetVisible())
{
ms_asGpsLayer[iRouteNum].Invoke("clear");
info.SetVisible(false);
ms_asGpsLayer[iRouteNum].SetDisplayInfo(info);
}
uiDebugf1("CMiniMap_RenderThread: Redrawing GPS route %d", iRouteNum);
GFxValue args[3];
if (!ms_MiniMapRenderState.m_bIsInPauseMap && !ms_MiniMapRenderState.m_bIsInCustomMap) // different road widths (due to scale) when in minimap or pausemap
{
args[0].SetNumber(fRoadWidthMiniMap);
}
else
{
args[0].SetNumber((fRoadWidthPauseMap * PAUSE_MAP_INITIAL_SCALER) * (CMiniMap_Common::GetScaleFromZoomLevel(ZOOM_LEVEL_4)-rage::Min(30.0f,ms_MiniMapRenderState.m_fPauseMapScale)));
}
args[1].SetNumber(colour.GetColor());
args[2].SetNumber(colour.GetAlphaf()*100.0f);
//uiDebugf1("lineStyle %0.2f, %0.2f, %0.2f", args[0].GetNumber(), args[1].GetNumber(), args[2].GetNumber());
ms_asGpsLayer[iRouteNum].Invoke("lineStyle", NULL, args, 3);
int iLastValidNode = 0;
if (iNumPoints > 0)
{
for (s32 i = 1; i < iNumPoints; i++)
{
if ((*(int*)&vPoints[i].w) == GNI_IGNORE_FOR_NAV)
continue;
Vector2 vMain = Vector2(vPoints[i].x+fOffsetX, vPoints[i].y+fOffsetY);
if (iLastValidNode == 0)
{
iLastValidNode = i;
Vector2 vLink(vPoints[0].x+fOffsetX, vPoints[0].y+fOffsetY);
if (bClipFirstLine)
{
Vector2 diff = vLink - vMain;
float length = diff.Mag();
Vector2 diffClip = Vector2(fClipX, fClipY) - vMain;
float lengthAlongLine = (diffClip.x * diff.x + diffClip.y * diff.y) / length;
lengthAlongLine = rage::Max(0.0f, lengthAlongLine);
if (lengthAlongLine < length)
{
// reduced line segment.
vLink = vMain + diff * (lengthAlongLine / length);
}
}
if ((*(int*)&vPoints[0].w) == GNI_PLAYER_TRAIL_POS) // Adding extra point
{
args[0].SetNumber(fClipX+fOffsetX);
args[1].SetNumber(-(fClipY+fOffsetY));
ms_asGpsLayer[iRouteNum].Invoke("moveTo", NULL, args, 2);
args[0].SetNumber(vLink.x);
args[1].SetNumber(-vLink.y);
//uiDebugf1("0 moveTo %0.2f, %0.2f", vLink.x, -vLink.y);
ms_asGpsLayer[iRouteNum].Invoke("lineTo", NULL, args, 2);
}
else
{
args[0].SetNumber(vLink.x);
args[1].SetNumber(-vLink.y);
//uiDebugf1("0 moveTo %0.2f, %0.2f", vLink.x, -vLink.y);
ms_asGpsLayer[iRouteNum].Invoke("moveTo", NULL, args, 2);
}
args[0].SetNumber(vMain.x);
args[1].SetNumber(-vMain.y);
//uiDebugf1("1 lineTo %0.2f, %0.2f", vMain.x, -vMain.y);
ms_asGpsLayer[iRouteNum].Invoke("lineTo", NULL, args, 2);
}
else
{
args[0].SetNumber(vMain.x);
args[1].SetNumber(-vMain.y);
ms_asGpsLayer[iRouteNum].Invoke("lineTo", NULL, args, 2);
if ((*(int*)&vPoints[i].w) == GNI_PLAYER_TRAIL_POS) // Adding extra point
{
args[0].SetNumber(vPoints[i+1].x+fOffsetX);
args[1].SetNumber(-(vPoints[i+1].y+fOffsetY));
ms_asGpsLayer[iRouteNum].Invoke("lineTo", NULL, args, 2);
}
//uiDebugf1("%d lineTo %0.2f, %0.2f", i, vMain.x, -vMain.y);
}
}
}
// make the layer visible again now the route has been drawn
info.SetVisible(true);
ms_asGpsLayer[iRouteNum].SetDisplayInfo(info);
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::ClearNavPath
// PURPOSE: clears any nav path from the minimap
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::ClearNavPath(s32 iRouteNum)
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::ClearNavPath can only be called on the RenderThread!");
return;
}
if (ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] == -1)
return;
// only invoke "clear" when the route is visible:
GFxValue::DisplayInfo info;
ms_asGpsLayer[iRouteNum].GetDisplayInfo(&info);
if (info.GetVisible())
{
// set to invisible and clear and dont set visible again (render will do this if a new route is set)
info.SetVisible(false);
ms_asGpsLayer[iRouteNum].SetDisplayInfo(info);
uiDebugf1("CMiniMap_RenderThread: Clearing GPS route %d", iRouteNum);
ms_asGpsLayer[iRouteNum].Invoke("clear");
}
}
Mat34V ToMat34V(GMatrix3D mtx)
{
return Mat34V(V_COL_MAJOR,
mtx[0], mtx[1], mtx[2],
mtx[4], mtx[5], mtx[6],
mtx[8], mtx[9], mtx[10],
mtx[12], mtx[13], mtx[14]
);
}
Mat44V ToMat44V(GMatrix3D mtx)
{
return Mat44V(V_COL_MAJOR,
mtx[0], mtx[1], mtx[2], mtx[3],
mtx[4], mtx[5], mtx[6], mtx[7],
mtx[8], mtx[9], mtx[10], mtx[11],
mtx[12], mtx[13], mtx[14], mtx[15]
);
}
void MakeOrthoMtx(Mat44V_InOut outMtx, float left, float right, float bottom, float top, float znear, float zfar)
{
// Stole
float oorl = 1.0f / (right - left);
float ootb = 1.0f / (top - bottom);
float oolr = 1.0f / (left - right);
float oobt = 1.0f / (bottom - top);
float cz, dz;
// D3DXMatrixOrthoOffCenterRH
cz = 1 / (znear-zfar);
dz = znear / (znear - zfar);
//
// taken from the D3D documentation
//
// 2/(r-l) 0 0 0
// 0 2/(t-b) 0 0
// 0 0 1/(zn-zf) 0
// (l+r)/(l-r) (t+b)/(b-t) zn/(zn-zf) l
//
// shearing sets it off in the x direction and / or in the y direction
// scaling makes it bigger in the x or y direction
//
Vector2 scale = grcViewport::GetCurrent()->GetWidthHeightScale();
Vector2 shear = grcViewport::GetCurrent()->GetPerspectiveShear();
Mat44V projection;
projection.SetCol0f(2 * oorl * scale.x, 0.0f, 0.0f, 0.0f);
projection.SetCol1f(0.0f, 2 * ootb * scale.y, 0.0f, 0.0f);
projection.SetCol2f(shear.x, shear.y, cz, 0.0f);
projection.SetCol3f((left + right) * oolr,(top + bottom) * oobt, dz, 1.0f);
outMtx = projection;
}
void CMiniMap_RenderThread::SetupStateForSupertileRender(Vector2 vBackgroundPos, Vector2 vBackgroundSize)
{
const float Drawable_zFar = 13.0f;
const float Drawable_zNear = -13.0f;
const bool Scissor = true;
GFxMovieView* pView = CScaleformMgr::GetMovieView(ms_iMovieId[MINIMAP_MOVIE_BACKGROUND]);
if (pView)
{
int clipX = 0;
int clipY = 0;
int clipW = VideoResManager::GetUIWidth();
int clipH = VideoResManager::GetUIHeight();
int totalWidth = clipW;
int totalHeight = clipH;
float mapWidth = (float)totalWidth;
float mapHeight = (float)totalHeight;
int offsetX = 0;
int offsetY = 0;
bool doMiniMapAlpha = ( (!ms_MiniMapRenderState.m_bIsInPauseMap) && (!ms_MiniMapRenderState.m_bIsInCustomMap) && (ms_MiniMapAlpha < 1.0f) && (ms_MiniMapRenderState.m_CurrentGolfMap == GOLF_COURSE_OFF) );
if (doMiniMapAlpha)
{
Vector2 maskPos,maskSize;
if( ms_bUseTexturedAlphaAllMovies || ms_bUseTextureAlphaBaseMovie )
{
maskPos = ms_MiniMapRenderState.m_vCurrentMiniMapBlurPosition;
maskSize = ms_MiniMapRenderState.m_vCurrentMiniMapBlurSize;
}
else
{
maskPos = ms_MiniMapRenderState.m_vCurrentMiniMapMaskPosition;
maskSize = ms_MiniMapRenderState.m_vCurrentMiniMapMaskSize;
}
clipX = Clamp(rage::round((maskPos.x)*mapWidth) - 1 + offsetX, 0, totalWidth);
clipY = Clamp(rage::round((maskPos.y)*mapHeight) - 1 + offsetY, 0, totalHeight);
clipW = Clamp(rage::round((maskSize.x)*mapWidth) + 1, 0, totalWidth - clipX);
clipH = Clamp(rage::round((maskSize.y)*mapHeight) + 1, 0, totalHeight - clipY);
}
else if (vBackgroundSize.x > 0.0f && vBackgroundSize.y > 0.0f)
{
// the in-game map seems to be already adjusted, fixing the pause map here
#if SUPPORT_MULTI_MONITOR
if(ms_MiniMapRenderState.m_bIsInPauseMap )
{
const GridMonitor &mon = GRCDEVICE.GetMonitorConfig().getLandscapeMonitor();
mapWidth = (float)mon.getWidth();
mapHeight = (float)mon.getHeight();
offsetX = mon.uLeft;
offsetY = mon.uTop;
}
#endif //SUPPORT_MULTI_MONITOR
if (Scissor)
{
clipX = Clamp(rage::round(mapWidth * vBackgroundPos.x) + offsetX, 0, totalWidth);
clipY = Clamp(rage::round(mapHeight * vBackgroundPos.y) + offsetY, 0, totalHeight);
clipW = Clamp(rage::round(mapWidth * vBackgroundSize.x), 0, totalWidth - clipX);
clipH = Clamp(rage::round(mapHeight * vBackgroundSize.y), 0, totalHeight - clipY);
}
}
grcBindTexture(NULL);
grcWorldIdentity();
GRCDEVICE.SetDefaultEffect(false,false);
GRCDEVICE.SetScissor(clipX, clipY, clipW, clipH);
if (g_RenderMinimapSea)
{
// bug in repeated ClearRenderTargetView calls so use ClearRect
GRCDEVICE.ClearRect(clipX, clipY, clipW, clipH, true, g_MinimapSeaColor, false, 0.0f, false, 0, true); // fix for 1763187
}
Mat34V camera(V_IDENTITY);
grcViewport::GetCurrent()->SetCameraMtx(camera);
// Set the projection matrix to the scaleform world-to-screen projection matrix, concatenated with
// the rage ortho screen matrix.
GMatrix3D worldToScreen = ms_LocalToScreen.GetRenderBuf();
{
GMatrix3D flipY;
flipY.Scaling(1.0f, -1.0f, 1.0f);
worldToScreen.Prepend(flipY);
}
Mat44V worldToScreenRage = ToMat44V(worldToScreen);
Mat44V orthoScreen;
MakeOrthoMtx(orthoScreen, 0.0, (float)totalWidth, (float)totalHeight, 0.0, Drawable_zNear, Drawable_zFar);
#if SUPPORT_MULTI_MONITOR && 0
// this is already taken care of
if (GRCDEVICE.GetMonitorConfig().isMultihead())
{
const GridMonitor &mon = GRCDEVICE.GetMonitorConfig().getLandscapeMonitor();
// computing the center difference of the preferred monitor versus the whole screen
const float ox = (mon.uLeft + mon.uRight)/mapWidth - 1.f;
const float oy = 1.f - (mon.uTop + mon.uBottom)/mapHeight;
Mat44V monMx(
mon.getWidth() / mapWidth, 0.0, 0.0, 0.0,
0.0, mon.getHeight() / mapHeight, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
ox, oy, 0.0, 1.0
);
Mat44V old = orthoScreen;
Multiply(orthoScreen, monMx, old);
}
#endif //SUPPORT_MULTI_MONITOR
// Now one additional transform to move from screen space to render target space
Mat44V proj;
Multiply(proj, orthoScreen, worldToScreenRage);
grcViewport::GetCurrent()->SetNearFarClip(Drawable_zNear, Drawable_zFar);
grcViewport::GetCurrent()->SetProjection(proj);
CShaderLib::SetGlobalToneMapScalers(Vector4(1.0, 1.0, 1.0, 1.0));
CShaderLib::SetGlobalAlpha(1.0f);
grcLightState::SetEnabled(false);
grcStateBlock::SetDepthStencilState(grcStateBlock::DSS_IgnoreDepth);
grcStateBlock::SetBlendState(grcStateBlock::BS_Normal);
grcStateBlock::SetRasterizerState(grcStateBlock::RS_NoBackfaceCull);
}
}
namespace rage
{
extern grcEffect *g_DefaultEffect;
extern grcEffectVar g_DefaultSampler;
}
void CMiniMap_RenderThread::RenderBitmaps()
{
#if 0 // Causes asserts since this is on the render thread
TUNE_GROUP_FLOAT(MINIMAP, AdjustBitmapX, 0.0f, -100.0f, 100.0f, 0.01f);
TUNE_GROUP_FLOAT(MINIMAP, AdjustBitmapY, 0.0f, -100.0f, 100.0f, 0.01f);
TUNE_GROUP_FLOAT(MINIMAP, AdjustBitmapWidth, 1.0f, 0.0f, 2.0f, 0.0001f);
TUNE_GROUP_FLOAT(MINIMAP, AdjustBitmapHeight, 1.0f, 0.0f, 2.0f, 0.0001f);
TUNE_GROUP_BOOL(MINIMAP, PointSampler, false);
#else
#if __DEV
const bool PointSampler = false;
#endif
// I found these values experimentally, but what are they? Maybe related to texel size (and zooming up by 1/1024)?
const float AdjustBitmapX = 0.0f;
const float AdjustBitmapY = 0.0f;
const float AdjustBitmapWidth = 1.0f;
const float AdjustBitmapHeight = 1.0f;
#endif
grcSamplerStateHandle oldSampler = g_DefaultEffect->GetSamplerState(g_DefaultSampler);
#if __DEV
if (PointSampler)
{
g_DefaultEffect->SetSamplerState(g_DefaultSampler, ms_MinimapBitmapSamplerStateNearestHandle);
}
else
#endif
{
g_DefaultEffect->SetSamplerState(g_DefaultSampler, ms_MinimapBitmapSamplerStateHandle);
}
grcStateBlock::SetRasterizerState(ms_MinimapBitmapRasterizerStateHandle);
strLocalIndex iLodTxdId = strLocalIndex(CMiniMap::ms_BitmapSuperLowRes.iDrawIdx.GetReadBuf());
if (iLodTxdId.Get() >= 0)
{
Vector2 bitmapPos = CMiniMap::sm_Tunables.Bitmap.vBitmapStart;
fwTxd* txd = g_TxdStore.Get(iLodTxdId);
if (uiVerifyf(txd, "Couldn't find a txd but we're in an active state. %d", iLodTxdId.Get()))
{
// grab the first texture in the dict (cause we don't know the name)
grcTexture* tex = txd->GetEntry(0);
if (uiVerifyf(tex, "Empty texture dictionary? %d", iLodTxdId.Get()))
{
grcBindTexture(tex);
CSprite2d::Draw(
bitmapPos + Vector2(0.0f, -CMiniMap::sm_Tunables.Bitmap.vBitmapTileSize.y * CMiniMap::sm_Tunables.Bitmap.iBitmapTilesY),
bitmapPos + Vector2(0.0f, 0.0f),
bitmapPos + Vector2(CMiniMap::sm_Tunables.Bitmap.vBitmapTileSize.x * CMiniMap::sm_Tunables.Bitmap.iBitmapTilesX, -CMiniMap::sm_Tunables.Bitmap.vBitmapTileSize.y * CMiniMap::sm_Tunables.Bitmap.iBitmapTilesY),
bitmapPos + Vector2(CMiniMap::sm_Tunables.Bitmap.vBitmapTileSize.x * CMiniMap::sm_Tunables.Bitmap.iBitmapTilesX, 0.0f),
Color_white);
}
}
}
for (s32 a = 0; a < MM_BITMAP_VERSION_NUM_ENUMS; a++)
{
float BitmapTileSizeX, BitmapTileSizeY, BitmapStartX, BitmapStartY;
BitmapTileSizeX = CMiniMap::sm_Tunables.Bitmap.vBitmapTileSize.x * AdjustBitmapWidth;
BitmapTileSizeY = CMiniMap::sm_Tunables.Bitmap.vBitmapTileSize.y * AdjustBitmapHeight;
BitmapStartX = CMiniMap::sm_Tunables.Bitmap.vBitmapStart.x + AdjustBitmapX;
BitmapStartY = CMiniMap::sm_Tunables.Bitmap.vBitmapStart.y + AdjustBitmapY;
Vector2 corners[4];
corners[0].Set(0.0f, -BitmapTileSizeY);
corners[1].Set(0.0f, 0.0f);
corners[2].Set(BitmapTileSizeX, -BitmapTileSizeY);
corners[3].Set(BitmapTileSizeX, 0.0f);
for (s32 i = 0; i < CMiniMap::sm_Tunables.Bitmap.iBitmapTilesX; i++)
{
for (s32 j = 0; j < CMiniMap::sm_Tunables.Bitmap.iBitmapTilesY; j++)
{
strLocalIndex iTxdId = strLocalIndex(CMiniMap::ms_BitmapBackground(a,i,j).iDrawIdx.GetReadBuf());
if (iTxdId.Get() >= 0)
{
Vector2 bitmapPos(BitmapStartX + i * BitmapTileSizeX, BitmapStartY - j * BitmapTileSizeY);
fwTxd* txd = g_TxdStore.Get(iTxdId);
if (uiVerifyf(txd, "Couldn't find a txd but we're in an active state. %d", iTxdId.Get()))
{
// grab the first texture in the dict (cause we don't know the name)
grcTexture* tex = txd->GetEntry(0);
if (uiVerifyf(tex, "Empty texture dictionary? %d", iTxdId.Get()))
{
grcBindTexture(tex);
CSprite2d::Draw(
bitmapPos + corners[0],
bitmapPos + corners[1],
bitmapPos + corners[2],
bitmapPos + corners[3],
Color_white
);
}
}
}
}
}
}
g_DefaultEffect->SetSamplerState(g_DefaultSampler, oldSampler);
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::Render
// PURPOSE: renders the minimap
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::RenderMiniMap(s32 iId, Vector2 vBackgroundPos, Vector2 vBackgroundSize, float fAlpha, float fSizeScalar)
{
if (!ms_MiniMapRenderState.m_bIsActive)
return;
if (ms_iMovieId[iId] == -1)
return;
PF_AUTO_PUSH_TIMEBAR(iId == MINIMAP_MOVIE_BACKGROUND ? "RenderMiniMap - background" : "RenderMiniMap - foreground");
#if RSG_PC
if (GRCDEVICE.IsStereoEnabled() && GRCDEVICE.CanUseStereo())
{
//float fVal = 0.0f;
//if (iId == MINIMAP_MOVIE_BACKGROUND)
// fVal = 1.0f;
GRCDEVICE.SetStereoScissor(false);
CShaderLib::SetStereoParams(Vector4(1.0f,0.0f,0.0f,0.0f));
}
#endif
if (BANK_ONLY(CMiniMap::ms_bRenderMiniMapBackground &&) iId == MINIMAP_MOVIE_BACKGROUND)
{
if ( (g_RenderMinimap) &&
( (ms_MiniMapRenderState.m_CurrentGolfMap == GOLF_COURSE_OFF) ||
(ms_MiniMapRenderState.m_bIsInPauseMap || ms_MiniMapRenderState.m_bIsInCustomMap) ) )
{
grcViewport oldVP = *grcViewport::GetCurrent();
SetupStateForSupertileRender(vBackgroundPos, vBackgroundSize);
RenderBitmaps();
ms_Supertiles.Render();
#if ENABLE_FOG_OF_WAR
if( ms_MiniMapRenderState.m_bShowFow && !CTheScripts::GetIsInDirectorMode())
{
CSprite2d fowRender;
grcRenderTarget *fow = CMiniMap_Common::GetFogOfWarCopyRT();
grcStateBlock::SetBlendState(ms_MinimapFoWBlendStateHandle);
fowRender.SetGeneralParams(Vector4(1.0f, 0.0f, 0.0f, 0.0f), Vector4(CMiniMap::sm_Tunables.FogOfWar.fBaseAlpha, CMiniMap::sm_Tunables.FogOfWar.fTopAlpha, 0.0, 0.0));
fowRender.SetTexelSize(Vector2(1.0f/((float)fow->GetWidth()),1.0f/((float)fow->GetHeight())));
fowRender.BeginCustomList(CSprite2d::CS_BLIT_TO_ALPHA_BLUR, fow);
ms_Supertiles.RenderFoW();
fowRender.EndCustomList();
grcStateBlock::SetBlendState(grcStateBlock::BS_Default);
}
#endif // ENABLE_FOG_OF_WAR
*grcViewport::GetCurrent() = oldVP;
}
}
#if __BANK
if ((CMiniMap::ms_bRenderMiniMapBackground && iId == MINIMAP_MOVIE_BACKGROUND) || (CMiniMap::ms_bRenderMiniMapForeground && iId == MINIMAP_MOVIE_FOREGROUND))
#endif
{
if( iId == MINIMAP_MOVIE_BACKGROUND ) // Disable AA only for the map itself
{
CScaleformMgr::GetMovieMgr()->SetEdgeAAEnable(false);
}
const float fTimeStep = CLiveManager::IsSystemUiShowing() ? -1.0f : fwTimer::GetTimeStep_NonPausedNonScaledClipped();
if (ms_MiniMapRenderState.m_bIsInPauseMap/* || ms_MiniMapRenderState.m_bIsInCustomMap*/) // fix for 1503078
{
CScaleformMgr::AffectRenderSizeOnly(ms_iMovieId[iId], fSizeScalar);
}
CScaleformMgr::RenderMovie(ms_iMovieId[iId], fTimeStep, true, false, fAlpha);
if( iId == MINIMAP_MOVIE_BACKGROUND )
{
CScaleformMgr::GetMovieMgr()->SetEdgeAAEnable(true);
}
#if ENABLE_FOG_OF_WAR
// NOTES: only enable this when rendering the island minimap
if( iId == MINIMAP_MOVIE_BACKGROUND && ms_MiniMapRenderState.m_bShowFow && !CTheScripts::GetIsInDirectorMode())
{
grcViewport oldVP = *grcViewport::GetCurrent();
SetupStateForSupertileRender(vBackgroundPos, vBackgroundSize);
{
CSprite2d fowRender;
grcRenderTarget *fow = CMiniMap_Common::GetFogOfWarCopyRT();
grcStateBlock::SetBlendState(ms_MinimapFoWBlendStateHandle);
fowRender.SetGeneralParams(Vector4(1.0f, 0.0f, 0.0f, 0.0f), Vector4(CMiniMap::sm_Tunables.FogOfWar.fBaseAlpha, CMiniMap::sm_Tunables.FogOfWar.fTopAlpha, 0.0, 0.0));
fowRender.SetTexelSize(Vector2(1.0f/((float)fow->GetWidth()),1.0f/((float)fow->GetHeight())));
fowRender.BeginCustomList(CSprite2d::CS_BLIT_TO_ALPHA_BLUR, fow);
CSupertile::RenderIslandFoW(); // 1 tile over whole Island map
fowRender.EndCustomList();
grcStateBlock::SetBlendState(grcStateBlock::BS_Default);
}
*grcViewport::GetCurrent() = oldVP;
}
#endif // ENABLE_FOG_OF_WAR
}
#if RSG_PC
if (GRCDEVICE.IsStereoEnabled() && GRCDEVICE.CanUseStereo())
{
//float fVal = 0.0f;
//if (iId == MINIMAP_MOVIE_BACKGROUND)
// fVal = 1.0f;
GRCDEVICE.SetStereoScissor(true);
CShaderLib::SetStereoParams(Vector4(0.0f,0.0f,0.0f,0.0f));
}
#endif
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::CanDisplayGpsLine
// PURPOSE: returns whether the gps line can be displayed based on current minimap
// settings (zoom etc)
/////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::CanDisplayGpsLine(bool bHideWhenZoomed)
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::CanDisplayGpsLine can only be called on the RenderThread!");
return true;
}
if (ms_MiniMapRenderState.m_iScriptZoomValue != 0 || ms_MiniMapRenderState.m_bLockedToDistanceZoom) // always display GPS line regardless of zoom level if script are setting it as its assumed they are in control of the value they are passing
return true;
if ( (ms_MiniMapRenderState.m_fAngle == 0.0f) && (!ms_MiniMapRenderState.m_bIsInBigMap) && (!ms_MiniMapRenderState.m_bIsInPauseMap) && (!ms_MiniMapRenderState.m_bIsInCustomMap) ) // no gps when at no angle and not in pausemap
return false;
if (ms_asMapContainerMc.IsDisplayObject())
{
if(bHideWhenZoomed)
{
GFxValue::DisplayInfo CurrInfo;
ms_asMapContainerMc.GetDisplayInfo(&CurrInfo);
if ((float)CurrInfo.GetXScale() <= MINIMAP_GPS_DISPLAY_LIMIT)
{
return true;
}
}
else
{
return true;
}
}
return false;
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::SetupHealthArmourOnStage
// PURPOSE: sets up the health and armour containers if required
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::SetupHealthArmourOnStage(bool bBigMapProperties)
{
GFxValue asHealthContainer;
if (uiVerifyf(ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED].GetMember("asHealthContainer", &asHealthContainer), "CMiniMap_RenderThread: 'asHealthContainer' cannot be found when switching to minimap"))
{
if (uiVerifyf(asHealthContainer.IsDisplayObject(), "CMiniMap_RenderThread: 'asHealthContainer' is not a display object when switching to minimap"))
{
GFxValue::DisplayInfo healthContainerDisplayInfo;
healthContainerDisplayInfo.SetVisible(true);
asHealthContainer.SetDisplayInfo(healthContainerDisplayInfo);
if (CScaleformMgr::BeginMethod(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND], SF_BASE_CLASS_MINIMAP, "REGISTER_HEALTH_ARMOUR"))
{
CScaleformMgr::AddParamGfxValue(asHealthContainer);
CScaleformMgr::EndMethod(true);
}
if (CScaleformMgr::BeginMethod(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND], SF_BASE_CLASS_MINIMAP, "SETUP_HEALTH_ARMOUR"))
{
if (bBigMapProperties)
{
CScaleformMgr::AddParamInt(2);
}
else
{
CScaleformMgr::AddParamInt(1);
}
CScaleformMgr::EndMethod(true);
}
CNewHud::ForceUpdateHealthInfoWithExistingValuesOnRT(); // fixes 1829470 (need to update health/armour bars straight away, instead of next frame)
#if !__FINAL
if(CMiniMap_Common::OutputDebugTransitions())
{
if (bBigMapProperties)
uiDisplayf("MINIMAP_TRANSITION: CMiniMap_RenderThread::SetupHealthArmourOnStage. Setup actionscript for BIGMAP properties(RT)");
else
uiDisplayf("MINIMAP_TRANSITION: CMiniMap_RenderThread::SetupHealthArmourOnStage. Setup actionscript for MINIMAP properties(RT)");
}
#endif
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::SetupForGalleryMap
// PURPOSE: sets the map to be in "gallery" mode
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::SetupForGalleryMap()
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::SetupForGalleryMap can only be called on the RenderThread!");
return;
}
#if __DEV
iTimeTaken = fwTimer::GetSystemTimeInMilliseconds();
#endif // __DEV
// Graeme - we can't call SetCurrentGolfMap() on the RenderThread so instead MiniMapUpdateState.m_CurrentGolfMap is set to GOLF_COURSE_OFF in CMiniMap::UpdateStatesOnUT() if IsInBigMap()
// turn off the golf course if it has been set:
// if (ms_MiniMapRenderState.m_CurrentGolfMap != GOLF_COURSE_OFF) // ensure golf course is turned off if bigmap becomes active
// {
// SetCurrentGolfMap(GOLF_COURSE_OFF);
// }
SetupHealthArmourOnStage(true);
// default the intial zoom value to starting pausemap scale
GFxValue::DisplayInfo info;
info.SetScale(ms_MiniMapRenderState.m_fPauseMapScale, ms_MiniMapRenderState.m_fPauseMapScale);
ms_asMapContainerMc.SetDisplayInfo(info);
ms_asBlipContainerMc.SetDisplayInfo(info);
SetMask(true);
for (s32 i = 0; i < MAX_MINIMAP_MOVIE_LAYERS; i++)
{
CScaleformMgr::ChangeMovieParams(ms_iMovieId[i], ms_MiniMapRenderState.m_vCurrentMiniMapPosition, ms_MiniMapRenderState.m_vCurrentMiniMapSize, GFxMovieView::SM_ExactFit);
}
// re-init the nav (so it changes for pausemap vs radar)
CGps::ForceUpdateOfGpsOnMiniMap();
UpdateSea(false);
UpdateWithActionScriptOnRT(true, false);
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::SetupForPauseMenu
// PURPOSE: sets the map to be in "pausemap" mode
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::SetupForPauseMenu(bool bFullScreen)
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::SetupForPauseMenu can only be called on the RenderThread!");
return;
}
AdjustVisualStageSpaceWithinMovie(0.0f);
#if __DEV
iTimeTaken = fwTimer::GetSystemTimeInMilliseconds();
#endif // __DEV
ms_vStageSize = ms_vOriginalStageSize;
float fScaler = 100.0f;
if (bFullScreen)
{
float fMapRatio = ms_vOriginalStageSize.x / ms_vOriginalStageSize.y;
fScaler *= fMapRatio/CHudTools::GetAspectRatio();
ms_vStageSize.x /= (fScaler/100.0f);
GFxValue asCrosshairMc;
if( ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED].GetMember("asCrosshair", &asCrosshairMc) )
{
GFxValue::DisplayInfo dispInfo;
dispInfo.SetPosition(ms_vStageSize.x*0.5f, ms_vStageSize.y*0.5f);
asCrosshairMc.SetDisplayInfo(dispInfo);
}
}
for (s32 i = 0; i < MAX_MINIMAP_ROOT_LAYERS; i++)
{
GFxValue::DisplayInfo dispInfo;
dispInfo.SetScale(fScaler, 100.0f);
ms_asRootContainer[i].SetDisplayInfo(dispInfo);
}
GFxValue::DisplayInfo info;
info.SetPosition((ms_vStageSize.x * 0.5f), (ms_vStageSize.y * 0.5f));
ms_asBaseLayerContainer[MINIMAP_LAYER_BACKGROUND].SetDisplayInfo(info);
ms_asBaseLayerContainer[MINIMAP_LAYER_FOREGROUND].SetDisplayInfo(info);
CScaleformMgr::ResetMeshCache();
// default the intial zoom value to starting pausemap scale
GFxValue::DisplayInfo info2;
info2.SetScale(ms_MiniMapRenderState.m_fPauseMapScale, ms_MiniMapRenderState.m_fPauseMapScale);
ms_asMapContainerMc.SetDisplayInfo(info2);
ms_asBlipContainerMc.SetDisplayInfo(info2);
GFxValue asHealthContainer;
if (uiVerifyf(ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED].GetMember("asHealthContainer", &asHealthContainer), "CMiniMap_RenderThread: 'asHealthContainer' cannot be found when switching to pausemap"))
{
if (uiVerifyf(asHealthContainer.IsDisplayObject(), "CMiniMap_RenderThread: 'asHealthContainer' is not a display object when switching to pausemenu"))
{
GFxValue::DisplayInfo healthContainerDisplayInfo;
healthContainerDisplayInfo.SetVisible(false);
asHealthContainer.SetDisplayInfo(healthContainerDisplayInfo);
}
}
GFxValue mainMap;
ms_asMapObject.GFxValue::GetMember("main_map", &mainMap);
GFxValue::DisplayInfo mapDisplayInfo;
mapDisplayInfo.SetVisible(true);
mainMap.SetDisplayInfo(mapDisplayInfo);
g_RenderMinimap = true;
GFxValue asSonarBlipLayer;
if (ms_asBaseOverlay3D[MINIMAP_LAYER_FOREGROUND].GetMember("asSonarBlipLayer", &asSonarBlipLayer))
{
GFxValue::DisplayInfo SonarLayerDisplayInfo;
SonarLayerDisplayInfo.SetVisible(false);
asSonarBlipLayer.SetDisplayInfo(SonarLayerDisplayInfo);
}
SetMask(true);
for (s32 i = 0; i < MAX_MINIMAP_MOVIE_LAYERS; i++)
{
CScaleformMgr::ChangeMovieParams(ms_iMovieId[i], ms_MiniMapRenderState.m_vCurrentMiniMapPosition, ms_MiniMapRenderState.m_vCurrentMiniMapSize, GFxMovieView::SM_ExactFit); // make it fill the screen in 4:3
}
// re-init the nav (so it changes for pausemap vs radar)
CGps::ForceUpdateOfGpsOnMiniMap();
UpdateSea(false);
UpdateWithActionScriptOnRT(true, false);
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::AdjustVisualStageSpaceWithinMovie
// PURPOSE: adjusts the contents of the movie by X amount of pixels in order for
// it to appear in the correct place onscreen even though it has a huge
// mask
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::AdjustVisualStageSpaceWithinMovie(float fAmount)
{
// move the map across
GFxValue::DisplayInfo rootContainerDisplayInfo6;
rootContainerDisplayInfo6.SetX(-fAmount);
ms_asRootContainer[MINIMAP_ROOT_LAYER_MASKED].SetDisplayInfo(rootContainerDisplayInfo6);
GFxValue::DisplayInfo rootContainerDisplayInfo5;
rootContainerDisplayInfo5.SetX(-fAmount);
ms_asRootContainer[MINIMAP_ROOT_MAP_TRANSPARENT].SetDisplayInfo(rootContainerDisplayInfo5);
// move the health container (frame) across
GFxValue asHealthContainer;
if (uiVerifyf(ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED].GetMember("asHealthContainer", &asHealthContainer), "CMiniMap_RenderThread: 'asHealthContainer' cannot be found when adjustingVisualSpace"))
{
if (uiVerifyf(asHealthContainer.IsDisplayObject(), "CMiniMap_RenderThread: 'asHealthContainer' is not a display object when adjustingVisualSpace"))
{
GFxValue::DisplayInfo healthContainerDisplayInfo;
healthContainerDisplayInfo.SetX(-fAmount);
asHealthContainer.SetDisplayInfo(healthContainerDisplayInfo);
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::SetupForMiniMap
// PURPOSE: sets the map to be in "minimap" mode
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::SetupForMiniMap()
{
SetupMiniMapProperties(false); // no bigmap
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::SetupForBigMap
// PURPOSE: sets the map to be in "bigmap" mode
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::SetupForBigMap()
{
SetupMiniMapProperties(true); // minimap with bigmap style
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::SetupMiniMapProperties
// PURPOSE: sets the map properties
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::SetupMiniMapProperties(bool bBigMapProperties)
{
if (!CSystem::IsThisThreadId(SYS_THREAD_RENDER)) // only on RT
{
sfAssertf(0, "CMiniMap_RenderThread::SetupForMiniMap can only be called on the RenderThread!");
return;
}
if (bBigMapProperties)
{
#if !__FINAL
if(CMiniMap_Common::OutputDebugTransitions())
uiDisplayf("MINIMAP_TRANSITION: CMiniMap_RenderThread::SetupMiniMapProperties. bBigMapProperties = TRUE (RT)");
#endif
AdjustVisualStageSpaceWithinMovie(__BIGMAP_INTERNAL_ADJUSTMENT_CONTAINERS); // we need to move the bigmap 34 pixels to avoid putting the movie offscreen whilst making it appear to be the same position of the minimap onscreen
}
else
{
#if !__FINAL
if(CMiniMap_Common::OutputDebugTransitions())
uiDisplayf("MINIMAP_TRANSITION: CMiniMap_RenderThread::SetupMiniMapProperties. bBigMapProperties = FALSE (RT)");
#endif
AdjustVisualStageSpaceWithinMovie(0.0f);
}
#if __DEV
iTimeTaken = fwTimer::GetSystemTimeInMilliseconds();
#endif // __DEV
ms_vStageSize = ms_vOriginalStageSize;
for (s32 i = 0; i < MAX_MINIMAP_ROOT_LAYERS; i++)
{
GFxValue::DisplayInfo dispInfo;
dispInfo.SetScale(100.0f, 100.0f);
ms_asRootContainer[i].SetDisplayInfo(dispInfo);
}
GFxValue::DisplayInfo info;
info.SetPosition((ms_vStageSize.x * 0.5f), (ms_vStageSize.y * 0.5f));
ms_asBaseLayerContainer[MINIMAP_LAYER_BACKGROUND].SetDisplayInfo(info);
ms_asBaseLayerContainer[MINIMAP_LAYER_FOREGROUND].SetDisplayInfo(info);
CScaleformMgr::ResetMeshCache();
SetupHealthArmourOnStage(bBigMapProperties);
GFxValue mainMap;
ms_asMapObject.GFxValue::GetMember("main_map", &mainMap);
GFxValue::DisplayInfo mapDisplayInfo;
mapDisplayInfo.SetVisible(true);
mainMap.SetDisplayInfo(mapDisplayInfo);
g_RenderMinimap = true;
GFxValue asSonarBlipLayer;
if (ms_asBaseOverlay3D[MINIMAP_LAYER_FOREGROUND].GetMember("asSonarBlipLayer", &asSonarBlipLayer))
{
GFxValue::DisplayInfo SonarLayerDisplayInfo;
SonarLayerDisplayInfo.SetVisible(true);
asSonarBlipLayer.SetDisplayInfo(SonarLayerDisplayInfo);
}
SetMask(true);
for (s32 i = 0; i < MAX_MINIMAP_MOVIE_LAYERS; i++)
{
CScaleformMgr::ChangeMovieParams(ms_iMovieId[i], ms_MiniMapRenderState.m_vCurrentMiniMapPosition, ms_MiniMapRenderState.m_vCurrentMiniMapSize, GFxMovieView::SM_ExactFit);
}
uiDebugf3("CMiniMap_RenderThread::SetupMiniMapProperties -- Minimap Position = %.2f, %.2f", ms_MiniMapRenderState.m_vCurrentMiniMapPosition.x, ms_MiniMapRenderState.m_vCurrentMiniMapPosition.y);
uiDebugf3("CMiniMap_RenderThread::SetupMiniMapProperties -- Minimap Size = %.2f, %.2f", ms_MiniMapRenderState.m_vCurrentMiniMapSize.x, ms_MiniMapRenderState.m_vCurrentMiniMapSize.y);
// re-init the nav (so it changes for pausemap vs radar)
CGps::ForceUpdateOfGpsOnMiniMap();
//
// set the crosshair as invisible for the minimap:
//
GFxValue asCrosshairMc;
if (ms_asRootContainer[MINIMAP_ROOT_LAYER_UNMASKED].GetMember("asCrosshair", &asCrosshairMc))
{
GFxValue::DisplayInfo newDisplayInfo;
newDisplayInfo.SetVisible(false);
asCrosshairMc.SetDisplayInfo(newDisplayInfo);
}
UpdateSea(true);
if (!bBigMapProperties)
{
if (ms_MiniMapRenderState.m_CurrentGolfMap != GOLF_COURSE_OFF)
{
SetupGolfCourseLayout();
}
}
UpdateWithActionScriptOnRT(true, false);
}
//
// new for 1881980 - render a code "wanted overlay"
//
void CMiniMap_RenderThread::RenderWantedOverlay()
{
static u32 iRangeTimer = fwTimer::GetTimeInMilliseconds();
static bool bOn = false;
if (ms_MiniMapRenderState.m_bFlashWantedOverlay)
{
if (fwTimer::GetTimeInMilliseconds()-iRangeTimer > CMiniMap::sm_Tunables.Display.WantedOverlayTime)
{
bOn = !bOn;
iRangeTimer = fwTimer::GetTimeInMilliseconds();
}
CRGBA overlayCol;
if (bOn)
{
overlayCol = CHudColour::GetRGBA(HUD_COLOUR_RED);
}
else
{
overlayCol = CHudColour::GetRGBA(HUD_COLOUR_BLUE);
}
grcDrawSingleQuadf(-1.0f,1.0f,1.0f,-1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, overlayCol);
}
else
{
iRangeTimer = fwTimer::GetTimeInMilliseconds();
bOn = false;
}
}
#if SUPPORT_MULTI_MONITOR
void CMiniMap_RenderThread::DrawFeatheredRect(Vector2 vBottomLeft, Vector2 vTopRight, Color32 middleColor)
{
#define NORM_TO_SCREEN(val) RemapRange(val, 0.0f, 1.0f, vBottomLeft.x, vTopRight.x)
#define SCREEN_TO_NORM(val) RemapRange(val, vBottomLeft.x, vTopRight.x, 0.0f, 1.0f)
fwRect middleScreen = GRCDEVICE.GetMonitorConfig().getLandscapeMonitor().getArea();
const float fLeftEdge = NORM_TO_SCREEN(middleScreen.GetLeft());
const float fRightEdge= NORM_TO_SCREEN(middleScreen.GetRight());
const float fFeatherPct = CMiniMap_RenderThread::sm_fMultiheadEdgeFeatherPct;
const float fFeatherZ = 0.0f;
// defines the bottom left and top right coordinate for each "tridrant"
Vector4 vPos[3] = { Vector4(fLeftEdge, vBottomLeft.y, fLeftEdge+fFeatherPct, vTopRight.y),
Vector4(fLeftEdge+fFeatherPct, vBottomLeft.y, fRightEdge-fFeatherPct, vTopRight.y),
Vector4(fRightEdge-fFeatherPct, vBottomLeft.y, fRightEdge, vTopRight.y) };
Vector4 uv[3] = { Vector4(SCREEN_TO_NORM(vPos[0].x), 0.0f, SCREEN_TO_NORM(vPos[0].z), 1.0f),
Vector4(SCREEN_TO_NORM(vPos[1].x), 0.0f, SCREEN_TO_NORM(vPos[1].z), 1.0f),
Vector4(SCREEN_TO_NORM(vPos[2].x), 0.0f, SCREEN_TO_NORM(vPos[2].z), 1.0f) };
rage::Color32 edgeColor(middleColor);
edgeColor.SetAlpha(0);
grcBegin(drawTriStrip,8);
grcVertex(vPos[0].x, vPos[0].y, fFeatherZ, 0,0,0, edgeColor, uv[0].x,uv[0].y);
grcVertex(vPos[0].x, vPos[0].w, fFeatherZ, 0,0,0, edgeColor, uv[0].x,uv[0].w);
grcVertex(vPos[0].z, vPos[0].y, fFeatherZ, 0,0,0, middleColor, uv[0].z,uv[0].y);
grcVertex(vPos[0].z, vPos[0].w, fFeatherZ, 0,0,0, middleColor, uv[0].z,uv[0].w);
grcVertex(vPos[1].z, vPos[1].y, fFeatherZ, 0,0,0, middleColor, uv[1].z,uv[1].y);
grcVertex(vPos[1].z, vPos[1].w, fFeatherZ, 0,0,0, middleColor, uv[1].z,uv[1].w);
grcVertex(vPos[2].z, vPos[2].y, fFeatherZ, 0,0,0, edgeColor, uv[2].z,uv[2].y);
grcVertex(vPos[2].z, vPos[2].w, fFeatherZ, 0,0,0, edgeColor, uv[2].z,uv[2].w);
grcEnd();
}
#endif // SUPPORT_MULTI_MONITOR
void CMiniMap_RenderThread::RenderPauseMap(Vector2 vBackgroundPos, Vector2 vBackgroundSize, float fAlphaFader, float fBlipFader, float fSizeScalar)
{
#if RSG_PC
if (ms_iMultiGPUCount > 0)
{
UploadFoWTextureData(true);
ms_iMultiGPUCount--;
}
#endif
Vector2 origPos(vBackgroundPos);
Vector2 origSize(vBackgroundSize);
CScaleformMgr::ScalePosAndSize(vBackgroundPos, vBackgroundSize, fSizeScalar);
grcStateBlock::SetRasterizerState(grcStateBlock::RS_Default);
grcRenderTarget *fbRT = CRenderTargets::GetOffscreenBuffer2();
grcRenderTarget *depthRT = CRenderTargets::GetUIDepthBuffer();
CRenderTargets::UnlockUIRenderTargets();
MULTI_MONITOR_ONLY( bool bDrawBlended = ms_MiniMapRenderState.bDrawCrosshair && GRCDEVICE.GetMonitorConfig().isMultihead() );
#if ENABLE_FOG_OF_WAR
// Prepare FoW map
{
grcTextureFactory::GetInstance().LockRenderTarget(0, CMiniMap_Common::GetFogOfWarCopyRT(), NULL);
grcStateBlock::SetBlendState(grcStateBlock::BS_Default);
CSprite2d fowCopy;
grcStateBlock::SetBlendState(grcStateBlock::BS_Default);
fowCopy.SetGeneralParams(Vector4(1.0f, 1.0f, 1.0f, 1.0f), Vector4(0.0f, 0.0, 0.0, 0.0));
fowCopy.BeginCustomList(CSprite2d::CS_BLIT, CMiniMap_Common::GetFogOfWarRT());
grcDrawSingleQuadf(-1.0f,1.0f,1.0f,-1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, Color32(0xffffffff));
fowCopy.EndCustomList();
// Render Blips
grcStateBlock::SetBlendState(grcStateBlock::BS_Add);
#if __PS3
// We need to use signed blend func here, so we force it.
cellGcmSetBlendFunc(GCM_CONTEXT, CELL_GCM_ONE, CELL_GCM_ONE, CELL_GCM_ONE, CELL_GCM_ONE);
cellGcmSetBlendEquation(GCM_CONTEXT, CELL_GCM_FUNC_ADD_SIGNED, CELL_GCM_FUNC_ADD_SIGNED);
cellGcmSetBlendEnable(GCM_CONTEXT, CELL_GCM_TRUE);
#endif // __PS3
// May want to filter to only blips that are on the island, but that should hit the side alone, so we don't really care
CMiniMap_Common::RenderBlipToFow();
grcTextureFactory::GetInstance().UnlockRenderTarget(0);
#if __PS3
// Reset to what everybody else think it actually is.
cellGcmSetBlendFunc(GCM_CONTEXT, CELL_GCM_ONE, CELL_GCM_ZERO, CELL_GCM_ONE, CELL_GCM_ZERO);
cellGcmSetBlendEquation(GCM_CONTEXT, CELL_GCM_FUNC_ADD, CELL_GCM_FUNC_ADD);
cellGcmSetBlendEnable(GCM_CONTEXT, CELL_GCM_FALSE);
grcStateBlock::MakeDirty();
#endif // __PS3
grcStateBlock::SetBlendState(grcStateBlock::BS_Default);
grcBindTexture(NULL);
}
#endif // ENABLE_FOG_OF_WAR
grcTextureFactory::GetInstance().LockRenderTarget(0, fbRT, depthRT);
int mapDeviceWidth = GRCDEVICE.GetWidth();
int mapDeviceHeight = GRCDEVICE.GetHeight();
float mapWidth = (float)VideoResManager::GetUIWidth();
float mapHeight = (float)VideoResManager::GetUIHeight();
int mapX = Clamp((int)(ms_MiniMapRenderState.m_vCurrentMiniMapPosition.x*mapWidth) - 2,0,mapDeviceWidth);
int mapY = Clamp((int)(ms_MiniMapRenderState.m_vCurrentMiniMapPosition.y*mapHeight) - 2,0,mapDeviceHeight);
int mapW = Clamp((int)(ms_MiniMapRenderState.m_vCurrentMiniMapSize.x*mapWidth) + 4,0,Min((int)mapWidth - mapX,mapDeviceWidth));
int mapH = Clamp((int)(ms_MiniMapRenderState.m_vCurrentMiniMapSize.y*mapHeight) + 10,0,Min((int)mapHeight - mapY,mapDeviceHeight));
if (mapH == mapDeviceHeight && mapW == mapDeviceWidth)
{
GRCDEVICE.Clear(true, Color32(0,0,0,0), false, 1.0f, true, 0);
}else
{
GRCDEVICE.ClearRect(mapX, mapY, mapW, mapH, true, Color32(0,0,0,0), false, 1.0f, true, 0, true);
}
RenderMiniMap(MINIMAP_MOVIE_BACKGROUND, origPos, origSize, 1.0f, 1.0f);
grcTextureFactory::GetInstance().UnlockRenderTarget(0);
#if DEVICE_MSAA
CRenderTargets::ResolveOffscreenBuffer2();
fbRT = CRenderTargets::GetOffscreenBuffer2_Resolved();
#endif //DEVICE_MSAA
CRenderTargets::LockUIRenderTargets();
// Blend minimap in
int screenDeviceWidth = GRCDEVICE.GetWidth();
int screenDeviceHeight = GRCDEVICE.GetHeight();
float screenWidth = (float)VideoResManager::GetUIWidth();
float screenHeight = (float)VideoResManager::GetUIHeight();
int screenX = Clamp((int)(ms_MiniMapRenderState.m_vCurrentMiniMapPosition.x*screenWidth) - 1,0,screenDeviceWidth);
int screenY = Clamp((int)(ms_MiniMapRenderState.m_vCurrentMiniMapPosition.y*screenHeight) - 1,0,screenDeviceHeight);
int screenW = Clamp((int)(ms_MiniMapRenderState.m_vCurrentMiniMapSize.x*screenWidth) + 1,0,Min((int)screenWidth - screenX,screenDeviceWidth));
int screenH = Clamp((int)(ms_MiniMapRenderState.m_vCurrentMiniMapSize.y*screenHeight) + 1,0,Min((int)screenHeight - screenY,screenDeviceHeight));
GRCDEVICE.SetScissor(screenX, screenY, screenW, screenH);
grcStateBlock::SetBlendState(grcStateBlock::BS_Normal);
CSprite2d minimapBlend;
float fDimmerColor = 1.0f;
if (ms_MiniMapRenderState.m_bIsInPauseMap || ms_MiniMapRenderState.m_bIsInCustomMap) // 1354721
{
// alternative shade of tint if navigating content (fixes 1481452)
eHUD_COLOURS whichTinter = HUD_COLOUR_PAUSEMAP_TINT;
if (CPauseMenu::IsNavigatingContent())
whichTinter = HUD_COLOUR_PAUSEMAP_TINT_HALF;
fDimmerColor = CHudColour::GetRGBA(whichTinter).GetAlphaf();
}
minimapBlend.SetGeneralParams(Vector4(fDimmerColor, fDimmerColor, fDimmerColor, fAlphaFader), Vector4(0.0f, 0.0, 0.0, 0.0));
const Vector2 TexSize(1.0f/float(fbRT->GetWidth()), 1.0f/float(fbRT->GetHeight()));
minimapBlend.SetTexelSize(TexSize);
int scissorX = rage::round(vBackgroundPos.x*screenWidth);
int scissorY = rage::round(vBackgroundPos.y*screenHeight);
int scissorW = rage::round(vBackgroundSize.x*screenWidth);
int scissorH = rage::round(vBackgroundSize.y*screenHeight);
if (scissorW < screenWidth || scissorH < screenHeight)
{
GRCDEVICE.SetScissor( scissorX, scissorY, scissorW, scissorH );
}
if(ms_MiniMapRenderState.m_bIsInPauseMap || ms_MiniMapRenderState.m_bIsInCustomMap) // 1354721
{
#if SUPPORT_MULTI_MONITOR
if( bDrawBlended )
{
eHUD_COLOURS hudColour = HUD_COLOUR_PAUSEMAP_TINT;
Color32 adjColor(CHudColour::GetRGBA(hudColour));
// the color is stored 'inverted', so reverse it
adjColor.SetAlpha( Clamp( int(float(255 - adjColor.GetAlpha()) * fAlphaFader), 0, 255) );
// (ab)using lambda closures because we can now (yay C++11!)
CSprite2d::DrawCustomShape( [&]() { DrawFeatheredRect(vBackgroundPos, vBackgroundPos+vBackgroundSize, adjColor); } );
}
else
#endif
{
CMapMenu::RenderPauseMapTint(vBackgroundPos, vBackgroundSize, fAlphaFader, false);
}
}
minimapBlend.BeginCustomList(CSprite2d::CS_BLIT, fbRT);
#if SUPPORT_MULTI_MONITOR
if( bDrawBlended )
{
DrawFeatheredRect(Vector2(-fSizeScalar, fSizeScalar), Vector2(fSizeScalar, -fSizeScalar), Color32(0xFFFFFFFF));
}
else
#endif
{
Vector4 vPos(-fSizeScalar,fSizeScalar,fSizeScalar,-fSizeScalar);
grcDrawSingleQuadf(vPos.x,vPos.y,vPos.z,vPos.w, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, Color32(0xffffffff));
}
minimapBlend.EndCustomList();
RenderMiniMap(MINIMAP_MOVIE_FOREGROUND, vBackgroundPos, vBackgroundSize, fBlipFader, fSizeScalar);
if (scissorW < screenWidth || scissorH < screenHeight)
{
GRCDEVICE.DisableScissor();
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::Render
// PURPOSE: renders the minimap
/////////////////////////////////////////////////////////////////////////////////////
#if ENABLE_FOG_OF_WAR
void CMiniMap_RenderThread::FOWRenderQuadLocation(Vec4f *quads, int numQuads)
{
CRenderTargets::UnlockUIRenderTargets();
grcTextureFactory::GetInstance().LockRenderTarget(0, CMiniMap_Common::GetFogOfWarRT(), NULL);
grcStateBlock::SetBlendState(grcStateBlock::BS_Default);
grcStateBlock::SetBlendState(grcStateBlock::BS_Add);
grcBindTexture(CShaderLib::LookupTexture("FoW"));
for (long index = 0; index < numQuads; index++)
{
grcDrawSingleQuadf(quads[index].GetX(),quads[index].GetY(),quads[index].GetZ(),quads[index].GetW(), 0.0f, 0.0f , 0.0f , 1.0f , 1.0f , fowColor);
}
grcTextureFactory::GetInstance().UnlockRenderTarget(0);
grcStateBlock::SetBlendState(grcStateBlock::BS_Default);
grcBindTexture(NULL);
CRenderTargets::LockUIRenderTargets();
}
#if RSG_PC
void CMiniMap_RenderThread::FOWRenderCatchupQuads()
{
CRenderTargets::UnlockUIRenderTargets();
grcTextureFactory::GetInstance().LockRenderTarget(0, CMiniMap_Common::GetFogOfWarRT(), NULL);
grcStateBlock::SetBlendState(grcStateBlock::BS_Default);
grcStateBlock::SetBlendState(grcStateBlock::BS_Add);
grcBindTexture(CShaderLib::LookupTexture("FoW"));
unsigned int currentRTFlag = (1 << CMiniMap_Common::GetCurrentExportRTIndex());
ms_gotQuads = false;
for (int i = 0; i < MAX_FOW_TARGETS*(MAX_FOG_SCRIPT_REVEALS + 1); i++)
{
if ( (ms_quads[i].flags & currentRTFlag) == 0)
{
grcDrawSingleQuadf(ms_quads[i].pos.GetX(),ms_quads[i].pos.GetY(),ms_quads[i].pos.GetZ(),ms_quads[i].pos.GetW(), 0.0f, 0.0f , 0.0f , 1.0f , 1.0f , fowColor);
ms_quads[i].flags |= currentRTFlag;
}
ms_gotQuads |= (ms_quads[i].flags != 0x7);
}
grcTextureFactory::GetInstance().UnlockRenderTarget(0);
grcStateBlock::SetBlendState(grcStateBlock::BS_Default);
grcBindTexture(NULL);
CRenderTargets::LockUIRenderTargets();
}
#endif
void CMiniMap_RenderThread::FOWClear()
{
FoWPrevX = 0.0f;
FoWPrevY = 0.0f;
CRenderTargets::UnlockUIRenderTargets();
// Update Fog of War
grcTextureFactory::GetInstance().LockRenderTarget(0, CMiniMap_Common::GetFogOfWarRT(), NULL);
GRCDEVICE.Clear(true, Color32(0,0,0,0),false,0.0f,false,0);
grcTextureFactory::GetInstance().UnlockRenderTarget(0);
#if RSG_DURANGO
// Clear the reveal ratio texture to prevent spurious Sightseer Achievement awards
grcTextureFactory::GetInstance().LockRenderTarget(0, CMiniMap_Common::GetFogOfWarRevealRatioRT(), NULL);
GRCDEVICE.Clear(true, Color32(0,0,0,0),false,0.0f,false,0);
grcTextureFactory::GetInstance().UnlockRenderTarget(0);
#endif
CRenderTargets::LockUIRenderTargets();
}
void CMiniMap_RenderThread::FOWReveal()
{
FoWPrevX = 0.0f;
FoWPrevY = 0.0f;
grcStateBlock::SetBlendState(grcStateBlock::BS_Default);
CRenderTargets::UnlockUIRenderTargets();
// Update Fog of War
#if RSG_PC
for(size_t i = 0; i < MAX_FOW_TARGETS; ++i)
{
#endif
grcTextureFactory::GetInstance().LockRenderTarget(0, CMiniMap_Common::GetFogOfWarRT(), NULL);
GRCDEVICE.Clear(true, Color32(0xffffffff),false,0.0f,false,0);
grcTextureFactory::GetInstance().UnlockRenderTarget(0);
#if RSG_PC
CMiniMap_Common::UpdateFogOfWarRBIndex();
}
#endif
CRenderTargets::LockUIRenderTargets();
grcStateBlock::SetBlendState(grcStateBlock::BS_Normal);
}
void CMiniMap_RenderThread::FOWDownSample()
{
CRenderTargets::UnlockUIRenderTargets();
grcStateBlock::SetBlendState(grcStateBlock::BS_Default);
grcStateBlock::SetRasterizerState(grcStateBlock::RS_NoBackfaceCull);
CSprite2d fowReveal;
Vector4 TexSize;
fowReveal.SetGeneralParams(Vector4(1.0f, 1.0f, 1.0f, 1.0f), Vector4(0.0f, 0.0, 0.0, 0.0));
grcTextureFactory::GetInstance().LockRenderTarget(0,PostFX::FogOfWarRT0, NULL);
TexSize = Vector4(1.0f/float(CMiniMap_Common::GetFogOfWarRT()->GetWidth()),1.0f/float(CMiniMap_Common::GetFogOfWarRT()->GetHeight()), 1.0f/float(PostFX::FogOfWarRT0->GetWidth()), 1.0f/float(PostFX::FogOfWarRT0->GetHeight()));
fowReveal.SetTexelSize(TexSize);
fowReveal.BeginCustomList(CSprite2d::CS_FOWCOUNT, CMiniMap_Common::GetFogOfWarRT());
grcDrawSingleQuadf(-1.0f,1.0f,1.0f,-1.0f,0.1f,0.0f,0.0f,1.0f,1.0f,Color32(0xffffffff));
fowReveal.EndCustomList();
// Add Height map
fowReveal.BeginCustomList(CSprite2d::CS_FOWFILL, NULL);
for(int x=0;x<fowTileSize;x++)
{
for( int y=0;y<fowTileSize;y++)
{
float fowX1 = ((float)x)/((float)fowTileSize);
float fowY1 = ((float)y)/((float)fowTileSize);
float fowX2 = fowX1 + 1.0f/((float)fowTileSize);
float fowY2 = fowY1 + 1.0f/((float)fowTileSize);
Vector2 world1 = FowToWorldCoord(fowX1,fowY1);
Vector2 world2 = FowToWorldCoord(fowX2,fowY2);
float xMin = Min(world1.x,world2.x);
float yMin = Min(world1.y,world2.y);
float xMax = Max(world1.x,world2.x);
float yMax = Max(world1.y,world2.y);
float height = CGameWorldHeightMap::GetMaxHeightFromWorldHeightMap(xMin, yMin, xMax, yMax);
if( height < CMiniMap::sm_Tunables.FogOfWar.fFowWaterHeight )
{
grcDrawSingleQuadf(fowX1,fowY1,fowX2,fowY2, 0.0f, 0.0f , 0.0f , 1.0f , 1.0f , Color32(0xffffffff));
}
}
}
fowReveal.EndCustomList();
grcTextureFactory::GetInstance().UnlockRenderTarget(0);
grcTextureFactory::GetInstance().LockRenderTarget(0,PostFX::FogOfWarRT1, NULL);
TexSize = Vector4(1.0f/float(PostFX::FogOfWarRT0->GetWidth()),1.0f/float(PostFX::FogOfWarRT0->GetHeight()),1.0f/float(PostFX::FogOfWarRT1->GetWidth()),1.0f/float(PostFX::FogOfWarRT1->GetHeight()));
fowReveal.SetTexelSize(TexSize);
fowReveal.BeginCustomList(CSprite2d::CS_FOWAVERAGE, PostFX::FogOfWarRT0);
grcDrawSingleQuadf(-1.0f,1.0f,1.0f,-1.0f,0.1f,0.0f,0.0f,1.0f,1.0f,Color32(0xffffffff));
fowReveal.EndCustomList();
grcTextureFactory::GetInstance().UnlockRenderTarget(0);
grcTextureFactory::GetInstance().LockRenderTarget(0,PostFX::FogOfWarRT2, NULL);
TexSize = Vector4(1.0f/float(PostFX::FogOfWarRT1->GetWidth()),1.0f/float(PostFX::FogOfWarRT1->GetHeight()),1.0f/float(PostFX::FogOfWarRT2->GetWidth()),1.0f/float(PostFX::FogOfWarRT2->GetHeight()));
fowReveal.SetTexelSize(TexSize);
fowReveal.BeginCustomList(CSprite2d::CS_FOWAVERAGE, PostFX::FogOfWarRT1);
grcDrawSingleQuadf(-1.0f,1.0f,1.0f,-1.0f,0.1f,0.0f,0.0f,1.0f,1.0f,Color32(0xffffffff));
fowReveal.EndCustomList();
grcTextureFactory::GetInstance().UnlockRenderTarget(0);
grcTextureFactory::GetInstance().LockRenderTarget(0,CMiniMap_Common::GetFogOfWarRevealRatioRT(), NULL);
TexSize = Vector4(1.0f/float(PostFX::FogOfWarRT2->GetWidth()),1.0f/float(PostFX::FogOfWarRT2->GetHeight()),1.0f/float(CMiniMap_Common::GetFogOfWarRevealRatioRT()->GetWidth()),1.0f/float(CMiniMap_Common::GetFogOfWarRevealRatioRT()->GetHeight()));
fowReveal.SetTexelSize(TexSize);
fowReveal.BeginCustomList(CSprite2d::CS_FOWAVERAGE, PostFX::FogOfWarRT2);
grcDrawSingleQuadf(-1.0f,1.0f,1.0f,-1.0f,0.1f,0.0f,0.0f,1.0f,1.0f,Color32(0xffffffff));
fowReveal.EndCustomList();
grcTextureFactory::GetInstance().UnlockRenderTarget(0);
grcStateBlock::SetBlendState(grcStateBlock::BS_Default);
grcStateBlock::SetRasterizerState(grcStateBlock::RS_Default);
CRenderTargets::LockUIRenderTargets();
}
#endif //ENABLE_FOG_OF_WAR
void CMiniMap_RenderThread::Render()
{
#if DISABLE_HUD_FOR_CONTENT_CONTROLLED_BUILD
return;
#else
GRC_ALLOC_SCOPE_AUTO_PUSH_POP()
grcStateBlock::SetRasterizerState(grcStateBlock::RS_Default);
#if RSG_PC
if (GRCDEVICE.IsStereoEnabled() && GRCDEVICE.CanUseStereo())
{
CShaderLib::SetStereoParams(Vector4(0.0f,0.0f,0.0f,0.0f));
}
#endif
#if ENABLE_FOG_OF_WAR
#if __D3D11
if( ms_MiniMapRenderState.m_bUploadFoWTextureData )
{
UploadFoWTextureData();
}
static bool fogOfWarRatioRTValid = false;
if (fogOfWarRatioRTValid)
ReadBackFoWFromStaging();
#endif
bool fogOfWarUpdated = false;
#if RSG_PC
if( ms_gotQuads )
{
FOWRenderCatchupQuads();
}
if (g_curFOWClearGPUCount > 0)
{
FOWClear();
g_curFOWClearGPUCount--;
}
if (g_curFOWRevealGPUCount > 0)
{
FOWReveal();
g_curFOWRevealGPUCount--;
}
#endif
if( ms_MiniMapRenderState.m_bUpdateFoW )
{
// Update Fog of War
Vector2 coords = WorldToFowCoord(ms_MiniMapRenderState.m_vPlayerPos.x, ms_MiniMapRenderState.m_vPlayerPos.y);
float fowWidth = (float)CMiniMap_Common::GetFogOfWarRT()->GetWidth();
float fowHeight = (float)CMiniMap_Common::GetFogOfWarRT()->GetHeight();
bool needPedRender = ms_MiniMapRenderState.m_bUpdatePlayerFoW && (abs(FoWPrevX - coords.x) > moveStep/fowWidth || abs(FoWPrevY - coords.y) > moveStep/fowHeight);
bool needScriptRender = ms_MiniMapRenderState.m_numScriptRevealRequested > 0;
if( needPedRender || needScriptRender )
{
const float aspectRatio = CMiniMap::AreFowCustomWorldExtentsEnabled()?
(CMiniMap::GetFowCustomWorldH() / CMiniMap::GetFowCustomWorldW()) :
(CMiniMap::sm_Tunables.FogOfWar.fWorldH / CMiniMap::sm_Tunables.FogOfWar.fWorldW);
float xDelta = (fowColorSizeX/fowWidth)*aspectRatio;
float yDelta = (fowColorSizeY/fowHeight)*aspectRatio;
Vec4f quads[MAX_FOG_SCRIPT_REVEALS + 1];
int numOfQuads = 0;
if( needPedRender )
{
FoWPrevX = coords.x;
FoWPrevY = coords.y;
quads[numOfQuads++] = Vec4f(coords.x-xDelta,coords.y-yDelta,coords.x+xDelta,coords.y+yDelta);
}
if( needScriptRender )
{
for(int i=0;i<ms_MiniMapRenderState.m_numScriptRevealRequested;i++)
{
Vector2 coords = WorldToFowCoord(ms_MiniMapRenderState.m_ScriptReveal[i].x, ms_MiniMapRenderState.m_ScriptReveal[i].y);
quads[numOfQuads++] = Vec4f(coords.x-xDelta,coords.y-yDelta,coords.x+xDelta,coords.y+yDelta);
}
}
if (numOfQuads )
{
FOWRenderQuadLocation(quads, numOfQuads);
#if RSG_PC
int quadIdx = 0;
unsigned int currentRTFlag = (1 << CMiniMap_Common::GetCurrentExportRTIndex());
for (int i = 0; i < MAX_FOW_TARGETS*(MAX_FOG_SCRIPT_REVEALS + 1); i++)
{
if( ms_quads[i].flags == 0x7 )
{
ms_quads[i].pos = quads[quadIdx];
ms_quads[i].flags = currentRTFlag;
ms_gotQuads = true;
quadIdx++;
if( quadIdx == numOfQuads )
break;
}
}
#endif
}
fogOfWarUpdated = true;
}
}
if( ms_MiniMapRenderState.m_bClearFoW )
{
FOWClear();
#if RSG_PC
g_curFOWClearGPUCount = GRCDEVICE.GetGPUCount(true)-1;
#endif
fogOfWarUpdated = true;
}
if( ms_MiniMapRenderState.m_bRevealFoW)
{
FOWReveal();
#if RSG_PC
g_curFOWRevealGPUCount = GRCDEVICE.GetGPUCount(true)-1;
#endif
fogOfWarUpdated = true;
}
// Downsample FoW.
FowLastFrameRead++;
if( FowLastFrameRead > fowFrameCount )
{
FowLastFrameRead = 0;
FOWDownSample();
#if __D3D11
// copy to current frame to staging buffer and increment frame number
CopyFoWForCPURead();
fogOfWarRatioRTValid = true;
#endif
}
#endif // ENABLE_FOG_OF_WAR
#if !__FINAL
XPARAM(nominimap);
if (PARAM_nominimap.Get())
{
if (!ms_MiniMapRenderState.m_bIsInPauseMap)
return;
}
#endif // !__FINAL
if ( (ms_MiniMapRenderState.m_bShouldProcessMiniMap) && (ms_MiniMapRenderState.m_bShouldRenderMiniMap) ) // if in pause map and not in map screen then dont render
{
#define __TEST_SCALEFORM_3D_ISSUE (0)
#if __TEST_SCALEFORM_3D_ISSUE
ms_MiniMapRenderState.m_vCurrentMiniMapPosition = Vector2(0.3f,0.8f);
ms_MiniMapRenderState.m_vCurrentMiniMapSize = Vector2(0.5f, 0.5f);
CScaleformMgr::ChangeMovieParams(ms_iMovieId[MINIMAP_MOVIE_BACKGROUND], ms_MiniMapRenderState.m_vCurrentMiniMapPosition, ms_MiniMapRenderState.m_vCurrentMiniMapSize, GFxMovieView::SM_ExactFit);
CScaleformMgr::ChangeMovieParams(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND], ms_MiniMapRenderState.m_vCurrentMiniMapPosition, ms_MiniMapRenderState.m_vCurrentMiniMapSize, GFxMovieView::SM_ExactFit);
#endif // __TEST_SCALEFORM_3D_ISSUE
// I'd love to skip the whole rigmarole of doing the scissoring and clear and copy, but it would appear
// the frontend menu relies on this behaviour to not spew map all over the screen...
bool doMiniMapAlpha = ( (!ms_MiniMapRenderState.m_bIsInPauseMap) && (!ms_MiniMapRenderState.m_bIsInCustomMap) && (ms_MiniMapAlpha < 1.0f) && (ms_MiniMapRenderState.m_CurrentGolfMap == GOLF_COURSE_OFF) );
float miniMapAlpha = doMiniMapAlpha ? ms_MiniMapAlpha : 1.0f;
if( ms_bUseTexturedAlphaAllMovies || ms_bUseTextureAlphaBaseMovie )
miniMapAlpha = 1.0f;
PF_PUSH_TIMEBAR("Scaleform Movie Render (MiniMap)");
bool useOffscreenBuffer = false;
if(doMiniMapAlpha)
useOffscreenBuffer = true;
Vector2 zero(0.0f, 0.0f);
Vector2 maskPos,maskSize;
int mapMaskX = 0;
int mapMaskY = 0;
int mapMaskW = 0;
int mapMaskH = 0;
int mapX = 0;
int mapY = 0;
int mapW = 0;
int mapH = 0;
if(useOffscreenBuffer)
{
int mapDeviceWidth = GRCDEVICE.GetWidth();
int mapDeviceHeight = GRCDEVICE.GetHeight();
float mapWidth = (float)VideoResManager::GetUIWidth();
float mapHeight = (float)VideoResManager::GetUIHeight();
#if SUPPORT_MULTI_MONITOR
MultiMonitorHudHelper helper(&ms_MiniMapRenderState);
#endif // SUPPORT_MULTI_MONITOR
if( ms_bUseTexturedAlphaAllMovies || ms_bUseTextureAlphaBaseMovie )
{
maskPos = ms_MiniMapRenderState.m_vCurrentMiniMapBlurPosition;
maskSize = ms_MiniMapRenderState.m_vCurrentMiniMapBlurSize;
}
else
{
maskPos = ms_MiniMapRenderState.m_vCurrentMiniMapMaskPosition;
maskSize = ms_MiniMapRenderState.m_vCurrentMiniMapMaskSize;
}
int mapMaskDeviceWidth = GRCDEVICE.GetWidth();
int mapMaskDeviceHeight = GRCDEVICE.GetHeight();
mapMaskX = Clamp((int)((maskPos.x)*mapWidth) - 1,0,mapMaskDeviceWidth);
mapMaskY = Clamp((int)((maskPos.y)*mapHeight) - 1,0,mapMaskDeviceHeight);
mapMaskW = Clamp((int)((maskSize.x)*mapWidth) + 1,0,Min((int)mapWidth - mapMaskX,mapMaskDeviceWidth));
mapMaskH = Clamp((int)((maskSize.y)*mapHeight) + 1,0,Min((int)mapHeight - mapMaskY,mapMaskDeviceHeight));
if (!ms_MiniMapRenderState.m_bBackgroundMapShouldBeHidden)
{
// Render the minimap to a secondary buffer and composite it to the final render
// That way we can apply a constant alpha blend to the whole thing, but let artists alpha blends elements together.
// Clever Shit.
// Render to offscreen target
grcRenderTarget *fbRT = CRenderTargets::GetOffscreenBuffer2();
grcRenderTarget *depthRT = CRenderTargets::GetUIDepthBuffer();
CRenderTargets::UnlockUIRenderTargets();
grcTextureFactory::GetInstance().LockRenderTarget(0, fbRT, depthRT);
if (GRCDEVICE.GetMSAA() || RSG_PC)
{
GRCDEVICE.Clear(true,Color32(0),false,1.f,false,0);
}
Vector2 vMapPos, vMapSize;
if( ms_bUseTexturedAlphaAllMovies || ms_bUseTextureAlphaBaseMovie )
{
vMapPos = ms_MiniMapRenderState.m_vCurrentMiniMapBlurPosition;
vMapSize = ms_MiniMapRenderState.m_vCurrentMiniMapBlurSize;
}
else
{
vMapPos = ms_MiniMapRenderState.m_vCurrentMiniMapPosition;
vMapSize = ms_MiniMapRenderState.m_vCurrentMiniMapSize;
}
mapX = Clamp((int)(vMapPos.x*mapWidth) - 1,0,mapDeviceWidth);
mapY = Clamp((int)(vMapPos.y*mapHeight) - 1,0,mapDeviceHeight);
mapW = Clamp((int)(vMapSize.x*mapWidth) + 1,0,Min((int)mapWidth - mapX,mapDeviceWidth));
mapH = Clamp((int)(vMapSize.y*mapHeight) + 1,0,Min((int)mapHeight - mapY,mapDeviceHeight));
GRCDEVICE.ClearRect(mapX, mapY, mapW, mapH, true, Color32(0,0,0,0),true,1.0f,true,0 ORBIS_ONLY(,true) DURANGO_ONLY(,true) WIN32PC_ONLY(,true));
RenderMiniMap(MINIMAP_MOVIE_BACKGROUND, zero, zero, 1.0f, 1.0f);
if( ms_bUseTexturedAlphaAllMovies )
{
RenderMiniMap(MINIMAP_MOVIE_FOREGROUND, zero, zero, 1.0f, 1.0f);
}
u32 now = fwTimer::GetTimeInMilliseconds();
float flashAlpha = Clamp(1.0f - (now-ms_MiniMapRenderState.m_uFlashStartTime)/float(CMiniMap::sm_Tunables.Display.ScriptOverlayTime), 0.0f, 1.0f);
if( flashAlpha > 0.0f )
{
CSprite2d minimapFlashOverlay;
CRGBA overlayCol = CHudColour::GetRGBF(ms_MiniMapRenderState.m_eFlashColour, flashAlpha);
minimapFlashOverlay.SetGeneralParams(Vector4(1.0f, 1.0f, 1.0f, 1.0f), Vector4(0.0f, 0.0, 0.0, 0.0));
minimapFlashOverlay.BeginCustomList(CSprite2d::CS_BLIT, grcTexture::NoneWhite);
grcDrawSingleQuadf(-1.0f,1.0f,1.0f,-1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, overlayCol);
minimapFlashOverlay.EndCustomList();
}
if(doMiniMapAlpha)
{
if( ms_bUseTexturedAlphaAllMovies || ms_bUseTextureAlphaBaseMovie )
{
CSprite2d minimapAlphaClear;
grcTexture *texture;
if(false && NetworkInterface::IsInCopsAndCrooks())
{ // use different radar mask textures for C&C (BS#6508644 - C&C - Radar Mask - Code set up our new Radar Mask Texture)
texture = ms_MiniMapRenderState.m_bIsInBigMap ? ms_MaskTextureCnCLg : ms_MaskTextureCnCSm;
}
else
{
texture = ms_MiniMapRenderState.m_bIsInBigMap ? ms_MaskTextureLg : ms_MaskTextureSm;
}
grcStateBlock::SetBlendState(ms_ClearAlphaMiniMapRenderBlendStateHandle);
// clear the full alpha background, because Scaleform leaks outside the rect...
minimapAlphaClear.SetGeneralParams(Vector4(0.0f, 0.0f, 0.0f, 0.0f), Vector4(0.0f, 0.0, 0.0, 0.0));
minimapAlphaClear.BeginCustomList(CSprite2d::CS_BLIT, grcTexture::NoneWhite);
grcDrawSingleQuadf(-1.0f,1.0f,1.0f,-1.0f,0.1f,0.0f,0.0f,1.0f,1.0f,Color32(0xffffffff));
minimapAlphaClear.EndCustomList();
// Render the textured blob....
float alphaOut = Lerp(flashAlpha, CMiniMap::sm_Tunables.Display.MaskNormalAlpha, CMiniMap::sm_Tunables.Display.MaskFlashAlpha );
minimapAlphaClear.SetGeneralParams(Vector4(1.0f, 0.0f, 0.0f, 0.0f), Vector4(0.0f, alphaOut, 0.0f, 0.0f));
minimapAlphaClear.SetTexelSize(Vector2(1.0f/((float)texture->GetWidth()),1.0f/((float)texture->GetHeight())));
minimapAlphaClear.BeginCustomList(CSprite2d::CS_BLIT_TO_ALPHA_BLUR, texture);
float ooScreenWidth = 1.0f/(float)VideoResManager::GetUIWidth();
float ooScreenHeight = 1.0f/(float)VideoResManager::GetUIHeight();
grcDrawSingleQuadf( maskPos.x-ooScreenWidth,
maskPos.y-ooScreenHeight,
maskPos.x + maskSize.x+ooScreenWidth,
maskPos.y + maskSize.y+ooScreenHeight,
0.0f,
0.0f,0.0f,1.0f,1.0f,
Color32(0xffffffff));
minimapAlphaClear.EndCustomList();
}
else
{
GRCDEVICE.SetScissor(mapMaskX, mapMaskY, mapMaskW, mapMaskH);
grcStateBlock::SetBlendState(ms_ClearAlphaMiniMapRenderBlendStateHandle);
CSprite2d minimapAlphaClear;
minimapAlphaClear.SetGeneralParams(Vector4(1.0f, 1.0f, 1.0f, 1.0f), Vector4(0.0f, 0.0, 0.0, 0.0));
minimapAlphaClear.BeginCustomList(CSprite2d::CS_BLIT, grcTexture::NoneWhite);
grcDrawSingleQuadf(-1.0f,1.0f,1.0f,-1.0f,0.1f,0.0f,0.0f,1.0f,1.0f,Color32(0xffffffff));
minimapAlphaClear.EndCustomList();
}
}
grcTextureFactory::GetInstance().UnlockRenderTarget(0);
{
#if DEVICE_EQAA
eqaa::ResolveArea area(mapX, mapY, mapW, mapH);
#endif // DEVICE_EQAA
CRenderTargets::ResolveOffscreenBuffer2();
fbRT = CRenderTargets::GetOffscreenBuffer2_Resolved();
}
CRenderTargets::LockUIRenderTargets();
// Blend minimap in
GRCDEVICE.SetScissor(mapMaskX, mapMaskY, mapMaskW, mapMaskH);
grcStateBlock::SetBlendState(grcStateBlock::BS_Normal);
CSprite2d minimapBlend;
const Vector2 TexSize(1.0f/float(fbRT->GetWidth()),1.0f/float(fbRT->GetHeight()));
minimapBlend.SetTexelSize(TexSize);
minimapBlend.SetGeneralParams(Vector4(miniMapAlpha, miniMapAlpha, miniMapAlpha, miniMapAlpha), Vector4(0.0f, 0.0, 0.0, 0.0));
minimapBlend.BeginCustomList(CSprite2d::CS_BLIT, fbRT);
grcDrawSingleQuadf(-1.0f,1.0f,1.0f,-1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, Color32(0xffffffff));
// if we attempt to flash the radar while wanted, we just get a brighter red radar. And that's no good
if( flashAlpha <= 0.0f )
RenderWantedOverlay();
minimapBlend.EndCustomList();
GRCDEVICE.DisableScissor();
}
if( ms_bUseTexturedAlphaAllMovies == false ) // we always want to show foreground (so we can render "blips only" mode) - fix for 1883759
{
if (!(RSG_PC && GRCDEVICE.GetMSAA()))
{
RenderMiniMap(MINIMAP_MOVIE_FOREGROUND, zero, zero, 1.0f, 1.0f);
}
else
{
grcRenderTarget *uiRT = CRenderTargets::GetUIBackBuffer();
grcRenderTarget *fbRT = CRenderTargets::GetOffscreenBuffer2();
grcRenderTarget *depthRT = CRenderTargets::GetUIDepthBuffer();
CRenderTargets::UnlockUIRenderTargets();
// Copy minimap back to OffscreenBuffer2 and render foreground layer with AA
grcTextureFactory::GetInstance().LockRenderTarget(0, fbRT, depthRT);
{
grcStateBlock::SetBlendState(ms_CopyAAMiniMapRenderBlendStateHandle);
GRCDEVICE.SetScissor(mapMaskX, mapMaskY, mapMaskW, mapMaskH);
CSprite2d minimapBlend;
const Vector2 TexSize(1.0f/float(fbRT->GetWidth()),1.0f/float(fbRT->GetHeight()));
minimapBlend.SetTexelSize(TexSize);
minimapBlend.SetGeneralParams(Vector4(miniMapAlpha, miniMapAlpha, miniMapAlpha, miniMapAlpha), Vector4(0.0f, 0.0, 0.0, 0.0));
minimapBlend.BeginCustomList(CSprite2d::CS_BLIT, uiRT);
{
grcDrawSingleQuadf(-1.0f,1.0f,1.0f,-1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, Color32(0xffffffff));
}
minimapBlend.EndCustomList();
RenderMiniMap(MINIMAP_MOVIE_FOREGROUND, zero, zero, 1.0f, 1.0f);
GRCDEVICE.DisableScissor();
}
grcTextureFactory::GetInstance().UnlockRenderTarget(0);
#if DEVICE_EQAA
eqaa::ResolveArea area(mapX, mapY, mapW, mapH);
#endif
CRenderTargets::ResolveOffscreenBuffer2();
fbRT = CRenderTargets::GetOffscreenBuffer2_Resolved();
CRenderTargets::LockUIRenderTargets();
// Copy composited minimap to UI Back Buffer
grcStateBlock::SetBlendState(ms_CopyAAMiniMapRenderBlendStateHandle);
GRCDEVICE.SetScissor(mapMaskX, mapMaskY, mapMaskW, mapMaskH);
CSprite2d minimapBlend;
const Vector2 TexSize(1.0f/float(fbRT->GetWidth()),1.0f/float(fbRT->GetHeight()));
minimapBlend.SetTexelSize(TexSize);
minimapBlend.SetGeneralParams(Vector4(miniMapAlpha, miniMapAlpha, miniMapAlpha, miniMapAlpha), Vector4(0.0f, 0.0, 0.0, 0.0));
minimapBlend.BeginCustomList(CSprite2d::CS_BLIT, fbRT);
{
grcDrawSingleQuadf(-1.0f,1.0f,1.0f,-1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, Color32(0xffffffff));
}
minimapBlend.EndCustomList();
GRCDEVICE.DisableScissor();
}
}
}
else
{
if (!ms_MiniMapRenderState.m_bBackgroundMapShouldBeHidden)
{
RenderMiniMap(MINIMAP_MOVIE_BACKGROUND, zero, zero, 1.0f, 1.0f);
}
RenderMiniMap(MINIMAP_MOVIE_FOREGROUND, zero, zero, 1.0f, 1.0f);
}
PF_POP_TIMEBAR();
#if __BANK
if (bDebug3DBlips && vGameScreenPos.x != 0 && vGameScreenPos.y != 0)
{
CSprite2d::DrawRect( fwRect(vGameScreenPos.x, vGameScreenPos.y, vGameScreenPos.x+0.003f, vGameScreenPos.y+0.005f), CRGBA(0,255,0,255) );
vGameScreenPos = Vector2(0,0); // reset it for next frame
}
#endif // __BANK
}
#endif
#if __DEV
if (iTimeTaken != 0)
{
uiDebugf1("Time taken to switch between MiniMap and PauseMap: %d", fwTimer::GetSystemTimeInMilliseconds() - iTimeTaken);
iTimeTaken = 0;
}
#endif // __DEV
#if __BANK && ENABLE_FOG_OF_WAR
if( DebugDrawFOW )
{
CSprite2d::SetRenderState(CMiniMap_Common::GetFogOfWarRT());
CSprite2d::SetGeneralParams(Vector4(1.0f,1.0f,1.0f,1.0f), Vector4(0.0f, 0.0, 0.0, 0.0));
CSprite2d::DrawRect(Vector2(DebugFOWX1,DebugFOWY1),
Vector2(DebugFOWX2,DebugFOWY1),
Vector2(DebugFOWX1,DebugFOWY2),
Vector2(DebugFOWX2,DebugFOWY2),
0.0f,
Vector2(0.0f,0.0f),
Vector2(1.0f,0.0f),
Vector2(0.0f,1.0f),
Vector2(1.0f,1.0f),
Color32(0xffffffff));
CSprite2d::ClearRenderState();
}
#endif // __BANK && ENABLE_FOG_OF_WAR
#if RSG_PC
if (GRCDEVICE.IsStereoEnabled() && GRCDEVICE.CanUseStereo())
{
CShaderLib::SetStereoParams(Vector4(0.0f,0.0f,0.0f,0.0f));
}
#endif
}
#if __D3D11 && ENABLE_FOG_OF_WAR
#if RSG_PC
bool CMiniMap_RenderThread::IsRenderMultiGPU()
{
return (ms_gotQuads || (g_curFOWClearGPUCount > 0) || (g_curFOWRevealGPUCount > 0));
}
#endif
void CMiniMap_RenderThread::CopyFoWForCPURead()
{
Assert(CSystem::IsThisThreadId(SYS_THREAD_RENDER));
grcTextureD3D11* fogOfWarTex11 = (grcTextureD3D11*)CMiniMap_Common::GetFogOfWarTex();
fogOfWarTex11->CopyFromGPUToStagingBuffer();
grcTextureD3D11* fogOfWarRatioTex11 = (grcTextureD3D11*)CMiniMap_Common::GetFogOfWarRevealRatioTex();
fogOfWarRatioTex11->CopyFromGPUToStagingBuffer();
#if RSG_PC
CMiniMap_Common::UpdateFogOfWarRBIndex();
#endif
ms_bUpdateFogOfWarData = true;
}
void CMiniMap_RenderThread::ReadBackFoWFromStaging()
{
Assert(CSystem::IsThisThreadId(SYS_THREAD_RENDER));
if(ms_bUpdateFogOfWarData)
{
PF_PUSH_TIMEBAR_BUDGETED("CMiniMap_Common::ms_MiniMapFogOfWarTex Read Back", 0.4f);
bool fogOfWarDataUpdated = false;
#if RSG_PC
grcTextureD3D11* fogOfWarTex11 = (grcTextureD3D11*)CMiniMap_Common::GetPreviousFogOfWarTex();
#else
grcTextureD3D11* fogOfWarTex11 = (grcTextureD3D11*)CMiniMap_Common::GetFogOfWarTex();
#endif
u8* fogOfWarData = CMiniMap_Common::GetFogOfWarData();
if(fogOfWarTex11->MapStagingBufferToBackingStore(true))
{
grcTextureLock lock;
if (fogOfWarTex11->LockRect( 0, 0, lock, grcsRead ))
{
u8* pBits = (u8*)lock.Base;
for (int col=0; col<lock.Height; col++)
{
sysMemCpy( fogOfWarData, pBits, sizeof(u8)*FOG_OF_WAR_RT_SIZE);
fogOfWarData += FOG_OF_WAR_RT_SIZE;
pBits += lock.Pitch / sizeof(u8);
}
fogOfWarTex11->UnlockRect(lock);
fogOfWarDataUpdated = true;
}
}
PF_POP_TIMEBAR();
PF_PUSH_TIMEBAR_BUDGETED("CMiniMap_Common::ms_MiniMapFogofWarRevealRatioTex Read Back", 0.4f);
bool fogOfWarRatioDataUpdated = false;
#if RSG_PC
grcTextureD3D11* fogOfWarRatioTex11 = (grcTextureD3D11*)CMiniMap_Common::GetPreviousFogOfWarRevealRatioTex();
#else
grcTextureD3D11* fogOfWarRatioTex11 = (grcTextureD3D11*)CMiniMap_Common::GetFogOfWarRevealRatioTex();
#endif
if(fogOfWarRatioTex11->MapStagingBufferToBackingStore(true))
{
grcTextureLock lock;
if (fogOfWarRatioTex11->LockRect( 0, 0, lock, grcsRead ))
{
*CMiniMap_Common::GetFogOfWarRevealRatioLockPtr() = *(float*)lock.Base;
fogOfWarRatioDataUpdated = true;
fogOfWarRatioTex11->UnlockRect(lock);
}
}
PF_POP_TIMEBAR();
ms_bUpdateFogOfWarData = !(fogOfWarDataUpdated && fogOfWarRatioDataUpdated);
}
}
void CMiniMap_RenderThread::UploadFoWTextureData(WIN32PC_ONLY(bool bMultiGPUSync))
{
Assert(CSystem::IsThisThreadId(SYS_THREAD_RENDER));
#if RSG_PC
// copy everything across the different textures
for(size_t i = 0; i < MAX_FOW_TARGETS; ++i)
{
((grcTextureD3D11*)CMiniMap_Common::GetFogOfWarTex(i))->UpdateGPUCopy(0, 0, CMiniMap_Common::GetFogOfWarLockPtr());
#if RSG_PC
if (!bMultiGPUSync)
#endif
((grcTextureD3D11*)CMiniMap_Common::GetFogOfWarTex(i))->CopyFromGPUToStagingBuffer();
}
#else
// UpdateGPU Copy is a lie...
grcTextureLock texLock;
if(CMiniMap_Common::GetFogOfWarTex()->LockRect(0, 0, texLock))
{
u8 *fogOfWarData = CMiniMap_Common::GetFogOfWarLockPtr();
u8* pBits = (u8*)texLock.Base;
for (int col=0; col<texLock.Height; col++)
{
sysMemCpy(pBits , fogOfWarData, sizeof(u8)*FOG_OF_WAR_RT_SIZE);
fogOfWarData += FOG_OF_WAR_RT_SIZE;
pBits += texLock.Pitch / sizeof(u8);
}
CMiniMap_Common::GetFogOfWarTex()->UnlockRect(texLock);
}
#endif
}
#endif // __D3D11
#if __RENDER_PED_VISUAL_FIELD
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::RenderPedVisualField
// PURPOSE: renders the ped visual field to the minimap (needs moving over to Scaleform)
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::RenderPedVisualField()
{
if (!GetInStealthMode()) // if not in stealth mode, then dont create any stealth blips
return;
// Render AI perception cones and dead peds
CEntityIterator entityIterator(IteratePeds);
CPed* pPed = static_cast<CPed*>(entityIterator.GetNext());
while(pPed)
{
if( pPed->GetPedConfigFlag( CPED_CONFIG_FLAG_DrawRadarVisualField ) )
{
if( pPed->IsInjured() )
{
DrawDeadPed(pPed);
}
else
{
#if __DEV
if (CTaskInvestigate::ms_bToggleRenderInvestigationPosition)
{
CTask* pTask = pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_INVESTIGATE);
if (pTask && pTask->GetTaskType() == CTaskTypes::TASK_INVESTIGATE)
{
DrawLine(VEC3V_TO_VECTOR3(pPed->GetTransform().GetPosition()),static_cast<CTaskInvestigate*>(pTask)->GetInvestigationPos(),Color_orange);
}
pTask = pPed->GetPedIntelligence()->FindTaskActiveByType(CTaskTypes::TASK_SEARCH);
if (pTask && pTask->GetTaskType() == CTaskTypes::TASK_SEARCH)
{
DrawLine(VEC3V_TO_VECTOR3(pPed->GetTransform().GetPosition()),static_cast<CTaskInvestigate*>(pTask)->GetInvestigationPos(),Color_orange);
}
}
#endif // __DEV
DrawPedVisualField(pPed);
}
}
pPed = static_cast<CPed*>(entityIterator.GetNext());
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::DrawPedVisualField
// PURPOSE: (needs moving over to Scaleform)
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::DrawPedVisualField( CPed* pPed )
{
if (pPed)
{
// Get global positions for the peds visual field
Vector3 avPerceptionCone[CPedPerception::VF_Max];
pPed->GetPedIntelligence()->GetPedPerception().GetVisualFieldLines(avPerceptionCone);//, pPed->GetPedIntelligence()->GetPedPerception().GetIdentificationRange());
Vector3 vHead = avPerceptionCone[CPedPerception::VF_HeadPos];
// Work out the line and fill colours
Color32 lineColour = pPed->GetPedIntelligence()->GetAlertnessState() == CPedIntelligence::AS_NotAlert ? Color_DarkGreen : Color_DarkOrange;
if( pPed->GetPedIntelligence()->GetQueriableInterface()->IsTaskCurrentlyRunning(CTaskTypes::TASK_COMBAT))
{
lineColour = Color_red;
}
Color32 fillColour = lineColour;
fillColour.SetAlpha(60);
// Convert the targets into screen coords
Vector3 vLeftEnd = avPerceptionCone[CPedPerception::VF_LeftFocus];
Vector3 vRightEnd = avPerceptionCone[CPedPerception::VF_RightFocus];
// Draw the field onto the hud
if( DrawPoly( vHead, vLeftEnd, vRightEnd, fillColour ) )
{
DrawLine(vHead, vLeftEnd, lineColour);
DrawLine(vHead, vRightEnd, lineColour);
}
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::DrawDeadPed
// PURPOSE: (needs moving over to Scaleform)
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::DrawDeadPed( CPed* pPed )
{
#define DEAD_PED_SIZE (1.0f)
Vector3 vCentre = VEC3V_TO_VECTOR3(pPed->GetTransform().GetPosition());
Vector3 vLineStart1 = Vector3(vCentre.x - DEAD_PED_SIZE, vCentre.y - DEAD_PED_SIZE, vCentre.z);
Vector3 vLineEnd1 = Vector3(vCentre.x + DEAD_PED_SIZE, vCentre.y + DEAD_PED_SIZE, vCentre.z);
Vector3 vLineStart2 = Vector3(vCentre.x + DEAD_PED_SIZE, vCentre.y - DEAD_PED_SIZE, vCentre.z);
Vector3 vLineEnd2 = Vector3(vCentre.x - DEAD_PED_SIZE, vCentre.y + DEAD_PED_SIZE, vCentre.z);
DrawLine(vLineStart1, vLineEnd1, Color_red);
DrawLine(vLineStart2, vLineEnd2, Color_red);
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::ConvertToScreenCoords()
// PURPOSE:
/////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::ConvertToScreenCoords(Vector2& screenCoordsOut, const Vector3& vWorldCoords)
{
if(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND] >= 0)
{
GPointF blipPoint, screenPoint;
blipPoint.x = vWorldCoords.x;
blipPoint.y = -vWorldCoords.y;
GFxMovieView* pView = CScaleformMgr::GetMovieView(ms_iMovieId[MINIMAP_MOVIE_FOREGROUND]);
if(pView && pView->TranslateLocalToScreen(BLIP_LAYER_PATH, blipPoint, &screenPoint))
{
screenCoordsOut.Set(screenPoint.x/SCREEN_WIDTH, screenPoint.y/SCREEN_HEIGHT);
return true;
}
}
return false;
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::DrawLine
// PURPOSE: (needs moving over to Scaleform)
/////////////////////////////////////////////////////////////////////////////////////
void CMiniMap_RenderThread::DrawLine( const Vector3 &vFrom, const Vector3 &vTo, const Color32 DEBUG_DRAW_ONLY(colour) )
{
Vector2 p1, p2;
ConvertToScreenCoords(p1, vFrom);
ConvertToScreenCoords(p2, vTo);
if( ClampInsideLimits(p1, p2) )
{
#if DEBUG_DRAW
grcDebugDraw::Line(p1, p2, colour, colour);
#endif
}
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::DrawPoly
// PURPOSE: (needs moving over to Scaleform)
/////////////////////////////////////////////////////////////////////////////////////
#if DEBUG_DRAW
bool CMiniMap_RenderThread::DrawPoly( const Vector3 &p1, const Vector3 &p2, const Vector3 &p3, const Color32 colour)
#else
bool CMiniMap_RenderThread::DrawPoly( const Vector3 &p1, const Vector3 &p2, const Vector3 &p3, const Color32 UNUSED_PARAM(colour))
#endif
{
s32 iNumValidLines = 0;
Vector2 vEdge1A, vEdge1B, vEdge2B;
ConvertToScreenCoords(vEdge1A, p1);
ConvertToScreenCoords(vEdge1B, p2);
Vector2 vEdge2A = vEdge1B;
ConvertToScreenCoords(vEdge2B, p3);
Vector2 vEdge3A = vEdge2B;
Vector2 vEdge3B = vEdge1A;
if( ClampInsideLimits(vEdge1A, vEdge1B) )
++iNumValidLines;
if( ClampInsideLimits(vEdge2A, vEdge2B) )
++iNumValidLines;
if( ClampInsideLimits(vEdge3A, vEdge3B) )
++iNumValidLines;
if( iNumValidLines == 3 )
{
#if DEBUG_DRAW
grcDebugDraw::Poly(vEdge3B, vEdge1A, vEdge3A, colour, colour, colour);
grcDebugDraw::Poly(vEdge1A, vEdge1B, vEdge3A, colour, colour, colour);
grcDebugDraw::Poly(vEdge1B, vEdge2A, vEdge3A, colour, colour, colour);
grcDebugDraw::Poly(vEdge2A, vEdge2B, vEdge3A, colour, colour, colour);
#endif
return true;
}
return false;
}
/////////////////////////////////////////////////////////////////////////////////////
// NAME: CMiniMap_RenderThread::ClampInsideLimits
// PURPOSE: (needs moving over to Scaleform)
/////////////////////////////////////////////////////////////////////////////////////
bool CMiniMap_RenderThread::ClampInsideLimits(Vector2 &vFrom, Vector2 &vTo)
{
// Transform to "minimap coordinates", ranged -0.5...0.5.
const float mapPosX = ms_MiniMapRenderState.m_vCurrentMiniMapPosition.x;
const float mapPosY = ms_MiniMapRenderState.m_vCurrentMiniMapPosition.y;
const float mapSizeX = ms_MiniMapRenderState.m_vCurrentMiniMapSize.x;
const float mapSizeY = ms_MiniMapRenderState.m_vCurrentMiniMapSize.y;
const float x1 = (vFrom.x - mapPosX)/mapSizeX - 0.5f;
const float y1 = (vFrom.y - mapPosY)/mapSizeY - 0.5f;
const float x2 = (vTo.x - mapPosX)/mapSizeX - 0.5f;
const float y2 = (vTo.y - mapPosY)/mapSizeY - 0.5f;
// Compute the direction of the line segment.
const float dirX = x2 - x1;
const float dirY = y2 - y1;
// Compute the square of the clip radius and the distance to the starting point.
static float s_ClipRadius = 0.43f; // MAGIC! This is MAX_2D_RADAR_DISTANCE in CMiniMap_RenderThread::UpdateIndividualBlip().
const float radiusSq = square(s_ClipRadius);
const float distSq = square(x1) + square(y1);
// Convert to a quadratic equation a*t^2 + b*t + c = 0.
const float a = square(dirX) + square(dirY);
const float b = 2.0f*(dirX*x1 + dirY*y1);
const float c = distSq - radiusSq;
// Make sure we don't divide by zero if it's a degenerate segment.
if(a != 0.0f)
{
// Transform to t^2 + p*t + q = 0 form.
const float p = b/a;
const float q = c/a;
// Check if there is a solution.
const float r2 = p*p - 4*q;
if(r2 > 0.0f)
{
// Yes, the infinite line intersects the circle.
// Compute the roots.
const float r = sqrtf(r2);
const float tt1 = 0.5f*(-p - r);
const float tt2 = 0.5f*(-p + r);
// Check if the relevant line segment part of the infinite line intersects.
if(tt2 >= 0.0f && tt1 <= 1.0f)
{
// Clamp the T values to not go outside the segment.
const float t1 = Clamp(tt1, 0.0f, 1.0f);
const float t2 = Clamp(tt2, 0.0f, 1.0f);
// Compute the clipped positions.
const float clippedx1 = x1 + dirX*t1;
const float clippedy1 = y1 + dirY*t1;
const float clippedx2 = x1 + dirX*t2;
const float clippedy2 = y1 + dirY*t2;
// Transform back to screen coordinates.
vFrom.x = (clippedx1 + 0.5f)*mapSizeX + mapPosX;
vFrom.y = (clippedy1 + 0.5f)*mapSizeY + mapPosY;
vTo.x = (clippedx2 + 0.5f)*mapSizeX + mapPosX;
vTo.y = (clippedy2 + 0.5f)*mapSizeY + mapPosY;
return true;
}
}
}
else if(c < 0.0f)
{
// Both points are in the same spot, but they are inside the circle.
return true;
}
// In this case, no part of the line segment intersects the disc.
return false;
}
#endif // __RENDER_PED_VISUAL_FIELD
Reference in New Issue View Git Blame Copy Permalink