Differential D4779 Diff 20923 ps/trunk/source/gui/ObjectTypes/CMiniMap.cpp

Changeset View

Standalone View

ps/trunk/source/gui/ObjectTypes/CMiniMap.cpp

Show All 17 Lines
#include "precompiled.h"		#include "precompiled.h"

#include "CMiniMap.h"		#include "CMiniMap.h"

#include "graphics/Canvas2D.h"		#include "graphics/Canvas2D.h"
#include "graphics/GameView.h"		#include "graphics/GameView.h"
#include "graphics/MiniMapTexture.h"		#include "graphics/MiniMapTexture.h"
#include "graphics/MiniPatch.h"		#include "graphics/MiniPatch.h"
#include "graphics/ShaderManager.h"
#include "graphics/ShaderProgramPtr.h"
#include "graphics/Terrain.h"		#include "graphics/Terrain.h"
#include "graphics/TerrainTextureEntry.h"		#include "graphics/TerrainTextureEntry.h"
#include "graphics/TerrainTextureManager.h"		#include "graphics/TerrainTextureManager.h"
#include "graphics/TextureManager.h"		#include "graphics/TextureManager.h"
#include "gui/CGUI.h"		#include "gui/CGUI.h"
#include "gui/GUIManager.h"		#include "gui/GUIManager.h"
#include "gui/GUIMatrix.h"
#include "lib/bits.h"		#include "lib/bits.h"
#include "lib/external_libraries/libsdl.h"		#include "lib/external_libraries/libsdl.h"
#include "lib/timer.h"		#include "lib/timer.h"
#include "maths/MathUtil.h"		#include "maths/MathUtil.h"
#include "ps/CLogger.h"		#include "ps/CLogger.h"
#include "ps/ConfigDB.h"		#include "ps/ConfigDB.h"
#include "ps/CStrInternStatic.h"
#include "ps/Filesystem.h"		#include "ps/Filesystem.h"
#include "ps/Game.h"		#include "ps/Game.h"
#include "ps/GameSetup/Config.h"		#include "ps/GameSetup/Config.h"
#include "ps/Profile.h"		#include "ps/Profile.h"
#include "ps/World.h"		#include "ps/World.h"
#include "renderer/Renderer.h"		#include "renderer/Renderer.h"
#include "renderer/RenderingOptions.h"
#include "renderer/SceneRenderer.h"		#include "renderer/SceneRenderer.h"
#include "renderer/WaterManager.h"		#include "renderer/WaterManager.h"
#include "scriptinterface/Object.h"		#include "scriptinterface/Object.h"
#include "simulation2/Simulation2.h"		#include "simulation2/Simulation2.h"
#include "simulation2/components/ICmpMinimap.h"		#include "simulation2/components/ICmpMinimap.h"
#include "simulation2/components/ICmpRangeManager.h"		#include "simulation2/components/ICmpRangeManager.h"
#include "simulation2/helpers/Los.h"		#include "simulation2/helpers/Los.h"
#include "simulation2/system/ParamNode.h"		#include "simulation2/system/ParamNode.h"
Show All 31 Lines	for (size_t idx = 0; idx < points.size(); ++idx)

lines->emplace_back(		lines->emplace_back(
direction.Dot(currentPoint) > direction.Dot(intersectionA) ? currentPoint : intersectionA);		direction.Dot(currentPoint) > direction.Dot(intersectionA) ? currentPoint : intersectionA);
lines->emplace_back(		lines->emplace_back(
direction.Dot(nextPoint) < direction.Dot(intersectionB) ? nextPoint : intersectionB);		direction.Dot(nextPoint) < direction.Dot(intersectionB) ? nextPoint : intersectionB);
}		}
}		}

