public void DebugDraw()
{
if (!m_simulationDataPrepared)
{
return;
}
SlidingOffset += 0.005f;
if (MyPetaInputComponent.DEBUG_DRAW_PATHS)
{
var selcolor = Color.Aqua;
DrawCube(m_grid.GridSize, SelectedCube, ref selcolor, null);
if (m_finishedData.All.ContainsKey(SelectedCube))
{
var node = m_finishedData.All[SelectedCube];
float spacing = 0.2f;
float offset = -spacing * node.Paths.Count / 2.0f;
float increment = spacing;
// if (drawOutgoing)
{
int p = 0;
float ratioSum = 0;
foreach (var path in node.Paths)
{
DebugDrawPath(path.Value, offset, p);
offset += increment;
p++;
ratioSum += path.Value.Ratio;
if (path.Value.Parents.Count > 1)
{
foreach (var ppath in path.Value.Parents)
{
DebugDrawPath(ppath, offset, p);
}
}
}
//foreach (var outg in node.OutgoingNodeswWithWeights)
//{
// if (outg.Count > 0)
// {
// string s = "";
// foreach (var outNode in outg)
// {
// s += outNode.Item2.ToString() + " + ";
// }
// Vector3 delta = outg[0].Item1.Pos - node.Pos;
// Vector3D pos = Vector3D.Transform((node.Pos + delta * 0.4f) * m_grid.GridSize, m_grid.WorldMatrix);
// MyRenderProxy.DebugDrawText3D(pos, s, Color.White, 0.5f, false, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER);
// }
//}
Vector3D selpos = Vector3D.Transform(node.Pos * m_grid.GridSize, m_grid.WorldMatrix);
MyRenderProxy.DebugDrawText3D(selpos + Vector3D.Up / 2, SelectedCube.ToString(), Color.White, 0.5f, false, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER);
//foreach (var nodesSup in node.SupportingNodeswWithWeights)
//{
// if (nodesSup.Count > 0)
// {
// string s = "";
// foreach (var outNode in nodesSup)
// {
// s += outNode.Item2.ToString() + " + ";
// }
// Vector3 delta = nodesSup[0].Item1.Pos - node.Pos;
// Vector3D pos = Vector3D.Transform((node.Pos + delta * 0.4f) * m_grid.GridSize, m_grid.WorldMatrix);
// MyRenderProxy.DebugDrawText3D(pos, s, Color.White, 0.5f, false, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER);
// }
//}
}
}
}
//MyRenderProxy.DebugDrawAABB(m_grid.PositionComp.WorldAABB, Color.White, 1, 1, false);
if (MyPetaInputComponent.DEBUG_DRAW_TENSIONS)
{
bool drawTensions = true;
var size = m_grid.GridSize;
if (drawTensions)
{
foreach (var c in m_finishedData.All)
{
Color color = Color.Gray;
float tension = 0;
if (c.Value.IsDynamicWeight)
{
continue;
}
if (!c.Value.IsStatic)
{
//1kg cube can hold 10kg
//0.5kg - 5kg
//etc.
//Max. supported weight <0..1> is then TotalSupportingWeight / (mass * MaxSupportedWeight)
float MaxSupportedWeight = 10;
//tension = c.Value.TotalSupportingWeight / (c.Value.Mass * MaxSupportedWeight);
tension = c.Value.TotalSupportingWeight / (c.Value.Mass * c.Value.PhysicalMaterial.SupportMultiplier);
//tension = c.Value.TotalSupportingWeight;
color = GetTension(tension, MaxSupportedWeight);
}
string text = tension.ToString("0.00");
//string text = c.Key.ToString();
DrawCube(size, c.Key, ref color, text);
}
}
else
{ //Draw weights
foreach (var c in m_finishedData.All)
{
Color color = GetTension(c.Value.Mass, 4);
string text = c.Value.Mass.ToString("0.00");
DrawCube(size, c.Key, ref color, text);
}
}
}
}
public override void AddRenderObjects()
{
var minCorner = m_planet.PositionLeftBottomCorner;
m_renderObjectIDs = new uint[16];
for (int index = 0; index < 16; ++index)
{
m_renderObjectIDs[index] = MyRenderProxy.RENDER_ID_UNASSIGNED;
}
int runningRenderObjectIndex = 0;
Debug.Assert((m_planet.Size % MyVoxelCoordSystems.RenderCellSizeInLodVoxels(0)) == Vector3I.Zero);
var clipmapSizeLod0 = m_planet.Size / MyVoxelCoordSystems.RenderCellSizeInLodVoxels(0);
Vector3 atmosphereWavelengths = new Vector3();
atmosphereWavelengths.X = 1.0f / (float)Math.Pow(m_planet.AtmosphereWavelengths.X, 4.0);
atmosphereWavelengths.Y = 1.0f / (float)Math.Pow(m_planet.AtmosphereWavelengths.Y, 4.0);
atmosphereWavelengths.Z = 1.0f / (float)Math.Pow(m_planet.AtmosphereWavelengths.Z, 4.0);
var voxel = (Entity as MyVoxelBase);
SetRenderObjectID(runningRenderObjectIndex++,
MyRenderProxy.CreateClipmap(
MatrixD.CreateTranslation(minCorner),
clipmapSizeLod0,
m_planet.ScaleGroup,
m_planet.PositionComp.GetPosition(),
m_planet.AtmosphereRadius,
m_planet.AverageRadius,
m_planet.HasAtmosphere,
atmosphereWavelengths,
m_planet.SpherizeWithDistance,
RenderFlags.Visible | RenderFlags.DrawOutsideViewDistance | RenderFlags.CastShadows,
IntersectStorage));
if (m_planet.HasAtmosphere)
{
MatrixD matrix = MatrixD.Identity * m_planet.AtmosphereRadius;
matrix.M44 = 1;
matrix.Translation = Entity.PositionComp.GetPosition();
m_atmosphereRenderIndex = runningRenderObjectIndex;
SetRenderObjectID(runningRenderObjectIndex++, MyRenderProxy.CreateRenderEntityAtmosphere(this.Entity.GetFriendlyName() + " " + this.Entity.EntityId.ToString(),
"Models\\Environment\\Atmosphere_sphere.mwm",
matrix,
MyMeshDrawTechnique.ATMOSPHERE,
RenderFlags.Visible | RenderFlags.DrawOutsideViewDistance,
GetRenderCullingOptions(),
m_planet.AtmosphereRadius,
m_planet.AverageRadius,
atmosphereWavelengths));
SetRenderObjectID(runningRenderObjectIndex++, MyRenderProxy.CreateRenderEntityAtmosphere(this.Entity.GetFriendlyName() + " " + this.Entity.EntityId.ToString(),
"Models\\Environment\\Atmosphere_sphere.mwm",
matrix,
MyMeshDrawTechnique.PLANET_SURFACE,
RenderFlags.Visible | RenderFlags.DrawOutsideViewDistance,
GetRenderCullingOptions(),
m_planet.AtmosphereRadius,
m_planet.AverageRadius,
atmosphereWavelengths));
UpdateAtmosphereSettings(m_planet.AtmosphereSettings);
}
m_shadowHelperRenderObjectIndex = runningRenderObjectIndex;
MatrixD shadowHelperWorldMatrix = MatrixD.CreateScale(m_planet.MinimumRadius);
shadowHelperWorldMatrix.Translation = m_planet.WorldMatrix.Translation;
SetRenderObjectID(runningRenderObjectIndex++, MyRenderProxy.CreateRenderEntity("Shadow helper", "Models\\Environment\\Sky\\ShadowHelperSphere.mwm",
shadowHelperWorldMatrix,
MyMeshDrawTechnique.MESH,
RenderFlags.Visible | RenderFlags.CastShadows | RenderFlags.DrawOutsideViewDistance | RenderFlags.NoBackFaceCulling | RenderFlags.SkipInMainView,
CullingOptions.Default,
Color.White, new Vector3(1, 1, 1)));
MyPlanetGeneratorDefinition definition = m_planet.Generator;
if (!MyFakes.ENABLE_PLANETARY_CLOUDS || definition == null || definition.CloudLayers == null)
{
return;
}
foreach (var cloudLayer in definition.CloudLayers)
{
double minScaledAltitude = (m_planet.AverageRadius + m_planet.MaximumRadius) / 2.0;
double layerAltitude = minScaledAltitude + (m_planet.MaximumRadius - minScaledAltitude) * cloudLayer.RelativeAltitude;
Vector3D rotationAxis = Vector3D.Normalize(cloudLayer.RotationAxis == Vector3D.Zero ? Vector3D.Up : cloudLayer.RotationAxis);
int index = runningRenderObjectIndex + m_cloudLayerRenderObjectIndexList.Count;
SetRenderObjectID(index,
MyRenderProxy.CreateRenderEntityCloudLayer(this.Entity.GetFriendlyName() + " " + this.Entity.EntityId.ToString(),
cloudLayer.Model,
cloudLayer.Textures,
Entity.PositionComp.GetPosition(),
layerAltitude,
minScaledAltitude,
cloudLayer.ScalingEnabled,
cloudLayer.FadeOutRelativeAltitudeStart,
cloudLayer.FadeOutRelativeAltitudeEnd,
cloudLayer.ApplyFogRelativeDistance,
m_planet.MaximumRadius,
MyMeshDrawTechnique.CLOUD_LAYER,
RenderFlags.Visible | RenderFlags.DrawOutsideViewDistance,
GetRenderCullingOptions(),
rotationAxis,
cloudLayer.AngularVelocity,
cloudLayer.InitialRotation));
m_cloudLayerRenderObjectIndexList.Add(index);
}
runningRenderObjectIndex += definition.CloudLayers.Count;
}
private static void PrepareMaterialBatches(MyRenderContext RC, List <MyScreenDecal> decals, uint sinceStartTs)
{
if (decals.Count == 0)
{
return;
}
List <uint> decalsToRemove = new List <uint>();
foreach (MyScreenDecal decal in decals)
{
var parent = MyIDTracker <MyActor> .FindByID(decal.ParentID);
bool world = decal.Flags.HasFlag(MyDecalFlags.World);
if (parent == null && !world)
{
decalsToRemove.Add(decal.ID);
continue;
}
Matrix volumeMatrix;
if (world)
{
volumeMatrix = decal.OBBox;
Vector3D translation = decal.Data.Position - MyRender11.Environment.CameraPosition;
volumeMatrix.Translation = translation;
}
else
{
MatrixD transform = decal.OBBox * parent.WorldMatrix;
transform.Translation = transform.Translation - MyRender11.Environment.CameraPosition;
volumeMatrix = transform;
}
uint fadeDiff = decal.FadeTimestamp - sinceStartTs;
float fadeAlpha = decal.FadeTimestamp - sinceStartTs >= DECAL_FADE_DURATION ? 1 : fadeDiff / (float)DECAL_FADE_DURATION;
m_jobs.Add(new MyDecalJob()
{
WorldMatrix = volumeMatrix, FadeAlpha = fadeAlpha
});
if (MyRenderProxy.Settings.DebugDrawDecals)
{
MatrixD worldMatrix;
if (parent == null)
{
worldMatrix = decal.OBBox;
worldMatrix.Translation = decal.Data.Position;
}
else
{
worldMatrix = decal.OBBox * parent.WorldMatrix;
}
MyRenderProxy.DebugDrawAxis(worldMatrix, 0.2f, false, true);
MyRenderProxy.DebugDrawOBB(worldMatrix, Color.Blue, 0.1f, false, false);
Vector3 position = worldMatrix.Translation;
MyRenderProxy.DebugDrawText3D(position, decal.SourceTarget, Color.White, 1, false);
}
}
foreach (uint id in decalsToRemove)
{
DecalNode node = m_nodeMap[id];
RemoveDecalByNode(node);
}
}
public void DebugDraw()
{
MyRenderProxy.DebugDrawSphere(this.m_center, this.m_innerRadius, Color.RoyalBlue, 0.4f, true, false, true, false);
MyRenderProxy.DebugDrawSphere(this.m_center, this.m_outerRadius, Color.Aqua, 0.4f, true, false, true, false);
}
public void Draw(List <VRageRender.MyBillboard> collectedBillboards)
{
VRage.Profiler.ProfilerShort.Begin("GPU_Draw");
if (m_renderId == MyRenderProxy.RENDER_ID_UNASSIGNED)
{
ProfilerShort.Begin("GPU_Create");
m_renderId = MyRenderProxy.CreateGPUEmitter();
ProfilerShort.End();
}
if (IsDirty)
{
ProfilerShort.Begin("GPU_FillDataComplete");
m_emitter = new MyGPUEmitter();
FillDataComplete(ref m_emitter);
m_lastFramePPS = m_emitter.ParticlesPerSecond;
MyParticlesManager.GPUEmitters.Add(m_emitter);
ProfilerShort.End();
m_dirty = m_animDirty = m_positionDirty = false;
}
else if (m_animatedTimeValues || m_animDirty)
{
ProfilerShort.Begin("GPU_FillData");
FillData(ref m_emitter);
m_lastFramePPS = m_emitter.ParticlesPerSecond;
MyParticlesManager.GPUEmitters.Add(m_emitter);
ProfilerShort.End();
m_animDirty = false;
}
else if (IsPositionDirty)
{
ProfilerShort.Begin("GPU_FillPosition");
var pps = GetParticlesPerSecond();
m_lastFramePPS = pps;
var transform = new MyGPUEmitterTransformUpdate()
{
GID = m_renderId,
Transform = CalculateWorldMatrix(),
Scale = m_effect.GetEmitterScale(),
Gravity = m_effect.Gravity * Gravity,
ParticlesPerSecond = pps
};
MyParticlesManager.GPUEmitterTransforms.Add(transform);
ProfilerShort.End();
m_positionDirty = false;
}
else if (ParticlesPerSecond.GetKeysCount() > 1)
{
ProfilerShort.Begin("GPU_FillLight");
var pps = GetParticlesPerSecond();
if (Math.Abs(m_lastFramePPS - pps) > 0.5f)
{
m_lastFramePPS = pps;
MyParticlesManager.GPUEmittersLight.Add(new MyGPUEmitterLight()
{
GID = m_renderId,
ParticlesPerSecond = pps
});
}
ProfilerShort.End();
}
ProfilerShort.End();
}
public void OnDeviceInit()
{
MyRenderProxy.Assert(m_textures.Count == 0);
RegisterDefaultTextures();
LoadAllRequested();
}
private void UpdateRenderInstanceData(Dictionary <ModelId, Tuple <List <MyCubeInstanceMergedData>, MyInstanceInfo> > instanceParts, RenderFlags renderFlags)
{
if (m_parentCullObject == MyRenderProxy.RENDER_ID_UNASSIGNED)
{
m_parentCullObject = MyRenderProxy.CreateManualCullObject(m_gridRenderComponent.Container.Entity.GetFriendlyName() + " " + m_gridRenderComponent.Container.Entity.EntityId.ToString() + ", cull object", m_gridRenderComponent.Container.Entity.PositionComp.WorldMatrix);
AddRenderObjectId(m_parentCullObject, true);
}
if (m_instanceBufferId == MyRenderProxy.RENDER_ID_UNASSIGNED)
{
m_instanceBufferId = MyRenderProxy.CreateRenderInstanceBuffer(
m_gridRenderComponent.Container.Entity.GetFriendlyName() + " "
+ m_gridRenderComponent.Container.Entity.EntityId.ToString()
+ ", instance buffer " + DebugName, MyRenderInstanceBufferType.Cube,
m_gridRenderComponent.GetRenderObjectID());
AddRenderObjectId(m_instanceBufferId, false);
}
ProfilerShort.Begin("Merge render parts");
// Merge data into one buffer
Debug.Assert(InstanceData.Count == 0, "Instance data is not cleared");
m_instanceInfo.Clear();
m_tmpDecalData.Clear();
int instaceDataIndex = -1;
foreach (var pair in instanceParts)
{
var modeId = pair.Key;
var tuple = pair.Value;
m_instanceInfo.Add(modeId, new MyRenderInstanceInfo(m_instanceBufferId, InstanceData.Count, tuple.Item1.Count, tuple.Item2.MaxViewDistance, tuple.Item2.Flags));
var instaceDatas = tuple.Item1;
for (int it1 = 0; it1 < instaceDatas.Count; it1++)
{
instaceDataIndex++;
InstanceData.Add(instaceDatas[it1].CubeInstanceData);
var decals = instaceDatas[it1].Decals;
if (decals == null)
{
continue;
}
for (int it2 = 0; it2 < decals.Count; it2++)
{
m_tmpDecalData.Add(new MyCubeInstanceDecalData()
{
DecalId = decals[it2], InstanceIndex = instaceDataIndex
});
}
}
}
ProfilerShort.End();
if (InstanceData.Count > 0)
{
ProfilerShort.Begin("Update instance buffer");
MyRenderProxy.UpdateRenderCubeInstanceBuffer(m_instanceBufferId, InstanceData, (int)(InstanceData.Count * 1.2f), m_tmpDecalData);
ProfilerShort.End();
}
InstanceData.Clear();
ProfilerShort.Begin("Update instance entitites");
UpdateRenderEntitiesInstanceData(renderFlags, m_parentCullObject);
ProfilerShort.End();
}
public static void DebugDraw(this IMyConveyorEndpoint endpoint)
{
if (!MyDebugDrawSettings.DEBUG_DRAW_CONVEYORS)
{
return;
}
Vector3 centerPos = new Vector3();
for (int i = 0; i < endpoint.GetLineCount(); ++i)
{
var position = endpoint.GetPosition(i);
Vector3 pos = new Vector3(position.LocalGridPosition) + 0.5f * new Vector3(position.VectorDirection);
centerPos += pos;
}
centerPos = centerPos * endpoint.CubeBlock.CubeGrid.GridSize / (float)endpoint.GetLineCount();
centerPos = Vector3.Transform(centerPos, endpoint.CubeBlock.CubeGrid.WorldMatrix);
for (int i = 0; i < endpoint.GetLineCount(); ++i)
{
var position = endpoint.GetPosition(i);
MyConveyorLine line = endpoint.GetConveyorLine(i);
Vector3 pos = (new Vector3(position.LocalGridPosition) + 0.5f * new Vector3(position.VectorDirection)) * endpoint.CubeBlock.CubeGrid.GridSize;
Vector3 pos2 = (new Vector3(position.LocalGridPosition) + 0.4f * new Vector3(position.VectorDirection)) * endpoint.CubeBlock.CubeGrid.GridSize;
pos = Vector3.Transform(pos, endpoint.CubeBlock.CubeGrid.WorldMatrix);
pos2 = Vector3.Transform(pos2, endpoint.CubeBlock.CubeGrid.WorldMatrix);
Vector3 dir = Vector3.TransformNormal(position.VectorDirection * endpoint.CubeBlock.CubeGrid.GridSize * 0.5f, endpoint.CubeBlock.CubeGrid.WorldMatrix);
Color color = line.IsFunctional ? Color.Orange : Color.DarkRed;
color = line.IsWorking ? Color.GreenYellow : color;
EndpointDebugShape shape = EndpointDebugShape.SHAPE_SPHERE;
float dirMultiplier = 1.0f;
float radius = 0.05f;
if (line.GetEndpoint(0) == null || line.GetEndpoint(1) == null)
{
if (line.Type == MyObjectBuilder_ConveyorLine.LineType.SMALL_LINE)
{
dirMultiplier = 0.2f;
radius = 0.015f;
shape = EndpointDebugShape.SHAPE_SPHERE;
}
else
{
dirMultiplier = 0.1f;
radius = 0.015f;
shape = EndpointDebugShape.SHAPE_CAPSULE;
}
}
else
{
if (line.Type == MyObjectBuilder_ConveyorLine.LineType.SMALL_LINE)
{
dirMultiplier = 1.0f;
radius = 0.05f;
shape = EndpointDebugShape.SHAPE_SPHERE;
}
else
{
dirMultiplier = 0.2f;
radius = 0.05f;
shape = EndpointDebugShape.SHAPE_CAPSULE;
}
}
MyRenderProxy.DebugDrawLine3D(pos, pos + dir * dirMultiplier, color, color, true);
if (shape == EndpointDebugShape.SHAPE_SPHERE)
{
MyRenderProxy.DebugDrawSphere(pos, radius * endpoint.CubeBlock.CubeGrid.GridSize, color.ToVector3(), 1.0f, false);
}
else if (shape == EndpointDebugShape.SHAPE_CAPSULE)
{
MyRenderProxy.DebugDrawCapsule(pos - dir * dirMultiplier, pos + dir * dirMultiplier, radius * endpoint.CubeBlock.CubeGrid.GridSize, color, false);
}
if (MyDebugDrawSettings.DEBUG_DRAW_CONVEYORS_LINE_IDS)
{
MyRenderProxy.DebugDrawText3D(pos2, line.GetHashCode().ToString(), color, 0.6f, false);
}
MyRenderProxy.DebugDrawLine3D(pos, centerPos, color, color, false);
}
}
public override void Draw()
{
base.Draw();
if (m_toggleMovementState)
{
var allCharacters = MyEntities.GetEntities().OfType <MyCharacter>();
Vector2 initPos = new Vector2(10, 200);
foreach (var character in allCharacters)
{
MyRenderProxy.DebugDrawText2D(initPos, character.GetCurrentMovementState().ToString(), Color.Green, 0.5f, MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_CENTER);
initPos += new Vector2(0, 20);
}
}
if (MySession.Static != null && MySession.Static.LocalCharacter != null)
{
Text("Character look speed: {0}", MySession.Static.LocalCharacter.RotationSpeed);
}
if (MySession.Static != null && MySession.Static.LocalCharacter != null)
{
var animController = MySession.Static.LocalCharacter.AnimationController;
System.Text.StringBuilder str = new System.Text.StringBuilder(1024);
if (animController != null && animController.Controller != null && animController.Controller.GetLayerByIndex(0) != null)
{
str.Clear();
foreach (int seqNum in animController.Controller.GetLayerByIndex(0).VisitedTreeNodesPath)
{
if (seqNum == 0)
{
break;
}
str.Append(seqNum);
str.Append(",");
}
Text(str.ToString());
}
if (animController != null && animController.Variables != null)
{
foreach (var variable in animController.Variables.AllVariables)
{
str.Clear();
str.Append(variable.Key);
str.Append(" = ");
str.Append(variable.Value);
Text(str.ToString());
}
}
if (animController != null)
{
if (animController.LastFrameActions != null)
{
foreach (MyStringId actionId in animController.LastFrameActions)
{
m_lastAnimationActions.Add(actionId.ToString());
}
if (m_lastAnimationActions.Count > m_maxLastAnimationActions)
{
m_lastAnimationActions.RemoveRange(0, m_lastAnimationActions.Count - m_maxLastAnimationActions);
}
}
Text(Color.Red, "--- RECENTLY TRIGGERED ACTIONS ---");
foreach (var action in m_lastAnimationActions)
{
Text(Color.Yellow, action);
}
}
}
if (m_toggleShowSkeleton)
{
DrawSkeleton();
}
MyRenderProxy.DebugDrawText2D(new Vector2(300, 10), "Debugging AC " + m_animationControllerName, Color.Yellow, 0.5f, MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_CENTER);
// debugging old animation system
if (MySession.Static != null && MySession.Static.LocalCharacter != null &&
MySession.Static.LocalCharacter.Definition != null &&
MySession.Static.LocalCharacter.Definition.AnimationController == null)
{
var allAnimationPlayers = MySession.Static.LocalCharacter.GetAllAnimationPlayers();
float posY = 40;
foreach (var animationPlayer in allAnimationPlayers)
{
MyRenderProxy.DebugDrawText2D(new Vector2(400, posY), (animationPlayer.Key != "" ? animationPlayer.Key : "Body") + ": "
+ animationPlayer.Value.ActualPlayer.AnimationNameDebug + " (" + animationPlayer.Value.ActualPlayer.AnimationMwmPathDebug + ")",
Color.Lime, 0.5f, MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_CENTER);
posY += 30;
}
}
}
private static void Save(Resource res, Stream stream, ImageFileFormat fmt)
{
var texture = res as Texture2D;
var textureCopy = new Texture2D(MyRender11.Device, new Texture2DDescription
{
Width = (int)texture.Description.Width,
Height = (int)texture.Description.Height,
MipLevels = 1,
ArraySize = 1,
Format = texture.Description.Format,
Usage = ResourceUsage.Staging,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
BindFlags = BindFlags.None,
CpuAccessFlags = CpuAccessFlags.Read,
OptionFlags = ResourceOptionFlags.None
});
RC.CopyResource(res, textureCopy);
DataStream dataStream;
var dataBox = RC.MapSubresource(
textureCopy,
0,
0,
MapMode.Read,
MapFlags.None,
out dataStream);
var dataRectangle = new DataRectangle
{
DataPointer = dataStream.DataPointer,
Pitch = dataBox.RowPitch
};
var bitmap = new Bitmap(
MyRender11.WIC,
textureCopy.Description.Width,
textureCopy.Description.Height,
PixelFormatFromFormat(textureCopy.Description.Format), // TODO: should use some conversion from textureCopy.Description.Format
dataRectangle);
using (var wicStream = new WICStream(MyRender11.WIC, stream))
{
BitmapEncoder bitmapEncoder;
switch (fmt)
{
case ImageFileFormat.Png:
bitmapEncoder = new PngBitmapEncoder(MyRender11.WIC, wicStream);
break;
case ImageFileFormat.Jpg:
bitmapEncoder = new JpegBitmapEncoder(MyRender11.WIC, wicStream);
break;
case ImageFileFormat.Bmp:
bitmapEncoder = new BmpBitmapEncoder(MyRender11.WIC, wicStream);
break;
default:
MyRenderProxy.Assert(false, "Unsupported file format.");
bitmapEncoder = null;
break;
}
if (bitmapEncoder != null)
{
using (var bitmapFrameEncode = new BitmapFrameEncode(bitmapEncoder))
{
bitmapFrameEncode.Initialize();
bitmapFrameEncode.SetSize(bitmap.Size.Width, bitmap.Size.Height);
var pixelFormat = PixelFormat.FormatDontCare;
bitmapFrameEncode.SetPixelFormat(ref pixelFormat);
bitmapFrameEncode.WriteSource(bitmap);
bitmapFrameEncode.Commit();
bitmapEncoder.Commit();
}
bitmapEncoder.Dispose();
}
}
RC.UnmapSubresource(textureCopy, 0);
textureCopy.Dispose();
bitmap.Dispose();
}
public override void Draw()
{
base.Draw();
if (!MyFakes.ENABLE_ARMOR_HAND)
{
return;
}
Vector3 forward = MySector.MainCamera.ForwardVector;
Vector3D origin = MySector.MainCamera.Position;
Vector3D end = origin + forward * 100f;
m_lastCubeGrid = null;
m_lastBone = null;
var hitInfo = MyPhysics.CastRay(origin, end, MyPhysics.ExplosionRaycastLayer);
var hitEntity = hitInfo.HasValue ? ((MyPhysicsBody)hitInfo.Value.HkHitInfo.Body.UserObject).Entity : null;
var grid = (hitEntity as MyCubeGrid);
if (grid != null)
{
m_lastCubeGrid = grid;
double shortestDistance = double.MaxValue;
LineD line = new LineD(origin, end);
Vector3I hitCube = new Vector3I();
double distanceSquared = double.MaxValue;
if (m_lastCubeGrid.GetLineIntersectionExactGrid(ref line, ref hitCube, ref distanceSquared))
{
m_lastCube = hitCube;
}
else
{
m_lastCube = null;
}
foreach (var bone in grid.Skeleton.Bones)
{
var bonePos = (Vector3D)(bone.Key / (float)grid.Skeleton.BoneDensity) * grid.GridSize + bone.Value;
bonePos -= new Vector3D(grid.GridSize / grid.Skeleton.BoneDensity);
Vector3D pos = Vector3D.Transform(bonePos, grid.PositionComp.WorldMatrix);
Color color = Color.Red;
double distance = MyUtils.GetPointLineDistance(ref origin, ref end, ref pos);
if (distance < 0.1f)
{
double distanceToCamera = (origin - pos).LengthSquared();
if (distanceToCamera < shortestDistance)
{
shortestDistance = distanceToCamera;
color = Color.Blue;
m_lastBone = bone.Key;
}
}
MyRenderProxy.DebugDrawSphere(pos, 0.05f, color.ToVector3(), 0.5f, false, true);
}
}
}
public void Invalidate(int voxelMaterialId)
{
MyRenderProxy.Assert(voxelMaterialId < MAX_ENTRIES);
m_needsUpdate[voxelMaterialId] = true;
}
public override void DebugDraw(Vector2 position, Vector2 size, List <MyBehaviorTreeNodeMemory> nodesMemory)
{
MyRenderProxy.DebugDrawText2D(position, "A:" + this.m_actionName.ToString(), nodesMemory[base.MemoryIndex].NodeStateColor, MyBehaviorTreeNode.DEBUG_TEXT_SCALE, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER, false);
}
internal static int Gather(MyGPUEmitterData[] data, out SharpDX.Direct3D11.ShaderResourceView textureArraySRV)
{
MyRenderStats.Generic.WriteFormat("GPU particles allocated: {0}", m_totalParticles, VRage.Stats.MyStatTypeEnum.CurrentValue, 300, 0);
MyRenderStats.Generic.WriteFormat("GPU particles overload: {0}", m_overloaded ? 1.0f : 0, VRage.Stats.MyStatTypeEnum.CurrentValue, 300, 0);
for (int i = 0; i < MAX_LIVE_EMITTERS; i++)
{
data[i].NumParticlesToEmitThisFrame = 0;
}
int maxEmitterIndex = -1;
uint textureIndex = 0;
foreach (var id in m_idIndex.Values)
{
if (MyCommon.TimerMs > m_emitters.Data[id.Index].DieAt)
{
m_emitters.Data[id.Index].GPUEmitter.Data.Flags |= GPUEmitterFlags.Dead;
}
float toEmit = MyCommon.LastFrameDelta() * m_emitters.Data[id.Index].GPUEmitter.ParticlesPerSecond +
m_emitters.Data[id.Index].ParticlesEmittedFraction;
m_emitters.Data[id.Index].GPUEmitter.Data.NumParticlesToEmitThisFrame = (int)toEmit;
m_emitters.Data[id.Index].ParticlesEmittedFraction = toEmit - m_emitters.Data[id.Index].GPUEmitter.Data.NumParticlesToEmitThisFrame;
if (m_emitters.Data[id.Index].TextureId != Resources.TexId.NULL)
{
MyRenderProxy.Assert(m_textureArrayIndices.ContainsKey(m_emitters.Data[id.Index].TextureId));
textureIndex = m_textureArrayIndices[m_emitters.Data[id.Index].TextureId].Index;
}
else
{
textureIndex = 0;
}
int bufferIndex = m_emitters.Data[id.Index].BufferIndex;
data[bufferIndex] = m_emitters.Data[id.Index].GPUEmitter.Data;
data[bufferIndex].Position = m_emitters.Data[id.Index].GPUEmitter.WorldPosition - MyEnvironment.CameraPosition;
data[bufferIndex].TextureIndex1 |= textureIndex << (ATLAS_INDEX_BITS + ATLAS_DIMENSION_BITS * 2);
if (bufferIndex > maxEmitterIndex)
{
maxEmitterIndex = bufferIndex;
}
}
UpdateTextureArray();
if (m_textureArray != null)
{
textureArraySRV = m_textureArray.ShaderView;
}
else
{
textureArraySRV = null;
}
foreach (var id in m_idIndex.Values.ToArray())
{
if ((m_emitters.Data[id.Index].GPUEmitter.Data.Flags & GPUEmitterFlags.Dead) > 0)
{
m_totalParticles -= m_emitters.Data[id.Index].GPUEmitter.MaxParticles();
Remove(id);
}
}
return(maxEmitterIndex + 1);
}
public override void InvalidateRenderObjects(bool sortIntoCullobjects = false)
{
MyRenderProxy.UpdateLineBasedObject(m_renderObjectIDs[0], WorldPivotA, WorldPivotB);
}
static void ClearDecals(MyGuiControlButton button)
{
MyRenderProxy.ClearDecals();
}
public override void ReleaseRenderObjectID(int index)
{
MyRenderProxy.RemoveRenderObject(m_renderObjectIDs[0]);
}
public void DebugDraw()
{
if (MyDebugDrawSettings.ENABLE_DEBUG_DRAW == false)
{
return;
}
m_aiming.DebugDraw(m_aimingPositionAndOrientation);
if (MyDebugDrawSettings.DEBUG_DRAW_BOT_STEERING)
{
foreach (var steering in m_steerings)
{
steering.DebugDraw();
}
}
if (MyDebugDrawSettings.DEBUG_DRAW_BOT_NAVIGATION)
{
Vector3 pos = PositionAndOrientation.Translation;// + /*PositionAndOrientation.Up * 1.5f + */ForwardVector;
Vector3 rightVector = Vector3.Cross(m_forwardVector, UpVector);
if (Stuck)
{
MyRenderProxy.DebugDrawSphere(pos, 1.0f, Color.Red.ToVector3(), 1.0f, false);
}
//MyRenderProxy.DebugDrawLine3D(pos, pos + ForwardVector, Color.Blue, Color.Blue, false);
//var normalizedCorrection = Vector3D.Normalize(m_correction);
//var normalizedCorrectedDirXZ = normalizedCorrection + m_forwardVector;
//normalizedCorrectedDirXZ = Vector3D.Normalize(Vector3D.Reject(normalizedCorrectedDirXZ, Vector3D.Up));
//MyRenderProxy.DebugDrawLine3D(pos, pos + normalizedCorrectedDirXZ * 3, Color.Lime, Color.Lime, false);
MyRenderProxy.DebugDrawArrow3D(pos, pos + ForwardVector, Color.Blue, Color.Blue, false, text: "Nav. FW");
MyRenderProxy.DebugDrawArrow3D(pos + ForwardVector, pos + ForwardVector + m_correction, Color.LightBlue, Color.LightBlue, false, text: "Correction");
//MyRenderProxy.DebugDrawLine3D(pos + ForwardVector, pos + ForwardVector + m_correction, Color.Yellow, Color.Yellow, false);
//MyRenderProxy.DebugDrawSphere(pos + ForwardVector + m_correction, 0.05f, Color.Yellow.ToVector3(), 1.0f, true);
if (m_destinationSphere != null)
{
m_destinationSphere.DebugDraw();
}
var character = this.BotEntity as MyCharacter;
if (character != null)
{
var viewMatrix = character.GetViewMatrix();
var worldMatrix = MatrixD.Invert(viewMatrix);
var headMatrix = character.GetHeadMatrix(true, true);
MyRenderProxy.DebugDrawLine3D(worldMatrix.Translation, Vector3D.Transform(Vector3D.Forward * 50, worldMatrix), Color.Yellow, Color.White, false);
MyRenderProxy.DebugDrawLine3D(headMatrix.Translation, Vector3D.Transform(Vector3D.Forward * 50, headMatrix), Color.Red, Color.Red, false);
if (character.CurrentWeapon != null)
{
var direction = character.CurrentWeapon.DirectionToTarget(character.AimedPoint);
var spos = (character.CurrentWeapon as MyEntity).WorldMatrix.Translation;
MyRenderProxy.DebugDrawSphere(character.AimedPoint, 1.0f, Color.Yellow, 1.0f, false);
MyRenderProxy.DebugDrawLine3D(spos, spos + direction * 20, Color.Purple, Color.Purple, false);
}
}
}
}
protected bool TestGridPlacementOnGrid(MyCubeGrid previewGrid, ref MyGridPlacementSettings settings, MyCubeGrid hitGrid)
{
Debug.Assert(previewGrid.GridSizeEnum == hitGrid.GridSizeEnum);
bool retval = true;
Vector3I gridOffset = hitGrid.WorldToGridInteger(previewGrid.PositionComp.WorldMatrix.Translation);
MatrixI transform = hitGrid.CalculateMergeTransform(previewGrid, gridOffset);
Matrix localPreviewMatrix = transform.GetFloatMatrix();
localPreviewMatrix.Translation *= previewGrid.GridSize;
if (MyDebugDrawSettings.DEBUG_DRAW_COPY_PASTE)
{
MyRenderProxy.DebugDrawText2D(new Vector2(0.0f, 60.0f), "First grid offset: " + gridOffset.ToString(), Color.Red, 1.0f);
}
retval = retval && MyCubeBuilder.CheckValidBlocksRotation(localPreviewMatrix, previewGrid);
retval = retval && hitGrid.GridSizeEnum == previewGrid.GridSizeEnum && hitGrid.CanMergeCubes(previewGrid, gridOffset);
retval = retval && MyCubeGrid.CheckMergeConnectivity(hitGrid, previewGrid, gridOffset);
// Check if any block connects to hit grid
if (retval)
{
bool connected = false;
foreach (var block in previewGrid.CubeBlocks)
{
if (block.FatBlock is MyCompoundCubeBlock)
{
MyCompoundCubeBlock compoundBlock = block.FatBlock as MyCompoundCubeBlock;
foreach (var blockInCompound in compoundBlock.GetBlocks())
{
connected |= CheckConnectivityOnGrid(blockInCompound, ref transform, ref settings, hitGrid);
if (connected)
{
break;
}
}
}
else
{
connected |= CheckConnectivityOnGrid(block, ref transform, ref settings, hitGrid);
}
if (connected)
{
break;
}
}
retval &= connected;
}
if (retval)
{
foreach (var block in previewGrid.CubeBlocks)
{
if (block.FatBlock is MyCompoundCubeBlock)
{
MyCompoundCubeBlock compoundBlock = block.FatBlock as MyCompoundCubeBlock;
foreach (var blockInCompound in compoundBlock.GetBlocks())
{
retval = retval && TestBlockPlacementOnGrid(blockInCompound, ref transform, ref settings, hitGrid);
if (!retval)
{
break;
}
}
}
else
{
retval = retval && TestBlockPlacementOnGrid(block, ref transform, ref settings, hitGrid);
}
if (!retval)
{
break;
}
}
}
return(retval);
}
internal static int Gather(MyGPUEmitterData[] data, out ISrvBindable textureArraySrv)
{
for (int i = 0; i < MAX_LIVE_EMITTERS; i++)
{
data[i].NumParticlesToEmitThisFrame = 0;
}
// sort emitters!
List <MyLiveData> emitters = m_emitters.Values.ToList();
//if (emitters.Count > MAX_LIVE_EMITTERS)
emitters.Sort();
int maxEmitterIndex = -1;
uint textureIndex = 0;
int unassociatedCount = 0;
int skipCount = 0;
int unsortedCount = 0;
int firstUnassociatedIndex = -1;
int lastAssociatedIndex = -1;
for (int i = 0; i < emitters.Count; i++)
{
var emitter = emitters[i];
// assiociate buffer index to new emitters & track overload to free space for unassociated near emitters later
if (emitter.BufferIndex == -1)
{
if (m_freeBufferIndices.Count > 0)
{
emitter.BufferIndex = m_freeBufferIndices.Pop();
}
else
{
unassociatedCount++;
if (firstUnassociatedIndex == -1)
{
firstUnassociatedIndex = i;
}
}
}
else
{
skipCount = unassociatedCount;
lastAssociatedIndex = i;
if (unassociatedCount > 0)
{
unsortedCount++;
}
}
if (MyCommon.TimerMs > emitter.DieAt)
{
emitter.GPUEmitter.Data.Flags |= GPUEmitterFlags.Dead;
}
if (emitter.BufferIndex != -1)
{
if ((emitter.GPUEmitter.Data.Flags & GPUEmitterFlags.FreezeEmit) == 0)
{
float toEmit = MyCommon.LastFrameDelta() * emitter.GPUEmitter.ParticlesPerSecond +
emitter.ParticlesEmittedFraction;
emitter.GPUEmitter.Data.NumParticlesToEmitThisFrame = (int)toEmit;
emitter.ParticlesEmittedFraction = toEmit - emitter.GPUEmitter.Data.NumParticlesToEmitThisFrame;
}
if (string.IsNullOrEmpty(emitter.GPUEmitter.AtlasTexture))
{
MyRenderProxy.Assert(m_textureArrayIndices.ContainsKey(emitter.GPUEmitter.AtlasTexture));
textureIndex = m_textureArrayIndices[emitter.GPUEmitter.AtlasTexture].Index;
}
else
{
textureIndex = 0;
}
int bufferIndex = emitter.BufferIndex;
data[bufferIndex] = emitter.GPUEmitter.Data;
Vector3 pos = emitter.GPUEmitter.WorldPosition - MyRender11.Environment.Matrices.CameraPosition;
data[bufferIndex].RotationMatrix.M14 = pos.X;
data[bufferIndex].RotationMatrix.M24 = pos.Y;
data[bufferIndex].RotationMatrix.M34 = pos.Z;
data[bufferIndex].PositionDelta = emitter.LastWorldPosition - emitter.GPUEmitter.WorldPosition;
data[bufferIndex].TextureIndex1 |= textureIndex << (ATLAS_INDEX_BITS + ATLAS_DIMENSION_BITS * 2);
if (bufferIndex > maxEmitterIndex)
{
maxEmitterIndex = bufferIndex;
}
}
emitter.LastWorldPosition = emitter.GPUEmitter.WorldPosition;
}
/*MyRenderStats.Generic.WriteFormat("GPU particles allocated: {0}", totalParticles, VRage.Stats.MyStatTypeEnum.CurrentValue, 300, 0);
* MyRenderStats.Generic.WriteFormat("GPU particles overload: {0}", overloadedParticles ? 1.0f : 0, VRage.Stats.MyStatTypeEnum.CurrentValue, 300, 0);
* MyRenderStats.Generic.WriteFormat("GPU emitters overload: {0}", overloadedEmitters ? 1.0f : 0, VRage.Stats.MyStatTypeEnum.CurrentValue, 300, 0);*/
UpdateTextureArray();
textureArraySrv = m_textureArray;
// stop emitters far away to make room for emitters nearby
if (skipCount > 0 && unsortedCount > 0)
{
// iterate until buffer-unassociated index is larger then unassocited one
for (int i = firstUnassociatedIndex, j = lastAssociatedIndex; i < j;)
{
var emitter = emitters[j];
// free last buffer-associated emitter
data[emitter.BufferIndex].Flags |= GPUEmitterFlags.Dead;
data[emitter.BufferIndex].NumParticlesToEmitThisFrame = 0;
m_freeBufferIndices.Push(emitter.BufferIndex);
emitter.BufferIndex = -1;
// find new last buffer-associated emitter
do
{
j--;
}while (j > 0 && emitters[j].BufferIndex == -1);
// find next buffer-unassociated emitter
do
{
i++;
} while (i < emitters.Count && emitters[i].BufferIndex != -1);
}
}
foreach (var emitter in emitters)
{
if ((emitter.GPUEmitter.Data.Flags & GPUEmitterFlags.Dead) > 0)
{
Remove(emitter);
}
}
return(maxEmitterIndex + 1);
}
// Draws the gizmo
public override void Draw()
{
if (!Active)
{
return;
}
if (DEBUG)
{
MyRenderProxy.DebugDrawLine3D(m_lastRay.From, m_lastRay.To, Color.Green, Color.Green, true);
}
if (ControlledEntity == null)
{
return;
}
if (ControlledEntity.Parent != null)
{
var parent = ControlledEntity.Parent;
while (parent != null)
{
// Draw line to parent
MyRenderProxy.DebugDrawLine3D(ControlledEntity.Parent.PositionComp.GetPosition(),
ControlledEntity.PositionComp.GetPosition(),
Color.Orange,
Color.Blue,
false);
parent = parent.Parent;
}
}
var textPosition = new Vector2(20, Session.Camera.ViewportSize.Y / 2);
switch (Operation)
{
case OperationMode.Translation:
MyRenderProxy.DebugDrawText2D(textPosition, "Translation", Color.Yellow, 1);
break;
case OperationMode.Rotation:
MyRenderProxy.DebugDrawText2D(textPosition, "Rotation", Color.Yellow, 1);
break;
case OperationMode.HierarchyAssignment:
MyRenderProxy.DebugDrawText2D(textPosition, "Hierarchy", Color.Yellow, 1);
break;
}
if (Operation == OperationMode.Translation && !DisableTransformation)
{
// Change the size of the control elements
var camPosition = Session.Camera.Position;
var distance = Vector3D.Distance(m_xBB.Center, camPosition);
var f = Session.Camera.ProjectionMatrix.Up.LengthSquared();
m_xBB.HalfExtent = Vector3D.One * 0.008 * distance * f;
m_yBB.HalfExtent = Vector3D.One * 0.008 * distance * f;
m_zBB.HalfExtent = Vector3D.One * 0.008 * distance * f;
DrawOBB(m_xBB, Color.Red, 0.5f, 0);
DrawOBB(m_yBB, Color.Green, 0.5f, 1);
DrawOBB(m_zBB, Color.Blue, 0.5f, 2);
}
if (Operation != OperationMode.HierarchyAssignment && !DisableTransformation)
{
DrawOBB(m_xPlane, Color.Red, 0.2f, 3);
DrawOBB(m_yPlane, Color.Green, 0.2f, 4);
DrawOBB(m_zPlane, Color.Blue, 0.2f, 5);
}
else
{
var volumeCenter = ControlledEntity.PositionComp.WorldVolume.Center;
var volumeRadius = ControlledEntity.PositionComp.WorldVolume.Radius;
MyRenderProxy.DebugDrawSphere(volumeCenter, (float)volumeRadius, Color.Yellow, 0.2f, true);
}
}
public MyShaderBundle GetShaderBundle(MyInstanceLodState state)
{
MyRenderProxy.Assert((int)state < m_shaderBundles.Length, "Shader bundle is not correctly initialised");
MyRenderProxy.Assert(m_shaderBundles[(int)state] != null, "Shader bundle is not defined for the state");
return(m_shaderBundles[(int)state]);
}
public void DebugDraw()
{
m_sensor.DebugDraw();
MyRenderProxy.DebugDrawSphere((Vector3)m_cutOut.Sphere.Center, (float)m_cutOut.Sphere.Radius, Color.Red, 0.6f, true);
}
/// <summary>
/// Update shown position of the weapon.
/// </summary>
private void UpdateGraphicalWeaponPosition()
{
var animController = Character.AnimationController;
MyHandItemDefinition handItemDefinition = Character.HandItemDefinition;
if (handItemDefinition == null || Character.CurrentWeapon == null || animController.CharacterBones == null)
{
return;
}
// ---------
// gather useful variables
bool isLocallyControlled = Character.ControllerInfo.IsLocallyControlled();
bool isInFirstPerson = (Character.IsInFirstPersonView || Character.ForceFirstPersonCamera) && isLocallyControlled;
var jetpack = Character.JetpackComp;
bool flying = jetpack != null && jetpack.Running;
if (m_lastStateWasFalling && flying)
{
m_currentAnimationToIkTime = m_animationToIKDelay * (float)Math.Cos(Character.HeadLocalXAngle - m_lastLocalRotX);
}
if (m_lastStateWasCrouching != Character.IsCrouching)
{
m_suppressBouncingForTimeSec = m_suppressBouncingDelay;
}
if (m_suppressBouncingForTimeSec > 0)
{
m_spineRestPositionX.Clear();
m_spineRestPositionY.Clear();
m_spineRestPositionZ.Clear();
}
m_lastLocalRotX = Character.HeadLocalXAngle;
// get head matrix
MatrixD weaponMatrixPositioned = Character.GetHeadMatrix(false, !flying, false, true, preferLocalOverSync: true) * Character.PositionComp.WorldMatrixInvScaled;
if (!isInFirstPerson && animController.CharacterBones.IsValidIndex(Character.HeadBoneIndex))
{
// apply feet ik (head bone is stabilized)
weaponMatrixPositioned.M42 += animController.CharacterBonesSorted[0].Translation.Y;
}
// ---------
// mix positioning matrices (variants: stand/walk/shoot/ironsight), all in character local space
// standing (IK)
MatrixD standingMatrix = isInFirstPerson ? handItemDefinition.ItemLocation : handItemDefinition.ItemLocation3rd;
// walking (IK)
MatrixD walkingMatrix = isInFirstPerson ? handItemDefinition.ItemWalkingLocation : handItemDefinition.ItemWalkingLocation3rd;
// shooting (IK)
MatrixD shootingMatrix = isInFirstPerson ? handItemDefinition.ItemShootLocation : handItemDefinition.ItemShootLocation3rd;
// ironsight (IK)
MatrixD ironsightMatrix = handItemDefinition.ItemIronsightLocation;
// animation pose
MatrixD weaponAnimMatrix = animController.CharacterBones.IsValidIndex(Character.WeaponBone)
? GetWeaponRelativeMatrix() * animController.CharacterBones[Character.WeaponBone].AbsoluteTransform
: GetWeaponRelativeMatrix();
ironsightMatrix.Translation = m_weaponIronsightTranslation;
if (Character.CurrentWeapon is MyEngineerToolBase)
{
ironsightMatrix.Translation = m_toolIronsightTranslation;
}
// get weights of all state variants
Vector4D variantWeights = UpdateAndGetWeaponVariantWeights(handItemDefinition);
// interpolate matrices to get the resulting one
MatrixD weaponMatrixLocal = variantWeights.X * standingMatrix
+ variantWeights.Y * walkingMatrix
+ variantWeights.Z * shootingMatrix
+ variantWeights.W * ironsightMatrix;
weaponMatrixLocal = MatrixD.Normalize(weaponMatrixLocal);
// weapon positioning - IK weight
double weaponDataPosWeight = 0;
if (handItemDefinition.ItemPositioning == MyItemPositioningEnum.TransformFromData && isInFirstPerson ||
handItemDefinition.ItemPositioning3rd == MyItemPositioningEnum.TransformFromData && !isInFirstPerson)
{
weaponDataPosWeight += variantWeights.X;
}
if (handItemDefinition.ItemPositioningWalk == MyItemPositioningEnum.TransformFromData && isInFirstPerson ||
handItemDefinition.ItemPositioningWalk3rd == MyItemPositioningEnum.TransformFromData && !isInFirstPerson)
{
weaponDataPosWeight += variantWeights.Y;
}
if (handItemDefinition.ItemPositioningShoot == MyItemPositioningEnum.TransformFromData && isInFirstPerson ||
handItemDefinition.ItemPositioningShoot3rd == MyItemPositioningEnum.TransformFromData && !isInFirstPerson)
{
weaponDataPosWeight += variantWeights.Z;
}
weaponDataPosWeight += variantWeights.W;
weaponDataPosWeight /= variantWeights.X + variantWeights.Y + variantWeights.Z + variantWeights.W;
// now computing hand IK weight
double armsIkWeight = 0;
if (handItemDefinition.ItemPositioning != MyItemPositioningEnum.TransformFromAnim && isInFirstPerson ||
handItemDefinition.ItemPositioning3rd != MyItemPositioningEnum.TransformFromAnim && !isInFirstPerson)
{
armsIkWeight += variantWeights.X;
}
if (handItemDefinition.ItemPositioningWalk != MyItemPositioningEnum.TransformFromAnim && isInFirstPerson ||
handItemDefinition.ItemPositioningWalk3rd != MyItemPositioningEnum.TransformFromAnim && !isInFirstPerson)
{
armsIkWeight += variantWeights.Y;
}
if (handItemDefinition.ItemPositioningShoot != MyItemPositioningEnum.TransformFromAnim && isInFirstPerson ||
handItemDefinition.ItemPositioningShoot3rd != MyItemPositioningEnum.TransformFromAnim && !isInFirstPerson)
{
armsIkWeight += variantWeights.Z;
}
armsIkWeight /= variantWeights.X + variantWeights.Y + variantWeights.Z + variantWeights.W;
ApplyWeaponBouncing(handItemDefinition, ref weaponMatrixLocal, (float)(1.0 - 0.95 * variantWeights.W));
// apply head transform on top of it
if (!isInFirstPerson)
{
weaponMatrixPositioned.M43 += 0.5 * weaponMatrixLocal.M43 * Math.Max(0, weaponMatrixPositioned.M32); // offset not to interfere with body
weaponMatrixPositioned.M42 += 0.5 * weaponMatrixLocal.M42 * Math.Max(0, weaponMatrixPositioned.M32); // offset not to interfere with body
}
MatrixD weaponMatrixPositionedLocal = weaponMatrixLocal * weaponMatrixPositioned;
// displace sensor (maybe move to logical part? does not seem to be used at all)
var characterWeaponEngToolBase = Character.CurrentWeapon as MyEngineerToolBase;
if (characterWeaponEngToolBase != null)
{
characterWeaponEngToolBase.SensorDisplacement = -weaponMatrixLocal.Translation;
}
// mix plain animation with (anim+ik) result - for example, medieval uses plain animations
double ikRatio = weaponDataPosWeight * m_currentAnimationToIkTime / m_animationToIKDelay;
MatrixD weaponFinalWorld = MatrixD.Lerp(weaponAnimMatrix, weaponMatrixPositionedLocal, ikRatio) * Character.WorldMatrix;
// propagate result to fields
GraphicalPositionWorld = weaponFinalWorld.Translation;
ArmsIkWeight = (float)armsIkWeight;
((MyEntity)Character.CurrentWeapon).WorldMatrix = weaponFinalWorld;
if (MyDebugDrawSettings.ENABLE_DEBUG_DRAW)
{
MyRenderProxy.DebugDrawAxis(weaponFinalWorld, 0.5f, false);
}
}
public void UpdateAtmosphereSettings(MyAtmosphereSettings settings)
{
MyRenderProxy.UpdateAtmosphereSettings(m_renderObjectIDs[m_atmosphereRenderIndex], settings);
}
protected override void ValueChanged(MyGuiControlBase sender)
{
MyRenderProxy.SetSettingsDirty();
}
private void Create()
{
bool dedicated = Sandbox.Engine.Platform.Game.IsDedicated;
Environment.SetEnvironmentVariable("SteamAppId", _appSteamId.ToString());
var service = MySteamServiceWrapper.Init(dedicated, _appSteamId);
MyServiceManager.Instance.AddService <IMyGameService>(service);
var serviceInstance = MySteamUgcService.Create(_appSteamId, service);
MyServiceManager.Instance.AddService <IMyUGCService>(serviceInstance);
if (dedicated && !MyGameService.HasGameServer)
{
_log.Warn("Steam service is not running! Please reinstall dedicated server.");
return;
}
SpaceEngineersGame.SetupBasicGameInfo();
SpaceEngineersGame.SetupPerGameSettings();
MyFinalBuildConstants.APP_VERSION = MyPerGameSettings.BasicGameInfo.GameVersion;
MySessionComponentExtDebug.ForceDisable = true;
MyPerGameSettings.SendLogToKeen = false;
// SpaceEngineersGame.SetupAnalytics();
MyFileSystem.ExePath = Path.GetDirectoryName(typeof(SpaceEngineersGame).Assembly.Location);
_tweakGameSettings();
MyFileSystem.Reset();
MyInitializer.InvokeBeforeRun(_appSteamId, _appName, _userDataPath);
// MyInitializer.InitCheckSum();
// Hook into the VRage plugin system for updates.
_getVRagePluginList().Add(_torch);
if (!MySandboxGame.IsReloading)
{
MyFileSystem.InitUserSpecific(dedicated ? null : MyGameService.UserId.ToString());
}
MySandboxGame.IsReloading = dedicated;
// render init
{
IMyRender renderer = null;
if (dedicated)
{
renderer = new MyNullRender();
}
else
{
MyPerformanceSettings preset = MyGuiScreenOptionsGraphics.GetPreset(MyRenderQualityEnum.NORMAL);
MyRenderProxy.Settings.User = MyVideoSettingsManager.GetGraphicsSettingsFromConfig(ref preset, false)
.PerformanceSettings.RenderSettings;
MyStringId graphicsRenderer = MySandboxGame.Config.GraphicsRenderer;
if (graphicsRenderer == MySandboxGame.DirectX11RendererKey)
{
renderer = new MyDX11Render(new MyRenderSettings?(MyRenderProxy.Settings));
if (!renderer.IsSupported)
{
MySandboxGame.Log.WriteLine(
"DirectX 11 renderer not supported. No renderer to revert back to.");
renderer = null;
}
}
if (renderer == null)
{
throw new MyRenderException(
"The current version of the game requires a Dx11 card. \\n For more information please see : http://blog.marekrosa.org/2016/02/space-engineers-news-full-source-code_26.html",
MyRenderExceptionEnum.GpuNotSupported);
}
MySandboxGame.Config.GraphicsRenderer = graphicsRenderer;
}
MyRenderProxy.Initialize(renderer);
MyRenderProfiler.SetAutocommit(false);
//This broke services?
//MyRenderProfiler.InitMemoryHack("MainEntryPoint");
}
// Loads object builder serializers. Intuitive, right?
_log.Info("Setting up serializers");
MyPlugins.RegisterGameAssemblyFile(MyPerGameSettings.GameModAssembly);
if (MyPerGameSettings.GameModBaseObjBuildersAssembly != null)
{
MyPlugins.RegisterBaseGameObjectBuildersAssemblyFile(MyPerGameSettings.GameModBaseObjBuildersAssembly);
}
MyPlugins.RegisterGameObjectBuildersAssemblyFile(MyPerGameSettings.GameModObjBuildersAssembly);
MyPlugins.RegisterSandboxAssemblyFile(MyPerGameSettings.SandboxAssembly);
MyPlugins.RegisterSandboxGameAssemblyFile(MyPerGameSettings.SandboxGameAssembly);
//typeof(MySandboxGame).GetMethod("Preallocate", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, null);
MyGlobalTypeMetadata.Static.Init(false);
}
private static void DrawMountPointsAxisHelpers(MyCubeBlockDefinition def, ref MatrixD drawMatrix, float cubeSize)
{
Vector3I centerGrid = def.Center;
Vector3 centerOffset = def.Size * 0.5f;
MatrixD drawTransf = MatrixD.CreateTranslation(centerGrid - centerOffset) * MatrixD.CreateScale(cubeSize) * drawMatrix;
// Draw axis helpers for the six mount point walls
for (int i = 0; i < 6; ++i)
{
Base6Directions.Direction dir = (Base6Directions.Direction)i;
Vector3D position = Vector3D.Zero;
position.Z = -0.2f;
Vector3D normal = Vector3.Forward;
Vector3D right = Vector3.Right;
Vector3D up = Vector3.Up;
position = def.MountPointLocalToBlockLocal(position, dir);
position = Vector3D.Transform(position, drawTransf);
normal = def.MountPointLocalNormalToBlockLocal(normal, dir);
normal = Vector3D.TransformNormal(normal, drawTransf);
up = def.MountPointLocalNormalToBlockLocal(up, dir);
up = Vector3D.TransformNormal(up, drawTransf);
right = def.MountPointLocalNormalToBlockLocal(right, dir);
right = Vector3D.TransformNormal(right, drawTransf);
MatrixD rightMat = MatrixD.CreateWorld(position + right * 0.25f, normal, right);
MatrixD upMat = MatrixD.CreateWorld(position + up * 0.25f, normal, up);
Vector4 rc = Color.Red.ToVector4();
Vector4 uc = Color.Green.ToVector4();
MyRenderProxy.DebugDrawSphere(position, 0.03f * cubeSize, Color.Red.ToVector3(), 1.0f, true);
MySimpleObjectDraw.DrawTransparentCylinder(ref rightMat, 0.0f, 0.03f * cubeSize, 0.5f * cubeSize, ref rc, false, 16, 0.01f * cubeSize);
MySimpleObjectDraw.DrawTransparentCylinder(ref upMat, 0.0f, 0.03f * cubeSize, 0.5f * cubeSize, ref uc, false, 16, 0.01f * cubeSize);
MyRenderProxy.DebugDrawLine3D(position, position - normal * 0.2f, Color.Red, Color.Red, true);
float textSizeX = 0.5f * cubeSize;
float textSizeY = 0.5f * cubeSize;
float textSizeDesc = 0.5f * cubeSize;
if (MySector.MainCamera != null)
{
float distX = (float)(position + right * 0.55f - MySector.MainCamera.Position).Length();
float distY = (float)(position + up * 0.55f - MySector.MainCamera.Position).Length();
float distDesc = (float)(position + normal * 0.1f - MySector.MainCamera.Position).Length();
textSizeX = textSizeX * 6 / distX;
textSizeY = textSizeY * 6 / distY;
textSizeDesc = textSizeDesc * 6 / distDesc;
}
MyRenderProxy.DebugDrawText3D(position + right * 0.55f, "X", Color.Red, textSizeX, false, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER);
MyRenderProxy.DebugDrawText3D(position + up * 0.55f, "Y", Color.Green, textSizeY, false, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER);
MyRenderProxy.DebugDrawText3D(position + normal * 0.1f, m_mountPointSideNames[i], Color.White, textSizeDesc, true, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER);
}
// If close enough, draw a black grid spaced by tenths of a mount point unit
float dist = (float)(drawTransf.Translation - MySector.MainCamera.Position).Length();
BoundingBoxD bb = new BoundingBoxD(-def.Size * cubeSize * 0.5f, def.Size * cubeSize * 0.5f);
dist -= (float)bb.Size.Max() * 0.866f; // sqrt(3) * 0.5 - half of the solid diagonal of a cube
Color black = Color.Black;
if (dist < cubeSize * 3.0f)
{
MySimpleObjectDraw.DrawTransparentBox(ref drawMatrix, ref bb, ref black, MySimpleObjectRasterizer.Wireframe, def.Size * 10, 0.005f / (float)bb.Size.Max() * cubeSize, onlyFrontFaces: true);
}
}
public static void TestGPUParticles()
{
if (VRage.Input.MyInput.Static.IsAnyShiftKeyPressed())
{
if (gid0 == 0)
{
gid0 = MyRenderProxy.CreateGPUEmitter();
gid1 = MyRenderProxy.CreateGPUEmitter();
}
var Position = MyTransparentGeometry.Camera.Translation;
var emitters = new MyGPUEmitter[2];
// sparks
emitters[0].GID = gid0;
emitters[0].ParticlesPerSecond = 30000.0f;
emitters[0].Data.Color0 = new Vector4(1.0f, 1.0f, 0.0f, 1f);
emitters[0].Data.Color1 = new Vector4(1.0f, 0.0f, 0.0f, 1f);
emitters[0].Data.Color2 = new Vector4(1.0f, 0.0f, 0.0f, 0.0f);
emitters[0].Data.ColorKey1 = 0.5f;
emitters[0].Data.ColorKey2 = 1.0f;
emitters[0].Data.AlphaKey1 = 0.95f;
emitters[0].Data.AlphaKey2 = 1.0f;
emitters[0].Data.Bounciness = 0.4f;
emitters[0].Data.Velocity = new Vector3(0.0f, 0.0f, -1.0f);
emitters[0].Data.NumParticlesToEmitThisFrame = 0;
emitters[0].Data.ParticleLifeSpan = 9.0f;
emitters[0].Data.Size0 = 0.02f;
emitters[0].Data.Size1 = 0.016f;
emitters[0].Data.Size2 = 0.0f;
emitters[0].Data.SizeKeys1 = 0.95f;
emitters[0].Data.SizeKeys2 = 1.0f;
emitters[0].Data.PositionVariance = new Vector3(0.1f, 0.1f, 0.1f);
emitters[0].Data.VelocityVariance = 0.4f;
emitters[0].Data.RotationVelocity = 0;
emitters[0].Data.Acceleration = new Vector3(0, 0, -0.98f);
emitters[0].Data.StreakMultiplier = 4.0f;
emitters[0].Data.Flags = GPUEmitterFlags.Streaks | GPUEmitterFlags.Collide | GPUEmitterFlags.SleepState;
emitters[0].Data.SoftParticleDistanceScale = 5;
emitters[0].Data.AnimationFrameTime = 1.0f;
emitters[0].Data.OITWeightFactor = 0.3f;
emitters[0].AtlasTexture = "Textures\\Particles\\gpuAtlas0.dds";
emitters[0].AtlasDimension = new Vector2I(2, 1);
emitters[0].AtlasFrameOffset = 1;
emitters[0].AtlasFrameModulo = 1;
emitters[0].WorldPosition = Position + new Vector3D(8.0f, 0.0f, 8.0f);
// smoke
emitters[1].GID = gid1;
emitters[1].ParticlesPerSecond = 100.0f;
emitters[1].Data.Color0 = new Vector4(0.5f, 0.5f, 0.5f, 1.0f);
emitters[1].Data.Color1 = new Vector4(0.6f, 0.6f, 0.65f, 1.0f);
emitters[1].Data.Color2 = new Vector4(0.6f, 0.6f, 0.65f, 0.0f);
emitters[1].Data.ColorKey1 = 0.5f;
emitters[1].Data.ColorKey2 = 1.0f;
emitters[1].Data.AlphaKey1 = 0.95f;
emitters[1].Data.AlphaKey2 = 1.0f;
emitters[1].Data.Velocity = new Vector3(0, 0, 1.0f);
emitters[1].Data.NumParticlesToEmitThisFrame = 0;
emitters[1].Data.ParticleLifeSpan = 150.0f;
emitters[1].Data.Size0 = 0.50f;
emitters[1].Data.Size1 = 2.2f;
emitters[1].Data.SizeKeys1 = 1.0f;
emitters[1].Data.SizeKeys2 = 1.0f;
emitters[1].Data.PositionVariance = new Vector3(0.2f, 0.2f, 0.2f);
emitters[1].Data.VelocityVariance = 0.3f;
emitters[1].Data.RotationVelocity = 100.0f;
emitters[1].Data.Acceleration = new Vector3(0.00707f, 0.00707f, -0.00003f * 9.8f);
emitters[1].Data.Flags = GPUEmitterFlags.Light | GPUEmitterFlags.VolumetricLight;
emitters[1].Data.SoftParticleDistanceScale = 2;
emitters[1].Data.AnimationFrameTime = 1.0f;
emitters[1].Data.OITWeightFactor = 1.0f;
emitters[1].AtlasTexture = "Textures\\Particles\\gpuAtlas1.dds";
emitters[1].AtlasDimension = new Vector2I(2, 1);
emitters[1].AtlasFrameOffset = 0;
emitters[1].AtlasFrameModulo = 1;
emitters[1].WorldPosition = Position + new Vector3D(2.0f, 0.0f, 1.0f);
MyRenderProxy.UpdateGPUEmitters(emitters);
}
}
public MyCpuFrustumCullPass At(int index)
{
MyRenderProxy.Assert(index < Count);
return(m_passes[index]);
}
