public override void Init(MyObjectBuilder_EntityBase objectBuilder) { ProfilerShort.Begin("MyEntity.Init(objectBuilder)"); if (objectBuilder != null) { if (objectBuilder.PositionAndOrientation.HasValue) { var posAndOrient = objectBuilder.PositionAndOrientation.Value; MatrixD matrix = MatrixD.CreateWorld(posAndOrient.Position, posAndOrient.Forward, posAndOrient.Up); MyUtils.AssertIsValid(matrix); Container.Entity.PositionComp.SetWorldMatrix(matrix); } // Do not copy EntityID if it gets overwritten later. It might // belong to some existing entity that we're making copy of. if (objectBuilder.EntityId != 0) { Container.Entity.EntityId = objectBuilder.EntityId; } Container.Entity.Name = objectBuilder.Name; Container.Entity.Render.PersistentFlags = objectBuilder.PersistentFlags; } AllocateEntityID(); Container.Entity.InScene = false; MyEntities.SetEntityName(m_entity, false); if (m_entity.SyncFlag) { m_entity.CreateSync(); } GameLogic.Init(objectBuilder); ProfilerShort.End(); }
public virtual void UpdateAfterSimulation() { ProfilerShort.Begin("MyEnvironmentalParticleLogic.UpdateAfterSimulation"); for (int index = 0; index < m_activeParticles.Count; ++index) { var particle = m_activeParticles[index]; if (MySandboxGame.TotalGamePlayTimeInMilliseconds - particle.BirthTime >= particle.LifeTime || (particle.Position - MySector.MainCamera.Position).Length() > m_particleDespawnDistance || !particle.Active) { m_particlesToRemove.Add(index); } } for (int index = m_particlesToRemove.Count - 1; index >= 0; --index) { var particleIndex = m_particlesToRemove[index]; m_nonActiveParticles.Add(m_activeParticles[particleIndex]); m_activeParticles[particleIndex].Deactivate(); m_activeParticles.RemoveAt(particleIndex); } m_particlesToRemove.Clear(); ProfilerShort.End(); }
void IWork.DoWork() { ProfilerShort.Begin("MyPrecalcWork"); m_timer.Start(); MyPrecalcJob work; while (Queue.TryDequeueFront(out work)) { work.DoWork(); m_finishedList.Add(work); if (m_timer.ElapsedMilliseconds >= MaxPrecalcTime) { break; } if (MyFakes.ENABLE_YIELDING_IN_PRECALC_TASK) { Thread.Yield(); } } m_timer.Stop(); m_timer.Reset(); ProfilerShort.End(); }
// Method finds intersection with line and any voxel triangleVertexes in this voxel map. Closes intersection is returned. internal override bool GetIntersectionWithLine(ref LineD worldLine, out MyIntersectionResultLineTriangleEx?t, IntersectionFlags flags = IntersectionFlags.ALL_TRIANGLES) { t = null; double intersectionDistance; LineD line = (LineD)worldLine; if (!PositionComp.WorldAABB.Intersects(line, out intersectionDistance)) { return(false); } ProfilerShort.Begin("VoxelMap.LineIntersection"); try { Line localLine = new Line(worldLine.From - PositionLeftBottomCorner, worldLine.To - PositionLeftBottomCorner, true); MyIntersectionResultLineTriangle tmpResult; if (Storage.Geometry.Intersect(ref localLine, out tmpResult, flags)) { t = new MyIntersectionResultLineTriangleEx(tmpResult, this, ref worldLine); var tmp = t.Value.IntersectionPointInWorldSpace; tmp.AssertIsValid(); return(true); } else { t = null; return(false); } } finally { ProfilerShort.End(); } }
public void OnNodeRemoved(MyEntity entity) { if (m_weldParent == null) { return; } ProfilerShort.Begin("WeldGroup.OnNodeRemoved"); if (m_weldParent == entity) { if (m_group.Nodes.Count == 1 && m_group.Nodes.First().NodeData.MarkedForClose) { } else if (m_group.Nodes.Count > 0) { ReplaceParent(null); } } else if (m_weldParent.Physics != null) { if (!entity.MarkedForClose) { (m_weldParent.Physics as MyPhysicsBody).Unweld(entity.Physics as MyPhysicsBody); } } if (m_weldParent != null && m_weldParent.Physics != null && m_weldParent.Physics.RigidBody != null) { Debug.Assert(m_weldParent.Physics.RigidBody.Layer > 0); m_weldParent.Physics.RigidBody.Activate(); m_weldParent.RaisePhysicsChanged(); } entity.RaisePhysicsChanged(); Debug.Assert(entity.MarkedForClose || entity.Physics == null || !(entity.Physics as MyPhysicsBody).IsWelded); Debug.Assert(entity.MarkedForClose || entity.Physics == null || entity.Physics.RigidBody == null || entity.Physics.RigidBody.Layer > 0); ProfilerShort.End(); }
private static void SetupReading( int lodIndex, ref Vector3I minInLod, ref Vector3I maxInLod, out float lodVoxelSizeHalf, out BoundingBox queryBox, out BoundingSphere querySphere) { ProfilerShort.Begin("SetupReading"); lodVoxelSizeHalf = MyVoxelConstants.VOXEL_SIZE_IN_METRES_HALF * (1 << lodIndex); Vector3 localMin, localMax; { Vector3D localPositionD; var min = minInLod << lodIndex; var max = maxInLod << lodIndex; MyVoxelCoordSystems.VoxelCoordToLocalPosition(ref min, out localPositionD); localMin = localPositionD; MyVoxelCoordSystems.VoxelCoordToLocalPosition(ref max, out localPositionD); localMax = localPositionD; localMin -= lodVoxelSizeHalf; localMax += lodVoxelSizeHalf; } queryBox = new BoundingBox(localMin, localMax); querySphere = BoundingSphere.CreateFromBoundingBox(queryBox); ProfilerShort.End(); }
public static MyEntity Spawn(MyPhysicalInventoryItem item, BoundingSphereD sphere, MyPhysicsComponentBase motionInheritedFrom = null, MyVoxelMaterialDefinition voxelMaterial = null) { ProfilerShort.Begin("MyFloatingObjects.Spawn"); var floatingBuilder = PrepareBuilder(ref item); ProfilerShort.Begin("Create"); var thrownEntity = MyEntities.CreateFromObjectBuilder(floatingBuilder); ProfilerShort.End(); ((MyFloatingObject)thrownEntity).VoxelMaterial = voxelMaterial; var size = thrownEntity.PositionComp.LocalVolume.Radius; var sphereSize = sphere.Radius - size; sphereSize = Math.Max(sphereSize, 0); sphere = new BoundingSphereD(sphere.Center, sphereSize); var pos = MyUtils.GetRandomBorderPosition(ref sphere); AddToPos(thrownEntity, pos, motionInheritedFrom); ProfilerShort.End(); return(thrownEntity); }
internal void OnCellRequest(MyCellCoord cell, Func <int> priorityFunction, Action <Color> debugDraw) { ProfilerShort.Begin("OnCellRequest"); try { var workId = cell.PackId64(); MyPrecalcJobRender.Start(new MyPrecalcJobRender.Args { Storage = m_voxelMap.Storage, ClipmapId = ClipmapId, Cell = cell, WorkId = workId, RenderWorkTracker = m_renderWorkTracker, Priority = priorityFunction, DebugDraw = debugDraw, }); } finally { ProfilerShort.End(); } }
internal static void Preprocess(MyStringId material, MyStringId pass, MyVertexLayoutInfo vertexLayout, out string vsSource, out string psSource) { ProfilerShort.Begin("MyShaders.MaterialPreprocess"); Debug.Assert(m_vertexTemplateBase != null); Debug.Assert(m_pixelTemplateBase != null); PrefetchMaterialSources(material); PrefetchPassSources(pass); StringBuilder source = new StringBuilder(); // vertex shader source.Append(m_vertexTemplateBase); source.Replace("__VERTEXINPUT_DECLARATIONS__", vertexLayout.SourceDeclarations); source.Replace("__VERTEXINPUT_TRANSFER__", vertexLayout.SourceDataMove); source.Replace("__MATERIAL_DECLARATIONS__", MaterialSources[material].Declarations); source.Replace("__MATERIAL_VERTEXPROGRAM__", MaterialSources[material].VertexShaderSource); source.AppendLine(); source.AppendLine(MaterialPassSources[pass].VertexStageTemplate); vsSource = source.ToString(); source.Clear(); // pixel shader source.Append(m_pixelTemplateBase); source.Replace("__MATERIAL_DECLARATIONS__", MaterialSources[material].Declarations); source.Replace("__MATERIAL_PIXELPROGRAM__", MaterialSources[material].PixelShaderSource); source.AppendLine(); source.AppendLine(MaterialPassSources[pass].PixelStageTemplate); psSource = source.ToString(); ProfilerShort.End(); }
// This is real initialization of this class!!! Instead of constructor. public virtual void Init(StringBuilder displayName, string model, MyEntity parentObject, float?scale, string modelCollision = null) { ProfilerShort.Begin("MyEntity.Init(...models...)"); MarkedForClose = false; Closed = false; this.Render.PersistentFlags = MyPersistentEntityFlags2.CastShadows; this.DisplayName = displayName != null?displayName.ToString() : null; RefreshModels(model, modelCollision); if (parentObject != null) { parentObject.Hierarchy.AddChild(this, false, false); } PositionComp.Scale = scale; AllocateEntityID(); ProfilerShort.End(); }
public void Submit() { ProfilerShort.Begin("RequestCollector.Submit"); MyCellCoord cell = default(MyCellCoord); foreach (var cellId in m_cancelRequests) { cell.SetUnpack(cellId); MyRenderProxy.CancelClipmapCell(m_clipmapId, cell); bool removed = m_sentRequests.Remove(cellId); Debug.Assert(removed); } foreach (var highPriorityRequest in m_unsentRequestsHigh) { cell.SetUnpack(highPriorityRequest); MyRenderProxy.RequireClipmapCell(m_clipmapId, cell, highPriority: true); } m_unsentRequestsHigh.Clear(); int addedCount = 0; for (int i = m_unsentRequestsLow.Length - 1; i >= 0; i--) { var unsent = m_unsentRequestsLow[i]; while (0 < unsent.Count && m_sentRequests.Count < m_maxRequests) { var cellId = unsent.FirstElement(); cell.SetUnpack(cellId); // Do Z-order style iteration of siblings that also need to // be requested. This ensures faster processing of cells and // shorter time when both lods are rendered. var baseCoord = (cell.CoordInLod >> 1) << 1; var offset = Vector3I.Zero; for (var it = new Vector3I.RangeIterator(ref Vector3I.Zero, ref Vector3I.One); it.IsValid(); it.GetNext(out offset)) { cell.CoordInLod = baseCoord + offset; cellId = cell.PackId64(); if (!unsent.Remove(cellId)) { continue; } Debug.Assert(!m_cancelRequests.Contains(cellId)); MyRenderProxy.RequireClipmapCell(m_clipmapId, cell, highPriority: false); bool added = m_sentRequests.Add(cellId); Debug.Assert(added); addedCount++; } } // When set reaches reasonably small size, stop freeing memory if (unsent.Count > 100) { unsent.TrimExcess(); } } m_cancelRequests.Clear(); ProfilerShort.End(); }
private void Update(ref Vector3D cameraPos, float farPlaneDistance) { ProfilerShort.Begin("MyRenderClipmap.Update"); var mostDetailedLod = (uint)DebugClipmapMostDetailedLod; if (m_lastMostDetailedLod != mostDetailedLod) { m_updateClipping = true; } m_lastMostDetailedLod = mostDetailedLod; for (uint lod = 0; lod < m_lodLevels.Length; ++lod) { m_lodLevels[lod].Visible = lod >= mostDetailedLod; } Vector3D localPosition; Vector3D.Transform(ref cameraPos, ref m_invWorldMatrix, out localPosition); double cellSizeHalf = MyVoxelCoordSystems.RenderCellSizeInMetersHalf(0); double threshold = cellSizeHalf * cellSizeHalf; if (!m_updateClipping && Vector3D.DistanceSquared(localPosition, m_lastClippingPosition) > threshold) { m_updateClipping = true; } if (m_updateClipping) { ProfilerShort.Begin("DoClipping"); Debug.Assert(m_scaleGroup == MyClipmapScaleEnum.Normal || m_scaleGroup == MyClipmapScaleEnum.Massive); for (int lod = m_lodLevels.Length - 1; lod >= mostDetailedLod; --lod) { ProfilerShort.Begin("Lod " + lod); m_lodLevels[lod].DoClipping(localPosition, farPlaneDistance, m_requestCollector); ProfilerShort.End(); } ProfilerShort.End(); ProfilerShort.Begin("KeepOrDiscardClippedCells"); for (int lod = m_lodLevels.Length - 1; lod >= mostDetailedLod; --lod) { m_lodLevels[lod].KeepOrDiscardClippedCells(m_requestCollector); } ProfilerShort.End(); m_lastClippingPosition = localPosition; m_updateClipping = false; } ProfilerShort.Begin("UpdateCellsInScene"); for (int lod = m_lodLevels.Length - 1; lod >= mostDetailedLod; --lod) { m_lodLevels[lod].UpdateCellsInScene(localPosition); } ProfilerShort.End(); m_requestCollector.Submit(); if (m_requestCollector.SentRequestsEmpty) { m_notReady.Remove(this); } ProfilerShort.End(); }
// Update all physics objects - AFTER physics simulation public static void UpdateAfterSimulation() { if (MySandboxGame.IsGameReady == false) { return; } VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("UpdateAfterSimulation"); { System.Diagnostics.Debug.Assert(MyEntities.UpdateInProgress == false); MyEntities.UpdateInProgress = true; ProfilerShort.Begin("UpdateAfter1"); m_entitiesForUpdate.List.ApplyChanges(); MySimpleProfiler.Begin("Blocks"); m_entitiesForUpdate.Iterate((x) => { ProfilerShort.Begin(x.GetType().Name); if (x.MarkedForClose == false) { if (ProfilePerBlock) { MyCubeBlock block = x as MyCubeBlock; if (block != null) { MySimpleProfiler.Begin(block.DefinitionDisplayNameText + (ProfilePerGrid ? $" - {block.CubeGrid.DisplayName}" : string.Empty)); if (ProfilePerGrid) { MySimpleProfiler.Begin("&&GRID&&" + block.CubeGrid.DisplayName); } } } if (ProfilePerGrid) { MyCubeGrid grid = x as MyCubeGrid; if (grid != null) { MySimpleProfiler.Begin("&&GRID&&" + grid.DisplayName); } } x.UpdateAfterSimulation(); if (ProfilePerBlock) { MyCubeBlock block = x as MyCubeBlock; if (block != null) { MySimpleProfiler.End(block.DefinitionDisplayNameText + (ProfilePerGrid ? $" - {block.CubeGrid.DisplayName}" : string.Empty)); if (ProfilePerGrid) { MySimpleProfiler.End("&&GRID&&" + block.CubeGrid.DisplayName); } } } if (ProfilePerGrid) { MyCubeGrid grid = x as MyCubeGrid; if (grid != null) { MySimpleProfiler.End("&&GRID&&" + grid.DisplayName); } } } ProfilerShort.End(); }); ProfilerShort.End(); ProfilerShort.Begin("UpdateAfter10"); m_entitiesForUpdate10.List.ApplyChanges(); m_entitiesForUpdate10.Iterate((x) => { ProfilerShort.Begin(x.GetType().Name); if (x.MarkedForClose == false) { if (ProfilePerBlock) { MyCubeBlock block = x as MyCubeBlock; if (block != null) { MySimpleProfiler.Begin(block.DefinitionDisplayNameText + (ProfilePerGrid ? $" - {block.CubeGrid.DisplayName}" : string.Empty)); if (ProfilePerGrid) { MySimpleProfiler.Begin("&&GRID&&" + block.CubeGrid.DisplayName); } } } if (ProfilePerGrid) { MyCubeGrid grid = x as MyCubeGrid; if (grid != null) { MySimpleProfiler.Begin("&&GRID&&" + grid.DisplayName); } } x.UpdateAfterSimulation10(); if (ProfilePerBlock) { MyCubeBlock block = x as MyCubeBlock; if (block != null) { MySimpleProfiler.End(block.DefinitionDisplayNameText + (ProfilePerGrid ? $" - {block.CubeGrid.DisplayName}" : string.Empty)); if (ProfilePerGrid) { MySimpleProfiler.End("&&GRID&&" + block.CubeGrid.DisplayName); } } } if (ProfilePerGrid) { MyCubeGrid grid = x as MyCubeGrid; if (grid != null) { MySimpleProfiler.End("&&GRID&&" + grid.DisplayName); } } } ProfilerShort.End(); }); ProfilerShort.End(); ProfilerShort.Begin("UpdateAfter100"); m_entitiesForUpdate100.List.ApplyChanges(); m_entitiesForUpdate100.Iterate((x) => { ProfilerShort.Begin(x.GetType().Name); if (x.MarkedForClose == false) { if (ProfilePerBlock) { MyCubeBlock block = x as MyCubeBlock; if (block != null) { MySimpleProfiler.Begin(block.DefinitionDisplayNameText + (ProfilePerGrid ? $" - {block.CubeGrid.DisplayName}" : string.Empty)); if (ProfilePerGrid) { MySimpleProfiler.Begin("&&GRID&&" + block.CubeGrid.DisplayName); } } } if (ProfilePerGrid) { MyCubeGrid grid = x as MyCubeGrid; if (grid != null) { MySimpleProfiler.Begin("&&GRID&&" + grid.DisplayName); } } x.UpdateAfterSimulation100(); if (ProfilePerBlock) { MyCubeBlock block = x as MyCubeBlock; if (block != null) { MySimpleProfiler.End(block.DefinitionDisplayNameText + (ProfilePerGrid ? $" - {block.CubeGrid.DisplayName}" : string.Empty)); if (ProfilePerGrid) { MySimpleProfiler.End("&&GRID&&" + block.CubeGrid.DisplayName); } } } if (ProfilePerGrid) { MyCubeGrid grid = x as MyCubeGrid; if (grid != null) { MySimpleProfiler.End("&&GRID&&" + grid.DisplayName); } } } ProfilerShort.End(); }); ProfilerShort.End(); MySimpleProfiler.End("Blocks"); MyEntities.UpdateInProgress = false; MyEntities.DeleteRememberedEntities(); } if (m_creationThread != null) { while (m_creationThread.ConsumeResult()) { ; // Add entities created asynchronously } } VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); }
public override void Draw() { ProfilerShort.Begin("base.Draw()"); base.Draw(); ProfilerShort.BeginNextBlock("DebugDraw"); DebugDraw(); if (BlockCreationIsActivated) { MyHud.Crosshair.Recenter(); } if (!IsActivated || CurrentBlockDefinition == null) { this.ClearRenderData(); ProfilerShort.End(); return; } this.DrawGuiIndicators(); if (!BuildInputValid) { this.ClearRenderData(); ProfilerShort.End(); return; } ProfilerShort.BeginNextBlock("DrawBuildingStepsCount"); DrawBuildingStepsCount(m_gizmo.SpaceDefault.m_startBuild, m_gizmo.SpaceDefault.m_startRemove, m_gizmo.SpaceDefault.m_continueBuild, ref m_gizmo.SpaceDefault.m_localMatrixAdd); ProfilerShort.End(); bool addPos = m_gizmo.SpaceDefault.m_startBuild.HasValue; bool removePos = false; float gridSize = 0; if (CurrentBlockDefinition != null) { gridSize = MyDefinitionManager.Static.GetCubeSize(CurrentBlockDefinition.CubeSize); } if (DynamicMode) { Vector3D freePlacementIntersectionPoint = IntersectionStart + IntersectionDistance * IntersectionDirection; if (m_hitInfo != null) { freePlacementIntersectionPoint = m_hitInfo.Value.Position; } addPos = this.CaluclateDynamicModePos(freePlacementIntersectionPoint, IsDynamicOverride()); MyCoordinateSystem.Static.Visible = false; } else { if (m_gizmo.SpaceDefault.m_startBuild == null && m_gizmo.SpaceDefault.m_startRemove == null) { if (!FreezeGizmo) { if (CurrentGrid != null) { MyCoordinateSystem.Static.Visible = false; ProfilerShort.Begin("MyCubeBuilder.Draw() - Calculate for grid"); addPos = GetAddAndRemovePositions(gridSize, PlacingSmallGridOnLargeStatic, out m_gizmo.SpaceDefault.m_addPos, out m_gizmo.SpaceDefault.m_addPosSmallOnLarge, out m_gizmo.SpaceDefault.m_addDir, out m_gizmo.SpaceDefault.m_removePos, out m_gizmo.SpaceDefault.m_removeBlock, out m_gizmo.SpaceDefault.m_blockIdInCompound, m_gizmo.SpaceDefault.m_removeBlocksInMultiBlock); if (addPos) { if (PlacingSmallGridOnLargeStatic) { m_gizmo.SpaceDefault.m_localMatrixAdd.Translation = m_gizmo.SpaceDefault.m_addPosSmallOnLarge.Value; } else { m_gizmo.SpaceDefault.m_localMatrixAdd.Translation = m_gizmo.SpaceDefault.m_addPos; } m_gizmo.SpaceDefault.m_worldMatrixAdd = m_gizmo.SpaceDefault.m_localMatrixAdd * CurrentGrid.WorldMatrix; var normal = GetSingleMountPointNormal(); // Gizmo add dir can be zero in some cases if (normal.HasValue && GridAndBlockValid && m_gizmo.SpaceDefault.m_addDir != Vector3I.Zero) { m_gizmo.SetupLocalAddMatrix(m_gizmo.SpaceDefault, normal.Value); } } ProfilerShort.End(); } else { MyCoordinateSystem.Static.Visible = true; ProfilerShort.Begin("MyCubeBuilder.Draw() - Calculate for voxel"); Vector3D localSnappedPos = m_lastLocalCoordSysData.LocalSnappedPos; if (!CubeBuilderDefinition.BuildingSettings.StaticGridAlignToCenter) { localSnappedPos -= new Vector3D(0.5 * gridSize, 0.5 * gridSize, -0.5 * gridSize); } Vector3I gridCoord = Vector3I.Round(localSnappedPos / gridSize); m_gizmo.SpaceDefault.m_addPos = gridCoord; m_gizmo.SpaceDefault.m_localMatrixAdd.Translation = m_lastLocalCoordSysData.LocalSnappedPos; m_gizmo.SpaceDefault.m_worldMatrixAdd = m_lastLocalCoordSysData.Origin.TransformMatrix; addPos = true; ProfilerShort.End(); } } Debug.Assert(!m_gizmo.SpaceDefault.m_worldMatrixAdd.IsNan(), "Invalid gizmo matrix"); if (m_gizmo.SpaceDefault.m_removeBlock != null) { removePos = true; } } } ProfilerShort.Begin("buildingDisabledByCockpit"); bool buildingDisabledByCockpit = MySession.Static.ControlledEntity != null && MySession.Static.ControlledEntity is MyCockpit && !SpectatorIsBuilding; if (!buildingDisabledByCockpit) { if (IsInSymmetrySettingMode) { m_gizmo.SpaceDefault.m_continueBuild = null; addPos = false; removePos = false; if (m_gizmo.SpaceDefault.m_removeBlock != null) { var min = (m_gizmo.SpaceDefault.m_removeBlock.Min * CurrentGrid.GridSize); var max = (m_gizmo.SpaceDefault.m_removeBlock.Max * CurrentGrid.GridSize); Vector3 center = (min + max) * 0.5f; Color color = DrawSymmetryPlane(m_symmetrySettingMode, CurrentGrid, center); DrawSemiTransparentBox(CurrentGrid, m_gizmo.SpaceDefault.m_removeBlock, color.ToVector4()); } } if (CurrentGrid != null && (UseSymmetry || IsInSymmetrySettingMode)) { if (CurrentGrid.XSymmetryPlane != null) { Vector3 center = CurrentGrid.XSymmetryPlane.Value * CurrentGrid.GridSize; DrawSymmetryPlane(CurrentGrid.XSymmetryOdd ? MySymmetrySettingModeEnum.XPlaneOdd : MySymmetrySettingModeEnum.XPlane, CurrentGrid, center); } if (CurrentGrid.YSymmetryPlane != null) { Vector3 center = CurrentGrid.YSymmetryPlane.Value * CurrentGrid.GridSize; DrawSymmetryPlane(CurrentGrid.YSymmetryOdd ? MySymmetrySettingModeEnum.YPlaneOdd : MySymmetrySettingModeEnum.YPlane, CurrentGrid, center); } if (CurrentGrid.ZSymmetryPlane != null) { Vector3 center = CurrentGrid.ZSymmetryPlane.Value * CurrentGrid.GridSize; DrawSymmetryPlane(CurrentGrid.ZSymmetryOdd ? MySymmetrySettingModeEnum.ZPlaneOdd : MySymmetrySettingModeEnum.ZPlane, CurrentGrid, center); } } } ProfilerShort.BeginNextBlock("UpdateGizmos"); UpdateGizmos(addPos, removePos, true); ProfilerShort.BeginNextBlock("UpdateRenderInstanceData"); m_renderData.UpdateRenderInstanceData(); ProfilerShort.BeginNextBlock("CurrentVoxelBase"); if (CurrentGrid == null || (DynamicMode && CurrentGrid != null)) { MatrixD drawMatrix = m_gizmo.SpaceDefault.m_worldMatrixAdd; Vector3D rotatedModelOffset; Vector3D.TransformNormal(ref CurrentBlockDefinition.ModelOffset, ref drawMatrix, out rotatedModelOffset); drawMatrix.Translation = drawMatrix.Translation + rotatedModelOffset; m_renderData.UpdateRenderEntitiesData(drawMatrix, UseTransparency, CurrentBlockScale); } else { m_renderData.UpdateRenderEntitiesData(CurrentGrid.WorldMatrix, UseTransparency); } ProfilerShort.BeginNextBlock("UpdateBlockInfoHud"); UpdateBlockInfoHud(); ProfilerShort.End(); }
public static void CutOutShapeWithProperties( MyVoxelBase voxelMap, MyShape shape, out float voxelsCountInPercent, out MyVoxelMaterialDefinition voxelMaterial, Dictionary <MyVoxelMaterialDefinition, int> exactCutOutMaterials = null, bool updateSync = false, bool onlyCheck = false, bool applyDamageMaterial = false, bool onlyApplyMaterial = false) { if (MySession.Static.EnableVoxelDestruction == false) { voxelsCountInPercent = 0; voxelMaterial = null; return; } ProfilerShort.Begin("MyVoxelGenerator::CutOutShapeWithProperties()"); int originalSum = 0; int removedSum = 0; bool materials = exactCutOutMaterials != null; // Bring the shape into voxel space. var oldTranmsform = shape.Transformation; var newTransf = oldTranmsform * voxelMap.PositionComp.WorldMatrixInvScaled; newTransf.Translation += voxelMap.SizeInMetresHalf; shape.Transformation = newTransf; // This boundary should now be in our local space var bbox = shape.GetWorldBoundaries(); Vector3I minCorner, maxCorner; ComputeShapeBounds(voxelMap, ref bbox, Vector3.Zero, voxelMap.Storage.Size, out minCorner, out maxCorner); bool readMaterial = exactCutOutMaterials != null || applyDamageMaterial; var cacheMin = minCorner - 1; var cacheMax = maxCorner + 1; //try on making the read/write cell alligned see MyOctreeStorage.WriteRange - Micro octree leaf /*const int SHIFT = 4; * const int REM = (1 << SHIFT) - 1; * const int MASK = ~REM; * cacheMin &= MASK; * cacheMax = (cacheMax + REM) & MASK;*/ voxelMap.Storage.ClampVoxelCoord(ref cacheMin); voxelMap.Storage.ClampVoxelCoord(ref cacheMax); m_cache.Resize(cacheMin, cacheMax); m_cache.ClearMaterials(0); // Advise that the read content shall be cached MyVoxelRequestFlags flags = MyVoxelRequestFlags.AdviseCache; voxelMap.Storage.ReadRange(m_cache, readMaterial ? MyStorageDataTypeFlags.ContentAndMaterial : MyStorageDataTypeFlags.Content, 0, ref cacheMin, ref cacheMax, ref flags); Vector3I center; if (materials) { center = m_cache.Size3D / 2; voxelMaterial = MyDefinitionManager.Static.GetVoxelMaterialDefinition(m_cache.Material(ref center)); } else { center = (cacheMin + cacheMax) / 2; voxelMaterial = voxelMap.Storage.GetMaterialAt(ref center); } MyVoxelMaterialDefinition voxelMat = null; ProfilerShort.Begin("Main loop"); Vector3I pos; for (pos.X = minCorner.X; pos.X <= maxCorner.X; ++pos.X) { for (pos.Y = minCorner.Y; pos.Y <= maxCorner.Y; ++pos.Y) { for (pos.Z = minCorner.Z; pos.Z <= maxCorner.Z; ++pos.Z) { // get original amount var relPos = pos - cacheMin; var lin = m_cache.ComputeLinear(ref relPos); var original = m_cache.Content(lin); if (original == MyVoxelConstants.VOXEL_CONTENT_EMPTY) // if there is nothing to remove { continue; } Vector3D spos = (Vector3D)(pos - voxelMap.StorageMin) * MyVoxelConstants.VOXEL_SIZE_IN_METRES; var volume = shape.GetVolume(ref spos); if (volume == 0f) // if there is no intersection { continue; } var maxRemove = (int)(volume * MyVoxelConstants.VOXEL_CONTENT_FULL); var toRemove = maxRemove; // (int)(maxRemove * voxelMat.DamageRatio); var newVal = Math.Max(original - toRemove, 0); //MathHelper.Clamp(original - toRemove, 0, original-maxRemove); var removed = original - newVal; if (!onlyCheck && !onlyApplyMaterial) { m_cache.Content(lin, (byte)newVal); } originalSum += original; removedSum += removed; if (readMaterial) { voxelMat = MyDefinitionManager.Static.GetVoxelMaterialDefinition(m_cache.Material(lin)); } if (exactCutOutMaterials != null) { int value = 0; exactCutOutMaterials.TryGetValue(voxelMat, out value); value += (MyFakes.ENABLE_REMOVED_VOXEL_CONTENT_HACK ? (int)(removed * 3.9f) : removed); exactCutOutMaterials[voxelMat] = value; } if (applyDamageMaterial && voxelMat.HasDamageMaterial && !onlyCheck) { m_cache.Material(lin, voxelMat.DamagedMaterialId); } } } } if (removedSum > 0 && updateSync && Sync.IsServer) { shape.SendDrillCutOutRequest(voxelMap, applyDamageMaterial); } ProfilerShort.BeginNextBlock("Write"); if (removedSum > 0 && !onlyCheck) { // Clear all small voxel that may have been created during explosion. They can be created even outside the range of // explosion sphere, e.g. if you have three voxels in a row A, B, C, where A is 255, B is 60, and C is 255. During the // explosion you change C to 0, so now we have 255, 60, 0. Than another explosion that will change A to 0, so we // will have 0, 60, 0. But B was always outside the range of the explosion. So this is why we need to do -1/+1 and remove // B voxels too. //!! TODO AR & MK : check if this is needed !! //RemoveSmallVoxelsUsingChachedVoxels(); var dataTypeFlags = applyDamageMaterial ? MyStorageDataTypeFlags.ContentAndMaterial : MyStorageDataTypeFlags.Content; if (MyFakes.LOG_NAVMESH_GENERATION) { MyAIComponent.Static.Pathfinding.VoxelPathfinding.DebugLog.LogStorageWrite(voxelMap, m_cache, dataTypeFlags, cacheMin, cacheMax); } voxelMap.Storage.WriteRange(m_cache, dataTypeFlags, ref cacheMin, ref cacheMax); } ProfilerShort.End(); voxelsCountInPercent = (originalSum > 0f) ? (float)removedSum / (float)originalSum : 0f; shape.Transformation = oldTranmsform; if (removedSum > 0) { OnVoxelChanged(MyVoxelBase.OperationType.Cut, voxelMap, shape); } ProfilerShort.End(); }
internal static void Run() { ProfilerShort.Begin("MyOutline.Run"); MyGpuProfiler.IC_BeginBlock("MyOutline.Run"); // set resolved depth/ stencil // render all with proper depth-stencil state // blur // blend to main target testing with stencil again MyOutlinePass.Instance.ViewProjection = MyEnvironment.ViewProjectionAt0; MyOutlinePass.Instance.Viewport = new MyViewport(MyRender11.ViewportResolution.X, MyRender11.ViewportResolution.Y); MyOutlinePass.Instance.PerFrame(); MyOutlinePass.Instance.Begin(); RC.Clear(); RC.DeviceContext.VertexShader.SetShaderResources(0, null, null, null, null, null, null); RC.DeviceContext.GeometryShader.SetShaderResources(0, null, null, null, null, null, null); RC.DeviceContext.PixelShader.SetShaderResources(0, null, null, null, null, null, null); RC.DeviceContext.ComputeShader.SetShaderResources(0, null, null, null, null, null, null); if (MyRender11.MultisamplingEnabled) { RC.DeviceContext.ClearRenderTargetView(MyRender11.m_rgba8_ms.m_RTV, new SharpDX.Color4(0, 0, 0, 0)); RC.DeviceContext.OutputMerger.SetTargets(MyGBuffer.Main.DepthStencil.m_DSV, MyRender11.m_rgba8_ms.m_RTV); } else { RC.DeviceContext.ClearRenderTargetView(MyRender11.m_rgba8_1.m_RTV, new SharpDX.Color4(0, 0, 0, 0)); RC.DeviceContext.OutputMerger.SetTargets(MyGBuffer.Main.DepthStencil.m_DSV, MyRender11.m_rgba8_1.m_RTV); } float maxThickness = 0f; foreach (var pair in m_outlines) { MyActor actor = MyIDTracker <MyActor> .FindByID(pair.Key); MyRenderableComponent renderableComponent; if (actor == null || (renderableComponent = actor.GetRenderable()) == null) { // If an actor has been removed without removing outlines, just remove the outlines too m_keysToRemove.Add(pair.Key); continue; } var renderLod = renderableComponent.Lods[renderableComponent.CurrentLod]; var model = renderableComponent.GetModel(); LodMeshId currentModelId; if (!MyMeshes.TryGetLodMesh(model, renderableComponent.CurrentLod, out currentModelId)) { Debug.Fail("Mesh for outlining not found!"); continue; } foreach (MyOutlineDesc descriptor in pair.Value) { if (!renderableComponent.IsRenderedStandAlone) { MyGroupLeafComponent leafComponent = actor.GetGroupLeaf(); MyGroupRootComponent groupComponent = leafComponent.RootGroup; if (groupComponent != null) { RecordMeshPartCommands(model, actor, groupComponent, groupComponent.m_proxy, descriptor, ref maxThickness); } continue; } if (descriptor.SectionIndex == -1) { RecordMeshPartCommands(model, currentModelId, renderableComponent, renderLod, descriptor, ref maxThickness); } else { RecordMeshSectionCommands(model, currentModelId, renderableComponent, renderLod, descriptor, ref maxThickness); } } } MyOutlinePass.Instance.End(); RC.SetBS(null); foreach (var outlineKey in m_keysToRemove) { m_outlines.Remove(outlineKey); } m_keysToRemove.SetSize(0); ShaderResourceView initialSourceView = MyRender11.MultisamplingEnabled ? MyRender11.m_rgba8_ms.m_SRV : MyRender11.m_rgba8_1.m_SRV; RenderTargetView renderTargetview = MyRender11.MultisamplingEnabled ? MyRender11.m_rgba8_ms.m_RTV : MyRender11.m_rgba8_1.m_RTV; if (maxThickness > 0) { MyBlur.Run(renderTargetview, MyRender11.m_rgba8_2.m_RTV, MyRender11.m_rgba8_2.m_SRV, initialSourceView, (int)Math.Round(5 * maxThickness), MyBlur.MyBlurDensityFunctionType.Exponential, 0.25f, null, MyFoliageRenderingPass.GrassStencilMask, MyRender11.Settings.BlurCopyOnDepthStencilFail); } MyGpuProfiler.IC_EndBlock(); ProfilerShort.End(); }
protected override void CalculateTransforms() { ProfilerShort.Begin("MyCharacter.CalculateTransforms"); base.CalculateTransforms(); VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("UpdateLeftHandItemPosition"); if (m_leftHandItem != null) { UpdateLeftHandItemPosition(); } VRageRender.MyRenderProxy.GetRenderProfiler().StartNextBlock("Calculate Hand IK"); m_aimedPoint = GetAimedPointFromCamera(); if (m_currentWeapon != null) { if (!MyPerGameSettings.UseAnimationInsteadOfIK) { UpdateWeaponPosition(); //mainly IK and some zoom + ironsight stuff if (m_handItemDefinition.SimulateLeftHand && m_leftHandIKStartBone != -1 && m_leftHandIKEndBone != -1 && (!UseAnimationForWeapon && m_animationToIKState == 0)) { MatrixD leftHand = (MatrixD)m_handItemDefinition.LeftHand * ((MyEntity)m_currentWeapon).WorldMatrix; CalculateHandIK(m_leftHandIKStartBone, m_leftForearmBone, m_leftHandIKEndBone, ref leftHand); } if (m_handItemDefinition.SimulateRightHand && m_rightHandIKStartBone != -1 && m_rightHandIKEndBone != -1 && (!UseAnimationForWeapon || m_animationToIKState != 0)) { MatrixD rightHand = (MatrixD)m_handItemDefinition.RightHand * ((MyEntity)m_currentWeapon).WorldMatrix; CalculateHandIK(m_rightHandIKStartBone, m_rightForearmBone, m_rightHandIKEndBone, ref rightHand); } } else { Debug.Assert(m_rightHandItemBone != -1, "Invalid bone for weapon."); if (m_rightHandItemBone != -1) { //use animation for right hand item MatrixD rightHandItemMatrix = Bones[m_rightHandItemBone].AbsoluteTransform * WorldMatrix; //var rightHandItemMatrix = ((MyEntity)m_currentWeapon).PositionComp.WorldMatrix; //use with UpdateWeaponPosition() but not working for barbarians Vector3D up = rightHandItemMatrix.Up; rightHandItemMatrix.Up = rightHandItemMatrix.Forward; rightHandItemMatrix.Forward = up; rightHandItemMatrix.Right = -rightHandItemMatrix.Right; ((MyEntity)m_currentWeapon).PositionComp.WorldMatrix = rightHandItemMatrix; } } } VRageRender.MyRenderProxy.GetRenderProfiler().StartNextBlock("ComputeBoneTransform"); for (int i = 0; i < Bones.Count; i++) { MyCharacterBone bone = Bones[i]; BoneRelativeTransforms[i] = bone.ComputeBoneTransform(); } VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); ProfilerShort.End(); }
void Scan() { m_lastScan = MySession.Static.GameplayFrameCounter; ProfilerShort.Begin("QueryTargets"); BoundingSphereD bs = new BoundingSphereD(Vector3D.Transform(m_queryLocal.Center, m_grid.WorldMatrix), m_queryLocal.Radius); m_targetRoots.Clear(); m_targetBlocks.Clear(); ProfilerShort.Begin("MyGamePruningStructure.GetAllTop..."); MyGamePruningStructure.GetAllTopMostEntitiesInSphere(ref bs, m_targetRoots); ProfilerShort.End(); int targetCount = m_targetRoots.Count; m_ownersA.AddList(m_grid.SmallOwners); m_ownersA.AddList(m_grid.BigOwners); for (int i = 0; i < targetCount; i++) { var grid = m_targetRoots[i] as MyCubeGrid; //perf: using grid owners to not querry friendly ships for blocks if (grid != null) { if (grid.Physics != null && !grid.Physics.Enabled) { continue; } ProfilerShort.Begin("Friend checks"); bool enemy = false; if (grid.BigOwners.Count == 0 && grid.SmallOwners.Count == 0) { foreach (var owner in m_ownersA) { if (MyIDModule.GetRelation(owner, 0) == VRage.Game.MyRelationsBetweenPlayerAndBlock.Enemies) { enemy = true; break; } } } else { m_ownersB.AddList(grid.BigOwners); m_ownersB.AddList(grid.SmallOwners); foreach (var owner in m_ownersA) { foreach (var other in m_ownersB) { if (MyIDModule.GetRelation(owner, other) == VRage.Game.MyRelationsBetweenPlayerAndBlock.Enemies) { enemy = true; break; } } } m_ownersB.Clear(); } ProfilerShort.End(); if (enemy) { ProfilerShort.Begin("grid.Hierarchy.QuerySphere"); var list = m_targetBlocks.GetOrAddList(grid); grid.Hierarchy.QuerySphere(ref bs, list); ProfilerShort.End(); } else { MyIDModule module; //performance unfriendly case when grid is not clearly neutral or enemy foreach (var block in grid.GetFatBlocks()) { var moduleOwner = ((MyEntity)block) as IMyComponentOwner <MyIDModule>; if (!(moduleOwner != null && moduleOwner.GetComponent(out module))) { continue; } var myID = block.OwnerId; foreach (var owner in m_ownersA) { if (MyIDModule.GetRelation(owner, myID) == VRage.Game.MyRelationsBetweenPlayerAndBlock.Enemies) { enemy = true; break; } } if (enemy) { break; } } if (enemy) { ProfilerShort.Begin("grid.Hierarchy.QuerySphere"); var list = m_targetBlocks.GetOrAddList(grid); grid.Hierarchy.QuerySphere(ref bs, list); ProfilerShort.End(); } } } } m_ownersA.Clear(); ProfilerShort.Begin("Filter small objects"); for (int i = m_targetRoots.Count - 1; i >= 0; i--) { var target = m_targetRoots[i]; if (target is Sandbox.Game.Entities.Debris.MyDebrisBase || target is MyFloatingObject || (target.Physics != null && !target.Physics.Enabled) || target.GetTopMostParent().Physics == null || !target.GetTopMostParent().Physics.Enabled) { m_targetRoots.RemoveAtFast(i); } } ProfilerShort.End(); ProfilerShort.End(); }
public static void FixPosition(MyFracturedPiece fp) { //return; ProfilerShort.Begin("FixPosition"); var shape = fp.Physics.BreakableBody.BreakableShape; if (shape.GetChildrenCount() == 0) { ProfilerShort.End(); return; } shape.GetChildren(m_tmpInfos); var offset = m_tmpInfos[0].GetTransform().Translation; if (offset.LengthSquared() < 1) { m_tmpInfos.Clear(); ProfilerShort.End(); return; } var lst = new List <HkdConnection>(); var set = new HashSet <HkdBreakableShape>(); var set2 = new HashSet <HkdBreakableShape>(); set.Add(shape); shape.GetConnectionList(lst); fp.PositionComp.SetPosition(Vector3D.Transform(offset, fp.PositionComp.WorldMatrix)); foreach (var child in m_tmpInfos) { var m = child.GetTransform(); m.Translation -= offset; child.SetTransform(ref m); m_tmpInfos2.Add(child); HkdBreakableShape par = child.Shape; par.GetConnectionList(lst); while (par.HasParent) { par = par.GetParent(); if (set.Add(par)) { par.GetConnectionList(lst); } else { } } set2.Add(child.Shape); } m_tmpInfos.Clear(); HkdBreakableShape compound = new HkdCompoundBreakableShape(shape, m_tmpInfos2); //HkMassProperties mp = new HkMassProperties(); ((HkdCompoundBreakableShape)compound).RecalcMassPropsFromChildren(); compound.SetChildrenParent(compound); foreach (var c in lst) { HkBaseSystem.EnableAssert(390435339, true); if (!set2.Contains(c.ShapeA) || !set2.Contains(c.ShapeB)) { continue; } var cref = c; compound.AddConnection(ref cref); } fp.Physics.BreakableBody.BreakableShape = compound; m_tmpInfos2.Clear(); ((HkdCompoundBreakableShape)compound).RecalcMassPropsFromChildren(); ProfilerShort.End(); }
public static void CutOutShapeWithProperties( MyVoxelBase voxelMap, MyShape shape, out float voxelsCountInPercent, out MyVoxelMaterialDefinition voxelMaterial, Dictionary <MyVoxelMaterialDefinition, int> exactCutOutMaterials = null, bool updateSync = false, bool onlyCheck = false) { ProfilerShort.Begin("MyVoxelGenerator::CutOutShapeWithProperties()"); int originalSum = 0; int removedSum = 0; var bbox = shape.GetWorldBoundaries(); Vector3I minCorner, maxCorner; ComputeShapeBounds(ref bbox, voxelMap.PositionLeftBottomCorner, voxelMap.Storage.Size, out minCorner, out maxCorner); var cacheMin = minCorner - 1; var cacheMax = maxCorner + 1; voxelMap.Storage.ClampVoxelCoord(ref cacheMin); voxelMap.Storage.ClampVoxelCoord(ref cacheMax); m_cache.Resize(cacheMin, cacheMax); voxelMap.Storage.ReadRange(m_cache, MyStorageDataTypeFlags.ContentAndMaterial, 0, ref cacheMin, ref cacheMax); { var shapeCenter = bbox.Center; Vector3I exactCenter; MyVoxelCoordSystems.WorldPositionToVoxelCoord(voxelMap.PositionLeftBottomCorner, ref shapeCenter, out exactCenter); exactCenter -= cacheMin; exactCenter = Vector3I.Clamp(exactCenter, Vector3I.Zero, m_cache.Size3D - 1); voxelMaterial = MyDefinitionManager.Static.GetVoxelMaterialDefinition(m_cache.Material(ref exactCenter)); } for (var it = new Vector3I.RangeIterator(ref minCorner, ref maxCorner); it.IsValid(); it.MoveNext()) { var relPos = it.Current - cacheMin; // get original amount var original = m_cache.Content(ref relPos); if (original == MyVoxelConstants.VOXEL_CONTENT_EMPTY) // if there is nothing to remove { continue; } Vector3D vpos; MyVoxelCoordSystems.VoxelCoordToWorldPosition(voxelMap.PositionLeftBottomCorner, ref it.Current, out vpos); var volume = shape.GetVolume(ref vpos); if (volume == 0f) // if there is no intersection { continue; } var maxRemove = (int)(volume * MyVoxelConstants.VOXEL_CONTENT_FULL); var voxelMat = MyDefinitionManager.Static.GetVoxelMaterialDefinition(m_cache.Material(ref relPos)); var toRemove = (int)(maxRemove * voxelMat.DamageRatio); var newVal = MathHelper.Clamp(original - toRemove, 0, maxRemove); var removed = Math.Abs(original - newVal); if (!onlyCheck) { m_cache.Content(ref relPos, (byte)newVal); } originalSum += original; removedSum += removed; if (exactCutOutMaterials != null) { int value = 0; exactCutOutMaterials.TryGetValue(voxelMat, out value); value += (MyFakes.ENABLE_REMOVED_VOXEL_CONTENT_HACK ? (int)(removed * 3.9f) : removed); exactCutOutMaterials[voxelMat] = value; } } if (removedSum > 0 && !onlyCheck) { // Clear all small voxel that may have been created during explosion. They can be created even outside the range of // explosion sphere, e.g. if you have three voxels in a row A, B, C, where A is 255, B is 60, and C is 255. During the // explosion you change C to 0, so now we have 255, 60, 0. Than another explosion that will change A to 0, so we // will have 0, 60, 0. But B was always outside the range of the explosion. So this is why we need to do -1/+1 and remove // B voxels too. //!! TODO AR & MK : check if this is needed !! RemoveSmallVoxelsUsingChachedVoxels(); voxelMap.Storage.WriteRange(m_cache, MyStorageDataTypeFlags.Content, ref cacheMin, ref cacheMax); } if (removedSum > 0 && updateSync && Sync.IsServer) { shape.SendDrillCutOutRequest(voxelMap.SyncObject); } voxelsCountInPercent = (originalSum > 0f) ? (float)removedSum / (float)originalSum : 0f; ProfilerShort.End(); }
internal static byte[] Compile(string filepath, ShaderMacro[] macros, MyShaderProfile profile, string sourceDescriptor, bool optimize, bool invalidateCache, out bool wasCached, out string compileLog) { ProfilerShort.Begin("MyShaders.Compile"); var globalMacros = GlobalShaderMacros; if (globalMacros.Length != 0) { var macroList = new List <ShaderMacro>(); macroList.AddRange(globalMacros); macroList.AddRange(macros); macros = macroList.ToArray(); } string function = ProfileEntryPoint(profile); string profileName = ProfileToString(profile); wasCached = false; compileLog = null; ProfilerShort.Begin("MyShaders.Preprocess"); string errors; string preprocessedSource = PreprocessShader(filepath, macros, out errors); if (preprocessedSource == null) { compileLog = errors; return(null); } // modify preprocessor to be readable for NSight if (MyCompilationSymbols.EnableShaderDebuggingInNSight) { preprocessedSource = Regex.Replace(preprocessedSource, "#line [^\n]*\n", ""); } MyShaderIdentity identity = null; if (!invalidateCache && !MyCompilationSymbols.EnableShaderDebuggingInNSight) { identity = MyShaderCache.ComputeShaderIdentity(preprocessedSource, profile); byte[] cached; if (MyShaderCache.TryFetch(identity, out cached)) { wasCached = true; ProfilerShort.End(); ProfilerShort.End(); return(cached); } } ProfilerShort.End(); try { string descriptor = sourceDescriptor + " " + profile + " " + macros.GetString(); CompilationResult compilationResult; if (MyCompilationSymbols.EnableShaderDebuggingInNSight) { if (MyCompilationSymbols.EnableShaderPreprocessorInNSight) { compilationResult = ShaderBytecode.Compile(preprocessedSource, function, profileName, 0, 0, macros, new MyIncludeProcessor(filepath)); } else { compilationResult = ShaderBytecode.CompileFromFile(filepath, function, profileName, 0, 0, macros, new MyIncludeProcessor(filepath)); } } else { compilationResult = ShaderBytecode.Compile(preprocessedSource, function, profileName, optimize ? ShaderFlags.OptimizationLevel3 : ShaderFlags.None, EffectFlags.None, filepath); } if (DUMP_CODE) { var disassembly = compilationResult.Bytecode.Disassemble(DisassemblyFlags.EnableColorCode | DisassemblyFlags.EnableInstructionNumbering); string asmPath; if (MyRender11.DebugMode) { asmPath = Path.GetFileName(descriptor + "__DEBUG.html"); } else { asmPath = Path.GetFileName(descriptor + "__O3.html"); } using (var writer = new StreamWriter(Path.Combine(MyFileSystem.ContentPath, "ShaderOutput", asmPath))) { writer.Write(disassembly); } } if (compilationResult.Message != null) { compileLog = compilationResult.Message; } if (!MyCompilationSymbols.EnableShaderDebuggingInNSight && compilationResult.Bytecode != null && compilationResult.Bytecode.Data.Length > 0) { MyShaderCache.Store(identity, compilationResult.Bytecode.Data); } return(compilationResult.Bytecode != null ? compilationResult.Bytecode.Data : null); } catch (Exception e) { Debug.WriteLine(preprocessedSource); compileLog = e.Message; } finally { ProfilerShort.End(); } return(null); }
public override void Init(MyObjectBuilder_EntityBase builder, Sandbox.Engine.Voxels.IMyStorage storage) { ProfilerShort.Begin("MyPlanet::Init()"); if (MyFakes.ENABLE_PLANETS == false) { throw new PlanetsNotEnabledException(); } ProfilerShort.Begin("MyVoxelBase Init"); SyncFlag = true; base.Init(builder); ProfilerShort.BeginNextBlock("Load Saved Data"); var ob = (MyObjectBuilder_Planet)builder; if (ob == null) { return; } if (ob.MutableStorage) { StorageName = ob.StorageName; } else { StorageName = string.Format("{0}", ob.StorageName); } m_planetInitValues.StorageName = StorageName; m_planetInitValues.PositionMinCorner = ob.PositionAndOrientation.Value.Position; m_planetInitValues.HasAtmosphere = ob.HasAtmosphere; m_planetInitValues.AtmosphereRadius = ob.AtmosphereRadius; m_planetInitValues.AtmosphereWavelengths = ob.AtmosphereWavelengths; m_planetInitValues.GravityFalloff = ob.GravityFalloff; m_planetInitValues.MarkAreaEmpty = ob.MarkAreaEmpty; m_planetInitValues.SurfaceGravity = ob.SurfaceGravity; m_planetInitValues.AddGps = ob.ShowGPS; m_planetInitValues.SpherizeWithDistance = ob.SpherizeWithDistance; m_planetInitValues.Generator = ob.PlanetGenerator == "" ? null : MyDefinitionManager.Static.GetDefinition <MyPlanetGeneratorDefinition>(MyStringHash.GetOrCompute(ob.PlanetGenerator)); if (m_planetInitValues.Generator == null) { string message = string.Format("No definition found for planet generator {0}.", ob.PlanetGenerator); MyLog.Default.WriteLine(message); throw new Exception(message); } m_planetInitValues.AtmosphereSettings = m_planetInitValues.Generator.AtmosphereSettings.HasValue ? m_planetInitValues.Generator.AtmosphereSettings.Value : MyAtmosphereSettings.Defaults(); m_planetInitValues.UserCreated = false; ProfilerShort.BeginNextBlock("Load Storage"); if (storage != null) { m_planetInitValues.Storage = storage; } else { m_planetInitValues.Storage = MyStorageBase.Load(ob.StorageName); } ProfilerShort.BeginNextBlock("Init Internal"); Init(m_planetInitValues); ProfilerShort.End(); ProfilerShort.End(); }
public static void MakeCrater(MyVoxelBase voxelMap, BoundingSphereD sphere, Vector3 normal, MyVoxelMaterialDefinition material) { ProfilerShort.Begin("MakeCrater"); Vector3I minCorner, maxCorner; { Vector3D sphereMin = sphere.Center - (sphere.Radius - MyVoxelConstants.VOXEL_SIZE_IN_METRES); Vector3D sphereMax = sphere.Center + (sphere.Radius + MyVoxelConstants.VOXEL_SIZE_IN_METRES); MyVoxelCoordSystems.WorldPositionToVoxelCoord(voxelMap.PositionLeftBottomCorner, ref sphereMin, out minCorner); MyVoxelCoordSystems.WorldPositionToVoxelCoord(voxelMap.PositionLeftBottomCorner, ref sphereMax, out maxCorner); } voxelMap.Storage.ClampVoxelCoord(ref minCorner); voxelMap.Storage.ClampVoxelCoord(ref maxCorner); // We are tracking which voxels were changed, so we can invalidate only needed cells in the cache bool changed = false; ProfilerShort.Begin("Reading cache"); m_cache.Resize(minCorner, maxCorner); voxelMap.Storage.ReadRange(m_cache, MyStorageDataTypeFlags.ContentAndMaterial, 0, ref minCorner, ref maxCorner); ProfilerShort.End(); ProfilerShort.Begin("Changing cache"); int removedVoxelContent = 0; Vector3I tempVoxelCoord; Vector3I cachePos; for (tempVoxelCoord.Z = minCorner.Z, cachePos.Z = 0; tempVoxelCoord.Z <= maxCorner.Z; tempVoxelCoord.Z++, ++cachePos.Z) { for (tempVoxelCoord.Y = minCorner.Y, cachePos.Y = 0; tempVoxelCoord.Y <= maxCorner.Y; tempVoxelCoord.Y++, ++cachePos.Y) { for (tempVoxelCoord.X = minCorner.X, cachePos.X = 0; tempVoxelCoord.X <= maxCorner.X; tempVoxelCoord.X++, ++cachePos.X) { Vector3D voxelPosition; MyVoxelCoordSystems.VoxelCoordToWorldPosition(voxelMap.PositionLeftBottomCorner, ref tempVoxelCoord, out voxelPosition); float addDist = (float)(voxelPosition - sphere.Center).Length(); float addDiff = (float)(addDist - sphere.Radius); byte newContent; if (addDiff > MyVoxelConstants.VOXEL_SIZE_IN_METRES_HALF) { newContent = MyVoxelConstants.VOXEL_CONTENT_EMPTY; } else if (addDiff < -MyVoxelConstants.VOXEL_SIZE_IN_METRES_HALF) { newContent = MyVoxelConstants.VOXEL_CONTENT_FULL; } else { // This formula will work even if diff is positive or negative newContent = (byte)(MyVoxelConstants.VOXEL_ISO_LEVEL - addDiff / MyVoxelConstants.VOXEL_SIZE_IN_METRES_HALF * MyVoxelConstants.VOXEL_ISO_LEVEL); } byte originalContent = m_cache.Content(ref cachePos); if (newContent > originalContent && originalContent > 0) { if (material != null) { m_cache.Material(ref cachePos, material.Index); } changed = true; m_cache.Content(ref cachePos, newContent); } float delDist = (float)(voxelPosition - (sphere.Center + (float)sphere.Radius * 0.7f * normal)).Length(); float delDiff = (float)(delDist - sphere.Radius); byte contentToRemove; if (delDiff > MyVoxelConstants.VOXEL_SIZE_IN_METRES_HALF) { contentToRemove = MyVoxelConstants.VOXEL_CONTENT_EMPTY; } else if (delDiff < -MyVoxelConstants.VOXEL_SIZE_IN_METRES_HALF) { contentToRemove = MyVoxelConstants.VOXEL_CONTENT_FULL; } else { // This formula will work even if diff is positive or negative contentToRemove = (byte)(MyVoxelConstants.VOXEL_ISO_LEVEL - delDiff / MyVoxelConstants.VOXEL_SIZE_IN_METRES_HALF * MyVoxelConstants.VOXEL_ISO_LEVEL); } originalContent = m_cache.Content(ref cachePos); if (originalContent > MyVoxelConstants.VOXEL_CONTENT_EMPTY && contentToRemove > MyVoxelConstants.VOXEL_CONTENT_EMPTY) { changed = true; int newVal = originalContent - contentToRemove; if (newVal < MyVoxelConstants.VOXEL_CONTENT_EMPTY) { newVal = MyVoxelConstants.VOXEL_CONTENT_EMPTY; } m_cache.Content(ref cachePos, (byte)newVal); removedVoxelContent += originalContent - newVal; } float setDist = (float)(voxelPosition - (sphere.Center - (float)sphere.Radius * 0.5f * normal)).Length(); float setDiff = (float)(setDist - sphere.Radius / 4f); if (setDiff <= MyVoxelConstants.VOXEL_SIZE_IN_METRES * 1.5f) // could be VOXEL_SIZE_IN_METRES_HALF, but we want to set material in empty cells correctly { byte indestructibleContentToSet = MyVoxelConstants.VOXEL_CONTENT_FULL; if (setDiff >= MyVoxelConstants.VOXEL_SIZE_IN_METRES_HALF) // outside { indestructibleContentToSet = MyVoxelConstants.VOXEL_CONTENT_EMPTY; } else if (setDiff >= -MyVoxelConstants.VOXEL_SIZE_IN_METRES_HALF) // boundary { indestructibleContentToSet = (byte)(MyVoxelConstants.VOXEL_ISO_LEVEL - setDiff / MyVoxelConstants.VOXEL_SIZE_IN_METRES_HALF * MyVoxelConstants.VOXEL_ISO_LEVEL); } MyVoxelMaterialDefinition originalMaterial = MyDefinitionManager.Static.GetVoxelMaterialDefinition(m_cache.Material(ref cachePos)); // Change the material: // - always on boundaries between material and nothing // - smoothly on inner boundaries MyVoxelMaterialDefinition newMaterial = material; if (setDiff > 0) { byte content = m_cache.Content(ref cachePos); if (content == MyVoxelConstants.VOXEL_CONTENT_FULL) { newMaterial = originalMaterial; } if (setDiff >= MyVoxelConstants.VOXEL_SIZE_IN_METRES_HALF && content != MyVoxelConstants.VOXEL_CONTENT_EMPTY) // set material behind boundary only for empty voxels { newMaterial = originalMaterial; } } if (originalMaterial == newMaterial) { continue; } m_cache.Material(ref cachePos, newMaterial.Index); changed = true; } float dist = (float)(voxelPosition - sphere.Center).Length(); float diff = (float)(dist - sphere.Radius); if (diff <= 0f) { originalContent = m_cache.Content(ref cachePos); if (originalContent > MyVoxelConstants.VOXEL_CONTENT_EMPTY) { bool wrinkled = m_cache.WrinkleVoxelContent(ref cachePos, MyVoxelConstants.DEFAULT_WRINKLE_WEIGHT_ADD, MyVoxelConstants.DEFAULT_WRINKLE_WEIGHT_REMOVE); if (wrinkled) { changed = true; } } } } } } ProfilerShort.End(); if (changed) { ProfilerShort.Begin("RemoveSmallVoxelsUsingChachedVoxels"); RemoveSmallVoxelsUsingChachedVoxels(); ProfilerShort.BeginNextBlock("Writing cache"); voxelMap.Storage.WriteRange(m_cache, MyStorageDataTypeFlags.ContentAndMaterial, ref minCorner, ref maxCorner); ProfilerShort.End(); } ProfilerShort.End(); }
private void Update(ref Vector3D cameraPos, ref Vector3 cameraForward, float farPlaneDistance) { ProfilerShort.Begin("MyRenderClipmap.Update"); LastCameraPosition = cameraPos; if (!Environment.Is64BitProcess) { UseCache = false; } if (NeedsResetCache) { MyClipmap.CellsCache.Reset(); NeedsResetCache = false; } for (uint lod = 0; lod < m_lodLevels.Length; lod++) { if (m_lodLevels[lod].IsDitheringInProgress()) { m_lodLevels[lod].UpdateDithering(); } } Vector3D localPosition; Vector3D.Transform(ref cameraPos, ref m_invWorldMatrix, out localPosition); Vector3 localForward; Vector3.TransformNormal(ref cameraForward, ref m_invWorldMatrix, out localForward); double cellSizeHalf = MyVoxelCoordSystems.RenderCellSizeInMetersHalf(0); double threshold = cellSizeHalf / 4.0f; float thresholdRotation = 0.03f; if (!m_updateClippingFrustum && (Vector3D.DistanceSquared(localPosition, m_lastClippingPosition) > threshold) || (Vector3.DistanceSquared(localForward, m_lastClippingForward) > thresholdRotation) || m_invalidated > 0) { ResetClipping(); m_lastClippingPosition = localPosition; m_lastClippingForward = localForward; } float camDistanceFromCenter = Vector3.Distance(m_massiveCenter, cameraPos); if (m_requestCollector.SentRequestsEmpty && m_updateClippingFrustum) { ProfilerShort.Begin("DoClipping"); //Top priority for 0 lod when invalidated (drill) if (m_invalidated == 2) { m_lodLevels[0].DoClipping(camDistanceFromCenter, localPosition, farPlaneDistance, m_requestCollector, true, 1); m_lodLevels[0].DiscardClippedCells(m_requestCollector); m_lodLevels[0].UpdateCellsInScene(camDistanceFromCenter, localPosition); if (!m_requestCollector.SentRequestsEmpty) { m_requestCollector.Submit(); ProfilerShort.End(); // DoClipping ProfilerShort.End(); // Update return; } m_updateClippingFrustum = false; m_invalidated = 1; } else { //Most important frustum culling for (int lod = m_lodLevels.Length - 1; lod >= 0; --lod) { ProfilerShort.Begin("Lod " + lod); m_lodLevels[lod].DoClipping(camDistanceFromCenter, localPosition, farPlaneDistance, m_requestCollector, true, 1); ProfilerShort.End(); } //ProfilerShort.End(); ProfilerShort.Begin("KeepOrDiscardClippedCells"); for (int lod = m_lodLevels.Length - 1; lod >= 0; --lod) { m_lodLevels[lod].DiscardClippedCells(m_requestCollector); } ProfilerShort.End(); ProfilerShort.Begin("UpdateCellsInScene"); for (int lod = m_lodLevels.Length - 1; lod >= 0; --lod) { m_lodLevels[lod].UpdateCellsInScene(camDistanceFromCenter, localPosition); } ProfilerShort.End(); if (!m_requestCollector.SentRequestsEmpty) { m_requestCollector.Submit(); ProfilerShort.End(); // DoClipping ProfilerShort.End(); // Update return; } m_invalidated = 0; m_notReady.Remove(this); m_updateClippingFrustum = false; } ProfilerShort.End(); } ProfilerShort.End(); }
public static void OnGlobalSpawnEvent(object senderEvent) { // Select a spawn group to spawn MySpawnGroupDefinition spawnGroup = PickRandomSpawnGroup(); if (spawnGroup == null) { return; } spawnGroup.ReloadPrefabs(); ProfilerShort.Begin("Generate position and direction"); double spawnDistance = NEUTRAL_SHIP_SPAWN_DISTANCE; Vector3D playerPosition = Vector3D.Zero; bool isWorldLimited = MyEntities.IsWorldLimited(); int numPlayers = 0; if (isWorldLimited) { spawnDistance = Math.Min(spawnDistance, MyEntities.WorldSafeHalfExtent() - spawnGroup.SpawnRadius); } else { // In infinite worlds players can be thousands of kilometers away, so spawn ship around random player // so cargo ships will be spawned around every player at some time var players = MySession.Static.Players.GetOnlinePlayers(); // In DS there can be no players connected numPlayers = Math.Max(0, players.Count - 1); int randomPlayerPosition = MyUtils.GetRandomInt(0, numPlayers); int i = 0; foreach (var player in players) { if (i == randomPlayerPosition) { if (player.Character != null) { playerPosition = player.GetPosition(); } break; } i++; } } if (spawnDistance < 0.0f) { MySandboxGame.Log.WriteLine("Not enough space in the world to spawn such a huge spawn group!"); return; } double forbiddenRadius = NEUTRAL_SHIP_FORBIDDEN_RADIUS; BoundingBoxD spawnBox; if (isWorldLimited) { spawnBox = new BoundingBoxD(new Vector3D(playerPosition - spawnDistance), new Vector3D(playerPosition + spawnDistance)); } else { // We need to extend bouding box so cargo ships aren't spawned near other players GetSafeBoundingBoxForPlayers(playerPosition, spawnDistance, out spawnBox); // Forbidden radius is sphere around all players in box. // Bounding box is generated from players positions so their distance to center shall be same for all players forbiddenRadius += spawnBox.HalfExtents.Max() - NEUTRAL_SHIP_FORBIDDEN_RADIUS; } // Get the direction to the center and deviate it randomly Vector3D?origin = MyUtils.GetRandomBorderPosition(ref spawnBox); origin = MyEntities.FindFreePlace(origin.Value, spawnGroup.SpawnRadius); if (!origin.HasValue) { MySandboxGame.Log.WriteLine("Could not spawn neutral ships - no free place found"); MyGlobalEvents.RescheduleEvent(senderEvent as MyGlobalEventBase, NEUTRAL_SHIP_RESCHEDULE_TIME); ProfilerShort.End(); return; } // Radius in arc units of the forbidden sphere in the center, when viewed from origin float centerArcRadius = (float)Math.Atan(forbiddenRadius / (origin.Value - spawnBox.Center).Length()); // Generate direction with elevation from centerArcRadius radians to (cAR + N_S_D_S) radians Vector3D direction = -Vector3D.Normalize(origin.Value); float theta = MyUtils.GetRandomFloat(centerArcRadius, centerArcRadius + NEUTRAL_SHIP_DIRECTION_SPREAD); float phi = MyUtils.GetRandomRadian(); Vector3D cosVec = Vector3D.CalculatePerpendicularVector(direction); Vector3D sinVec = Vector3D.Cross(direction, cosVec); cosVec *= (Math.Sin(theta) * Math.Cos(phi)); sinVec *= (Math.Sin(theta) * Math.Sin(phi)); direction = direction * Math.Cos(theta) + cosVec + sinVec; Vector3D destination = Vector3D.Zero; RayD ray = new RayD(origin.Value, direction); double? intersection = ray.Intersects(spawnBox); Vector3D directionMult; if (!intersection.HasValue || intersection.Value < NEUTRAL_SHIP_MINIMAL_ROUTE_LENGTH) { directionMult = direction * NEUTRAL_SHIP_MINIMAL_ROUTE_LENGTH; } else { directionMult = direction * intersection.Value; } destination = origin.Value + directionMult; Vector3D upVector = Vector3D.CalculatePerpendicularVector(direction); Vector3D rightVector = Vector3D.Cross(direction, upVector); MatrixD originMatrix = MatrixD.CreateWorld(origin.Value, direction, upVector); ProfilerShort.End(); ProfilerShort.Begin("Check free space"); // CH:TODO: Convex cast to detect collision // Check ships' path to avoid possible collisions. (TODO: But only if it is said in the definitions) m_raycastHits.Clear(); foreach (var shipPrefab in spawnGroup.Prefabs) { var prefabDef = MyDefinitionManager.Static.GetPrefabDefinition(shipPrefab.SubtypeId); Debug.Assert(prefabDef != null); Vector3D shipPosition = Vector3.Transform(shipPrefab.Position, originMatrix); Vector3D shipDestination = shipPosition + directionMult; float radius = prefabDef == null ? 10.0f : prefabDef.BoundingSphere.Radius; MyPhysics.CastRay(shipPosition, shipDestination, m_raycastHits, MyPhysics.ObjectDetectionCollisionLayer); if (m_raycastHits.Count() > 0) { MySandboxGame.Log.WriteLine("Could not spawn neutral ships due to collision"); MyGlobalEvents.RescheduleEvent(senderEvent as MyGlobalEventBase, NEUTRAL_SHIP_RESCHEDULE_TIME); ProfilerShort.End(); return; } for (int i = 0; i < 4; ++i) { Vector3D shiftVector = upVector * m_upVecMultipliers[i] * radius + rightVector * m_rightVecMultipliers[i] * radius; MyPhysics.CastRay(shipPosition + shiftVector, shipDestination + shiftVector, m_raycastHits, MyPhysics.ObjectDetectionCollisionLayer); if (m_raycastHits.Count() > 0) { MySandboxGame.Log.WriteLine("Could not spawn neutral ships due to collision"); MyGlobalEvents.RescheduleEvent(senderEvent as MyGlobalEventBase, NEUTRAL_SHIP_RESCHEDULE_TIME); ProfilerShort.End(); return; } } } ProfilerShort.End(); ProfilerShort.Begin("Spawn ships"); //This is not an NPC so that it doesn't show up in assign ownership drop down menu MyIdentity spawnGroupIdentity = Sync.Players.CreateNewIdentity("Neutral NPC"); long spawnGroupId = spawnGroupIdentity.IdentityId; // The ships were collision-free. Now spawn them foreach (var shipPrefab in spawnGroup.Prefabs) { ProfilerShort.Begin(shipPrefab.BeaconText); // Yes, this could have been saved in the previous loop, but compared to (e.g.) raycasts, this does not take too much time to recalculate Vector3D shipPosition = Vector3D.Transform((Vector3D)shipPrefab.Position, originMatrix); Vector3D shipDestination = shipPosition + directionMult; Vector3D up = Vector3D.CalculatePerpendicularVector(-direction); m_tmpGridList.Clear(); // Deploy ship ProfilerShort.Begin("Spawn cargo ship"); MyPrefabManager.Static.SpawnPrefab( resultList: m_tmpGridList, prefabName: shipPrefab.SubtypeId, position: shipPosition, forward: direction, up: up, initialLinearVelocity: shipPrefab.Speed * direction, beaconName: shipPrefab.BeaconText, spawningOptions: Sandbox.ModAPI.SpawningOptions.RotateFirstCockpitTowardsDirection | Sandbox.ModAPI.SpawningOptions.SpawnRandomCargo | Sandbox.ModAPI.SpawningOptions.DisableDampeners, updateSync: true); ProfilerShort.End(); foreach (var grid in m_tmpGridList) { grid.ChangeGridOwnership(spawnGroupId, MyOwnershipShareModeEnum.None); var cockpit = grid.GetFirstBlockOfType <MyCockpit>(); if (cockpit != null) { MySimpleAutopilot ai = new MySimpleAutopilot(shipDestination, (Vector3)direction); cockpit.AttachAutopilot(ai); break; } } m_tmpGridList.Clear(); ProfilerShort.End(); } ProfilerShort.End(); }
// Sends input (keyboard/mouse) to screen which has focus (top-most) public void HandleInput() { ProfilerShort.Begin("MyGuiManager.HandleInput"); try { if (MyInput.Static.IsAnyAltKeyPressed() && MyInput.Static.IsNewKeyPressed(MyKeys.F4)) { MyAnalyticsTracker.SendGameEnd("Alt+F4", MySandboxGame.TotalTimeInMilliseconds / 1000); // Exit application MySandboxGame.ExitThreadSafe(); return; } // Screenshot(s) if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.SCREENSHOT)) { MyGuiAudio.PlaySound(MyGuiSounds.HudMouseClick); TakeScreenshot(); } bool newPressf12 = MyInput.Static.IsNewKeyPressed(MyKeys.F12); bool newPressf2 = MyInput.Static.IsNewKeyPressed(MyKeys.F2); if ((newPressf2 || newPressf12) && MyInput.Static.IsAnyShiftKeyPressed() && MyInput.Static.IsAnyAltKeyPressed()) { if (MySession.Static != null && MySession.Static.CreativeMode) { if (newPressf12) { MyDebugDrawSettings.DEBUG_DRAW_PHYSICS = !MyDebugDrawSettings.DEBUG_DRAW_PHYSICS; if (!m_shapeRenderingMessageBoxShown) { m_shapeRenderingMessageBoxShown = true; AddScreen(MyGuiSandbox.CreateMessageBox( messageCaption: new StringBuilder("PHYSICS SHAPES"), messageText: new StringBuilder("Enabled physics shapes rendering. This feature is for modders only and is not part of the gameplay."))); } } } else { AddScreen(MyGuiSandbox.CreateMessageBox( messageCaption: new StringBuilder("MODDING HELPER KEYS"), messageText: new StringBuilder("Use of helper key combinations for modders is only allowed in creative mode."))); } return; } if (MyInput.Static.IsNewKeyPressed(MyKeys.H) && MyInput.Static.IsAnyCtrlKeyPressed()) { if (MyFakes.ENABLE_NETGRAPH) { MyHud.IsNetgraphVisible = !MyHud.IsNetgraphVisible; } } if (MyInput.Static.IsNewKeyPressed(MyKeys.F11)) { if (MyInput.Static.IsAnyShiftKeyPressed() && !MyInput.Static.IsAnyCtrlKeyPressed()) { SwitchTimingScreen(); } } if (MyFakes.ENABLE_MISSION_SCREEN && MyInput.Static.IsNewKeyPressed(MyKeys.U)) { MyScreenManager.AddScreen(new MyGuiScreenMission()); } if (!MyInput.Static.ENABLE_DEVELOPER_KEYS && Sync.MultiplayerActive && m_currentDebugScreen is MyGuiScreenDebugOfficial) { RemoveScreen(m_currentDebugScreen); m_currentDebugScreen = null; } bool inputHandled = false; if (MySession.Static != null && MySession.Static.CreativeMode || MyInput.Static.ENABLE_DEVELOPER_KEYS) { F12Handling(); } if (MyInput.Static.ENABLE_DEVELOPER_KEYS) { // Statistics screen if (MyInput.Static.IsNewKeyPressed(MyKeys.F11) && !MyInput.Static.IsAnyShiftKeyPressed() && MyInput.Static.IsAnyCtrlKeyPressed()) { SwitchStatisticsScreen(); } if (MyInput.Static.IsAnyShiftKeyPressed() && MyInput.Static.IsAnyAltKeyPressed() && MyInput.Static.IsAnyCtrlKeyPressed() && MyInput.Static.IsNewKeyPressed(MyKeys.Home)) { throw new InvalidOperationException("Controlled crash"); } // Forge GC to run if (MyInput.Static.IsNewKeyPressed(MyKeys.Pause) && MyInput.Static.IsAnyShiftKeyPressed()) { GC.Collect(GC.MaxGeneration); } if (MyInput.Static.IsAnyCtrlKeyPressed() && MyInput.Static.IsNewKeyPressed(MyKeys.F2)) { //Reload textures if (MyInput.Static.IsKeyPress(MyKeys.LeftShift)) { MyDefinitionManager.Static.ReloadDecalMaterials(); VRageRender.MyRenderProxy.ReloadTextures(); } else if (MyInput.Static.IsKeyPress(MyKeys.LeftAlt)) { VRageRender.MyRenderProxy.ReloadModels(); } else { VRageRender.MyRenderProxy.ReloadEffects(); } } //WS size if (MyInput.Static.IsNewKeyPressed(MyKeys.F3) && MyInput.Static.IsKeyPress(MyKeys.LeftShift)) { #if !XB1 WinApi.SetProcessWorkingSetSize(Process.GetCurrentProcess().Handle, -1, -1); #endif // !XB1 } inputHandled = HandleDebugInput(); } if (!inputHandled) { MyScreenManager.HandleInput(); } } finally { ProfilerShort.End(); } }
public static List <MyCubeBlockDefinition.MountPoint> AutogenerateMountpoints(HkShape[] shapes, float gridSize) { ProfilerShort.Begin("AutogenerateMountpoints"); HkShapeCutterUtil cutter = new HkShapeCutterUtil(); List <BoundingBox>[] aabbsPerDirection = new List <BoundingBox> [Base6Directions.EnumDirections.Length]; var newMountPoints = new List <MyCubeBlockDefinition.MountPoint>(); foreach (var directionEnum in Base6Directions.EnumDirections) { int dirEnum = (int)directionEnum; //int dirEnum = 2; Vector3 direction = Base6Directions.Directions[dirEnum]; foreach (var shape in shapes) { if (shape.ShapeType == HkShapeType.List) { var listShape = (HkListShape)shape; var iterator = listShape.GetIterator(); while (iterator.IsValid) { HkShape childShape = iterator.CurrentValue; if (childShape.ShapeType == HkShapeType.ConvexTransform) { HkConvexTransformShape transformShape = (HkConvexTransformShape)childShape; FindMountPoint(cutter, transformShape.Base, direction, gridSize, newMountPoints); } else if (childShape.ShapeType == HkShapeType.ConvexTranslate) { HkConvexTranslateShape translateShape = (HkConvexTranslateShape)childShape; FindMountPoint(cutter, translateShape.Base, direction, gridSize, newMountPoints); } else { FindMountPoint(cutter, childShape, direction, gridSize, newMountPoints); } iterator.Next(); } break; } else if (shape.ShapeType == HkShapeType.Mopp) { var compoundShape = (HkMoppBvTreeShape)shape; for (int s = 0; s < compoundShape.ShapeCollection.ShapeCount; s++) { HkShape childShape = compoundShape.ShapeCollection.GetShape((uint)s, null); if (childShape.ShapeType == HkShapeType.ConvexTranslate) { HkConvexTranslateShape translateShape = (HkConvexTranslateShape)childShape; FindMountPoint(cutter, translateShape.Base, direction, gridSize, newMountPoints); } } break; } else { FindMountPoint(cutter, shape, direction, gridSize, newMountPoints); } } } ProfilerShort.End(); return(newMountPoints); }
// Draw all screens public void Draw() { VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("MyGuiSandbox::Draw"); ProfilerShort.Begin("ScreenManager.Draw"); MyScreenManager.Draw(); ProfilerShort.End(); m_debugText.Clear(); if (MyInput.Static.ENABLE_DEVELOPER_KEYS && MySandboxGame.Config.DebugComponentsInfo != MyDebugComponent.MyDebugComponentInfoState.NoInfo) { var h = 0f; var i = 0; bool drawBackground = false; MyDebugComponent.ResetFrame(); foreach (var userInputComponent in UserDebugInputComponents) { if (userInputComponent.Enabled) { if (h == 0) { m_debugText.AppendLine("Debug input:"); m_debugText.AppendLine(); h += 0.0630f; } m_debugText.ConcatFormat("{0} (Ctrl + numPad{1})", UserDebugInputComponents[i].GetName(), i); m_debugText.AppendLine(); h += 0.0265f; if (MySession.Static != null) { userInputComponent.DispatchUpdate(); } userInputComponent.Draw(); drawBackground = true; } ++i; } if (drawBackground) { MyGuiManager.DrawSpriteBatch(@"Textures\GUI\Controls\rectangle_dark_center.dds", new Vector2(MyGuiManager.GetMaxMouseCoord().X, 0f), new Vector2(MyGuiManager.MeasureString(MyFontEnum.White, m_debugText, 1f).X + 0.012f, h), new Color(0, 0, 0, 130), MyGuiDrawAlignEnum.HORISONTAL_RIGHT_AND_VERTICAL_TOP); MyGuiManager.DrawString(MyFontEnum.White, m_debugText, new Vector2(MyGuiManager.GetMaxMouseCoord().X - 0.01f, 0f), 1f, Color.White, MyGuiDrawAlignEnum.HORISONTAL_RIGHT_AND_VERTICAL_TOP); } } bool hwCursor = MyVideoSettingsManager.IsHardwareCursorUsed(); var screenWithFocus = MyScreenManager.GetScreenWithFocus(); if (((screenWithFocus != null) && (screenWithFocus.GetDrawMouseCursor() == true)) || (MyScreenManager.InputToNonFocusedScreens && MyScreenManager.GetScreensCount() > 1)) { #if XB1 SetMouseCursorVisibility(false, false); DrawMouseCursor(GetMouseOverTexture(screenWithFocus)); #else SetMouseCursorVisibility(hwCursor, false); if (!hwCursor || MyFakes.FORCE_SOFTWARE_MOUSE_DRAW) { DrawMouseCursor(GetMouseOverTexture(screenWithFocus)); } #endif } else { if (hwCursor) { if (screenWithFocus != null) { SetMouseCursorVisibility(screenWithFocus.GetDrawMouseCursor()); } } } VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); }
public static void UpdateBeforeSimulation() { if (MySandboxGame.IsGameReady == false) { return; } ProfilerShort.Begin("MyEntities.UpdateBeforeSimulation"); System.Diagnostics.Debug.Assert(MyEntities.UpdateInProgress == false); MyEntities.UpdateInProgress = true; { ProfilerShort.Begin("Before first frame"); MyEntities.UpdateOnceBeforeFrame(); ProfilerShort.BeginNextBlock("Each update"); m_entitiesForUpdate.List.ApplyChanges(); m_entitiesForUpdate.Update(); MySimpleProfiler.Begin("Blocks"); m_entitiesForUpdate.Iterate((x) => { ProfilerShort.Begin(x.GetType().Name); if (x.MarkedForClose == false) { if (ProfilePerBlock) { MyCubeBlock block = x as MyCubeBlock; if (block != null) { MySimpleProfiler.Begin(block.DefinitionDisplayNameText + (ProfilePerGrid ? $" - {block.CubeGrid.DisplayName}" : string.Empty)); if (ProfilePerGrid) { MySimpleProfiler.Begin("&&GRID&&" + block.CubeGrid.DisplayName); } } } if (ProfilePerGrid) { MyCubeGrid grid = x as MyCubeGrid; if (grid != null) { MySimpleProfiler.Begin("&&GRID&&" + grid.DisplayName); } } x.UpdateBeforeSimulation(); if (ProfilePerBlock) { MyCubeBlock block = x as MyCubeBlock; if (block != null) { MySimpleProfiler.End(block.DefinitionDisplayNameText + (ProfilePerGrid ? $" - {block.CubeGrid.DisplayName}" : string.Empty)); if (ProfilePerGrid) { MySimpleProfiler.End("&&GRID&&" + block.CubeGrid.DisplayName); } } } if (ProfilePerGrid) { MyCubeGrid grid = x as MyCubeGrid; if (grid != null) { MySimpleProfiler.End("&&GRID&&" + grid.DisplayName); } } } ProfilerShort.End(); }); ProfilerShort.BeginNextBlock("10th update"); m_entitiesForUpdate10.List.ApplyChanges(); m_entitiesForUpdate10.Update(); m_entitiesForUpdate10.Iterate((x) => { ProfilerShort.Begin(x.GetType().Name); if (x.MarkedForClose == false) { if (ProfilePerBlock) { MyCubeBlock block = x as MyCubeBlock; if (block != null) { MySimpleProfiler.Begin(block.DefinitionDisplayNameText + (ProfilePerGrid ? $" - {block.CubeGrid.DisplayName}" : string.Empty)); if (ProfilePerGrid) { MySimpleProfiler.Begin("&&GRID&&" + block.CubeGrid.DisplayName); } } } if (ProfilePerGrid) { MyCubeGrid grid = x as MyCubeGrid; if (grid != null) { MySimpleProfiler.Begin("&&GRID&&" + grid.DisplayName); } } x.UpdateBeforeSimulation10(); if (ProfilePerBlock) { MyCubeBlock block = x as MyCubeBlock; if (block != null) { MySimpleProfiler.End(block.DefinitionDisplayNameText + (ProfilePerGrid ? $" - {block.CubeGrid.DisplayName}" : string.Empty)); if (ProfilePerGrid) { MySimpleProfiler.End("&&GRID&&" + block.CubeGrid.DisplayName); } } } if (ProfilePerGrid) { MyCubeGrid grid = x as MyCubeGrid; if (grid != null) { MySimpleProfiler.End("&&GRID&&" + grid.DisplayName); } } } ProfilerShort.End(); }); ProfilerShort.BeginNextBlock("100th update"); m_entitiesForUpdate100.List.ApplyChanges(); m_entitiesForUpdate100.Update(); m_entitiesForUpdate100.Iterate((x) => { ProfilerShort.Begin(x.GetType().Name); if (x.MarkedForClose == false) { if (ProfilePerBlock) { MyCubeBlock block = x as MyCubeBlock; if (block != null) { MySimpleProfiler.Begin(block.DefinitionDisplayNameText + (ProfilePerGrid ? $" - {block.CubeGrid.DisplayName}" : string.Empty)); if (ProfilePerGrid) { MySimpleProfiler.Begin("&&GRID&&" + block.CubeGrid.DisplayName); } } } if (ProfilePerGrid) { MyCubeGrid grid = x as MyCubeGrid; if (grid != null) { MySimpleProfiler.Begin("&&GRID&&" + grid.DisplayName); } } x.UpdateBeforeSimulation100(); if (ProfilePerBlock) { MyCubeBlock block = x as MyCubeBlock; if (block != null) { MySimpleProfiler.End(block.DefinitionDisplayNameText + (ProfilePerGrid ? $" - {block.CubeGrid.DisplayName}" : string.Empty)); if (ProfilePerGrid) { MySimpleProfiler.End("&&GRID&&" + block.CubeGrid.DisplayName); } } } if (ProfilePerGrid) { MyCubeGrid grid = x as MyCubeGrid; if (grid != null) { MySimpleProfiler.Begin("&&GRID&&" + grid.DisplayName); } } } ProfilerShort.End(); }); ProfilerShort.End(); } MySimpleProfiler.End("Blocks"); MyEntities.UpdateInProgress = false; ProfilerShort.End(); }
public MyIsoMesh Precalc(IMyStorage storage, int lod, Vector3I voxelStart, Vector3I voxelEnd, bool generateMaterials) { // change range so normal can be computed at edges (expand by 1 in all directions) voxelStart -= 1; voxelEnd += 1; m_cache.Resize(voxelStart, voxelEnd); storage.ReadRange(m_cache, MyStorageDataTypeFlags.Content, lod, ref voxelStart, ref voxelEnd); if (!m_cache.ContainsIsoSurface()) { return(null); } if (generateMaterials) { storage.ReadRange(m_cache, MyStorageDataTypeFlags.Material, lod, ref voxelStart, ref voxelEnd); } else { m_cache.ClearMaterials(0); } var voxelSize = MyVoxelConstants.VOXEL_SIZE_IN_METRES * (1 << lod); ProfilerShort.Begin("Dual Contouring"); unsafe { fixed(byte *voxels = m_cache.Data) { var size3d = m_cache.Size3D; Debug.Assert(size3d.X == size3d.Y && size3d.Y == size3d.Z); IsoMesher.Calculate(size3d.X, (VoxelData *)voxels, m_buffer); } } ProfilerShort.End(); if (m_buffer.VerticesCount == 0 && m_buffer.Triangles.Count == 0) { return(null); } ProfilerShort.Begin("Geometry post-processing"); { var vertexCellOffset = voxelStart - AffectedRangeOffset; var positions = m_buffer.Positions.GetInternalArray(); var vertexCells = m_buffer.Cells.GetInternalArray(); for (int i = 0; i < m_buffer.VerticesCount; i++) { var min = -Vector3.One; var max = Vector3.One; // Debug.Assert(positions[i].IsInsideInclusive(ref min, ref max)); vertexCells[i] += vertexCellOffset; } float numCellsHalf = 0.5f * (m_cache.Size3D.X - 3); m_buffer.PositionOffset = (vertexCellOffset + numCellsHalf) * voxelSize; m_buffer.PositionScale = new Vector3(numCellsHalf * voxelSize); } ProfilerShort.End(); // Replace filled mesh with new one. // This way prevents allocation of meshes which then end up empty. var buffer = m_buffer; m_buffer = new MyIsoMesh(); return(buffer); }