void DrawTexture(
Renderer::Backend::IDeviceCommandContext* deviceCommandContext,
float angle, float x, float y, float x2, float y2, float mapScale)
{
// Rotate the texture coordinates (0,0)-(coordMax,coordMax) around their center point (m,m)
// Scale square maps to fit in circular minimap area
const float s = sin(angle) * mapScale;
const float c = cos(angle) * mapScale;
const float m = 0.5f;

float quadTex[] =
{
m(-c + s + 1.f), m(-c + -s + 1.f),
m(c + s + 1.f), m(-c + s + 1.f),
m(c + -s + 1.f), m(c + s + 1.f),

m(c + -s + 1.f), m(c + s + 1.f),
m(-c + -s + 1.f), m(c + -s + 1.f),
m(-c + s + 1.f), m(-c + -s + 1.f)
};
float quadVerts[] =
{
x, y, 0.0f,
x2, y, 0.0f,
x2, y2, 0.0f,

x2, y2, 0.0f,
x, y2, 0.0f,
x, y, 0.0f
};

deviceCommandContext->SetVertexAttributeFormat(
Renderer::Backend::VertexAttributeStream::POSITION,
Renderer::Backend::Format::R32G32B32_SFLOAT, 0, 0,
Renderer::Backend::VertexAttributeRate::PER_VERTEX, 0);
deviceCommandContext->SetVertexAttributeFormat(
Renderer::Backend::VertexAttributeStream::UV0,
Renderer::Backend::Format::R32G32_SFLOAT, 0, 0,
Renderer::Backend::VertexAttributeRate::PER_VERTEX, 1);

deviceCommandContext->SetVertexBufferData(
0, quadVerts, std::size(quadVerts) * sizeof(quadVerts[0]));
deviceCommandContext->SetVertexBufferData(
1, quadTex, std::size(quadTex) * sizeof(quadTex[0]));

deviceCommandContext->Draw(0, 6);
}

} // anonymous namespace		} // anonymous namespace

const CStr CMiniMap::EventNameWorldClick = "WorldClick";		const CStr CMiniMap::EventNameWorldClick = "WorldClick";

CMiniMap::CMiniMap(CGUI& pGUI) :		CMiniMap::CMiniMap(CGUI& pGUI) :
IGUIObject(pGUI),		IGUIObject(pGUI),
m_MapSize(0), m_MapScale(1.f), m_Mask(this, "mask", false),		m_MapSize(0), m_MapScale(1.f), m_Mask(this, "mask", false),
m_FlareTextureCount(this, "flare_texture_count", 0), m_FlareRenderSize(this, "flare_render_size", 0),		m_FlareTextureCount(this, "flare_texture_count", 0), m_FlareRenderSize(this, "flare_render_size", 0),
▲ Show 20 Lines • Show All 245 Lines • ▼ Show 20 Lines	void CMiniMap::Draw(CCanvas2D& canvas)
// The terrain isn't actually initialized until the map is loaded, which		// The terrain isn't actually initialized until the map is loaded, which
// happens when the game is started, so abort until then.		// happens when the game is started, so abort until then.
if (!g_Game \|\| !g_Game->IsGameStarted())		if (!g_Game \|\| !g_Game->IsGameStarted())
return;		return;

if (!m_Mask)		if (!m_Mask)
canvas.DrawRect(m_CachedActualSize, CColor(0.0f, 0.0f, 0.0f, 1.0f));		canvas.DrawRect(m_CachedActualSize, CColor(0.0f, 0.0f, 0.0f, 1.0f));

canvas.Flush();

CSimulation2* sim = g_Game->GetSimulation2();		CSimulation2* sim = g_Game->GetSimulation2();
CmpPtr<ICmpRangeManager> cmpRangeManager(*sim, SYSTEM_ENTITY);		CmpPtr<ICmpRangeManager> cmpRangeManager(*sim, SYSTEM_ENTITY);
ENSURE(cmpRangeManager);		ENSURE(cmpRangeManager);

// Set our globals in case they hadn't been set before		// Set our globals in case they hadn't been set before
const CTerrain* terrain = g_Game->GetWorld()->GetTerrain();		const CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
m_MapSize = terrain->GetVerticesPerSide();		m_MapSize = terrain->GetVerticesPerSide();
m_MapScale = (cmpRangeManager->GetLosCircular() ? 1.f : 1.414f);		m_MapScale = (cmpRangeManager->GetLosCircular() ? 1.f : 1.414f);

