internal void UpdateRenderEntitiesData(ref MatrixD worldMatrixD, bool useTransparency, float transparency)
{
int model = this.Model;
bool flag = this.RenderObjectId != uint.MaxValue;
if (this.InstanceCount <= 0)
{
if (flag)
{
this.UnloadRenderObjects();
}
}
else
{
RenderFlags flags = RenderFlags.Visible | RenderFlags.CastShadows;
if (!flag)
{
string byId = MyModel.GetById(model);
this.RenderObjectId = MyRenderProxy.CreateRenderEntity("Instance parts, part: " + model, byId, this.Parent.SectorMatrix, MyMeshDrawTechnique.MESH, flags, CullingOptions.Default, Vector3.One, Vector3.Zero, useTransparency ? transparency : 0f, this.MaxViewDistance, 0, 1f, true);
}
MyRenderProxy.SetInstanceBuffer(this.RenderObjectId, this.InstanceBuffer, 0, this.InstanceData.Count, this.Parent.SectorBox, null);
MyRenderProxy.UpdateRenderEntity(this.RenderObjectId, new Color?(Vector3.One), new Vector3?(Vector3.Zero), new float?(useTransparency ? transparency : 0f), true);
MatrixD sectorMatrix = this.Parent.SectorMatrix;
BoundingBox?aabb = null;
Matrix? localMatrix = null;
MyRenderProxy.UpdateRenderObject(this.RenderObjectId, new MatrixD?(sectorMatrix), aabb, -1, localMatrix);
}
}
public override void AddRenderObjects()
{
if (Models.Count == 0)
{
return;
}
m_renderObjectIDs = new uint[Models.Count + 1];
m_renderObjectIDs[0] = VRageRender.MyRenderProxy.RENDER_ID_UNASSIGNED;
SetRenderObjectID(0, MyRenderProxy.CreateManualCullObject(Container.Entity.Name ?? "Fracture", Container.Entity.PositionComp.WorldMatrix));
for (int i = 0; i < Models.Count; ++i)
{
m_renderObjectIDs[i + 1] = VRageRender.MyRenderProxy.RENDER_ID_UNASSIGNED;
SetRenderObjectID(i + 1, MyRenderProxy.CreateRenderEntity
(
"Fractured piece " + i.ToString() + " " + Container.Entity.EntityId.ToString(),
Models[i].Name,
Models[i].LocalTransform,
MyMeshDrawTechnique.MESH,
GetRenderFlags(),
GetRenderCullingOptions(),
m_diffuseColor,
m_colorMaskHsv
));
MyRenderProxy.SetParentCullObject(m_renderObjectIDs[i + 1], m_renderObjectIDs[0], Models[i].LocalTransform);
}
}
public override void AddRenderObjects()
{
if (this.Models.Count != 0)
{
MyCubeBlock entity = base.Container.Entity as MyCubeBlock;
if (entity != null)
{
this.CalculateBlockDepthBias(entity);
}
base.m_renderObjectIDs = new uint[this.Models.Count + 1];
base.m_parentIDs = new uint[this.Models.Count + 1];
base.m_parentIDs[0] = base.m_renderObjectIDs[0] = uint.MaxValue;
string name = base.Container.Entity.Name;
this.SetRenderObjectID(0, MyRenderProxy.CreateManualCullObject(name ?? "Fracture", base.Container.Entity.PositionComp.WorldMatrix));
for (int i = 0; i < this.Models.Count; i++)
{
base.m_parentIDs[i + 1] = base.m_renderObjectIDs[i + 1] = uint.MaxValue;
long entityId = base.Container.Entity.EntityId;
this.SetRenderObjectID(i + 1, MyRenderProxy.CreateRenderEntity("Fractured piece " + i.ToString() + " " + entityId.ToString(), this.Models[i].Name, this.Models[i].LocalTransform, MyMeshDrawTechnique.MESH, this.GetRenderFlags(), this.GetRenderCullingOptions(), base.m_diffuseColor, base.m_colorMaskHsv, 0f, float.MaxValue, base.DepthBias, 1f, base.FadeIn));
if (base.m_textureChanges != null)
{
MyRenderProxy.ChangeMaterialTexture(base.m_renderObjectIDs[i + 1], base.m_textureChanges);
}
base.SetParent(i + 1, base.m_renderObjectIDs[0], new Matrix?((Matrix)this.Models[i].LocalTransform));
}
}
}
public override void AddRenderObjects()
{
if ((this.m_model != null) && (base.m_renderObjectIDs[0] == uint.MaxValue))
{
this.SetRenderObjectID(0, MyRenderProxy.CreateRenderEntity(base.Container.Entity.GetFriendlyName() + " " + base.Container.Entity.EntityId.ToString(), this.m_model.AssetName, base.Container.Entity.PositionComp.WorldMatrix, MyMeshDrawTechnique.MESH, this.GetRenderFlags(), this.GetRenderCullingOptions(), base.m_diffuseColor, base.m_colorMaskHsv, base.Transparency, float.MaxValue, base.DepthBias, this.m_model.ScaleFactor, (base.Transparency == 0f) && base.FadeIn));
if (base.m_textureChanges != null)
{
MyRenderProxy.ChangeMaterialTexture(base.m_renderObjectIDs[0], base.m_textureChanges);
}
}
}
public void UpdateRenderEntitiesData(MatrixD gridWorldMatrix, bool useTransparency, float rescale = 1)
{
// Create/Remove/Update render objects
foreach (var item in m_instanceInfo)
{
uint renderObjectId;
bool exists = m_instanceGroupRenderObjects.TryGetValue(item.Key, out renderObjectId);
bool hasAnyInstances = item.Value.InstanceCount > 0;
RenderFlags flags = item.Value.CastShadows ? RenderFlags.CastShadows : (RenderFlags)0;
flags |= RenderFlags.Visible;
if (!exists && hasAnyInstances)
{
var model = MyModel.GetById(item.Key);
renderObjectId = MyRenderProxy.CreateRenderEntity(
"Cube builder, part: " + item.Key,
model,
MatrixD.Identity,
MyMeshDrawTechnique.MESH,
flags,
CullingOptions.Default,
Vector3.One,
MyPlayer.SelectedColor,
dithering: useTransparency ? Transparency : 0,
maxViewDistance: item.Value.MaxViewDistance,
rescale: rescale
);
m_instanceGroupRenderObjects[item.Key] = renderObjectId;
}
else if (exists && !hasAnyInstances)
{
uint objectId = m_instanceGroupRenderObjects[item.Key];
MyRenderProxy.RemoveRenderObject(objectId);
m_instanceGroupRenderObjects.Remove(item.Key);
continue;
}
if (hasAnyInstances)
{
MyRenderProxy.UpdateRenderEntity(renderObjectId, Color.White, MyPlayer.SelectedColor, useTransparency ? Transparency : 0);
MyRenderProxy.UpdateRenderObject(renderObjectId, ref gridWorldMatrix, false);
MyRenderProxy.SetInstanceBuffer(renderObjectId, item.Value.InstanceBufferId, item.Value.InstanceStart, item.Value.InstanceCount, m_cubeBuilderAABB, m_instanceDataArray);
}
}
}
public override void AddRenderObjects()
{
base.AddRenderObjects();
base.ResizeRenderObjectArray(0x10);
int length = base.RenderObjectIDs.Length;
Vector3D positionLeftBottomCorner = this.m_planet.PositionLeftBottomCorner;
Vector3 atmosphereWavelengths = new Vector3 {
X = 1f / ((float)Math.Pow((double)this.m_planet.AtmosphereWavelengths.X, 4.0)),
Y = 1f / ((float)Math.Pow((double)this.m_planet.AtmosphereWavelengths.Y, 4.0)),
Z = 1f / ((float)Math.Pow((double)this.m_planet.AtmosphereWavelengths.Z, 4.0))
};
IMyEntity entity = base.Entity;
if (this.m_planet.HasAtmosphere)
{
MatrixD xd2 = MatrixD.Identity * this.m_planet.AtmosphereRadius;
xd2.M44 = 1.0;
xd2.Translation = base.Entity.PositionComp.GetPosition();
this.m_atmosphereRenderIndex = length;
length++;
long entityId = base.Entity.EntityId;
this.SetRenderObjectID(length, MyRenderProxy.CreateRenderEntityAtmosphere(base.Entity.GetFriendlyName() + " " + entityId.ToString(), @"Models\Environment\Atmosphere_sphere.mwm", xd2, MyMeshDrawTechnique.ATMOSPHERE, RenderFlags.DrawOutsideViewDistance | RenderFlags.Visible, this.GetRenderCullingOptions(), this.m_planet.AtmosphereRadius, this.m_planet.AverageRadius, atmosphereWavelengths, 0f, float.MaxValue, base.FadeIn));
this.UpdateAtmosphereSettings(this.m_planet.AtmosphereSettings);
}
this.m_shadowHelperRenderObjectIndex = length;
MatrixD worldMatrix = MatrixD.CreateScale((double)this.m_planet.MinimumRadius);
worldMatrix.Translation = this.m_planet.WorldMatrix.Translation;
length++;
this.SetRenderObjectID(length, MyRenderProxy.CreateRenderEntity("Shadow helper", @"Models\Environment\Sky\ShadowHelperSphere.mwm", worldMatrix, MyMeshDrawTechnique.MESH, RenderFlags.CastShadowsOnLow | RenderFlags.SkipInMainView | RenderFlags.NoBackFaceCulling | RenderFlags.DrawOutsideViewDistance | RenderFlags.Visible | RenderFlags.CastShadows, CullingOptions.Default, Color.White, new Vector3(1f, 1f, 1f), 0f, float.MaxValue, 0, 1f, base.FadeIn));
MyPlanetGeneratorDefinition generator = this.m_planet.Generator;
if ((MyFakes.ENABLE_PLANETARY_CLOUDS && (generator != null)) && (generator.CloudLayers != null))
{
foreach (MyCloudLayerSettings settings in generator.CloudLayers)
{
double minScaledAltitude = ((double)(this.m_planet.AverageRadius + this.m_planet.MaximumRadius)) / 2.0;
double altitude = minScaledAltitude + ((this.m_planet.MaximumRadius - minScaledAltitude) * settings.RelativeAltitude);
Vector3D rotationAxis = Vector3D.Normalize((settings.RotationAxis == Vector3D.Zero) ? Vector3D.Up : settings.RotationAxis);
int index = length + this.m_cloudLayerRenderObjectIndexList.Count;
this.SetRenderObjectID(index, MyRenderProxy.CreateRenderEntityCloudLayer((this.m_atmosphereRenderIndex != -1) ? base.m_renderObjectIDs[this.m_atmosphereRenderIndex] : uint.MaxValue, base.Entity.GetFriendlyName() + " " + base.Entity.EntityId.ToString(), settings.Model, settings.Textures, base.Entity.PositionComp.GetPosition(), altitude, minScaledAltitude, settings.ScalingEnabled, (double)settings.FadeOutRelativeAltitudeStart, (double)settings.FadeOutRelativeAltitudeEnd, settings.ApplyFogRelativeDistance, (double)this.m_planet.MaximumRadius, rotationAxis, settings.AngularVelocity, settings.InitialRotation, settings.Color.ToLinearRGB(), base.FadeIn));
this.m_cloudLayerRenderObjectIndexList.Add(index);
}
length += generator.CloudLayers.Count;
}
}
public void AddModel(int model, Matrix localMatrix, Vector3 colorMaskHsv, float transparency)
{
RenderFlags flags = ((RenderFlags)0) | RenderFlags.Visible;
int num = this.NumUsedModels + 1;
this.NumUsedModels = num;
if (this.RenderEntities.Count >= num)
{
MyBlockBuilderRenderData.MyEntity entity3 = this.RenderEntities[this.NumUsedModels - 1];
entity3.LocalMatrix = localMatrix;
entity3.ColorMashHsv = colorMaskHsv;
this.RenderEntities[this.NumUsedModels - 1] = entity3;
}
else
{
string byId = MyModel.GetById(model);
MyBlockBuilderRenderData.MyEntity item = new MyBlockBuilderRenderData.MyEntity {
LocalMatrix = localMatrix,
RenderEntityId = MyRenderProxy.CreateRenderEntity("Cube builder, part: " + model, byId, MatrixD.Identity, MyMeshDrawTechnique.MESH, flags, CullingOptions.Default, Vector3.One, colorMaskHsv, transparency, float.MaxValue, 0, 1f, false),
ColorMashHsv = colorMaskHsv
};
this.RenderEntities.Add(item);
}
}
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();
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);
}
if (m_renderEnabled == false)
{
MyRenderProxy.EnableRenderModule((uint)MyRenderModuleEnum.Atmosphere, true);
m_renderEnabled = true;
}
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 unsafe void UpdateRenderEntitiesInstanceData(RenderFlags renderFlags, uint parentCullObject)
{
foreach (KeyValuePair <MyInstanceBucket, MyRenderInstanceInfo> pair in this.m_instanceInfo)
{
uint num;
bool inScene;
int num1;
bool flag = this.m_instanceGroupRenderObjects.TryGetValue(pair.Key, out num);
if (pair.Value.InstanceCount <= 0)
{
inScene = false;
}
else
{
IMyEntity entity = this.m_gridRenderComponent.Entity;
if (entity != null)
{
inScene = entity.InScene;
}
else
{
IMyEntity local1 = entity;
inScene = false;
}
}
bool flag2 = (bool)num1;
RenderFlags flags = renderFlags;
if (!(!flag & flag2))
{
if (flag && !flag2)
{
uint renderObjectId = this.m_instanceGroupRenderObjects[pair.Key];
this.RemoveRenderObjectId(!MyFakes.MANUAL_CULL_OBJECTS, ref renderObjectId, MyRenderProxy.ObjectType.Entity);
this.m_instanceGroupRenderObjects.Remove(pair.Key);
continue;
}
}
else
{
uint * numPtr1;
object[] objArray1 = new object[] { "CubeGridRenderCell ", this.m_gridRenderComponent.Container.Entity.DisplayName, " ", this.m_gridRenderComponent.Container.Entity.EntityId, ", part: ", pair.Key };
this.AddRenderObjectId(!MyFakes.MANUAL_CULL_OBJECTS, out (uint)ref numPtr1, MyRenderProxy.CreateRenderEntity(string.Concat(objArray1), MyModel.GetById(pair.Key.ModelId), this.m_gridRenderComponent.Container.Entity.PositionComp.WorldMatrix, MyMeshDrawTechnique.MESH, flags, CullingOptions.Default, this.m_gridRenderComponent.GetDiffuseColor(), Vector3.Zero, this.m_gridRenderComponent.Transparency, pair.Value.MaxViewDistance, 0, this.m_gridRenderComponent.CubeGrid.GridScale, (this.m_gridRenderComponent.Transparency == 0f) && this.m_gridRenderComponent.FadeIn));
if (pair.Key.SkinSubtypeId != MyStringHash.NullOrEmpty)
{
Dictionary <string, MyTextureChange> assetModifierDefinitionForRender = MyDefinitionManager.Static.GetAssetModifierDefinitionForRender(pair.Key.SkinSubtypeId);
if (assetModifierDefinitionForRender != null)
{
numPtr1 = (uint *)ref num;
MyRenderProxy.ChangeMaterialTexture(num, assetModifierDefinitionForRender);
}
}
this.m_instanceGroupRenderObjects[pair.Key] = num;
if (MyFakes.MANUAL_CULL_OBJECTS)
{
MyRenderProxy.SetParentCullObject(num, parentCullObject, new Matrix?(Matrix.Identity));
}
}
if (flag2)
{
MyRenderProxy.SetInstanceBuffer(num, pair.Value.InstanceBufferId, pair.Value.InstanceStart, pair.Value.InstanceCount, this.m_boundingBox, null);
}
}
}
public void UpdateRenderObjects()
{
var modelName = MyModel.GetById(Model);
if (InstanceOIDs == null)
{
var bounds = Bounds;
bounds.Translate(m_parent.WorldMatrix.Translation);
if (RenderObjectId == MyRenderProxy.RENDER_ID_UNASSIGNED)
{
RenderObjectId = MyRenderProxy.CreateRenderEntity(
string.Format("RO::{0}: {1}", m_parent.Name, modelName),
modelName,
m_parent.WorldMatrix,
MyMeshDrawTechnique.MESH,
RenderFlags.Visible | RenderFlags.CastShadows,
CullingOptions.Default,
Vector3.One, colorMaskHsv: Vector3.Zero, dithering: 0, maxViewDistance: 100000
);
MyRenderProxy.UpdateRenderEntity(RenderObjectId, Vector3.One, Vector3.Zero, 0);
}
if (InstanceBufferId == MyRenderProxy.RENDER_ID_UNASSIGNED)
{
InstanceBufferId = MyRenderProxy.CreateRenderInstanceBuffer(string.Format("IB::{0}: {1}", m_parent.Name, modelName),
MyRenderInstanceBufferType.Generic);
}
MyRenderProxy.UpdateRenderInstanceBufferRange(InstanceBufferId, Instances);
MyRenderProxy.UpdateRenderInstanceBufferSettings(InstanceBufferId, m_parent.Lod == 0);
MyRenderProxy.SetInstanceBuffer(RenderObjectId, InstanceBufferId, 0, Instances.Length, bounds);
MyRenderProxy.UpdateRenderObject(RenderObjectId, ref m_parent.WorldMatrix, false, (BoundingBoxD)bounds);
}
else
{
unsafe
{
if (InstanceOIDs.Length != Instances.Length)
ResizeActorBuffer();
fixed(MyInstanceData *instances = Instances)
for (int i = 0; i < InstanceOIDs.Length; ++i)
{
if (InstanceOIDs[i] == MyRenderProxy.RENDER_ID_UNASSIGNED && instances[i].m_row0.PackedValue != 0)
{
MatrixD matrix = instances[i].LocalMatrix * m_parent.WorldMatrix;
var bounds = (BoundingBoxD)ModelBb;
bounds = bounds.TransformFast(ref matrix);
//bounds.Translate(m_parent.WorldMatrix.Translation);
var obj = MyRenderProxy.CreateRenderEntity(
string.Format("RO::{0}: {1}", m_parent.Name, modelName),
modelName,
matrix,
MyMeshDrawTechnique.MESH,
RenderFlags.Visible | RenderFlags.CastShadows,
CullingOptions.Default,
Vector3.One, colorMaskHsv: Vector3.Zero, dithering: 0, maxViewDistance: 100000
);
MyRenderProxy.UpdateRenderObject(obj, ref matrix, false, (BoundingBoxD)bounds);
InstanceOIDs[i] = obj;
}
}
}
}
}
