private void MyEntities_OnEntityCreate(MyEntity entity)
{
var powerEntity = entity as IMyPowerProducer;
if (powerEntity == null)
{
return;
}
if (gridHudParams.ContainsKey(powerEntity.CubeGrid.EntityId) == false)
{
var hudParams = new MyHudEntityParams(new StringBuilder("test"), powerEntity.OwnerId, MyHudIndicatorFlagsEnum.SHOW_ALL);
hudParams.Share = MyOwnershipShareModeEnum.All;
hudParams.Position = powerEntity.CubeGrid.GetPosition();
MyHud.LocationMarkers.RegisterMarker(powerEntity.CubeGrid.EntityId, hudParams);
}
else
{
//do more stuff
}
//test.Add(powerEntity.CubeGrid.EntityId, 0f);
//MyDataBroadcaster broadcast = new MyDataBroadcaster();
//broadcast.
}
public virtual unsafe void AddHudMarker()
{
MyHudEntityParams *paramsPtr1;
MyHudEntityParams hudParams = new MyHudEntityParams {
FlagsEnum = MyHudIndicatorFlagsEnum.SHOW_TEXT
};
paramsPtr1.Text = (this.m_definition.DisplayNameEnum != null) ? MyTexts.Get(this.m_definition.DisplayNameEnum.Value) : new StringBuilder();
paramsPtr1 = (MyHudEntityParams *)ref hudParams;
hudParams.Owner = 0L;
MyHud.LocationMarkers.RegisterMarker(this, hudParams);
}
public MyGuiScreenHudSpace()
: base()
{
RecreateControls(true);
m_markerRender = new MyHudMarkerRender(this);
m_oreHudMarkerStyle = m_markerRender.AllocateMarkerStyle(MyFontEnum.White, MyHudTexturesEnum.DirectionIndicator, MyHudTexturesEnum.Target_neutral, Color.White);
m_gpsHudMarkerStyle = m_markerRender.AllocateMarkerStyle(MyFontEnum.DarkBlue, MyHudTexturesEnum.DirectionIndicator, MyHudTexturesEnum.Target_me, MyHudConstants.GPS_COLOR);
m_buttonPanelHudMarkerStyle = m_markerRender.AllocateMarkerStyle(MyFontEnum.DarkBlue, MyHudTexturesEnum.DirectionIndicator, MyHudTexturesEnum.Target_me, MyHudConstants.GPS_COLOR);
m_tmpHudEntityParams = new MyHudEntityParams()
{
Text = new StringBuilder(),
FlagsEnum = MyHudIndicatorFlagsEnum.SHOW_ALL,
IconColor = MyHudConstants.GPS_COLOR,
OffsetText = true
};
Static = this;
}
private void UpdateHUD(MySmallShip friend, bool isFriend)
{
MyHudEntityParams?gettedHudParams = MyHud.GetHudParams(friend);
if (gettedHudParams != null)
{
MyHudEntityParams hudParams = gettedHudParams.Value;
if (isFriend)
{
hudParams.FlagsEnum &= ~MyHudIndicatorFlagsEnum.ALPHA_CORRECTION_BY_DISTANCE;
hudParams.FlagsEnum &= ~MyHudIndicatorFlagsEnum.SHOW_ONLY_IF_DETECTED_BY_RADAR;
hudParams.MaxDistance = 0f;
}
else
{
hudParams.FlagsEnum |= MyHudIndicatorFlagsEnum.ALPHA_CORRECTION_BY_DISTANCE;
hudParams.FlagsEnum |= MyHudIndicatorFlagsEnum.SHOW_ONLY_IF_DETECTED_BY_RADAR;
hudParams.MaxDistance = 10000f;
}
MyHud.ChangeText(friend, hudParams.Text, hudParams.TargetMode, hudParams.MaxDistance, hudParams.FlagsEnum, hudParams.DisplayFactionRelation, maxDistanceMultiplerType: hudParams.MaxDistanceMultiplerType);
}
}
private unsafe void MyBeacon_IsWorkingChanged(MyCubeBlock obj)
{
if (this.RadioBroadcaster != null)
{
this.RadioBroadcaster.Enabled = base.IsWorking;
}
if (!MyFakes.ENABLE_RADIO_HUD)
{
if (base.IsWorking)
{
MyHudEntityParams *paramsPtr1;
MyHudEntityParams hudParams = new MyHudEntityParams {
FlagsEnum = ~MyHudIndicatorFlagsEnum.NONE
};
paramsPtr1.Text = (this.HudText.Length > 0) ? this.HudText : base.CustomName;
paramsPtr1 = (MyHudEntityParams *)ref hudParams;
MyHud.LocationMarkers.RegisterMarker(this, hudParams);
}
else
{
MyHud.LocationMarkers.UnregisterMarker(this);
}
}
}
/// <summary>
/// Draws location marker on screen.
/// </summary>
public void DrawLocationMarker(int styleHandle, Vector3D position, MyHudEntityParams hudParams, float targetDamageRatio, float targetArmorRatio, float alphaMultiplifier = 1f)
{
if (MySession.ControlledEntity == null)
{
return;
}
// Transform point to camera space, so Z = -1 is always forward and then do projective transformation
Vector3D transformedPoint = Vector3D.Transform(position, MySector.MainCamera.ViewMatrix);
Vector4D projectedPoint = Vector4D.Transform(transformedPoint, MySector.MainCamera.ProjectionMatrix);
// If point is behind camera we swap X and Y (this is mirror-like transformation)
if (transformedPoint.Z > 0)
{
projectedPoint.X *= -1;
projectedPoint.Y *= -1;
}
if (projectedPoint.W == 0)
{
return;
}
MyMarkerStyle markerStyle = m_markerStyles[styleHandle];
double distance = Vector3D.Distance(position, MySession.ControlledEntity.Entity.WorldMatrix.Translation);
float maxDistance = hudParams.MaxDistance;
byte colorAlphaInByte = 255;
var hudColor = MyFakes.SHOW_FACTIONS_GUI ? markerStyle.Color : Color.White;
hudColor.A = (byte)(colorAlphaInByte * alphaMultiplifier);
// Calculate centered coordinates in range <0..1>
Vector2 projectedPoint2D = new Vector2((float)(projectedPoint.X / projectedPoint.W / 2.0f) + 0.5f, (float)(-projectedPoint.Y / projectedPoint.W) / 2.0f + 0.5f);
if (MyVideoSettingsManager.IsTripleHead())
{
projectedPoint2D.X = (projectedPoint2D.X - (1.0f / 3.0f)) / (1.0f / 3.0f);
}
float objectNameYOffset = 0.0f; //offset to direction indicator
// This will bound the rectangle in circle, although it isn't real circle because we work in [1,1] dimensions,
// but number of horizontal pixels is bigger, so at the end it's more elypse
// It must be done when point is out of circle or behind the camera
Vector2 direction = projectedPoint2D - MyHudConstants.DIRECTION_INDICATOR_SCREEN_CENTER;
if ((direction.Length() > MyHudConstants.DIRECTION_INDICATOR_MAX_SCREEN_DISTANCE) || (transformedPoint.Z > 0))
{
if ((hudParams.FlagsEnum & MyHudIndicatorFlagsEnum.SHOW_BORDER_INDICATORS) == 0)
{
return;
}
if (direction.LengthSquared() > MyMathConstants.EPSILON_SQUARED)
{
direction.Normalize();
}
else
{
direction = new Vector2(1f, 0f);
}
projectedPoint2D = MyHudConstants.DIRECTION_INDICATOR_SCREEN_CENTER + direction * MyHudConstants.DIRECTION_INDICATOR_MAX_SCREEN_DISTANCE;
// Fix vertical scale
projectedPoint2D.Y *= MyGuiManager.GetHudSize().Y;
AddTexturedQuad(markerStyle.TextureDirectionIndicator, projectedPoint2D + direction * MyHudConstants.HUD_DIRECTION_INDICATOR_SIZE * 2.5f, direction,
hudColor, MyHudConstants.HUD_DIRECTION_INDICATOR_SIZE * 1.2f, MyHudConstants.HUD_DIRECTION_INDICATOR_SIZE * 0.8f);
}
else
{
// Fix vertical scale
projectedPoint2D.Y *= MyGuiManager.GetHudSize().Y;
Color rectangleColor = Color.White;
rectangleColor.A = colorAlphaInByte;
if ((hudParams.FlagsEnum & MyHudIndicatorFlagsEnum.SHOW_FOCUS_MARK) > 0)
{
Vector2 upVector = new Vector2(0, -1);
if (markerStyle.TextureTargetRotationSpeed != 0)
{
upVector = new Vector2((float)Math.Cos(MySandboxGame.TotalGamePlayTimeInMilliseconds / 1000f * markerStyle.TextureTargetRotationSpeed * MathHelper.Pi),
(float)Math.Sin(MySandboxGame.TotalGamePlayTimeInMilliseconds / 1000f * markerStyle.TextureTargetRotationSpeed * MathHelper.Pi));
}
AddTexturedQuad(markerStyle.TextureTarget, projectedPoint2D, upVector, hudColor, MyHudConstants.HUD_DIRECTION_INDICATOR_SIZE * markerStyle.TextureTargetScale, MyHudConstants.HUD_DIRECTION_INDICATOR_SIZE * markerStyle.TextureTargetScale);
}
objectNameYOffset = -MyHudConstants.HUD_TEXTS_OFFSET;
}
if (hudParams.Text != null && hudParams.Text.Length > 0 && (hudParams.FlagsEnum & MyHudIndicatorFlagsEnum.SHOW_TEXT) != 0)
{
// Add object's name
MyHudText objectName = m_hudScreen.AllocateText();
if (objectName != null)
{
objectName.Start(markerStyle.Font, projectedPoint2D + new Vector2(0, hudParams.OffsetText ? objectNameYOffset : 0),
hudColor, 0.8f, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER);
objectName.Append(hudParams.Text);
}
}
// display hud icon
if (hudParams.Icon != null && (hudParams.FlagsEnum & MyHudIndicatorFlagsEnum.SHOW_ICON) != 0)
{
Color iconColor = hudParams.IconColor.HasValue && MyFakes.SHOW_FACTIONS_GUI ? hudParams.IconColor.Value : Color.White;
iconColor.A = (byte)(colorAlphaInByte * alphaMultiplifier);
AddTexturedQuad(hudParams.Icon.Value, projectedPoint2D + hudParams.IconOffset, new Vector2(0, -1), iconColor, hudParams.IconSize.X / 2f, hudParams.IconSize.Y / 2f);
}
if (MyFakes.SHOW_HUD_DISTANCES && (hudParams.FlagsEnum & MyHudIndicatorFlagsEnum.SHOW_DISTANCE) != 0)
{
// Add distance to object
MyHudText objectDistance = m_hudScreen.AllocateText();
if (objectDistance != null)
{
objectDistance.Start(markerStyle.Font, projectedPoint2D + new Vector2(0, MyHudConstants.HUD_TEXTS_OFFSET),
hudColor, 0.8f, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER);
// Create string builder with distance in metres, e.g. "123m"
objectDistance.AppendInt32((int)Math.Round(distance));
objectDistance.Append("m");
}
}
}
internal void RegisterMarker(MyEntity entity, MyHudEntityParams hudParams)
{
m_markerEntities[entity] = hudParams;
m_blinkingTimes[entity] = hudParams.BlinkingTime;
}
private void DrawOreMarkers(MyHudOreMarkers oreMarkers)
{
ProfilerShort.Begin("MyGuiScreenHud.DrawOreMarkers");
if (m_nearestOreDeposits == null || m_nearestOreDeposits.Length < MyDefinitionManager.Static.VoxelMaterialCount)
{
m_nearestOreDeposits = new OreDepositMarker[MyDefinitionManager.Static.VoxelMaterialCount];
m_nearestDistanceSquared = new float[m_nearestOreDeposits.Length];
}
for (int i = 0; i < m_nearestOreDeposits.Length; i++)
{
m_nearestOreDeposits[i] = default(OreDepositMarker);
m_nearestDistanceSquared[i] = float.MaxValue;
}
foreach (var oreMarker in oreMarkers)
{
bool debugBoxDrawn = false;
foreach (var depositData in oreMarker.Materials)
{
var oreMaterial = depositData.Material;
Vector3D oreWorldPosition;
depositData.ComputeWorldPosition(oreMarker.VoxelMap, out oreWorldPosition);
float distanceSquared = float.MaxValue;
if (MySession.Static != null && MySession.Static.ControlledEntity != null)
{
distanceSquared = Vector3.DistanceSquared((Vector3)oreWorldPosition, (Vector3)((MyEntity)MySession.Static.ControlledEntity).WorldMatrix.Translation);
}
float nearestDistanceSquared = m_nearestDistanceSquared[oreMaterial.Index];
if (distanceSquared < nearestDistanceSquared)
{
m_nearestOreDeposits[oreMaterial.Index] = MyTuple.Create(oreWorldPosition, oreMarker);
m_nearestDistanceSquared[oreMaterial.Index] = distanceSquared;
}
if (false && !debugBoxDrawn)
{
const int shift = MyOreDetectorComponent.CELL_SIZE_IN_VOXELS_BITS + MyOreDetectorComponent.QUERY_LOD;
var worldPosition = oreWorldPosition;
Vector3I cellCoord;
MyVoxelCoordSystems.WorldPositionToVoxelCoord(oreMarker.VoxelMap.PositionLeftBottomCorner, ref worldPosition, out cellCoord);
cellCoord >>= shift;
worldPosition = cellCoord * MyOreDetectorComponent.CELL_SIZE_IN_METERS + MyVoxelConstants.VOXEL_SIZE_IN_METRES_HALF;
worldPosition += oreMarker.VoxelMap.PositionLeftBottomCorner;
var bbox = new BoundingBoxD(worldPosition, worldPosition + MyOreDetectorComponent.CELL_SIZE_IN_METERS);
VRageRender.MyRenderProxy.DebugDrawAABB(bbox, Vector3.One, 1f, 1f, false);
debugBoxDrawn = true;
}
}
}
for (int i = 0; i < m_nearestOreDeposits.Length; i++)
{
var nearestOreDeposit = m_nearestOreDeposits[i];
if (nearestOreDeposit.Item2 == null ||
nearestOreDeposit.Item2.VoxelMap == null ||
nearestOreDeposit.Item2.VoxelMap.Closed)
continue;
MyVoxelMaterialDefinition voxelMaterial = MyDefinitionManager.Static.GetVoxelMaterialDefinition((byte)i);
string oreSubtype = voxelMaterial.MinedOre;
var hudParams = new MyHudEntityParams()
{
FlagsEnum = MyHudIndicatorFlagsEnum.SHOW_ALL,
Text = new StringBuilder(oreSubtype),
OffsetText = true,
Icon = MyHudTexturesEnum.HudOre,
IconSize = new Vector2(0.02f, 0.02f)
};
m_markerRender.DrawLocationMarker(
m_oreHudMarkerStyle,
nearestOreDeposit.Item1,
hudParams,
0, 0);
}
DrawTexts();
ProfilerShort.End();
}
internal void RegisterMarker(MyEntity target, MyHudEntityParams hudParams)
{
m_markers[target] = hudParams;
}
public void RegisterMarker(MyEntity entity, MyHudEntityParams hudParams)
{
if (hudParams.Entity == null)
hudParams.Entity = entity;
m_markerEntities[entity] = hudParams;
}
private static void Add3DCueToUpdateList(IMy3DSoundEmitter source, MySoundCuesEnum cueEnum)
{
m_3Dsounds.Add(source);
MyHudEntityParams hudEntityParams = new MyHudEntityParams()
{
FlagsEnum = MyHudIndicatorFlagsEnum.SHOW_ALL,
Text = new StringBuilder(cueEnum.ToString()),
};
if (MyFakes.DEBUG_DRAW_AUDIO)
MyHud.LocationMarkers.RegisterMarker(m_3Dsounds[m_3Dsounds.Count - 1].Entity, hudEntityParams);
}