// Draw the main textured quad		// Draw the main textured quad
CMiniMapTexture& miniMapTexture = g_Game->GetView()->GetMiniMapTexture();		CMiniMapTexture& miniMapTexture = g_Game->GetView()->GetMiniMapTexture();
if (miniMapTexture.GetTexture())		if (miniMapTexture.GetTexture())
{		{
CShaderDefines baseDefines;		const CVector2D center = m_CachedActualSize.CenterPoint();
baseDefines.Add(str_MINIMAP_BASE, str_1);		const CRect source(
		0, miniMapTexture.GetTexture()->GetHeight(),
CShaderTechniquePtr tech = g_Renderer.GetShaderManager().LoadEffect(str_minimap, baseDefines);		miniMapTexture.GetTexture()->GetWidth(), 0);
Renderer::Backend::GraphicsPipelineStateDesc pipelineStateDesc =		const CSize2D size(m_CachedActualSize.GetSize() / m_MapScale);
tech->GetGraphicsPipelineStateDesc();		const CRect destination(center - size / 2.0f, size);
pipelineStateDesc.blendState.enabled = true;		canvas.DrawRotatedTexture(
pipelineStateDesc.blendState.srcColorBlendFactor = pipelineStateDesc.blendState.srcAlphaBlendFactor =		miniMapTexture.GetTexture(), destination, source,
Renderer::Backend::BlendFactor::SRC_ALPHA;		CColor(1.0f, 1.0f, 1.0f, 1.0f), CColor(0.0f, 0.0f, 0.0f, 0.0f), 0.0f,
pipelineStateDesc.blendState.dstColorBlendFactor = pipelineStateDesc.blendState.dstAlphaBlendFactor =		center, GetAngle());
Renderer::Backend::BlendFactor::ONE_MINUS_SRC_ALPHA;
pipelineStateDesc.blendState.colorBlendOp = pipelineStateDesc.blendState.alphaBlendOp =
Renderer::Backend::BlendOp::ADD;
Renderer::Backend::IDeviceCommandContext* deviceCommandContext =
g_Renderer.GetDeviceCommandContext();
deviceCommandContext->SetGraphicsPipelineState(pipelineStateDesc);
deviceCommandContext->BeginPass();

Renderer::Backend::IShaderProgram* shader = tech->GetShader();

deviceCommandContext->SetTexture(
shader->GetBindingSlot(str_baseTex), miniMapTexture.GetTexture());

const CMatrix3D baseTransform = GetDefaultGuiMatrix();
CMatrix3D baseTextureTransform;
baseTextureTransform.SetIdentity();

deviceCommandContext->SetUniform(
shader->GetBindingSlot(str_transform), baseTransform.AsFloatArray());
deviceCommandContext->SetUniform(
shader->GetBindingSlot(str_textureTransform), baseTextureTransform.AsFloatArray());

const float x = m_CachedActualSize.left, y = m_CachedActualSize.bottom;
const float x2 = m_CachedActualSize.right, y2 = m_CachedActualSize.top;
const float angle = GetAngle();
DrawTexture(deviceCommandContext, angle, x, y, x2, y2, m_MapScale);

deviceCommandContext->EndPass();
}		}

for (const CMiniMapTexture::Icon& icon : miniMapTexture.GetIcons())		for (const CMiniMapTexture::Icon& icon : miniMapTexture.GetIcons())
{		{
const CVector2D center = WorldSpaceToMiniMapSpace(		const CVector2D center = WorldSpaceToMiniMapSpace(
CVector3D(icon.worldPosition.X, 0.0f, icon.worldPosition.Y));		CVector3D(icon.worldPosition.X, 0.0f, icon.worldPosition.Y));
const CRect destination(		const CRect destination(
center.X - icon.halfSize, center.Y - icon.halfSize,		center.X - icon.halfSize, center.Y - icon.halfSize,
Show All 32 Lines