public void transform()
{
CCApplication application = CCApplication.sharedApplication();
if (this.m_bIsTransformGLDirty)
{
TransformUtils.CGAffineToGL(this.nodeToParentTransform(), ref this.m_pTransformGL);
this.m_bIsTransformGLDirty = false;
}
this.m_tCCNodeTransform = TransformUtils.CGAffineToMatrix(this.m_pTransformGL);
if (this.m_fVertexZ > 0f)
{
this.m_tCCNodeTransform *= Matrix.CreateRotationZ(this.m_fVertexZ);
}
if ((this.m_pCamera != null) && ((this.m_pGrid == null) || !this.m_pGrid.Active))
{
if (this.m_tAnchorPointInPixels.x == 0f)
{
float y = this.m_tAnchorPointInPixels.y;
}
Matrix?nullable = this.m_pCamera.locate();
if (nullable.HasValue)
{
this.m_tCCNodeTransform = ((Matrix.CreateTranslation(-this.m_tAnchorPointInPixels.x, -this.m_tAnchorPointInPixels.y, 0f) * nullable.Value) * Matrix.CreateTranslation(this.m_tAnchorPointInPixels.x, this.m_tAnchorPointInPixels.y, 0f)) * this.m_tCCNodeTransform;
}
}
application.basicEffect.World = this.m_tCCNodeTransform * application.basicEffect.World;
}
internal void UpdateRenderEntitiesData(ref MatrixD worldMatrixD, bool useTransparency, float transparency)
{
int model = this.Model;
bool flag = this.RenderObjectId != uint.MaxValue;
if (this.InstanceCount <= 0)
{
if (flag)
{
this.UnloadRenderObjects();
}
}
else
{
RenderFlags flags = RenderFlags.Visible | RenderFlags.CastShadows;
if (!flag)
{
string byId = MyModel.GetById(model);
this.RenderObjectId = MyRenderProxy.CreateRenderEntity("Instance parts, part: " + model, byId, this.Parent.SectorMatrix, MyMeshDrawTechnique.MESH, flags, CullingOptions.Default, Vector3.One, Vector3.Zero, useTransparency ? transparency : 0f, this.MaxViewDistance, 0, 1f, true);
}
MyRenderProxy.SetInstanceBuffer(this.RenderObjectId, this.InstanceBuffer, 0, this.InstanceData.Count, this.Parent.SectorBox, null);
MyRenderProxy.UpdateRenderEntity(this.RenderObjectId, new Color?(Vector3.One), new Vector3?(Vector3.Zero), new float?(useTransparency ? transparency : 0f), true);
MatrixD sectorMatrix = this.Parent.SectorMatrix;
BoundingBox?aabb = null;
Matrix? localMatrix = null;
MyRenderProxy.UpdateRenderObject(this.RenderObjectId, new MatrixD?(sectorMatrix), aabb, -1, localMatrix);
}
}
public ScreenEngine(GameEngine game, string fileName)
{
this.game = game;
this.Content = new ContentManager(game.Services, GameEngine.ContentRootDirectory);
this.FileName = fileName;
this.CurrentEvents = new Dictionary <string, bool>();
this.tapAreas = new List <XTapArea>();
this.obstacles = new List <XElement>();
this.spriteBatch = new SpriteBatchWithFloats(this.game.GraphicsDevice);
if (this.game.Scale != Vector3.One)
{
scaleMatrix = Matrix.CreateScale(this.game.Scale);
}
this.initializeParameters = new InitializeParameters()
{
Game = game, ScreenEngine = this
};
this.updateParameters = new UpdateParameters()
{
Game = game, ScreenEngine = this
};
this.drawParameters = new DrawParameters()
{
Game = game, ScreenEngine = this, SpriteBatch = spriteBatch
};
}
//public static Dictionary<VertexElementUsage, int> vertexChannelSize = new Dictionary<VertexElementUsage, int>()
//{
// { VertexElementUsage.Position, 3 }
// { VertexElementUsage., 3 }
//};
/// <summary>
/// transform = null: apply ParentBone.Transform and set it to identity
/// </summary>
public static void ApplyTransform(Model model, Matrix?transform = null)
{
foreach (ModelMesh mesh in model.Meshes)
{
ApplyTransform(mesh, transform);
}
}
/// <summary>
/// Begins a new sprite and text batch with the specified render state.
/// </summary>
/// <param name="sortMode">The drawing order for sprite and text drawing. <see cref="SpriteSortMode.Deferred"/> by default.</param>
/// <param name="blendState">State of the blending. Uses <see cref="BlendState.AlphaBlend"/> if null.</param>
/// <param name="samplerState">State of the sampler. Uses <see cref="SamplerState.LinearClamp"/> if null.</param>
/// <param name="depthStencilState">State of the depth-stencil buffer. Uses <see cref="DepthStencilState.None"/> if null.</param>
/// <param name="rasterizerState">State of the rasterization. Uses <see cref="RasterizerState.CullCounterClockwise"/> if null.</param>
/// <param name="effect">A custom <see cref="Effect"/> to override the default sprite effect. Uses default sprite effect if null.</param>
/// <param name="transformMatrix">An optional matrix used to transform the sprite geometry. Uses <see cref="Matrix.Identity"/> if null.</param>
/// <exception cref="InvalidOperationException">Thrown if <see cref="Begin"/> is called next time without previous <see cref="End"/>.</exception>
/// <remarks>This method uses optional parameters.</remarks>
/// <remarks>The <see cref="Begin"/> Begin should be called before drawing commands, and you cannot call it again before subsequent <see cref="End"/>.</remarks>
public void Begin
(
SpriteSortMode sortMode = SpriteSortMode.Deferred,
BlendState blendState = null,
SamplerState samplerState = null,
DepthStencilState depthStencilState = null,
RasterizerState rasterizerState = null,
Effect effect = null,
Matrix?transformMatrix = null
)
{
if (_beginCalled)
{
throw new InvalidOperationException("Begin cannot be called again until End has been successfully called.");
}
// defaults
_sortMode = sortMode;
_blendState = blendState ?? BlendState.AlphaBlend;
_samplerState = samplerState ?? SamplerState.LinearClamp;
_depthStencilState = depthStencilState ?? DepthStencilState.None;
_rasterizerState = rasterizerState ?? RasterizerState.CullCounterClockwise;
_effect = effect;
_matrix = transformMatrix ?? Matrix.Identity;
// Setup things now so a user can change them.
if (sortMode == SpriteSortMode.Immediate)
{
Setup();
}
_beginCalled = true;
}
public IEnumerable <SceneObject> BuildDoodads(IEnumerable <IModelDefinition> definitions, IList <StringReference> references,
RectangleF bounds, Matrix?rootTransform = null)
{
foreach (var definition in definitions)
{
if (definition.Id != null && !_builtIds.Add(definition.Id.Value))
{
continue;
}
var doodad = Files.GetDoodad(definition.GetModelReference(references));
if (doodad.Triangles.Length == 0)
{
continue;
}
var transform = definition.GetTranform();
if (rootTransform.HasValue)
{
transform = transform * rootTransform.Value;
}
var sceneObject = BuildModelFromTransform(doodad.Vertices, doodad.Triangles, transform, definition.GetModelReference(references));
if (bounds.Intersects(sceneObject.Bounds))
{
yield return(sceneObject);
}
}
}
public void Begin(
BlendState blendState = null,
SamplerState samplerState = null,
DepthStencilState depthStencilState = null,
RasterizerState rasterizerState = null,
Effect effect = null,
Matrix?viewMatrix = null)
{
CheckAfterDraw();
var projectionMatrix = Matrix
.CreateOrthographicOffCenter(
new Rectangle(Point.Zero, Runner.Application.ActualSize),
-1000f, 1000f);
_graphicsDevice.BlendState = blendState ?? BlendState.AlphaBlend;
_graphicsDevice.SamplerStates[0] = samplerState ?? SamplerState.PointClamp;
_graphicsDevice.RasterizerState = rasterizerState ?? RasterizerState.CullNone;
_graphicsDevice.DepthStencilState = depthStencilState ?? DepthStencilState.None;
_effect = effect ?? _basicEffect;
if (_effect is IEffectMatrices)
{
var effectMatrices = _effect as IEffectMatrices;
effectMatrices.Projection = projectionMatrix;
effectMatrices.View = viewMatrix ?? Matrix.Identity;
}
_hasBegun = true;
}
static public IEnumerable <Vector2> GetEllipseOutlinePoints(Vector2 center, float width, float height, float rotation, float angleStart, float angleSize, int sampling)
{
rotation = MathHelper.WrapAngle(rotation);
angleStart = MathHelper.WrapAngle(angleStart);
bool completed = angleSize >= MathHelper.TwoPi;
Matrix?rotationMatrix = null;
if (!rotation.EqualsZero())
{
rotationMatrix = Matrix.CreateFromAxisAngle(Vector3.Backward, rotation);
}
int stepCount = GetEllipseOutlinePointsCount(angleSize, sampling);
float stepSize = angleSize / (!completed ? stepCount - 1 : stepCount);
for (int i = 0; i < stepCount; i++)
{
float step = angleStart + i * stepSize;
var vertex = new Vector2((float)System.Math.Cos(step) * width, (float)System.Math.Sin(step) * height);
if (rotationMatrix.HasValue)
{
vertex = Vector2.Transform(vertex, rotationMatrix.Value);
}
yield return(center + vertex);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TriangleMeshObject"/> class.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="pos">The pos.</param>
/// <param name="rotation">The rotation.</param>
/// <param name="scale">The scale.</param>
/// <param name="materialDescription">The material description.</param>
public TriangleMeshObject(IModelo model, Vector3 pos, Matrix?rotation = null, Vector3?scale = null, MaterialDescription materialDescription = null)
{
if (materialDescription == null)
{
materialDescription = MaterialDescription.DefaultBepuMaterial();
}
if (!rotation.HasValue)
{
rotation = Matrix.Identity;
}
if (!scale.HasValue)
{
scale = Vector3.One;
}
System.Diagnostics.Debug.Assert(model != null);
System.Diagnostics.Debug.Assert(scale != Vector3.Zero);
this.rotation = rotation.Value;
this.scale = scale.Value;
this.position = pos;
Vector3[] vertices = null;
int[] indices = null;
ExtractData(ref vertices, ref indices, model);
triangleGroup = new StaticMesh(vertices, indices, new AffineTransform(scale.Value, Quaternion.CreateFromRotationMatrix(rotation.Value), position));
faceVector = Vector3.Transform(Vector3.Forward, triangleGroup.WorldTransform.Matrix);
triangleGroup.Material = new BEPUphysics.Materials.Material(materialDescription.StaticFriction, materialDescription.DynamicFriction, materialDescription.Bounciness);
}
public static Matrix GetBaseEnemyFleetTrans(
App app,
List <ShipInfo> shipIDs,
int systemID)
{
bool flag = false;
Matrix matrix = Matrix.Identity;
if (shipIDs.Count > 0)
{
int index = Math.Abs(App.GetSafeRandom().Next()) % shipIDs.Count;
Matrix?shipSystemPosition = app.GameDatabase.GetShipSystemPosition(shipIDs[index].ID);
if (shipSystemPosition.HasValue)
{
matrix = shipSystemPosition.Value;
flag = true;
}
}
if (!flag)
{
int encounterOrbitalId = app.GameDatabase.GetEncounterOrbitalId(EasterEgg.EE_ASTEROID_MONITOR, systemID);
float length = app.GameDatabase.GetOrbitalTransform(encounterOrbitalId).Position.Length;
matrix = Matrix.CreateRotationYPR(MathHelper.DegreesToRadians(0.0f), 0.0f, 0.0f);
matrix.Position = -matrix.Forward * length;
}
return(matrix);
}
/// <summary>
/// Starts the specified batch.
/// </summary>
/// <param name="batch">The batch.</param>
/// <param name="useCamera">if set to <c>true</c> camera matrix will be applied.</param>
/// <param name="sortMode">The sort mode.</param>
/// <param name="blendState">State of the blend.</param>
/// <param name="samplerState">State of the sampler.</param>
/// <param name="depthStencilState">State of the depth stencil.</param>
/// <param name="rasterizerState">State of the rasterizer.</param>
/// <param name="effect">The effect.</param>
/// <param name="transform">The transformation matrix.</param>
public static void Start(this SpriteBatch batch,
bool useCamera = false,
SpriteSortMode sortMode = SpriteSortMode.Deferred,
BlendState blendState = null,
SamplerState samplerState = null,
DepthStencilState depthStencilState = null,
RasterizerState rasterizerState = null,
Effect effect = null,
Matrix?transform = null)
{
Matrix matrix = AlmiranteEngine.IsWinForms ? Matrix.Identity : AlmiranteEngine.Settings.Resolution.Matrix;
if (useCamera)
{
matrix = AlmiranteEngine.Camera.Matrix * matrix;
}
if (transform.HasValue)
{
matrix = transform.Value * matrix;
}
BatchExtensions._sortMode = sortMode;
BatchExtensions._blendState = blendState;
BatchExtensions._samplerState = samplerState;
BatchExtensions._depthStencilState = depthStencilState;
BatchExtensions._rasterizerState = rasterizerState;
BatchExtensions._effect = effect;
BatchExtensions._matrix = matrix;
batch.Begin(sortMode, blendState, samplerState, depthStencilState, rasterizerState, effect, matrix);
}
public void CalcMatrix()
{
if (IsWeighted)
{
_matrix = new Matrix();
foreach (BoneWeight w in _weights)
{
if (w.Bone != null)
{
_matrix += (w.Bone.Matrix * w.Bone.InverseBindMatrix) * w.Weight;
}
}
//The inverse matrix is only used for unweighting vertices so we don't need to set it now
_invMatrix = null;
}
else if (_weights.Count == 1)
{
if (Bone != null)
{
_matrix = Bone.Matrix;
_invMatrix = Bone.InverseMatrix;
}
}
else
{
_invMatrix = _matrix = Matrix.Identity;
}
}
public void Begin(ICanvas canvas, Matrix?transformMatrix = default(Matrix?))
{
var batch = canvas.GetCanvasGraphics <SpriteBatch>();
var transform = transformMatrix ?? Matrix.Identity;
batch.Begin(SpriteSortMode.Deferred, blendState: BlendState.Opaque, samplerState: SamplerState.LinearWrap, transformMatrix: transform);
}
private TrackableResult UpdateWorldCenterResult(out Matrix?cameraTransform)
{
TrackableResult result = null;
Matrix? additionalTransform = null;
cameraTransform = null;
if (this.WorldCenterMode == WorldCenterMode.FirstTarget)
{
result = this.TrackableResults.FirstOrDefault();
}
else if (this.WorldCenterMode == WorldCenterMode.SpecificTarget &&
this.WorldCenterTrackable != null)
{
result = this.WorldCenterTrackable.FindMatchedTrackable(this.platformSpecificARService.TrackableResults);
var resultTransform = this.WorldCenterTrackable.Owner.FindComponent <Transform3D>(false);
if (resultTransform != null)
{
additionalTransform = Matrix.CreateFromTRS(resultTransform.Position, resultTransform.Orientation, Vector3.One);
}
}
if (result != null)
{
cameraTransform = Matrix.Invert(result.Pose);
if (additionalTransform.HasValue)
{
cameraTransform *= additionalTransform.Value;
}
}
return(result);
}
/// <summary>
/// Gets the <see cref="Gdi32.HDC"/> from the the given <paramref name="deviceContext"/>.
/// </summary>
/// <remarks>
/// When a <see cref="Graphics"/> object is created from a <see cref="Gdi32.HDC"/> the clipping region and
/// the viewport origin are applied (<see cref="Gdi32.GetViewportExtEx(Gdi32.HDC, out Size)"/>). The clipping
/// region isn't reflected in <see cref="Graphics.Clip"/>, which is combined with the HDC HRegion.
///
/// The Graphics object saves and restores DC state when performing operations that would modify the DC to
/// maintain the DC in its original or returned state after <see cref="Graphics.ReleaseHdc()"/>.
/// </remarks>
/// <param name="applyGraphicsState">
/// Applies the origin transform and clipping region of the <paramref name="deviceContext"/> if it is an
/// object of type <see cref="Graphics"/>. Otherwise this is a no-op.
/// </param>
/// <param name="saveHdcState">
/// When true, saves and restores the <see cref="Gdi32.HDC"/> state.
/// </param>
public DeviceContextHdcScope(
IDeviceContext deviceContext,
bool applyGraphicsState = true,
bool saveHdcState = false)
{
DeviceContext = deviceContext ?? throw new ArgumentNullException(nameof(deviceContext));
ApplyGraphicsProperties apply = applyGraphicsState ? ApplyGraphicsProperties.All : ApplyGraphicsProperties.None;
_savedHdcState = 0;
if (apply == ApplyGraphicsProperties.None || !(DeviceContext is Graphics graphics))
{
// GetHdc() locks the Graphics object, it cannot be used until ReleaseHdc() is called
HDC = (Gdi32.HDC)DeviceContext.GetHdc();
_savedHdcState = saveHdcState ? Gdi32.SaveDC(HDC) : 0;
return;
}
bool applyTransform = apply.HasFlag(ApplyGraphicsProperties.TranslateTransform);
bool applyClipping = apply.HasFlag(ApplyGraphicsProperties.Clipping);
// This API is very expensive
object[]? data = applyTransform || applyClipping ? (object[])graphics.GetContextInfo() : null;
using Region? clipRegion = (Region?)data?[0];
using Matrix? worldTransform = (Matrix?)data?[1];
// elements (XFORM) = [eM11, eM12, eM21, eM22, eDx, eDy], eDx/eDy specify the translation offset.
float[]? elements = applyTransform ? worldTransform?.Elements : null;
int dx = elements != null ? (int)elements[4] : 0;
int dy = elements != null ? (int)elements[5] : 0;
applyTransform = applyTransform && elements != null && (dx != 0 || dy != 0);
using var graphicsRegion = applyClipping ? new Gdi32.RegionScope(clipRegion !, graphics) : default;
public static Matrix GetBaseEnemyFleetTrans(
App app,
List <ShipInfo> shipIDs,
OrbitalObjectInfo[] objects)
{
bool flag = false;
Matrix matrix = Matrix.Identity;
if (shipIDs.Count > 0)
{
int index = Math.Abs(App.GetSafeRandom().Next()) % shipIDs.Count;
Matrix?shipSystemPosition = app.GameDatabase.GetShipSystemPosition(shipIDs[index].ID);
if (shipSystemPosition.HasValue)
{
matrix = shipSystemPosition.Value;
flag = true;
}
}
if (!flag)
{
int orbitalId = 0;
foreach (OrbitalObjectInfo orbitalObjectInfo in objects)
{
if (app.GameDatabase.GetAsteroidBeltInfo(orbitalObjectInfo.ID) != null)
{
orbitalId = orbitalObjectInfo.ID;
}
}
float length = app.GameDatabase.GetOrbitalTransform(orbitalId).Position.Length;
matrix = Matrix.CreateRotationYPR(0.0f, 0.0f, 0.0f);
matrix.Position = -matrix.Forward * length;
}
return(matrix);
}
private bool IOS_IsPressed(Matrix2D?scale, Matrix?transform3)
{
var touches = TouchPanel.GetState();
for (int i = 0; i < touches.Count; i++)
{
if (OnlyTriggerOnRelease)
{
if (touches[i].State != TouchLocationState.Released)
{
continue;
}
}
var coor = new Vector2(touches[i].Position.X, touches[i].Position.Y);
if (scale.HasValue)
{
coor = Vector2.Transform(coor, Matrix2D.Invert(scale.Value));
}
if (transform3.HasValue)
{
coor = Vector2.Transform(coor, Matrix.Invert(transform3.Value));
}
if (TouchTriggerRect.Contains(coor))
{
this.Press();
return(true);
}
}
return(false);
}
public void Draw(TiledMapLayer layer, Matrix?viewMatrix = null, Matrix?projectionMatrix = null, Effect effect = null, float depth = 0.0f)
{
var viewMatrix1 = viewMatrix ?? Matrix.Identity;
var projectionMatrix1 = projectionMatrix ?? Matrix.CreateOrthographicOffCenter(0, GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height, 0, 0, -1);
Draw(layer, ref viewMatrix1, ref projectionMatrix1, effect, depth);
}
public void Flatten(Matrix?matrix, float flatness)
{
IntPtr m = (matrix == null) ? IntPtr.Zero : matrix.NativeMatrix;
int status = Gdip.GdipFlattenPath(_nativePath, m, flatness);
Gdip.CheckStatus(status);
}
public TextureConverter(uint[] data, int width, byte?alphaTolerance,
float?hullTolerance, bool?holeDetection, bool?multipartDetection,
bool?pixelOffsetOptimization, Matrix?transform)
{
Initialize(data, width, alphaTolerance, hullTolerance, holeDetection,
multipartDetection, pixelOffsetOptimization, transform);
}
private void SyncFleetShipModels()
{
foreach (FleetInfo fleetInfo in this.App.GameDatabase.GetFleetsByPlayerAndSystem(this.App.LocalPlayer.ID, this._targetSystemID, FleetType.FL_ALL))
{
if (fleetInfo.PlayerID == this.App.LocalPlayer.ID)
{
IEnumerable <ShipInfo> source = this.App.GameDatabase.GetShipInfoByFleetID(fleetInfo.ID, true).Where <ShipInfo>((Func <ShipInfo, bool>)(x => !((IEnumerable <DesignSectionInfo>)x.DesignInfo.DesignSections).Any <DesignSectionInfo>((Func <DesignSectionInfo, bool>)(y => ShipSectionAsset.IsBattleRiderClass(y.ShipSectionAsset.RealClass)))));
this._manager.PostSetProp("AddFleet", (object)fleetInfo.ID, (object)source.Count <ShipInfo>());
foreach (ShipInfo shipInfo in source)
{
List <object> objectList = new List <object>();
objectList.Add((object)0);
ShipDummy state = new ShipDummy(this.App, CreateShipDummyParams.ObtainShipDummyParams(this.App, shipInfo));
this.App.AddExistingObject((IGameObject)state, objectList.ToArray());
this._manager.PostObjectAddObjects((IGameObject)state);
this._pendingObjects.Add((IGameObject)state);
Vector3?shipFleetPosition = this.App.GameDatabase.GetShipFleetPosition(shipInfo.ID);
Matrix? shipSystemPosition = this.App.GameDatabase.GetShipSystemPosition(shipInfo.ID);
state.PostSetProp("SetShipID", shipInfo.ID);
int commandPointCost = this.App.GameDatabase.GetCommandPointCost(shipInfo.DesignID);
state.PostSetProp("SetShipCommandCost", commandPointCost);
state.PostSetProp("SetFleetID", fleetInfo.ID);
state.PostSetProp("SetShipName", shipInfo.ShipName);
if (shipFleetPosition.HasValue)
{
state.PostSetProp("SetFleetPosition", (object)shipFleetPosition.Value.X, (object)shipFleetPosition.Value.Y, (object)shipFleetPosition.Value.Z);
}
if (shipSystemPosition.HasValue)
{
state.PostSetProp("SetSystemTransform", shipSystemPosition.Value);
}
}
}
}
}
private void RecreateConstraints()
{
MyCubeGridRenderCell orAddCell = base.CubeGrid.RenderData.GetOrAddCell((Vector3)(base.Position * base.CubeGrid.GridSize), true);
using (List <MyEntitySubpart> .Enumerator enumerator = this.m_subparts.GetEnumerator())
{
while (true)
{
if (!enumerator.MoveNext())
{
break;
}
MyEntitySubpart current = enumerator.Current;
if (!current.Closed && !current.MarkedForClose)
{
Matrix?childToParent = null;
current.Render.SetParent(0, orAddCell.ParentCullObject, childToParent);
current.NeedsWorldMatrix = false;
current.InvalidateOnMove = false;
continue;
}
return;
}
}
this.DisposeConstraints();
if ((base.InScene && (base.CubeGrid.Physics != null)) && (base.CubeGrid.Physics.IsInWorld || ((MyPhysicsBody)base.CubeGrid.Physics).IsInWorldWelded()))
{
this.CreateConstraints();
}
if (base.CubeGrid.Physics != null)
{
this.UpdateHavokCollisionSystemID(base.CubeGrid.GetPhysicsBody().HavokCollisionSystemID, false);
}
this.UpdateDoorPosition();
}
public void Begin(Matrix?matrix = null)
{
this.matrix = matrix;
this.lastItem = ItemType.Unknown;
this.isInBeginEndPair = true;
this.PrepareCullingParameters();
}
public override unsafe void DebugDraw(Vector2 pos, Vector2 size, List <MyBehaviorTreeNodeMemory> nodesMemory)
{
MyRenderProxy.DebugDrawText2D(pos, this.DebugSign, nodesMemory[base.MemoryIndex].NodeStateColor, MyBehaviorTreeNode.DEBUG_TEXT_SCALE, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER, false);
float *singlePtr1 = (float *)ref size.X;
singlePtr1[0] *= MyBehaviorTreeNode.DEBUG_SCALE;
Vector2 position = (this.m_children.Count > 1) ? (pos - (size * 0.5f)) : pos;
float * singlePtr2 = (float *)ref position.Y;
singlePtr2[0] += MyBehaviorTreeNode.DEBUG_TEXT_Y_OFFSET;
float *singlePtr3 = (float *)ref size.X;
singlePtr3[0] /= (float)Math.Max(this.m_children.Count - 1, 1);
foreach (MyBehaviorTreeNode node in this.m_children)
{
Vector2 vector2 = position - pos;
vector2.Normalize();
Vector2 pointTo = position - (vector2 * MyBehaviorTreeNode.DEBUG_LINE_OFFSET_MULT);
Matrix? projection = null;
MyRenderProxy.DebugDrawLine2D(pos + (vector2 * MyBehaviorTreeNode.DEBUG_LINE_OFFSET_MULT), pointTo, nodesMemory[node.MemoryIndex].NodeStateColor, nodesMemory[node.MemoryIndex].NodeStateColor, projection, false);
node.DebugDraw(position, size, nodesMemory);
float *singlePtr4 = (float *)ref position.X;
singlePtr4[0] += size.X;
}
}
/// <summary>
/// Begins a new primitive.
/// </summary>
#if WINDOWS_PHONE
/// <param name="lineWidth">This value will always be 1 on Windows Phone.</param>
#endif
public void BeginPrimitive(PrimitiveType primitiveType, Texture2D texture, Matrix?world, float lineWidth)
{
if (hasPrimitiveBegin)
{
throw new InvalidOperationException("Begin cannot be called until End has been successfully called.");
}
hasPrimitiveBegin = true;
currentPrimitive = new PrimitiveGroupEntry();
currentPrimitive.LineWidth = lineWidth;
currentPrimitive.World = world;
currentPrimitive.PrimitiveType = primitiveType;
currentPrimitive.Texture = texture;
currentPrimitive.StartVertex = currentVertex;
currentPrimitive.StartIndex = currentIndex;
currentBaseVertex = currentVertex;
currentBaseIndex = currentIndex;
beginSegment = currentSegment;
#if !WINDOWS_PHONE
lineIndices.Clear();
currentLineVertex = 0;
lastLineVertex = -1;
#endif
}
internal void DerivePhysicsTransform(Vector3?worldPosition, Matrix?worldRotation, Vector3?worldScale, out Matrix outMatrix)
{
Vector3 translation = worldPosition ?? Entity.Transform.WorldPosition(), scale;
Matrix rotation;
if (worldScale.HasValue)
{
scale = worldScale.Value;
}
else
{
Entity.Transform.WorldMatrix.GetScale(out scale);
}
if (worldRotation.HasValue)
{
rotation = worldRotation.Value;
}
else
{
Entity.Transform.WorldMatrix.GetRotationMatrix(out rotation);
}
var translationMatrix = Matrix.Translation(translation);
Matrix.Multiply(ref rotation, ref translationMatrix, out outMatrix);
}
public RenderContext Derive(RectangleF bounds, Matrix?localLayoutTransform,
Matrix?localRenderTransform, Vector2?renderTransformOrigin,
double localOpacity)
{
Matrix finalTransform = _transform.Clone();
if (localLayoutTransform.HasValue && localLayoutTransform != Matrix.Identity)
{
// Layout transforms don't support translations, so center the transformation matrix at the start point
// of the control and apply the layout transform without translation
Vector2 origin = new Vector2(bounds.X + 0.5f * bounds.Width, bounds.Y + 0.5f * bounds.Height);
Matrix transform = Matrix.Translation(new Vector3(-origin.X, -origin.Y, 0));
transform *= localLayoutTransform.Value.RemoveTranslation();
transform *= Matrix.Translation(new Vector3(origin.X, origin.Y, 0));
finalTransform = transform * finalTransform;
}
if (localRenderTransform.HasValue && localRenderTransform != Matrix.Identity)
{
Vector2 origin = renderTransformOrigin.HasValue ? new Vector2(
bounds.X + bounds.Width * renderTransformOrigin.Value.X,
bounds.Y + bounds.Height * renderTransformOrigin.Value.Y) : new Vector2(bounds.X, bounds.Y);
Matrix transform = Matrix.Translation(new Vector3(-origin.X, -origin.Y, 0));
transform *= localRenderTransform.Value;
transform *= Matrix.Translation(new Vector3(origin.X, origin.Y, 0));
finalTransform = transform * finalTransform;
}
RenderContext result = new RenderContext(finalTransform, _opacity * localOpacity, bounds, _zOrder - 0.001f);
return(result);
}
public List <MyRenderElement> TransparentRenderElementsToDraw; // if null, MyEntities.Draw() will be used
public void Clear()
{
CallerID = null;
RenderTargets = null;
CameraPosition = null;
ViewMatrix = null;
ProjectionMatrix = null;
AspectRatio = null;
Fov = null;
Viewport = null;
EnableHDR = null;
EnableLights = null;
EnableSun = null;
ShadowRenderer = null;
EnableShadowInterleaving = null;
EnableSmallLights = null;
EnableSmallLightShadows = null;
EnableDebugHelpers = null;
EnableEnvironmentMapping = null;
EnableNear = null;
BackgroundColor = null;
EnableOcclusionQueries = true;
FogMultiplierMult = 1.0f;
DepthToAlpha = false;
DepthCopy = false;
EnabledModules = null;
EnabledPostprocesses = null;
EnabledRenderStages = null;
}
/// <summary>
/// Create new drawing context.
/// </summary>
/// <param name="createInfo">Create info.</param>
/// <param name="disposables">Array of elements to dispose after drawing has finished.</param>
public DrawingContextImpl(CreateInfo createInfo, params IDisposable[] disposables)
{
_dpi = createInfo.Dpi;
_visualBrushRenderer = createInfo.VisualBrushRenderer;
_disposables = disposables;
_canTextUseLcdRendering = !createInfo.DisableTextLcdRendering;
_grContext = createInfo.GrContext;
_gpu = createInfo.Gpu;
if (_grContext != null)
{
Monitor.Enter(_grContext);
}
Surface = createInfo.Surface;
Canvas = createInfo.Canvas ?? createInfo.Surface?.Canvas;
_session = createInfo.CurrentSession;
if (Canvas == null)
{
throw new ArgumentException("Invalid create info - no Canvas provided", nameof(createInfo));
}
if (!_dpi.NearlyEquals(SkiaPlatform.DefaultDpi))
{
_postTransform =
Matrix.CreateScale(_dpi.X / SkiaPlatform.DefaultDpi.X, _dpi.Y / SkiaPlatform.DefaultDpi.Y);
}
Transform = Matrix.Identity;
}
public static void LoadFromUserFolder(out string nextFreeName, out Matrix?lastShipPos)
{
if (m_attachedPhysObjects == null) // When triler was not loaded
{
m_attachedPhysObjects = new Dictionary <MyEntity, Dictionary <int, MyPhysObjectTrackedTickData> >();
}
foreach (var obj in m_attachedPhysObjects)
{
var entity = obj.Key;
if (MyEntities.GetEntities().Contains(entity))
{
obj.Key.MarkForClose();
}
}
m_attachedPhysObjects.Clear();
lastShipPos = null;
var path = Path.Combine(MyFileSystemUtils.GetApplicationUserDataFolder(), "Trailer");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
int maxFileName = 0;
var files = Directory.GetFiles(path, "*.tracked");
for (int i = 0; i < files.Length; i++)
{
string fileWithoutExt = Path.GetFileNameWithoutExtension(files[i]);
int num;
if (int.TryParse(fileWithoutExt, out num) && num > maxFileName)
{
maxFileName = num;
}
var smallShip = MyGuiScreenGamePlay.Static.CreateFakeMinerShip(null, MinerWars.CommonLIB.AppCode.ObjectBuilders.Object3D.MyMwcObjectBuilder_SmallShip_TypesEnum.GETTYSBURG, new Vector3((i * 100) + 10000, (i * 100) + 10000, (i * 100) + 10000), false, 1.0f);
AttachPhysObjectFullPath(smallShip, files[i]);
}
if (m_attachedPhysObjects.Count > 0)
{
var firstTick = m_attachedPhysObjects.Values.Last().First().Value;
var m = firstTick.Orientation;
m.Translation = firstTick.Position;
lastShipPos = m;
}
m_isEnabled = true;
m_fromTick = MillisecondsToTick(0); // start now
m_toTick = MillisecondsToTick(1000 * 1000); // max length 20min
m_activeTick = m_fromTick;
nextFreeName = (maxFileName + 1).ToString("D3");
}
public SquareMeshBuilder(float[,] heightMap, Vector3 offset, float tileSize, Matrix? rootTransform = null)
{
_tileSize = tileSize;
_rootTransform = rootTransform;
_offset = offset;
_heightMap = heightMap;
var rows = heightMap.GetLength(0);
var cols = heightMap.GetLength(1);
_jumpIndices = ArrayUtil.MakeTwoDimensionalArray(-1, rows, cols);
_vertices = new List<Vector3>(rows * cols);
}
/// <summary>
/// Initializes a new instance of the <see cref="ARPanel">Augmented Reality Panel</see> control.
/// </summary>
public ARPanel()
{
SizeChanged += panel_SizeChanged;
Loaded += panel_Loaded;
Unloaded += panel_Unloaded;
view = Matrix.CreateLookAt(new Vector3(0, 0, 1), Vector3.Zero, Vector3.Up);
world = Matrix.CreateWorld(Vector3.Zero, new Vector3(0, 0, -1), new Vector3(0, 1, 0));
if (IsDesignMode)
_attitude = Matrix.Identity; //This will make control render design time looking horizontal north
}
public void Backup(SpriteSortMode SortMode = SpriteSortMode.Deferred, BlendState BlendState = null,
SamplerState SamplerState = null, DepthStencilState DepthStencilState = null,
RasterizerState RasterizerState = null, Effect Effect = null, Matrix? Matrix = null)
{
this.SortMode = SortMode;
this.BlendState = BlendState;
this.SamplerState = SamplerState;
this.DepthStencilState = DepthStencilState;
this.RasterizerState = RasterizerState;
this.Effect = Effect;
this.Matrix = Matrix;
}
internal void Construct()
{
m_components.Clear();
m_visible = true;
m_renderProxyDirty = true;
m_ID = new MyIDTracker<MyActor>();
m_localAabb = null;
m_relativeTransform = null;
Aabb = BoundingBoxD.CreateInvalid();
}
public override void Update(GameTime gameTime)
{
if (null == augmentedReality || null == augmentedReality.DetectionResults)
return;
var filteredResults = augmentedReality.DetectionResults.Where(r => r.Confidence > confidenceThreshold).ToList();
if (filteredResults.Count > 0)
Transform = Utils.ToXnaMatrix(filteredResults.OrderByDescending(r => r.Confidence).First().Transformation);
else
Transform = null;
base.Update(gameTime);
}
internal void Construct()
{
CustomViewProjection = null;
IgnoreDepth = false;
if(List == null)
{
List = new List<MyVertexFormatPositionColor>();
}
else
{
List.Clear();
}
VertexCount = 0;
StartVertex = 0;
}
public DrawingContext(IDrawingContextImpl impl, Matrix? hiddenPostTransform = null)
{
_impl = impl;
_hiddenPostTransform = hiddenPostTransform;
}
/// <summary>
/// Updates the transform's cached value.
/// </summary>
private void UpdateValue()
{
var centerX = (Single)CenterX;
var centerY = (Single)CenterY;
var degrees = MathUtil.IsApproximatelyZero(Angle % 360) ? 0f : Angle;
var radians = Radians.FromDegrees(degrees);
var hasCenter = (centerX != 0 || centerY != 0);
if (hasCenter)
{
var mtxRotate = Matrix.CreateRotationZ(radians);
var mtxTransformCenter = Matrix.CreateTranslation(-centerX, -centerY, 0f);
var mtxTransformCenterInverse = Matrix.CreateTranslation(centerX, centerY, 0f);
Matrix mtxResult;
Matrix.Concat(ref mtxTransformCenter, ref mtxRotate, out mtxResult);
Matrix.Concat(ref mtxResult, ref mtxTransformCenterInverse, out mtxResult);
this.value = mtxResult;
}
else
{
this.value = Matrix.CreateRotationZ(radians);
}
Matrix invertedValue;
this.inverse = Matrix.TryInvert(value, out invertedValue) ? invertedValue : (Matrix?)null;
this.isIdentity = Matrix.Identity.Equals(value);
}
public override void Render(RenderContext parentRenderContext)
{
if (!IsVisible)
return;
RectangleF bounds = ActualBounds;
if (bounds.Width <= 0 || bounds.Height <= 0)
return;
Matrix? layoutTransformMatrix = LayoutTransform == null ? new Matrix?() : LayoutTransform.GetTransform();
Matrix? renderTransformMatrix = RenderTransform == null ? new Matrix?() : RenderTransform.GetTransform();
RenderContext localRenderContext = parentRenderContext.Derive(bounds, layoutTransformMatrix,
renderTransformMatrix, RenderTransformOrigin, Opacity);
Matrix finalTransform = localRenderContext.Transform;
if (finalTransform != _finalTransform)
{
_finalTransform = finalTransform;
_inverseFinalTransform = Matrix.Invert(_finalTransform.Value);
_renderedBoundingBox = CalculateBoundingBox(_innerRect, finalTransform);
}
Brushes.Brush opacityMask = OpacityMask;
if (opacityMask == null && Effect == null)
// Simply render without opacity mask
RenderOverride(localRenderContext);
else
{
// Control has an opacity mask or Effect
// Get global render surface and render texture or create them if they doesn't exist
RenderTextureAsset renderTexture = ContentManager.Instance.GetRenderTexture(GLOBAL_RENDER_TEXTURE_ASSET_KEY);
// Ensure they are allocated
renderTexture.AllocateRenderTarget(GraphicsDevice.Width, GraphicsDevice.Height);
if (!renderTexture.IsAllocated)
return;
// Morpheus_xx: these are typical performance results comparing direct rendering to texture and rendering
// to surfaces (for multisampling support).
// Results inside GUI-Test OpacityMask screen for default skin (720p windowed / fullscreen 1080p)
// Surface + full StretchRect -> Texture : 350 fps / 174 fps
// Texture : 485 fps / 265 fps
// Results inside GUI-Test OpacityMask screen for Reflexion skin (fullscreen 1080p)
// Surface + full StretchRect -> Texture : 142 fps
// Texture : 235 fps
// Create a temporary render context and render the control to the render texture
RenderContext tempRenderContext = new RenderContext(localRenderContext.Transform, localRenderContext.Opacity, bounds, localRenderContext.ZOrder);
// An additional copy step is only required for multisampling surfaces
bool isMultiSample = GraphicsDevice.Setup.IsMultiSample;
if (isMultiSample)
{
RenderTargetAsset renderSurface = ContentManager.Instance.GetRenderTarget(GLOBAL_RENDER_SURFACE_ASSET_KEY);
renderSurface.AllocateRenderTarget(GraphicsDevice.Width, GraphicsDevice.Height);
if (!renderSurface.IsAllocated)
return;
// First render to the multisampled surface
RenderToSurface(renderSurface, tempRenderContext);
// Unfortunately, brushes/brush effects are based on textures and cannot work with surfaces, so we need this additional copy step
GraphicsDevice.Device.StretchRectangle(
renderSurface.Surface, new Rectangle(Point.Empty, renderSurface.Size),
renderTexture.Surface0, new Rectangle(Point.Empty, renderTexture.Size),
TextureFilter.None);
}
else
// Directly render to texture
RenderToTexture(renderTexture, tempRenderContext);
// Add bounds to our calculated, occupied area.
// If we don't do that, lines at the border of this element might be dimmed because of the filter (see OpacityMask test in GUITestPlugin).
// The value was just found by testing. Any better solution is welcome.
if (opacityMask != null)
{
const float OPACITY_MASK_BOUNDS = 0.9f;
RectangleF occupiedTransformedBounds = tempRenderContext.OccupiedTransformedBounds;
occupiedTransformedBounds.X -= OPACITY_MASK_BOUNDS;
occupiedTransformedBounds.Y -= OPACITY_MASK_BOUNDS;
occupiedTransformedBounds.Width += OPACITY_MASK_BOUNDS * 2;
occupiedTransformedBounds.Height += OPACITY_MASK_BOUNDS * 2;
// If the control bounds have changed we need to update our primitive context to make the
// texture coordinates match up
if (_updateOpacityMask || _opacityMaskContext == null ||
occupiedTransformedBounds != _lastOccupiedTransformedBounds ||
renderTexture.Size != _lastOpacityRenderSize)
{
UpdateOpacityMask(occupiedTransformedBounds, renderTexture.Width, renderTexture.Height, localRenderContext.ZOrder);
_lastOccupiedTransformedBounds = occupiedTransformedBounds;
_updateOpacityMask = false;
_lastOpacityRenderSize = renderTexture.Size;
}
// Now render the opacity texture with the OpacityMask brush)
if (opacityMask.BeginRenderOpacityBrush(renderTexture.Texture, new RenderContext(Matrix.Identity, bounds)))
{
_opacityMaskContext.Render(0);
opacityMask.EndRender();
}
}
// Render Effect
Effects.Effect effect = Effect;
if (effect != null)
{
UpdateEffectMask(effect, tempRenderContext.OccupiedTransformedBounds, renderTexture.Width, renderTexture.Height, localRenderContext.ZOrder);
if (effect.BeginRender(renderTexture.Texture, new RenderContext(Matrix.Identity, 1.0d, bounds, localRenderContext.ZOrder)))
{
_effectContext.Render(0);
effect.EndRender();
}
}
}
// Calculation of absolute render size (in world coordinate system)
parentRenderContext.IncludeTransformedContentsBounds(localRenderContext.OccupiedTransformedBounds);
_lastZIndex = localRenderContext.ZOrder;
}
public void CalcMatrix()
{
if (IsWeighted)
{
_matrix = new Matrix();
foreach (BoneWeight w in _weights)
if (w.Bone != null)
_matrix += (w.Bone.Matrix * w.Bone.InverseBindMatrix) * w.Weight;
//The inverse matrix is only used for unweighting vertices so we don't need to set it now
_invMatrix = null;
}
else if (_weights.Count == 1)
{
if (Bone != null)
{
_matrix = Bone.Matrix;
_invMatrix = Bone.InverseMatrix;
}
}
else
_invMatrix = _matrix = Matrix.Identity;
}
private void motion_CurrentValueChanged(object sender, Microsoft.Devices.Sensors.SensorReadingEventArgs<Microsoft.Devices.Sensors.MotionReading> e)
{
lock (_attitudeLock)
{
//When device changes orientation, the attitude value is invalidated
_attitude = null;
}
//When the device changes orientation, it invalidates the placement of the elements
Dispatcher.BeginInvoke(() => InvalidateArrange());
}
private void panel_SizeChanged(object sender, SizeChangedEventArgs e)
{
_viewport = null; //If the size changes, it invalidates the viewport
_cameraProjection = null; //camera projection relies on viewport - force reset
this.Clip = new RectangleGeometry() { Rect = new Rect(0, 0, e.NewSize.Width, e.NewSize.Height) };
InvalidateArrange();
}
/// <summary>
/// Updates the transform's cached value.
/// </summary>
private void UpdateValue()
{
this.value = Matrix.CreateTranslation((Single)X, (Single)Y, 0f);
Matrix inverse;
if (Matrix.TryInvert(value, out inverse))
{
this.inverse = inverse;
}
else
{
this.inverse = null;
}
this.isIdentity = Matrix.Identity.Equals(value);
}
internal void SetCustomViewProjection(ref Matrix m)
{
m_customViewProjection = m;
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
PostBaseInit();
//MyDebug.AssertDebug(objectBuilder.TypeId == typeof(MyObjectBuilder_Cockpit));
var def = MyDefinitionManager.Static.GetCubeBlockDefinition(objectBuilder.GetId());
m_isLargeCockpit = (def.CubeSize == MyCubeSize.Large);
m_cockpitInteriorModel = BlockDefinition.InteriorModel;
m_cockpitGlassModel = BlockDefinition.GlassModel;
NeedsUpdate = MyEntityUpdateEnum.EACH_100TH_FRAME;
MyObjectBuilder_Cockpit cockpitOb = (MyObjectBuilder_Cockpit)objectBuilder;
if (cockpitOb.Pilot != null)
{
MyEntity pilotEntity;
MyCharacter pilot = null;
if (MyEntities.TryGetEntityById(cockpitOb.Pilot.EntityId, out pilotEntity))
{ //Pilot already exists, can be the case after cube grid split
pilot = (MyCharacter)pilotEntity;
if (pilot.IsUsing is MyShipController && pilot.IsUsing != this)
{
System.Diagnostics.Debug.Assert(false, "Pilot already sits on another place!");
pilot = null;
}
}
else
{
pilot = (MyCharacter)MyEntities.CreateFromObjectBuilder(cockpitOb.Pilot);
}
if (pilot != null)
{
AttachPilot(pilot, storeOriginalPilotWorld: false, calledFromInit: true);
if (cockpitOb.PilotRelativeWorld.HasValue)
m_pilotRelativeWorld = cockpitOb.PilotRelativeWorld.Value.GetMatrix();
else
m_pilotRelativeWorld = null;
m_singleWeaponMode = cockpitOb.UseSingleWeaponMode;
}
IsInFirstPersonView = cockpitOb.IsInFirstPersonView;
}
if (cockpitOb.Autopilot != null)
{
MyAutopilotBase autopilot = MyAutopilotFactory.CreateAutopilot(cockpitOb.Autopilot);
autopilot.Init(cockpitOb.Autopilot);
AttachAutopilot(autopilot, updateSync: false);
}
m_pilotGunDefinition = cockpitOb.PilotGunDefinition;
// backward compatibility check for automatic rifle without subtype
if (m_pilotGunDefinition.HasValue)
{
if (m_pilotGunDefinition.Value.TypeId == typeof(MyObjectBuilder_AutomaticRifle)
&& string.IsNullOrEmpty(m_pilotGunDefinition.Value.SubtypeName))
m_pilotGunDefinition = new MyDefinitionId(typeof(MyObjectBuilder_AutomaticRifle), "RifleGun");
}
if (!string.IsNullOrEmpty(m_cockpitInteriorModel))
{
if (MyModels.GetModelOnlyDummies(m_cockpitInteriorModel).Dummies.ContainsKey("head"))
m_headLocalPosition = MyModels.GetModelOnlyDummies(m_cockpitInteriorModel).Dummies["head"].Matrix.Translation;
}
else
{
if (MyModels.GetModelOnlyDummies(BlockDefinition.Model).Dummies.ContainsKey("head"))
m_headLocalPosition = MyModels.GetModelOnlyDummies(BlockDefinition.Model).Dummies["head"].Matrix.Translation;
}
AddDebugRenderComponent(new Components.MyDebugRenderComponentCockpit(this));
InitializeConveyorEndpoint();
AddDebugRenderComponent(new Components.MyDebugRenderComponentDrawConveyorEndpoint(m_conveyorEndpoint));
m_oxygenLevel = cockpitOb.OxygenLevel;
}
public void RemoveOriginalPilotPosition()
{
m_pilotRelativeWorld = null;
}
protected override void sync_PilotRelativeEntryUpdated(MyPositionAndOrientation relativeEntry)
{
base.sync_PilotRelativeEntryUpdated(relativeEntry);
m_pilotRelativeWorld = relativeEntry.GetMatrix();
}
public void AttachPilot(MyCharacter pilot, bool storeOriginalPilotWorld = true, bool calledFromInit = false)
{
System.Diagnostics.Debug.Assert(pilot != null);
System.Diagnostics.Debug.Assert(m_pilot == null);
m_pilot = pilot;
m_pilot.OnMarkForClose += m_pilotClosedHandler;
m_pilot.IsUsing = this;
//m_soundEmitter.OwnedBy = m_pilot;
if (MyFakes.ENABLE_NEW_SOUNDS)
StartLoopSound();
if (storeOriginalPilotWorld)
{
m_pilotRelativeWorld = (Matrix)MatrixD.Multiply(pilot.WorldMatrix, this.PositionComp.GetWorldMatrixNormalizedInv());
if (Sync.IsServer)
{
var relativeEntry = new MyPositionAndOrientation(m_pilotRelativeWorld.Value);
SyncObject.SendPilotRelativeEntryUpdate(ref relativeEntry);
}
}
if (pilot.InScene)
MyEntities.Remove(pilot);
m_pilot.Physics.Enabled = false;
m_pilot.PositionComp.SetWorldMatrix(WorldMatrix);
m_pilot.Physics.Clear();
//m_pilot.SetPosition(GetPosition() - WorldMatrix.Forward * 0.5f);
Hierarchy.AddChild(m_pilot, true, true);
var gunEntity = m_pilot.CurrentWeapon as MyEntity;
if (gunEntity != null)
{
var ob = gunEntity.GetObjectBuilder();
m_pilotGunDefinition = ob.GetId();
}
else
m_pilotGunDefinition = null;
MyAnimationDefinition animationDefinition;
MyDefinitionId id = new MyDefinitionId(typeof(MyObjectBuilder_AnimationDefinition), BlockDefinition.CharacterAnimation);
if (!MyDefinitionManager.Static.TryGetDefinition(id, out animationDefinition) && !MyFileSystem.FileExists(BlockDefinition.CharacterAnimation))
{
BlockDefinition.CharacterAnimation = null;
}
PlacePilotInSeat(pilot);
m_rechargeSocket.PlugIn(m_pilot.SuitBattery);
// Control should be handled elsewhere if we initialize the grid in the Init(...)
if (!calledFromInit) GiveControlToPilot();
m_pilot.SwitchToWeapon(null);
}
/// <summary>
/// Arranges the UI element and positions it in the given rectangle.
/// </summary>
/// <param name="outerRect">The final position and size the parent computed for this child element.</param>
public void Arrange(RectangleF outerRect)
{
if (_isMeasureInvalid)
{
#if DEBUG_LAYOUT
#if DEBUG_MORE_LAYOUT
System.Diagnostics.Trace.WriteLine(string.Format("Arrange {0} Name='{1}', exiting because measurement is invalid", GetType().Name, Name));
#endif
#endif
InvalidateLayout(true, true); // Re-schedule arrangement
return;
}
#if DEBUG_LAYOUT
#if DEBUG_MORE_LAYOUT
System.Diagnostics.Trace.WriteLine(string.Format("Arrange {0} Name='{1}', outerRect={2}", GetType().Name, Name, outerRect));
#endif
#endif
if (!_isArrangeInvalid && SameRect(_outerRect, outerRect))
{ // Optimization: If our input data is the same and the layout isn't invalid, we don't need to arrange again
#if DEBUG_LAYOUT
#if DEBUG_MORE_LAYOUT
System.Diagnostics.Trace.WriteLine(string.Format("Arrange {0} Name='{1}', cutting short, outerRect={2} is like before and arrangement is not invalid", GetType().Name, Name, outerRect));
#endif
#endif
return;
}
#if DEBUG_LAYOUT
#if !DEBUG_MORE_LAYOUT
System.Diagnostics.Trace.WriteLine(string.Format("Arrange {0} Name='{1}', outerRect={2}", GetType().Name, Name, outerRect));
#endif
#endif
_isArrangeInvalid = false;
// Those two properties have to be set by the render loop again the next time we render. We need to reset the values to null
// because the BoundingBox property then uses a fallback value. It would be wrong to use the old _boundingBox value if we
// re-arrange our contents.
_renderedBoundingBox = null;
_finalTransform = null;
_inverseFinalTransform = null;
_outerRect = SharpDXExtensions.CreateRectangleF(outerRect.Location, outerRect.Size);
RectangleF rect = SharpDXExtensions.CreateRectangleF(outerRect.Location, outerRect.Size);
RemoveMargin(ref rect, Margin);
if (LayoutTransform != null)
{
Matrix layoutTransform = LayoutTransform.GetTransform().RemoveTranslation();
if (!layoutTransform.IsIdentity)
{
SizeF resultInnerSize = _innerDesiredSize;
SizeF resultOuterSize = resultInnerSize;
layoutTransform.TransformIncludingRectangleSize(ref resultOuterSize);
if (resultOuterSize.Width > rect.Width + DELTA_DOUBLE || resultOuterSize.Height > rect.Height + DELTA_DOUBLE)
// Transformation of desired size doesn't fit into the available rect
resultInnerSize = FindMaxTransformedSize(layoutTransform, rect.Size);
rect = new RectangleF(
rect.Location.X + (rect.Width - resultInnerSize.Width) / 2,
rect.Location.Y + (rect.Height - resultInnerSize.Height) / 2,
resultInnerSize.Width,
resultInnerSize.Height);
}
}
_innerRect = rect;
InitializeTriggers();
CheckFireLoaded(); // Has to be done after all triggers are initialized to make EventTriggers for UIElement.Loaded work properly
ArrangeOverride();
UpdateFocus(); // Has to be done after all children have arranged to make SetFocusPrio work properly
}
public static void ResetClipPlanes(bool applyNow = false)
{
Debug.Assert(m_backupMatrix.HasValue, "Nothing to reset, use change clip planes first");
ProjectionMatrix = m_backupMatrix.Value;
m_backupMatrix = null;
if (applyNow)
{
UpdateCamera();
}
//ChangeClipPlanes(GetSafeNear(), MyCamera.FAR_PLANE_DISTANCE, applyNow);
}
public override void Render(RenderContext parentRenderContext)
{
if (!IsVisible)
return;
RectangleF bounds = ActualBounds;
if (bounds.Width <= 0 || bounds.Height <= 0)
return;
Matrix? layoutTransformMatrix = LayoutTransform == null ? new Matrix?() : LayoutTransform.GetTransform();
Matrix? renderTransformMatrix = RenderTransform == null ? new Matrix?() : RenderTransform.GetTransform();
RenderContext localRenderContext = parentRenderContext.Derive(bounds, layoutTransformMatrix, renderTransformMatrix, RenderTransformOrigin, Opacity);
Matrix finalTransform = localRenderContext.Transform;
if (finalTransform != _finalTransform)
{
_finalTransform = finalTransform;
_inverseFinalTransform = Matrix.Invert(_finalTransform.Value);
_renderedBoundingBox = CalculateBoundingBox(_innerRect, finalTransform);
}
Brushes.Brush opacityMask = OpacityMask;
Effect effect = Effect;
if (opacityMask == null && effect == null)
// Simply render without opacity mask
RenderOverride(localRenderContext);
else
{
// Control has an opacity mask or Effect
// Get global render surface and render texture or create them if they doesn't exist
RenderTextureAsset renderTexture = ContentManager.Instance.GetRenderTexture(GLOBAL_RENDER_TEXTURE_ASSET_KEY);
// Ensure they are allocated
renderTexture.AllocateRenderTarget(GraphicsDevice.Width, GraphicsDevice.Height);
if (!renderTexture.IsAllocated)
return;
// Morpheus_xx: these are typical performance results comparing direct rendering to texture and rendering
// to surfaces (for multisampling support).
// Results inside GUI-Test OpacityMask screen for default skin (720p windowed / fullscreen 1080p)
// Surface + full StretchRect -> Texture : 350 fps / 174 fps
// Texture : 485 fps / 265 fps
// After OpacityMask fix:
// Surface + full StretchRect -> Texture : 250 fps / 155 fps
// Surface + Occupied Rect -> Texture : 325 fps / 204 fps
// Texture : 330 fps / 213 fps
// Results inside GUI-Test OpacityMask screen for Reflexion skin (fullscreen 1080p)
// Surface + full StretchRect -> Texture : 142 fps
// Texture : 235 fps
// Create a temporary render context and render the control to the render texture
RenderContext tempRenderContext = new RenderContext(localRenderContext.Transform, localRenderContext.Opacity, bounds, localRenderContext.ZOrder);
// If no effect is applied, clear only the area of the control, not whole render target (performance!)
tempRenderContext.ClearOccupiedAreaOnly = effect == null;
// An additional copy step is only required for multisampling surfaces
bool isMultiSample = GraphicsDevice.Setup.IsMultiSample;
if (isMultiSample)
{
RenderTargetAsset renderSurface = ContentManager.Instance.GetRenderTarget(GLOBAL_RENDER_SURFACE_ASSET_KEY);
renderSurface.AllocateRenderTarget(GraphicsDevice.Width, GraphicsDevice.Height);
if (!renderSurface.IsAllocated)
return;
// First render to the multisampled surface
RenderToSurface(renderSurface, tempRenderContext);
// Unfortunately, brushes/brush effects are based on textures and cannot work with surfaces, so we need this additional copy step
// Morpheus_xx, 03/2013: changed to copy only the occupied area of Surface, instead of complete area. This improves performance a lot.
GraphicsDevice.Device.StretchRectangle(
renderSurface.Surface, ToRect(tempRenderContext.OccupiedTransformedBounds, renderSurface.Size), // new Rectangle(new Point(), renderSurface.Size),
renderTexture.Surface0, ToRect(tempRenderContext.OccupiedTransformedBounds, renderTexture.Size), // new Rectangle(new Point(), renderTexture.Size),
TextureFilter.None);
}
else
{
// Directly render to texture
RenderToTexture(renderTexture, tempRenderContext);
}
// Render Effect
if (effect == null)
{
// Use a default effect to draw the render target if none is set
if (_defaultEffect == null)
{
_defaultEffect = new SimpleShaderEffect { ShaderEffectName = "normal" };
}
effect = _defaultEffect;
}
UpdateEffectMask(effect, tempRenderContext.OccupiedTransformedBounds, renderTexture.Width, renderTexture.Height, localRenderContext.ZOrder);
if (effect.BeginRender(renderTexture.Texture, new RenderContext(Matrix.Identity, 1.0d, bounds, localRenderContext.ZOrder)))
{
_effectContext.Render(0);
effect.EndRender();
}
}
// Calculation of absolute render size (in world coordinate system)
parentRenderContext.IncludeTransformedContentsBounds(localRenderContext.OccupiedTransformedBounds);
_lastZIndex = localRenderContext.ZOrder;
}
public Matrix GetCachedFinalBrushTransform()
{
Matrix? transform = _finalBrushTransform;
if (transform.HasValue)
return transform.Value;
if (Transform != null)
{
transform = Matrix.Scaling(new Vector3(_vertsBounds.Width, _vertsBounds.Height, 1));
transform *= Matrix.Invert(Transform.GetTransform());
transform *= Matrix.Scaling(new Vector3(1/_vertsBounds.Width, 1/_vertsBounds.Height, 1));
}
else
transform = Matrix.Identity;
_finalBrushTransform = transform;
return transform.Value;
}
public virtual void Init(string hudLabelText, MyMwcObjectBuilder_SmallShip_Bot objectBuilder)
{
System.Diagnostics.Debug.Assert(objectBuilder.Faction != 0);
//StringBuilder label = new StringBuilder(hudLabelText);
TotalAliveBots++;
string fixedHudLabelText = hudLabelText;
if (string.IsNullOrEmpty(hudLabelText) || hudLabelText == GetFriendlyName())
{
fixedHudLabelText = MyTextsWrapper.GetFormatString(MyTextsWrapperEnum.Ship);
}
base.Init(fixedHudLabelText, objectBuilder);
Faction = objectBuilder.Faction;
m_aiTemplate = MyBotAITemplates.GetTemplate(objectBuilder.AITemplate);
Aggressivity = objectBuilder.Aggressivity;
SeeDistance = objectBuilder.SeeDistance == 0 ? 1000 : objectBuilder.SeeDistance;
SleepDistance = objectBuilder.SleepDistance == 0 ? 1000 : objectBuilder.SleepDistance;
PatrolMode = objectBuilder.PatrolMode;
ActiveAI = true;
m_leaderId = objectBuilder.Leader;
AITemplate.SetIdleBehavior(objectBuilder.IdleBehavior);
LeaderLostEnabled = objectBuilder.LeaderLostEnabled;
ActiveAI = ActiveAI;
SetupWeapons(objectBuilder);
SetupDifficulty();
//if (hudLabelText == GetFriendlyName())
//{
// label = new StringBuilder("");
//}
//if (string.IsNullOrEmpty(hudLabelText) || hudLabelText == GetFriendlyName())
//{
// DisplayName = MyTextsWrapper.GetFormatString(MyTextsWrapperEnum.Ship);
//}
//MyHud.ChangeText(this, label, null, 10000, MyHudIndicatorFlagsEnum.SHOW_ALL);
MyModelDummy dummy;
if (GetModelLod0().Dummies.TryGetValue("destruction", out dummy))
{
m_biochemEffectLocalMatrix = dummy.Matrix;
}
m_shock_time = -1;
MyBotCoordinator.AddBot(this);
InitSpoiledHolograms();
MyEntities.OnEntityRemove += MyEntities_OnEntityRemove;
m_dangerZoneId = MyDangerZones.Instance.Register(this);
MySession.Static.LinkEntities += OnLinkEntities;
}
private void UpdateViewMatrix(PageOrientation orientation)
{
if (orientation == LandscapeLeft)
{
view = Microsoft.Xna.Framework.Matrix.CreateLookAt(
new Microsoft.Xna.Framework.Vector3(0, 0, 1),
Microsoft.Xna.Framework.Vector3.Zero,
Microsoft.Xna.Framework.Vector3.Right);
}
else if (orientation == LandscapeRight)
{
view = Microsoft.Xna.Framework.Matrix.CreateLookAt(
new Microsoft.Xna.Framework.Vector3(0, 0, 1),
Microsoft.Xna.Framework.Vector3.Zero,
Microsoft.Xna.Framework.Vector3.Left);
}
else //if (orientation == PageOrientation.PortraitUp)
{
view = Microsoft.Xna.Framework.Matrix.CreateLookAt(
new Microsoft.Xna.Framework.Vector3(0, 0, 1),
Microsoft.Xna.Framework.Vector3.Zero,
Microsoft.Xna.Framework.Vector3.Up);
}
//Camera projection relies on the view matrix - invalidate camera projection
_cameraProjection = null;
InvalidateArrange();
}
public static void ChangeClipPlanes(float near, float far, bool applyNow = false)
{
Debug.Assert(!m_backupMatrix.HasValue, "Reset clip planes before changing clip planes again");
m_backupMatrix = ProjectionMatrix;
ProjectionMatrix = Matrix.CreatePerspectiveFieldOfView(FieldOfView, AspectRatio, near, far);
if (applyNow)
{
UpdateCamera();
}
}
protected void ResetViewMatrix()
{
this.viewMatrix = null;
}
protected virtual void OnTransformChanged(IObservable trans)
{
_finalBrushTransform = null;
FireChanged();
}
internal void SetRelativeTransform(Matrix? m)
{
m_relativeTransform = m;
}
public override void DeepCopy(IDeepCopyable source, ICopyManager copyManager)
{
Detach();
base.DeepCopy(source, copyManager);
Brush b = (Brush) source;
Opacity = b.Opacity;
RelativeTransform = copyManager.GetCopy(b.RelativeTransform);
Transform = copyManager.GetCopy(b.Transform);
Freezable = b.Freezable;
_finalBrushTransform = null;
Attach();
}
public void Draw()
{
if (!this.FollowCamera)
{
this.StarsMesh.Position = this.AdditionalZoom * Vector3.Forward * 125f - 2400f * Vector3.Forward;
this.StarsMesh.Scale = new Vector3(1f + this.AdditionalScale, 1f + this.AdditionalScale, 1f);
}
else if (!this.GameState.InFpsMode)
{
FakePointSpritesEffect pointSpritesEffect = this.StarEffect;
StarField starField1 = this;
StarField starField2 = this;
Matrix? nullable1 = new Matrix?();
Matrix? nullable2 = nullable1;
starField2.savedViewMatrix = nullable2;
Matrix? nullable3;
Matrix? nullable4 = nullable3 = nullable1;
starField1.savedViewMatrix = nullable3;
Matrix? nullable5 = nullable4;
pointSpritesEffect.ForcedViewMatrix = nullable5;
this.StarsMesh.Position = this.CameraManager.InterpolatedCenter * 0.5f;
this.StarsMesh.Scale = new Vector3((float) (112.5 / ((double) this.CameraManager.Radius / (double) SettingsManager.GetViewScale(this.GraphicsDevice) + 40.0)));
if (this.HasHorizontalTrails)
{
this.TrailsMesh.Position = this.StarsMesh.Position;
this.TrailsMesh.Scale = this.StarsMesh.Scale = new Vector3((float) (65.0 / ((double) this.CameraManager.Radius / (double) SettingsManager.GetViewScale(this.GraphicsDevice) + 25.0)));
}
}
else if (this.CameraManager.ProjectionTransition)
{
if (this.CameraManager.Viewpoint != Viewpoint.Perspective)
this.StarEffect.ForcedViewMatrix = new Matrix?(Matrix.Lerp(this.CameraManager.View, this.CameraManager.View, Easing.EaseOut((double) this.CameraManager.ViewTransitionStep, EasingType.Quadratic)));
else if (!this.savedViewMatrix.HasValue)
this.savedViewMatrix = new Matrix?(this.CameraManager.View);
}
this.StarsMesh.Material.Opacity = this.Opacity;
this.StarsMesh.Draw();
if (!this.Enabled || !this.HasHorizontalTrails)
return;
this.TrailsMesh.Draw();
}
