internal MyLodModel AddLOD(float distance, string model)
{
try
{
MyLodModel lodModel = new MyLodModel();
if (!string.IsNullOrEmpty(model))
{
lodModel.Model = MyRenderModels.GetModel(model);
if (lodModel.Model.LoadState == LoadState.Error)
{
return(null);
}
lodModel.Model.CloneMaterials(lodModel.MeshMaterials);
}
lodModel.Distance = distance;
m_lods.Add(lodModel);
return(lodModel);
}
catch (Exception e)
{
throw new ApplicationException("Error adding lod: " + model + ", distance: " + distance, e);
}
}
public void ChangeShadowModels(int lodIndex, string model)
{
if (model != null)
{
m_lods[lodIndex].ShadowModel = MyRenderModels.GetModel(model);
}
}
public void ChangeModels(int lodIndex, string model)
{
if (model != null)
{
m_lods[lodIndex].Model = MyRenderModels.GetModel(model);
m_lods[lodIndex].Model.CloneMaterials(m_lods[lodIndex].MeshMaterials);
}
}
private void CreateVertexBuffer(List <MyRenderBatchPart> batchParts, int vbSize)
{
if (m_vertexBuffer == null || m_vertexBuffer.Description.SizeInBytes < vbSize)
{
if (m_vertexBuffer != null)
{
m_vertexBuffer.Dispose();
}
m_vertexBuffer = new VertexBuffer(MyRender.GraphicsDevice, vbSize, Usage.WriteOnly, VertexFormat.None, Pool.Default);
}
// Transform and copy vertices
int vbOffset = 0;
for (int i = 0; i < batchParts.Count; i++)
{
var part = batchParts[i];
var model = MyRenderModels.GetModel(part.Model);
var matrix = part.ModelMatrix;
var modelVb = model.VertexBuffer.Lock(0, model.GetVBSize, LockFlags.ReadOnly);
var compoundVb = m_vertexBuffer.Lock(vbOffset, model.GetVBSize, LockFlags.None);
for (int v = 0; v < model.GetVerticesCount(); v++)
{
var vertexPos = v * model.GetVertexStride();
modelVb.Seek(vertexPos, System.IO.SeekOrigin.Begin);
var position = modelVb.Read <HalfVector4>();
Vector3D pos = (Vector3D)VF_Packer.UnpackPosition(ref position);
var transformedPos = Vector3D.Transform(pos, matrix);
m_localAABB = m_localAABB.Include(ref transformedPos);
var transformedPos2 = (Vector3)transformedPos;
compoundVb.Write <HalfVector4>(VF_Packer.PackPosition(ref transformedPos2)); // Transform and copy position
compoundVb.WriteRange(modelVb.PositionPointer, model.GetVertexStride() - (modelVb.Position - vertexPos)); // Copy rest
}
m_vertexBuffer.Unlock();
model.VertexBuffer.Unlock();
vbOffset += model.GetVBSize;
}
BoundingSphereD.CreateFromBoundingBox(ref m_localAABB, out m_localVolume);
m_localVolumeOffset = m_localVolume.Center;
SetDirty();
}
private static void DrawDebugMessages()
{
//DepthStencilState.None.Apply();
DepthStencilState.DepthRead.Apply();
BlendState.NonPremultiplied.Apply();
while (m_debugDrawMessages.Count > 0)
{
IMyRenderMessage debugDrawMessage = m_debugDrawMessages.Dequeue();
MyRenderMessageEnum messageType = debugDrawMessage.MessageType;
switch (messageType)
{
case MyRenderMessageEnum.DebugDrawLine3D:
{
MyRenderMessageDebugDrawLine3D message = (MyRenderMessageDebugDrawLine3D)debugDrawMessage;
MyDebugDraw.DrawLine3D(
message.PointFrom,
message.PointTo,
message.ColorFrom,
message.ColorTo,
message.DepthRead);
break;
}
case MyRenderMessageEnum.DebugDrawLine2D:
{
MyRenderMessageDebugDrawLine2D message = (MyRenderMessageDebugDrawLine2D)debugDrawMessage;
MyDebugDraw.DrawLine2D(
message.PointFrom,
message.PointTo,
message.ColorFrom,
message.ColorTo,
message.Projection);
break;
}
case MyRenderMessageEnum.DebugDrawSphere:
{
MyRenderMessageDebugDrawSphere message = (MyRenderMessageDebugDrawSphere)debugDrawMessage;
MyDebugDraw.DrawSphere(
message.Position,
message.Radius,
message.Color,
message.Alpha,
message.DepthRead,
message.Smooth,
message.Cull);
break;
}
case MyRenderMessageEnum.DebugDrawAABB:
{
MyRenderMessageDebugDrawAABB message = (MyRenderMessageDebugDrawAABB)debugDrawMessage;
Color color = new Color(message.Color, message.Alpha);
var aabb = new BoundingBoxD(message.AABB.Min, message.AABB.Max);
MyDebugDraw.DrawAABBLine(
ref aabb,
ref color,
message.Scale,
message.DepthRead);
break;
}
case MyRenderMessageEnum.DebugDrawAxis:
{
MyRenderMessageDebugDrawAxis message = (MyRenderMessageDebugDrawAxis)debugDrawMessage;
MyDebugDraw.DrawAxis(
(MatrixD)message.Matrix,
message.AxisLength,
1,
message.DepthRead);
break;
}
case MyRenderMessageEnum.DebugDrawOBB:
{
MyRenderMessageDebugDrawOBB message = (MyRenderMessageDebugDrawOBB)debugDrawMessage;
if (message.Smooth)
{
MyDebugDraw.DrawLowresBoxSmooth(
message.Matrix,
message.Color,
message.Alpha,
message.DepthRead,
message.Cull);
}
else
{
MyDebugDraw.DrawOBBLine(
new MyOrientedBoundingBoxD(message.Matrix),
message.Color,
message.Alpha,
message.DepthRead);
//BoundingBoxD bd = new BoundingBoxD(message.Matrix.Translation - new Vector3(100),message.Matrix.Translation + new Vector3(100));
//Vector4 c = new Vector4(message.Color.X, message.Color.Y, message.Color.Z, message.Alpha);
//MyDebugDraw.DrawAABBLine(ref bd, ref c, 1, false);
}
break;
}
case MyRenderMessageEnum.DebugDrawCylinder:
{
MyRenderMessageDebugDrawCylinder message = (MyRenderMessageDebugDrawCylinder)debugDrawMessage;
if (message.Smooth)
{
MyDebugDraw.DrawLowresCylinderSmooth(
(MatrixD)message.Matrix,
message.Color,
message.Alpha,
message.DepthRead);
}
else
{
MyDebugDraw.DrawLowresCylinderWireframe(
(MatrixD)message.Matrix,
message.Color,
message.Alpha,
message.DepthRead);
}
break;
}
case MyRenderMessageEnum.DebugDrawTriangle:
{
MyRenderMessageDebugDrawTriangle message = (MyRenderMessageDebugDrawTriangle)debugDrawMessage;
MyDebugDraw.DrawTriangle((Vector3D)message.Vertex0, (Vector3D)message.Vertex1, (Vector3D)message.Vertex2, message.Color, message.Color, message.Color, message.Smooth, message.DepthRead);
break;
}
case MyRenderMessageEnum.DebugDrawTriangles:
{
MyRenderMessageDebugDrawTriangles message = (MyRenderMessageDebugDrawTriangles)debugDrawMessage;
MyDebugDraw.DrawTriangles(message.WorldMatrix, message.Vertices, message.Indices, message.Color,
message.DepthRead, message.Shaded);
break;
}
case MyRenderMessageEnum.DebugDrawCapsule:
{
MyRenderMessageDebugDrawCapsule message = (MyRenderMessageDebugDrawCapsule)debugDrawMessage;
if (message.Shaded)
{
MyDebugDraw.DrawCapsuleShaded(message.P0, message.P1, message.Radius, message.Color, message.DepthRead);
}
else
{
MyDebugDraw.DrawCapsule(message.P0, message.P1, message.Radius, message.Color, message.DepthRead);
}
break;
}
case MyRenderMessageEnum.DebugDrawText2D:
{
MyRenderMessageDebugDrawText2D message = (MyRenderMessageDebugDrawText2D)debugDrawMessage;
MyDebugDraw.DrawText(
message.Coord,
new StringBuilder(message.Text),
message.Color,
message.Scale,
false,
message.Align);
break;
}
case MyRenderMessageEnum.DebugDrawText3D:
{
MyRenderMessageDebugDrawText3D message = (MyRenderMessageDebugDrawText3D)debugDrawMessage;
MyDebugDraw.DrawText(
(Vector3D)message.Coord,
new StringBuilder(message.Text),
message.Color,
message.Scale,
message.DepthRead,
message.Align,
message.CustomViewProjection);
break;
}
case MyRenderMessageEnum.DebugDrawModel:
{
MyRenderMessageDebugDrawModel message = (MyRenderMessageDebugDrawModel)debugDrawMessage;
MyDebugDraw.DrawModel(MyRenderModels.GetModel(message.Model), message.WorldMatrix, message.Color,
message.DepthRead);
break;
}
case MyRenderMessageEnum.DebugDrawPlane:
{
MyRenderMessageDebugDrawPlane message = (MyRenderMessageDebugDrawPlane)debugDrawMessage;
MyDebugDraw.DrawPlane((Vector3D)message.Position, message.Normal, message.Color, message.DepthRead);
break;
}
default:
{
System.Diagnostics.Debug.Assert(false, "Unknown debug draw message");
break;
}
}
}
}
void UpdateBatch(List <MyRenderBatchPart> batchParts)
{
// Clear all lists
foreach (var pair in m_materialGroups)
{
pair.Value.Clear();
}
int vbSize = 0;
int triangleCount = 0;
m_vertexCount = 0;
m_vertexDeclaration = null;
if (batchParts.Count == 0)
{
return;
}
// Add meshes to lists
for (int i = 0; i < batchParts.Count; i++)
{
var part = batchParts[i];
var model = MyRenderModels.GetModel(part.Model);
model.LoadData();
if (model.LoadState == LoadState.Unloaded)
{
model.LoadInDraw(LoadingMode.Immediate);
}
if (model.LoadState == LoadState.Loading)
{
Debug.Fail("Batch model is loading, this should not happen");
}
if (m_vertexDeclaration == null)
{
m_vertexStride = model.GetVertexStride();
m_vertexDeclaration = model.GetVertexDeclaration();
}
else if (m_vertexDeclaration != model.GetVertexDeclaration())
{
Debug.Fail("Models in batch must have same declaration");
continue;
}
foreach (var mesh in model.GetMeshList())
{
List <MyRenderMeshInfo> meshList = new List <MyRenderMeshInfo>();
if (!m_materialGroups.TryGetValue(mesh.Material, out meshList))
{
meshList = new List <MyRenderMeshInfo>();
m_materialGroups.Add(mesh.Material, meshList);
}
meshList.Add(new MyRenderMeshInfo()
{
Model = model, Mesh = mesh, VertexOffset = m_vertexCount
});
}
vbSize += model.GetVBSize;
m_vertexCount += model.GetVerticesCount();
triangleCount += model.GetTrianglesCount();
}
CreateVertexBuffer(batchParts, vbSize);
CreateIndexBuffer(triangleCount);
}
public static void Draw()
{
if (!Visible)
{
return;
}
MyRenderModel model = MyRenderModels.GetModel(Model);//MySession.Static.PlayerShip.CockpitGlassModelEnum);
RasterizerState.CullNone.Apply();
MyStateObjects.DepthStencil_StencilReadOnly.Apply();
BlendState.NonPremultiplied.Apply();
MyEffectCockpitGlass effect = (MyEffectCockpitGlass)MyRender.GetEffect(MyEffects.CockpitGlass);
effect.SetGlassDirtLevelAlpha(new Vector4(GlassDirtAlpha, 0, 0, 0));
var inMatrix = PlayerHeadForCockpitInteriorWorldMatrix;
MatrixD drawMatrix;
MatrixD.Multiply(ref inMatrix, ref MyRenderCamera.InversePositionTranslationMatrix, out drawMatrix);
effect.SetWorldMatrix((Matrix)drawMatrix);
effect.SetViewMatrix((Matrix)MyRenderCamera.ViewMatrix);
Matrix projection = MyRenderCamera.ProjectionMatrixForNearObjects;
effect.SetWorldViewProjectionMatrix((Matrix)(drawMatrix * MyRenderCamera.ViewMatrixAtZero * projection));
MyRenderMeshMaterial cockpitMaterial = model.GetMeshList()[0].Material;
cockpitMaterial.PreloadTexture();
effect.SetCockpitGlassTexture(cockpitMaterial.DiffuseTexture);
Texture depthRT = MyRender.GetRenderTarget(MyRenderTargets.Depth);
effect.SetDepthTexture(depthRT);
effect.SetHalfPixel(MyUtilsRender9.GetHalfPixel(depthRT.GetLevelDescription(0).Width, depthRT.GetLevelDescription(0).Height));
Vector4 sunColor = MyRender.Sun.Color;
effect.SetSunColor(new Vector3(sunColor.X, sunColor.Y, sunColor.Z));
effect.SetDirectionToSun(-MyRender.Sun.Direction);
effect.SetAmbientColor(Vector3.Zero);
effect.SetReflectorPosition((Vector3)((Vector3)MyRenderCamera.Position - 4 * MyRenderCamera.ForwardVector));
if (MyRender.RenderLightsForDraw.Count > 0)
{
effect.SetNearLightColor(MyRender.RenderLightsForDraw[0].Color);
effect.SetNearLightRange(MyRender.RenderLightsForDraw[0].Range);
}
MyRender.GetShadowRenderer().SetupShadowBaseEffect(effect);
effect.SetShadowBias(0.001f);
MyLights.UpdateEffect(effect, true);
effect.Begin();
model.Render();
effect.End();
//MyDebugDraw.DrawSphereWireframe(PlayerHeadForCockpitInteriorWorldMatrix, Vector3.One, 1);
}
