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(); } }
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); }