public MyRenderAtmosphere(uint id, string debugName, string model, MatrixD worldMatrix, MyMeshDrawTechnique drawTechnique, RenderFlags renderFlags, float atmosphereRadius, float planetRadius, Vector3 atmosphereWavelengths)
: base(id, debugName,model, worldMatrix,drawTechnique, renderFlags)
{
m_atmosphereWavelengths = atmosphereWavelengths;
m_atmosphereRadius = atmosphereRadius;
m_planetRadius = planetRadius;
}
public MyRenderEntity(uint id, string debugName, string model, MatrixD worldMatrix, MyMeshDrawTechnique drawTechnique, RenderFlags renderFlags)
: base(id, debugName, worldMatrix, renderFlags)
{
System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(model));
var renderModel = AddLODs(model);
if (renderModel != null)
{
m_localAABB = (BoundingBoxD)renderModel.BoundingBox;
m_localVolume = (BoundingSphereD)renderModel.BoundingSphere;
m_localVolumeOffset = (Vector3D)renderModel.BoundingSphere.Center;
}
m_drawTechnique = drawTechnique;
m_isDataSet = true;
}
public MyRenderMeshMaterial(string name, string contentDir, string materialName, MyTexture2D diff, MyTexture2D norm)
{
if (name != null)
{
m_diffuseName = name + MyRenderMesh.C_POSTFIX_DIFFUSE_EMISSIVE + ".dds";
m_normalName = name + MyRenderMesh.C_POSTFIX_NORMAL_SPECULAR + ".dds";
}
m_contentDir = contentDir;
m_materialName = materialName;
m_drawTechnique = MyMeshDrawTechnique.MESH;
HashCode = 0;
m_diffuseTex = diff;
m_normalTex = norm;
m_hasNormalTexture = m_normalTex != null;
ComputeHashCode();
}
public int GetModelIndex(MyLodTypeEnum lod, MyMeshDrawTechnique technique)
{
return ((byte)lod * DrawTechniqueCount) + (int)technique;
}
public static uint CreateRenderEntity(
string debugName,
string model,
MatrixD worldMatrix,
MyMeshDrawTechnique technique,
RenderFlags flags,
CullingOptions cullingOptions,
Color diffuseColor,
Vector3 colorMaskHsv,
float dithering = 0,
float maxViewDistance = float.MaxValue,
byte depthBias = 0
)
{
var message = MessagePool.Get<MyRenderMessageCreateRenderEntity>(MyRenderMessageEnum.CreateRenderEntity);
uint id = GetMessageId();
message.ID = id;
message.DebugName = debugName;
message.Model = model;
message.WorldMatrix = worldMatrix;
message.Technique = technique;
message.Flags = flags;
message.CullingOptions = cullingOptions;
message.MaxViewDistance = maxViewDistance;
message.DepthBias = depthBias;
EnqueueMessage(message);
UpdateRenderEntity(id, diffuseColor, colorMaskHsv, dithering);
return id;
}
public static uint CreateRenderEntityCloudLayer(
string debugName,
string model,
List<string> textures,
Vector3D centerPoint,
double altitude,
double minScaledAltitude,
bool scalingEnabled,
double fadeOutRelativeAltitudeStart,
double fadeOutRelativeAltitudeEnd,
float applyFogRelativeDistance,
double maxPlanetHillRadius,
MyMeshDrawTechnique technique,
RenderFlags flags,
CullingOptions cullingOptions,
Vector3D rotationAxis,
float angularVelocity,
float initialRotation
)
{
var message = MessagePool.Get<MyRenderMessageCreateRenderEntityClouds>(MyRenderMessageEnum.CreateRenderEntityClouds);
uint id = GetMessageId();
message.ID = id;
message.Model = model;
message.Textures = textures;
message.CenterPoint = centerPoint;
message.Altitude = altitude;
message.MinScaledAltitude = minScaledAltitude;
message.ScalingEnabled = scalingEnabled;
message.DebugName = debugName;
message.Technique = technique;
message.RotationAxis = rotationAxis;
message.AngularVelocity = angularVelocity;
message.InitialRotation = initialRotation;
message.MaxPlanetHillRadius = maxPlanetHillRadius;
message.FadeOutRelativeAltitudeStart = fadeOutRelativeAltitudeStart;
message.FadeOutRelativeAltitudeEnd = fadeOutRelativeAltitudeEnd;
message.ApplyFogRelativeDistance = applyFogRelativeDistance;
EnqueueMessage(message);
UpdateRenderEntity(id, null, null);
return id;
}
public bool Import(BinaryReader reader)
{
m_MaterialHash = reader.ReadInt32();
m_MeshRenderTechnique = (MyMeshDrawTechnique)reader.ReadInt32();
int nCount = reader.ReadInt32();
for (int i = 0; i < nCount; ++i)
{
m_Indicies.Add(reader.ReadInt32());
}
bool bMatDesc = reader.ReadBoolean();
bool bRes = true;
if (bMatDesc)
{
m_MaterialDesc = new MyMaterialDescriptor();
bRes = m_MaterialDesc.Read(reader);
}
else
{
m_MaterialDesc = null;
}
return bRes;
}
public void Init(StringBuilder hudLabelText, Models.MyModelsEnum? modelLod0Enum, Models.MyModelsEnum? modelLod1Enum, MyMeshDrawTechnique? drawTechnique = null)
{
base.Init(hudLabelText, modelLod0Enum, null, null, null, null);
this.Name = hudLabelText != null ? hudLabelText.ToString() : null;
if (this.Name != null)
{
MinerWars.AppCode.Game.HUD.MyHud.ChangeText(this, new StringBuilder(this.Name));
}
this.WorldMatrix = Matrix.Identity;
if (drawTechnique != null)
InitDrawTechniques(drawTechnique.Value);
}
internal static MyMeshMaterialId GetMaterialId(string name, string contentPath, string colorMetalTexture, string normalGlossTexture, string extensionTexture, MyMeshDrawTechnique technique)
{
MyMeshMaterialInfo desc;
desc = new MyMeshMaterialInfo
{
Name = X.TEXT_(name),
ColorMetal_Texture = MyResourceUtils.GetTextureFullPath(colorMetalTexture, contentPath),
NormalGloss_Texture = MyResourceUtils.GetTextureFullPath(normalGlossTexture, contentPath),
Extensions_Texture = MyResourceUtils.GetTextureFullPath(extensionTexture, contentPath),
Alphamask_Texture = String.Empty,
Technique = technique,
TextureTypes = GetMaterialTextureTypes(colorMetalTexture, normalGlossTexture, extensionTexture, null),
Facing = MyFacingEnum.None,
};
return(GetMaterialId(ref desc));
}
protected sealed override unsafe void RecordCommandsInternal(MyRenderableProxy proxy)
{
if ((proxy.Mesh.Buffers.IB == null && proxy.MergedMesh.Buffers.IB == null) ||
proxy.DrawSubmesh.IndexCount == 0 ||
proxy.Flags.HasFlags(MyRenderableProxyFlags.SkipInMainView))
{
return;
}
++Stats.Draws;
SetProxyConstants(proxy);
BindProxyGeometry(proxy, RC);
Debug.Assert(proxy.Shaders.VS != null);
MyRenderUtils.BindShaderBundle(RC, proxy.Shaders);
if (MyRender11.Settings.Wireframe)
{
SetDepthStencilView(false);
RC.SetBlendState(null);
if (proxy.Flags.HasFlags(MyRenderableProxyFlags.DisableFaceCulling))
{
RC.SetRasterizerState(MyRasterizerStateManager.NocullWireframeRasterizerState);
}
else
{
RC.SetRasterizerState(MyRasterizerStateManager.WireframeRasterizerState);
}
}
else
{
MyMeshDrawTechnique technique = MyMeshDrawTechnique.MESH;
if (proxy.Material != MyMeshMaterialId.NULL)
{
technique = proxy.Material.Info.Technique;
}
if (proxy.Flags.HasFlags(MyRenderableProxyFlags.DisableFaceCulling))
{
switch (technique)
{
case MyMeshDrawTechnique.DECAL:
SetDepthStencilView(true);
MyMeshMaterials1.BindMaterialTextureBlendStates(RC, proxy.Material.Info.TextureTypes, true);
RC.SetRasterizerState(MyRasterizerStateManager.NocullDecalRasterizerState);
break;
case MyMeshDrawTechnique.DECAL_NOPREMULT:
SetDepthStencilView(true);
MyMeshMaterials1.BindMaterialTextureBlendStates(RC, proxy.Material.Info.TextureTypes, false);
RC.SetRasterizerState(MyRasterizerStateManager.NocullDecalRasterizerState);
break;
case MyMeshDrawTechnique.DECAL_CUTOUT:
SetDepthStencilView(true);
RC.SetBlendState(null);
RC.SetRasterizerState(MyRasterizerStateManager.NocullDecalRasterizerState);
break;
default:
SetDepthStencilView(false);
RC.SetBlendState(null);
RC.SetRasterizerState(MyRasterizerStateManager.NocullRasterizerState);
break;
}
}
else
{
switch (technique)
{
case MyMeshDrawTechnique.DECAL:
SetDepthStencilView(true);
MyMeshMaterials1.BindMaterialTextureBlendStates(RC, proxy.Material.Info.TextureTypes, true);
RC.SetRasterizerState(MyRasterizerStateManager.DecalRasterizerState);
break;
case MyMeshDrawTechnique.DECAL_NOPREMULT:
SetDepthStencilView(true);
MyMeshMaterials1.BindMaterialTextureBlendStates(RC, proxy.Material.Info.TextureTypes, false);
RC.SetRasterizerState(MyRasterizerStateManager.DecalRasterizerState);
break;
case MyMeshDrawTechnique.DECAL_CUTOUT:
SetDepthStencilView(true);
RC.SetBlendState(null);
RC.SetRasterizerState(MyRasterizerStateManager.DecalRasterizerState);
break;
default:
SetDepthStencilView(false);
RC.SetBlendState(null);
RC.SetRasterizerState(null);
break;
}
}
}
var submesh = proxy.DrawSubmesh;
if (submesh.MaterialId != Locals.matTexturesID)
{
++Stats.MaterialConstantsChanges;
Locals.matTexturesID = submesh.MaterialId;
var material = MyMaterials1.ProxyPool.Data[submesh.MaterialId.Index];
MyRenderUtils.MoveConstants(RC, ref material.MaterialConstants);
MyRenderUtils.SetConstants(RC, ref material.MaterialConstants, MyCommon.MATERIAL_SLOT);
MyRenderUtils.SetSrvs(RC, ref material.MaterialSrvs);
}
if (proxy.InstanceCount == 0)
{
if (!MyStereoRender.Enable)
{
RC.DrawIndexed(submesh.IndexCount, submesh.StartIndex, submesh.BaseVertex);
}
else
{
MyStereoRender.DrawIndexedGBufferPass(RC, submesh.IndexCount, submesh.StartIndex, submesh.BaseVertex);
}
++Stats.Instances;
Stats.Triangles += submesh.IndexCount / 3;
}
else
{
//MyRender11.AddDebugQueueMessage("GbufferPass DrawIndexedInstanced " + proxy.Material.ToString());
if (!MyStereoRender.Enable)
{
RC.DrawIndexedInstanced(submesh.IndexCount, proxy.InstanceCount, submesh.StartIndex, submesh.BaseVertex, proxy.StartInstance);
}
else
{
MyStereoRender.DrawIndexedInstancedGBufferPass(RC, submesh.IndexCount, proxy.InstanceCount, submesh.StartIndex, submesh.BaseVertex, proxy.StartInstance);
}
Stats.Instances += proxy.InstanceCount;
Stats.Triangles += proxy.InstanceCount * submesh.IndexCount / 3;
}
}
public void SetDrawTechnique(MyMeshDrawTechnique drawTechnique)
{
m_drawTechnique = drawTechnique;
}
private void ShowModelsChange(MyGuiControlCheckbox sender, List<MyEntity> entities, string modelPath, MyMeshDrawTechnique? drawTechnique = null, bool staticAsteroids = false, MyMwcVoxelMaterialsEnum? voxelMaterial = null, List<MyMwcObjectBuilder_StaticAsteroid_TypesEnum> asteroidEnums = null)
{
if (sender.Checked)
{
string[] modelNames = Enum.GetNames(typeof(MyModelsEnum));
int numModels = modelNames.Length;
Vector3 forward = MySession.PlayerShip.GetWorldRotation().Forward;
Vector3 currentPosition = MySession.PlayerShip.GetPosition() + forward * 20;
if (!staticAsteroids)
{
for (int i = 0; i < numModels; i++)
{
if (!MyModels.GetModelAssetName((MyModelsEnum)i).StartsWith(modelPath))
continue;
MyModel model = MyModels.GetModelOnlyData((MyModelsEnum)i);
MyEntity debugDebris = addDebris(new StringBuilder(modelNames[i]), (MyModelsEnum)i, null, ref currentPosition, forward, drawTechnique);
MyEntities.Add(debugDebris);
entities.Add(debugDebris);
}
}
else
{
//foreach(MyMwcObjectBuilder_StaticAsteroid_TypesEnum statEnum in Enum.GetValues(typeof(MyMwcObjectBuilder_StaticAsteroid_TypesEnum)))
foreach(MyMwcObjectBuilder_StaticAsteroid_TypesEnum statEnum in asteroidEnums)
{
MyEntity debugDebris = addStaticAsteroid(new StringBuilder(statEnum.ToString()), statEnum, ref currentPosition, forward, null, voxelMaterial.Value);
MyEntities.Add(debugDebris);
entities.Add(debugDebris);
}
}
}
else
{
foreach (MyEntity entity in entities)
{
entity.MarkForClose();
}
entities.Clear();
}
}
MyEntity addDebris(StringBuilder hudLabel, MyModelsEnum? lod0, MyModelsEnum? lod1, ref Vector3 currentPosition, Vector3 forward, MyMeshDrawTechnique? drawTechnique = null)
{
MyDebugDebris debugDebris = new MyDebugDebris();
debugDebris.Init(hudLabel, lod0, lod1, drawTechnique);
return addEntity(debugDebris, ref currentPosition, forward);
}
MyEntity addStaticAsteroid(StringBuilder hudLabel, MyMwcObjectBuilder_StaticAsteroid_TypesEnum staticEnum, ref Vector3 currentPosition, Vector3 forward, MyMeshDrawTechnique? drawTechnique = null, MyMwcVoxelMaterialsEnum? material = null)
{
MyStaticAsteroid staticAsteroid = new MyStaticAsteroid();
MyMwcObjectBuilder_StaticAsteroid objectBuilder = new MyMwcObjectBuilder_StaticAsteroid(staticEnum, material);
staticAsteroid.Init(hudLabel.ToString(), objectBuilder, Matrix.Identity);
return addEntity(staticAsteroid, ref currentPosition, forward);
}
public MyRenderModel(MyMeshDrawTechnique drawTechnique)
{
m_loadedData = false;
m_loadedContent = false;
m_drawTechnique = drawTechnique;
LoadState = Textures.LoadState.Unloaded;
}
/// <summary>
/// Inits the specified hud label text.
/// </summary>
/// <param name="hudLabelText">The hud label text.</param>
/// <param name="objectBuilder">The object builder.</param>
public void Init(string hudLabelText, MyMwcObjectBuilder_StaticAsteroid objectBuilder, Matrix matrix)
{
MyStaticAsteroidModels models = GetModelsFromType(objectBuilder.AsteroidType);
StringBuilder hudLabelTextSb = (hudLabelText == null) ? null : new StringBuilder(hudLabelText);
if (objectBuilder.Generated)
{
Flags &= ~EntityFlags.EditableInEditor;
Flags &= ~EntityFlags.NeedsId;
}
else
{
Flags |= EntityFlags.EditableInEditor;
Flags |= EntityFlags.NeedsId;
}
CastShadows = !objectBuilder.Generated;
if (!objectBuilder.AsteroidMaterial1.HasValue && MySector.Area.HasValue)
{
var area = MySolarSystemConstants.Areas[MySector.Area.Value];
objectBuilder.AsteroidMaterial1 = area.SecondaryStaticAsteroidMaterial;
objectBuilder.FieldDir = MinerWars.AppCode.Game.GUI.MyGuiScreenGamePlay.Static.GetDirectionToSunNormalized();
}
NeedsUpdate = false;
Init(hudLabelTextSb, models.LOD0, models.LOD1, null, null, objectBuilder, null, models.LOD2);
AsteroidType = objectBuilder.AsteroidType;
SetWorldMatrix(matrix);
FieldDir = objectBuilder.FieldDir;
if (objectBuilder.AsteroidMaterial.HasValue)
{
VoxelMaterial = objectBuilder.AsteroidMaterial.Value;
VoxelMaterial1 = objectBuilder.AsteroidMaterial1;
m_drawTechnique = MyMeshDrawTechnique.VOXELS_STATIC_ASTEROID;
}
if (objectBuilder.UseModelTechnique)
{
m_meshMaterial = MyVoxelMaterials.GetMaterialForMesh(VoxelMaterial);
m_drawTechnique = MyMeshDrawTechnique.MESH;
}
InitDrawTechniques();
InitPhysics();
MyModels.OnContentLoaded += InitDrawTechniques;
InitDrawTechniques();
}
private static MyDrawTechniqueBase GetTechnique(MyMeshDrawTechnique technique)
{
return(m_drawTechniques[(int)technique]);
}
public bool Import(BinaryReader reader, int version)
{
m_MaterialHash = reader.ReadInt32();
if (version < 01052001)
reader.ReadInt32(); //MyMeshDrawTechnique
int nCount = reader.ReadInt32();
for (int i = 0; i < nCount; ++i)
{
m_indices.Add(reader.ReadInt32());
}
bool bMatDesc = reader.ReadBoolean();
bool bRes = true;
if (bMatDesc)
{
m_MaterialDesc = new MyMaterialDescriptor();
bRes = m_MaterialDesc.Read(reader, version);
bRes &= Enum.TryParse(m_MaterialDesc.Technique, out Technique);
if (m_MaterialDesc.Technique == "FOLIAGE")
{
Technique = MyMeshDrawTechnique.ALPHA_MASKED;
}
}
else
{
m_MaterialDesc = null;
}
return bRes;
}
public MyRenderAtmosphere(uint id, string debugName, string model, MatrixD worldMatrix, MyMeshDrawTechnique drawTechnique, RenderFlags renderFlags, float atmosphereRadius, float planetRadius)
: base(id, debugName, model, worldMatrix, drawTechnique, renderFlags)
{
m_atmosphereRadius = atmosphereRadius;
m_planetRadius = planetRadius;
}
public static bool IsPhysical(MyMeshDrawTechnique technique)
{
//return true;
return technique != MyMeshDrawTechnique.HOLO && technique != MyMeshDrawTechnique.DECAL && technique != MyMeshDrawTechnique.ALPHA_MASKED;
}
internal static MyStringId MapTechniqueToDefaultPass(MyMeshDrawTechnique technique)
{
switch (technique)
{
case MyMeshDrawTechnique.GLASS:
return STATIC_GLASS_PASS_ID;
default:
return GBUFFER_PASS_ID;
}
}
public static uint CreateRenderEntityAtmosphere(
string debugName,
string model,
MatrixD worldMatrix,
MyMeshDrawTechnique technique,
RenderFlags flags,
CullingOptions cullingOptions,
float atmosphereRadius,
float planetRadius,
Vector3 atmosphereWavelengths,
float dithering = 0,
float maxViewDistance = float.MaxValue
)
{
var message = MessagePool.Get<MyRenderMessageCreateRenderEntityAtmosphere>(MyRenderMessageEnum.CreateRenderEntityAtmosphere);
uint id = GetMessageId();
message.ID = id;
message.DebugName = debugName;
message.Model = model;
message.WorldMatrix = worldMatrix;
message.Technique = technique;
message.Flags = flags;
message.CullingOptions = cullingOptions;
message.MaxViewDistance = maxViewDistance;
message.AtmosphereRadius = atmosphereRadius;
message.PlanetRadius = planetRadius;
message.AtmosphereWavelengths = atmosphereWavelengths;
EnqueueMessage(message);
UpdateRenderEntity(id, Vector3.Zero, Vector3.Zero, dithering);
return id;
}
internal static MyStringId MapTechniqueToShaderMaterial(MyMeshDrawTechnique technique)
{
switch (technique)
{
case MyMeshDrawTechnique.VOXEL_MAP_SINGLE:
return SINGLE_MATERIAL_TAG;
case MyMeshDrawTechnique.VOXEL_MAP_MULTI:
return MULTI_MATERIAL_TAG;
case MyMeshDrawTechnique.ALPHA_MASKED:
case MyMeshDrawTechnique.FOLIAGE:
return ALPHA_MASKED_MATERIAL_TAG;
default:
return DEFAULT_MATERIAL_TAG;
}
}
public MyRenderAtmosphere(uint id, string debugName, MatrixD worldMatrix, MyMeshDrawTechnique drawTechnique, RenderFlags renderFlags)
: base(id, debugName, worldMatrix,drawTechnique, renderFlags)
{
}
protected void InitDrawTechniques(MyMeshDrawTechnique drawTechnique)
{
InitDrawTechnique(ModelLod0, drawTechnique);
InitDrawTechnique(ModelLod1, drawTechnique);
InitDrawTechnique(ModelLod2, drawTechnique);
}
internal void CollectRenderElements(List<VRageRender.MyRender.MyRenderElement> renderElements, List<VRageRender.MyRender.MyRenderElement> transparentRenderElements, MyRenderModel model, List<MyRenderMeshMaterial> materials, int lodIndex)
{
if (model.LoadState == LoadState.Unloaded)
{
//model.LoadInDraw(LoadingMode.Background);
model.LoadInDraw(LoadingMode.Immediate);
return;
}
if (model.LoadState == LoadState.Loading)
return;
if (m_instanceBuffer != null && m_instanceCount == 0)
return;
var drawMatrix = GetWorldMatrixForDraw();
int meshCount = model.GetMeshList().Count;
for (int i = 0; i < meshCount; i++)
{
MyRenderMesh mesh = model.GetMeshList()[i];
MyRenderMeshMaterial material = model.HasSharedMaterials ? mesh.Material : materials[i];
if (!material.Enabled)
continue;
if (material.DrawTechnique == MyMeshDrawTechnique.GLASS && EntityDithering == 0)
{
m_drawTechnique = MyMeshDrawTechnique.GLASS;
continue;
}
//Preload needs to be here because of reloadcontent
material.PreloadTexture(LoadingMode.Background);
VRageRender.MyRender.MyRenderElement renderElement;
VRageRender.MyRender.AllocateRenderElement(out renderElement);
if (!MyRender.IsRenderOverloaded)
{
//renderElement.DebugName = entity.Name;
renderElement.RenderObject = this;
renderElement.VertexBuffer = model.VertexBuffer;
renderElement.IndexBuffer = model.IndexBuffer;
renderElement.VertexCount = model.GetVerticesCount();
renderElement.VertexDeclaration = model.GetVertexDeclaration();
renderElement.VertexStride = model.GetVertexStride();
renderElement.InstanceBuffer = null;
renderElement.BonesUsed = mesh.BonesUsed;
renderElement.IndexStart = mesh.IndexStart;
renderElement.TriCount = mesh.TriCount;
renderElement.WorldMatrixForDraw = drawMatrix;
renderElement.WorldMatrix = WorldMatrix;
renderElement.Material = material;
renderElement.DrawTechnique = m_drawTechnique == MyMeshDrawTechnique.MESH || m_drawTechnique == MyMeshDrawTechnique.GLASS ? material.DrawTechnique : m_drawTechnique;
renderElement.Color = EntityColor * material.DiffuseColor;
renderElement.Dithering = mesh.GlassDithering == 0 ? EntityDithering : mesh.GlassDithering;
renderElement.ColorMaskHSV = EntityColorMaskHSV;
if (m_instanceBuffer != null)
{
renderElement.VertexStride = m_lods[lodIndex].VertexStride;
renderElement.VertexDeclaration = m_lods[lodIndex].VertexDeclaration;
renderElement.InstanceBuffer = m_instanceBuffer.InstanceBuffer;
renderElement.InstanceStart = m_instanceStart;
renderElement.InstanceCount = m_instanceCount;
renderElement.InstanceStride = m_instanceBuffer.Stride;
if (m_instanceBuffer.Type == MyRenderInstanceBufferType.Generic)
renderElement.DrawTechnique = renderElement.DrawTechnique == MyMeshDrawTechnique.ALPHA_MASKED ? MyMeshDrawTechnique.MESH_INSTANCED_GENERIC_MASKED : MyMeshDrawTechnique.MESH_INSTANCED_GENERIC;
else
renderElement.DrawTechnique = model.BoneIndices.Length > 0 ? MyMeshDrawTechnique.MESH_INSTANCED_SKINNED : MyMeshDrawTechnique.MESH_INSTANCED;
}
Debug.Assert(renderElement.VertexBuffer != null, "Vertex buffer cannot be null!");
Debug.Assert(renderElement.IndexBuffer != null, "Index buffer cannot be null!");
if (material.DrawTechnique == MyMeshDrawTechnique.HOLO)
{
if (transparentRenderElements != null)
transparentRenderElements.Add(renderElement);
}
else
{
renderElements.Add(renderElement);
}
}
}
}
private void InitDrawTechnique(MyModel model, MyMeshDrawTechnique drawTechnique)
{
if (model != null)
{
//Be careful about this, return correct technique in entity::GetMaterial
model.SetDrawTechnique(drawTechnique);
foreach (MyMesh mesh in model.GetMeshList())
{
foreach (MyMeshMaterial material in mesh.Materials)
{
material.DrawTechnique = drawTechnique;
}
}
}
}
public MyRenderEntity(uint id, string debugName, MatrixD worldMatrix, MyMeshDrawTechnique drawTechnique, RenderFlags renderFlags)
: base(id, debugName, worldMatrix, renderFlags)
{
m_drawTechnique = drawTechnique;
m_isDataSet = false;
}
private static void SetupShaderPerDraw(MyEffectBase shader, MyMeshDrawTechnique technique)
{
// m_renderProfiler.StartProfilingBlock("SetupShaderPerDraw");
MyCamera.SetupBaseEffect(shader, m_currentSetup.FogMultiplierMult);
if (m_currentLodDrawPass == MyLodTypeEnum.LOD_NEAR)
shader.SetProjectionMatrix(ref MyCamera.ProjectionMatrixForNearObjects);
else
shader.SetProjectionMatrix(ref MyCamera.ProjectionMatrix);
shader.SetViewMatrix(ref MyCamera.ViewMatrixAtZero);
switch (technique)
{
case MyMeshDrawTechnique.DECAL:
{
MyStateObjects.Static_Decals_BlendState.Apply();
MyStateObjects.BiasedRasterizer_StaticDecals.Apply();
MyStateObjects.DepthStencil_TestFarObject_DepthReadOnly.Apply();
}
break;
case MyMeshDrawTechnique.HOLO:
{
RasterizerState.CullNone.Apply();
MyStateObjects.Holo_BlendState.Apply();
MyEffectModelsDNS dnsShader = shader as MyEffectModelsDNS;
dnsShader.SetHalfPixel(MyCamera.ForwardViewport.Width, MyCamera.ForwardViewport.Height);
dnsShader.SetScale(GetScaleForViewport(GetRenderTarget(MyRenderTargets.Depth)));
if (m_currentLodDrawPass != MyLodTypeEnum.LOD_NEAR && !MyRenderConstants.RenderQualityProfile.ForwardRender)
{
//m_device.DepthStencilState = DepthStencilState.DepthRead;
MyStateObjects.DepthStencil_TestFarObject_DepthReadOnly.Apply();
MyStateObjects.HoloRasterizerState.Apply();
/*dnsShader.SetDepthTextureNear(GetRenderTarget(MyRenderTargets.Lod0Depth));
dnsShader.SetDepthTextureFar(GetRenderTarget(MyRenderTargets.Lod1Depth));
*/
}
else
{
DepthStencilState.DepthRead.Apply();
}
}
break;
case MyMeshDrawTechnique.ALPHA_MASKED:
{
if (!Wireframe)
RasterizerState.CullCounterClockwise.Apply();
else
MyStateObjects.WireframeRasterizerState.Apply();
BlendState.Opaque.Apply();
}
break;
case MyMeshDrawTechnique.VOXEL_MAP:
{
if (!Wireframe)
RasterizerState.CullCounterClockwise.Apply();
else
MyStateObjects.WireframeRasterizerState.Apply();
break;
}
case MyMeshDrawTechnique.VOXELS_STATIC_ASTEROID:
{
if (!Wireframe)
RasterizerState.CullNone.Apply();
else
MyStateObjects.WireframeRasterizerState.Apply();
break;
}
default:
{
if (!Wireframe)
RasterizerState.CullCounterClockwise.Apply();
else
MyStateObjects.WireframeRasterizerState.Apply();
}
break;
}
// m_renderProfiler.EndProfilingBlock();
}
/// <summary>
/// c-tor - this constructor should be used just for max models - not voxels!
/// </summary>
/// <param name="assetName"></param>
/// <param name="unloadableModel"></param>
/// <param name="drawTechnique"></param>
/// <param name="modelEnum"></param>
public MyRenderModel(string assetName, MyMeshDrawTechnique drawTechnique)
{
m_assetName = assetName;
m_loadedData = false;
m_loadedContent = false;
m_drawTechnique = drawTechnique;
var fsPath = Path.IsPathRooted(AssetName) ? AssetName : Path.Combine(MyFileSystem.ContentPath, AssetName);
System.Diagnostics.Debug.Assert(MyFileSystem.FileExists(fsPath), "Model data for " + m_assetName + " does not exists!");
LoadState = Textures.LoadState.Unloaded;
}
static MyEffectBase GetShader(MyMeshDrawTechnique technique)
{
switch (technique)
{
case MyMeshDrawTechnique.MESH:
case MyMeshDrawTechnique.DECAL:
case MyMeshDrawTechnique.HOLO:
case MyMeshDrawTechnique.ALPHA_MASKED:
return GetEffect(MyEffects.ModelDNS) as MyEffectModelsDNS;
case MyMeshDrawTechnique.VOXELS_DEBRIS:
return GetEffect(MyEffects.VoxelDebrisMRT) as MyEffectVoxelsDebris;
case MyMeshDrawTechnique.VOXEL_MAP:
return MyRender.GetEffect(MyEffects.VoxelsMRT) as MyEffectVoxels;
case MyMeshDrawTechnique.VOXELS_STATIC_ASTEROID:
return GetEffect(MyEffects.VoxelStaticAsteroidMRT) as MyEffectVoxelsStaticAsteroid;
default:
throw new MyMwcExceptionApplicationShouldNotGetHere();
}
}
public void SetDrawTechnique(MyMeshDrawTechnique drawTechnique)
{
m_drawTechnique = drawTechnique;
}
static void BeginShaderAlternative(MyEffectBase shader, MyMeshDrawTechnique technique, MyVoxelCacheCellRenderBatchType batchType)
{
switch (technique)
{
case MyMeshDrawTechnique.DECAL:
{
if (shader is MyEffectModelsDNS)
{
(shader as MyEffectModelsDNS).BeginBlended();
}
}
break;
case MyMeshDrawTechnique.HOLO:
{
if (m_currentLodDrawPass != MyLodTypeEnum.LOD_NEAR && !MyRenderConstants.RenderQualityProfile.ForwardRender)
{
(shader as MyEffectModelsDNS).ApplyHolo(false);
}
else
{
(shader as MyEffectModelsDNS).ApplyHolo(true);
}
}
break;
case MyMeshDrawTechnique.ALPHA_MASKED:
{
(shader as MyEffectModelsDNS).ApplyMasked();
}
break;
case MyMeshDrawTechnique.VOXEL_MAP:
{
MyEffectVoxels effectVoxels = shader as MyEffectVoxels;
if (batchType == MyVoxelCacheCellRenderBatchType.SINGLE_MATERIAL)
{
effectVoxels.Apply();
}
else if (batchType == MyVoxelCacheCellRenderBatchType.MULTI_MATERIAL)
{
effectVoxels.ApplyMultimaterial();
}
break;
}
case MyMeshDrawTechnique.VOXELS_STATIC_ASTEROID:
{
((MyEffectVoxelsStaticAsteroid)shader).Apply();
}
break;
case MyMeshDrawTechnique.MESH:
{
((MyEffectModelsDNS)shader).SetTechnique(MyRenderConstants.RenderQualityProfile.ModelsRenderTechnique);
}
break;
case MyMeshDrawTechnique.VOXELS_DEBRIS:
{
((MyEffectVoxelsDebris)shader).SetTechnique(MyRenderConstants.RenderQualityProfile.VoxelsRenderTechnique);
}
break;
default:
{
System.Diagnostics.Debug.Assert(false);
}
break;
}
}
private static MyDrawTechniqueBase GetTechnique(MyMeshDrawTechnique technique)
{
return m_drawTechniques[(int)technique];
}
public int GetModelIndex(MyLodTypeEnum lod, MyMeshDrawTechnique technique)
{
return(((byte)lod * DrawTechniqueCount) + (int)technique);
}
