Exemplo n.º 1
0
 internal static void AddFont(int id, MyRenderFont font, bool isDebugFont)
 {
     Debug.Assert(!m_fontsById.ContainsKey(id), "Adding font with ID that already exists.");
     if (isDebugFont)
     {
         Debug.Assert(m_debugFont == null, "Debug font was already specified and it will be overwritten.");
         m_debugFont = font;
     }
     m_fontsById[id] = font;
 }
 internal static void AddFont(int id, MyRenderFont font, bool isDebugFont)
 {
     Debug.Assert(!m_fontsById.ContainsKey(id), "Adding font with ID that already exists.");
     if (isDebugFont)
     {
         Debug.Assert(m_debugFont == null, "Debug font was already specified and it will be overwritten.");
         m_debugFont = font;
     }
     m_fontsById[id] = font;
 }
        private static void ProcessMessageInternal(MyRenderMessageBase message)
        {
            switch (message.MessageType)
            {
                #region Sprites
                case MyRenderMessageEnum.DrawSprite:
                case MyRenderMessageEnum.DrawSpriteNormalized:
                case MyRenderMessageEnum.DrawSpriteAtlas:
                case MyRenderMessageEnum.SpriteScissorPush:
                case MyRenderMessageEnum.SpriteScissorPop:
                    {
                        EnqueueDrawMessage(message);
                        break;
                    }

                #endregion

                #region Textures

                case MyRenderMessageEnum.PreloadTextures:
                    {
                        var preloadMsg = message as MyRenderMessagePreloadTextures;

                        MyTextureManager.PreloadTextures(preloadMsg.InDirectory, preloadMsg.Recursive);

                        break;
                    }

                case MyRenderMessageEnum.UnloadTexture:
                    {
                        var texMessage = (MyRenderMessageUnloadTexture)message;

                        MyTextureManager.UnloadTexture(texMessage.Texture);



                        break;
                    }

                #endregion

                #region Profiler

                case MyRenderMessageEnum.RenderProfiler:
                    {
                        var profMessage = (MyRenderMessageRenderProfiler)message;

                        MyRenderProfiler.HandleInput(profMessage.Command, profMessage.Index);

                        break;
                    }

                #endregion

                #region Render objects

                case MyRenderMessageEnum.CreateRenderEntity:
                    {
                        var rMessage = (MyRenderMessageCreateRenderEntity)message;

                        MyRenderEntity renderEntity;

                        // AlesR : refactor
                        if (string.IsNullOrEmpty(rMessage.Model))
                        {
                            ProfilerShort.Begin("CreateRenderEntity-NoModel");
                            renderEntity = new MyRenderEntity(
                                rMessage.ID,
                                rMessage.DebugName,
                                rMessage.WorldMatrix,
                                rMessage.Technique,
                                rMessage.Flags
                            );
                            ProfilerShort.BeginNextBlock("SetMaxDist");
                            renderEntity.MaxViewDistance = rMessage.MaxViewDistance;
                            ProfilerShort.End();
                        }
                        else
                        {
                            ProfilerShort.Begin("CreateRenderEntity-Model");
                            renderEntity = new MyRenderEntity(
                                rMessage.ID,
                                rMessage.DebugName,
                                rMessage.Model,
                                rMessage.WorldMatrix,
                                rMessage.Technique,
                                rMessage.Flags
                            );
                            ProfilerShort.End();

                            if (renderEntity.Lods.Count == 0)
                                return;

                            ProfilerShort.Begin("SetMaxDist");
                            renderEntity.MaxViewDistance = rMessage.MaxViewDistance;
                            ProfilerShort.End();
                            ProfilerShort.Begin("renderEntity.LoadContent");
                            renderEntity.LoadContent();
                            ProfilerShort.End();
                        }

                        ProfilerShort.Begin("AddRenderObjectFromProxy");
                        AddRenderObjectFromProxy(renderEntity);
                        ProfilerShort.End();

                        break;
                    }

                case MyRenderMessageEnum.CreateRenderEntityAtmosphere:
                    {
                        var rMessage = (MyRenderMessageCreateRenderEntityAtmosphere)message;

                        MyRenderEntity renderEntity;


                        ProfilerShort.Begin("CreateRenderEntity-Atmosphere");
                        renderEntity = new MyRenderAtmosphere(
                            rMessage.ID,
                            rMessage.DebugName,
                            rMessage.Model,
                            rMessage.WorldMatrix,
                            rMessage.Technique,
                            rMessage.Flags,
                            rMessage.AtmosphereRadius,
                            rMessage.PlanetRadius,
                            rMessage.AtmosphereWavelengths
                        );
                        ProfilerShort.End();

                        if (renderEntity.Lods.Count == 0)
                            return;

                        ProfilerShort.Begin("SetMaxDist");
                        renderEntity.MaxViewDistance = rMessage.MaxViewDistance;
                        ProfilerShort.End();
                        ProfilerShort.Begin("renderEntity.LoadContent");
                        renderEntity.LoadContent();
                        ProfilerShort.End();

                        ProfilerShort.Begin("AddRenderObjectFromProxy");
                        AddRenderObjectFromProxy(renderEntity);
                        ProfilerShort.End();

                        break;
                    }

                case MyRenderMessageEnum.AddRuntimeModel:
                    {
                        var rMessage = (MyRenderMessageAddRuntimeModel)message;
                        var model = new MyRenderModel(MyMeshDrawTechnique.MESH);
                        ProfilerShort.Begin("LoadBuffers");
                        model.LoadBuffers(rMessage.ModelData);
                        ProfilerShort.End();
                        MyRenderModels.AddRuntimeModel(rMessage.Name, model);
                        break;
                    }

                case MyRenderMessageEnum.PreloadModel:
                    {
                        var rMessage = (MyRenderMessagePreloadModel)message;
                        MyRenderModels.GetModel(rMessage.Name);
                        break;
                    }


                case MyRenderMessageEnum.UnloadModel:
                    {
                        var rMessage = (MyRenderMessageUnloadModel)message;

                        MyRenderModels.UnloadModel(rMessage.Name);

                        break;
                    }
                case MyRenderMessageEnum.PreloadMaterials:
                    {
                        var rMessage = (MyRenderMessagePreloadMaterials)message;
                        MyRenderModels.GetMaterials(rMessage.Name);
                        break;
                    }

                case MyRenderMessageEnum.SetRenderEntityData:
                    {
                        var rMessage = (MyRenderMessageSetRenderEntityData)message;
                        var entity = (MyRenderEntity)GetRenderObject(rMessage.ID);

                        if (entity != null)
                            entity.AddData(rMessage);

                        break;
                    }


                case MyRenderMessageEnum.SetRenderEntityLOD:
                    {
                        var rMessage = (MyRenderMessageSetRenderEntityLOD)message;

                        var entity = (MyRenderEntity)GetRenderObject(rMessage.ID);
                        if (entity != null)
                        {
                            entity.AddLOD(rMessage.Distance, rMessage.Model);
                        }

                        break;
                    }

                case MyRenderMessageEnum.CreateRenderBatch:
                    {
                        var rMessage = (MyRenderMessageCreateRenderBatch)message;

                        MyRenderBatch renderBatch = new MyRenderBatch(
                            rMessage.ID,
                            rMessage.DebugName,
                            (MatrixD)rMessage.WorldMatrix,
                            rMessage.Flags,
                            rMessage.RenderBatchParts
                            );

                        renderBatch.LoadContent();
                        AddRenderObjectFromProxy(renderBatch);



                        break;
                    }

                case MyRenderMessageEnum.CreateRenderInstanceBuffer:
                    {
                        var rMessage = (MyRenderMessageCreateRenderInstanceBuffer)message;

                        MyRenderInstanceBuffer renderBatch = new MyRenderInstanceBuffer(rMessage.ID, rMessage.DebugName, rMessage.Type);

                        renderBatch.LoadContent();
                        AddRenderObjectFromProxy(renderBatch);



                        break;
                    }

                case MyRenderMessageEnum.CreateLineBasedObject:
                    {
                        var rMessage = (MyRenderMessageCreateLineBasedObject)message;

                        var lineBasedObj = new MyRenderLineBasedObject(rMessage.ID, rMessage.DebugName);
                        lineBasedObj.LoadContent();
                        AddRenderObjectFromProxy(lineBasedObj);

                        break;
                    }

                case MyRenderMessageEnum.UpdateLineBasedObject:
                    {
                        var rMessage = (MyRenderMessageUpdateLineBasedObject)message;

                        var obj = (MyRenderLineBasedObject)GetRenderObject(rMessage.ID);
                        if (obj != null)
                        {
                            obj.SetWorldPoints(ref rMessage.WorldPointA, ref rMessage.WorldPointB);
                            UpdateRenderObject(obj);
                        }

                        break;
                    }

                case MyRenderMessageEnum.UpdateRenderCubeInstanceBuffer:
                    {
                        var rMessage = (MyRenderMessageUpdateRenderCubeInstanceBuffer)message;

                        var obj = (MyRenderInstanceBuffer)GetRenderObject(rMessage.ID);
                        obj.UpdateCube(rMessage.InstanceData, rMessage.Capacity);

                        rMessage.InstanceData.Clear();


                        break;
                    }

                case MyRenderMessageEnum.UpdateRenderInstanceBuffer:
                    {
                        var rMessage = (MyRenderMessageUpdateRenderInstanceBuffer)message;

                        var obj = (MyRenderInstanceBuffer)GetRenderObject(rMessage.ID);
                        obj.Update(rMessage.InstanceData, rMessage.Capacity);

                        rMessage.InstanceData.Clear();


                        break;
                    }


                case MyRenderMessageEnum.SetInstanceBuffer:
                    {
                        var rMessage = (MyRenderMessageSetInstanceBuffer)message;

                        var entity = (MyRenderEntity)GetRenderObject(rMessage.ID);
                        if (entity != null)
                        {
                            //RemoveRenderObject(entity);
                            var buffer = rMessage.InstanceBufferId == MyRenderProxy.RENDER_ID_UNASSIGNED ? null : (MyRenderInstanceBuffer)GetRenderObject(rMessage.InstanceBufferId);
                            entity.SetInstanceData(buffer, rMessage.InstanceStart, rMessage.InstanceCount, (BoundingBoxD)rMessage.LocalAabb);
                            MoveRenderObject(entity);
                        }


                        break;
                    }

                case MyRenderMessageEnum.CreateManualCullObject:
                    {
                        var rMessage = (MyRenderMessageCreateManualCullObject)message;

                        MyManualCullableRenderObject manualCullObject = new MyManualCullableRenderObject(rMessage.ID, (MatrixD)rMessage.WorldMatrix);
                        manualCullObject.DebugName = rMessage.DebugName;
                        manualCullObject.WorldMatrix = (MatrixD)rMessage.WorldMatrix;

                        AddRenderObjectFromProxy(manualCullObject, false);



                        break;
                    }

                case MyRenderMessageEnum.SetParentCullObject:
                    {
                        var rMessage = (MyRenderMessageSetParentCullObject)message;

                        MyRenderObject renderObject = GetRenderObject(rMessage.ID);
                        RemoveRenderObject(renderObject);
                        //m_renderObjects.Remove(rMessage.ID);

                        MyManualCullableRenderObject manualCullObject = GetRenderObject(rMessage.CullObjectID) as MyManualCullableRenderObject;
                        if (manualCullObject != null)
                        {
                            RemoveRenderObject(manualCullObject);

                            manualCullObject.AddRenderObject(renderObject, (MatrixD?)rMessage.ChildToParent);

                            AddRenderObject(manualCullObject);
                        }
                        else
                        { 
                        }
                        break;
                    }

                case MyRenderMessageEnum.SetCameraViewMatrix:
                    {
                        var rMessage = (MyRenderMessageSetCameraViewMatrix)message;
                        rMessage.UpdateTime = MyRender.CurrentUpdateTime;

                        // EnqueueDrawMessage(rMessage);

                        // var rMessage = (MyRenderMessageSetCameraViewMatrix)drawMessage;

                        MyRenderCamera.ProjectionMatrix = rMessage.ProjectionMatrix;
                        MyRenderCamera.ProjectionMatrixForNearObjects = rMessage.NearProjectionMatrix;
                        MyRenderCamera.SetViewMatrix(rMessage.ViewMatrix, rMessage.UpdateTime);

                        MyRenderCamera.SafeNearForForward = rMessage.SafeNear;
                        MyRenderCamera.FieldOfView = rMessage.FOV;
                        MyRenderCamera.FieldOfViewForNearObjects = rMessage.NearFOV;

                        if ((MyRenderCamera.NEAR_PLANE_DISTANCE != rMessage.NearPlane) ||
                            (MyRenderCamera.FAR_PLANE_DISTANCE != rMessage.FarPlane) ||
                            (MyRenderCamera.NEAR_PLANE_FOR_NEAR_OBJECTS != rMessage.NearObjectsNearPlane) ||
                            (MyRenderCamera.FAR_PLANE_FOR_NEAR_OBJECTS != rMessage.NearObjectsFarPlane))
                        {
                            MyRenderCamera.NEAR_PLANE_DISTANCE = rMessage.NearPlane;
                            MyRenderCamera.FAR_PLANE_DISTANCE = rMessage.FarPlane;
                            MyRenderCamera.NEAR_PLANE_FOR_NEAR_OBJECTS = rMessage.NearObjectsNearPlane;
                            MyRenderCamera.FAR_PLANE_FOR_NEAR_OBJECTS = rMessage.NearObjectsFarPlane;

                            foreach (var effect in m_effects)
                            {
                                if (effect != null)
                                {
                                    effect.SetNearPlane(MyRenderCamera.NEAR_PLANE_DISTANCE);
                                    effect.SetFarPlane(MyRenderCamera.FAR_PLANE_DISTANCE);
                                }
                            }
                        }

                        MyRenderCamera.UpdateCamera();

                        break;
                    }

                case MyRenderMessageEnum.DrawScene:
                    {
                        var rMessage = (MyRenderMessageBase)message;
                        EnqueueDrawMessage(rMessage);

                        break;
                    }

                case MyRenderMessageEnum.UpdateRenderObject:
                    {
                        var rMessage = (MyRenderMessageUpdateRenderObject)message;

                        MyRenderObject renderObject;
                        if (m_renderObjects.TryGetValue(rMessage.ID, out renderObject))
                        {
                            //System.Diagnostics.Debug.Assert(renderObject.ParentCullObject == null);
                            if (renderObject.ParentCullObject != null)
                            {
                                MyRenderTransformObject transformObject = renderObject as MyRenderTransformObject;
                                if (transformObject != null)
                                {
                                    //System.Diagnostics.Debug.Assert(Vector3D.IsZero(transformObject.WorldMatrix.Translation - rMessage.WorldMatrix.Translation, 0.01f));
                                }
                            }

                            {
                                MyRenderCharacter characterObject = renderObject as MyRenderCharacter;
                                if (characterObject != null)
                                {
                                    if (rMessage.AABB.HasValue)
                                        characterObject.ActualWorldAABB = rMessage.AABB.Value;
                                }
                                MyRenderTransformObject transformObject = renderObject as MyRenderTransformObject;
                                if (transformObject != null)
                                {
                                    transformObject.WorldMatrix = rMessage.WorldMatrix;
                                    UpdateRenderObject(transformObject, rMessage.SortIntoCulling);
                                }
                                MyRenderClipmap clipmap = renderObject as MyRenderClipmap;
                                if (clipmap != null)
                                {
                                    clipmap.UpdateWorldMatrix(ref rMessage.WorldMatrix, rMessage.SortIntoCulling);
                                    UpdateRenderObject(clipmap, rMessage.SortIntoCulling);
                                }
                                MyManualCullableRenderObject manualCullableRenderObject = renderObject as MyManualCullableRenderObject;
                                if (manualCullableRenderObject != null)
                                {
                                    manualCullableRenderObject.WorldMatrix = rMessage.WorldMatrix;
                                    UpdateRenderObject(manualCullableRenderObject, rMessage.SortIntoCulling);
                                }
                            }
                        }



                        break;
                    }

                case MyRenderMessageEnum.UpdateRenderObjectVisibility:
                    {
                        var rMessage = (MyRenderMessageUpdateRenderObjectVisibility)message;

                        MyRenderObject renderObject;
                        if (m_renderObjects.TryGetValue(rMessage.ID, out renderObject))
                        {
                            MyRenderTransformObject transformObject = renderObject as MyRenderTransformObject;
                            if (transformObject != null)
                            {
                                transformObject.ClearInterpolator();
                            }
                            MyManualCullableRenderObject manualCullableRenderObject = renderObject as MyManualCullableRenderObject;
                            if (manualCullableRenderObject != null)
                            {
                                manualCullableRenderObject.ClearInterpolator();
                            }

                            if (renderObject.NearFlag != rMessage.NearFlag)
                            {
                                var parentCullObject = renderObject.ParentCullObject;
                                if (parentCullObject != null)
                                {
                                    parentCullObject.RemoveRenderObject(renderObject);
                                }

                                RemoveRenderObject(renderObject, true);

                                renderObject.NearFlag = rMessage.NearFlag;

                                if (parentCullObject != null)
                                {
                                    RemoveRenderObject(parentCullObject);
                                    parentCullObject.AddRenderObject(renderObject);
                                    AddRenderObject(parentCullObject);

                                    if (renderObject.NearFlag && !m_nearObjects.Contains(renderObject))
                                    {
                                        m_nearObjects.Add(renderObject);
                                    }
                                }
                                else
                                {
                                    AddRenderObject(renderObject);
                                }
                            }
                            else
                            {
                                renderObject.Visible = rMessage.Visible;
                            }
                        }



                        break;
                    }

                case MyRenderMessageEnum.RemoveRenderObject:
                    {
                        var rMessage = (MyRenderMessageRemoveRenderObject)message;

                        MyRenderObject renderObject;
                        if (m_renderObjects.TryGetValue(rMessage.ID, out renderObject))
                        {
                            RemoveRenderObject(renderObject);
                            m_renderObjects.Remove(rMessage.ID);
                            renderObject.UnloadContent();
                        }
                        else
                        {
                        } // Put breakpoint here



                        break;
                    }


                case MyRenderMessageEnum.UpdateRenderEntity:
                    {
                        var rMessage = (MyRenderMessageUpdateRenderEntity)message;

                        MyRenderObject renderObject;
                        if (m_renderObjects.TryGetValue(rMessage.ID, out renderObject))
                        {
                            MyRenderEntity renderEntity = (MyRenderEntity)renderObject;
                            if (rMessage.DiffuseColor.HasValue)
                            {
                                renderEntity.EntityColor = rMessage.DiffuseColor.Value;
                            }
                            if (rMessage.ColorMaskHSV.HasValue)
                            {
                                renderEntity.EntityColorMaskHSV = rMessage.ColorMaskHSV.Value;
                            }
                            renderEntity.EntityDithering = rMessage.Dithering;
                        }



                        break;
                    }

                case MyRenderMessageEnum.EnableRenderModule:
                    {
                        var rMessage = (MyRenderMessageEnableRenderModule)message;

                        EnableRenderModule((MyRenderModuleEnum)rMessage.ID, rMessage.Enable);

                        break;
                    }

                case MyRenderMessageEnum.UseCustomDrawMatrix:
                    {
                        var rMessage = (MyRenderMessageUseCustomDrawMatrix)message;

                        MyRenderObject renderObject;
                        if (m_renderObjects.TryGetValue(rMessage.ID, out renderObject))
                        {
                            MyRenderEntity renderEntity = (MyRenderEntity)renderObject;

                            renderEntity.UseCustomDrawMatrix = rMessage.Enable;
                            renderEntity.DrawMatrix = (MatrixD)rMessage.DrawMatrix;
                        }

                        break;
                    }

                case MyRenderMessageEnum.CreateClipmap:
                    {
                        var rMessage = (MyRenderMessageCreateClipmap)message;

                        var clipmap = new MyRenderClipmap(rMessage);

                        AddRenderObjectFromProxy(clipmap);
                        clipmap.LoadContent();

                        break;
                    }

                case MyRenderMessageEnum.UpdateClipmapCell:
                    {
                        var rMessage = (MyRenderMessageUpdateClipmapCell)message;

                        MyRenderObject renderObject;
                        if (m_renderObjects.TryGetValue(rMessage.ClipmapId, out renderObject))
                        {
                            var clipmap = (MyRenderClipmap)renderObject;
                            clipmap.UpdateCell(rMessage);
                        }

                        break;
                    }

                case MyRenderMessageEnum.InvalidateClipmapRange:
                    {
                        var rMessage = (MyRenderMessageInvalidateClipmapRange)message;

                        MyRenderObject renderObject;
                        if (m_renderObjects.TryGetValue(rMessage.ClipmapId, out renderObject))
                        {
                            var clipmap = (MyRenderClipmap)renderObject;
                            clipmap.InvalidateRange(rMessage.MinCellLod0, rMessage.MaxCellLod0);
                        }
                        break;
                    }


                case MyRenderMessageEnum.RebuildCullingStructure:
                    {
                        MyRender.RebuildCullingStructure();

                        break;
                    }

                case MyRenderMessageEnum.ReloadGrass:
                case MyRenderMessageEnum.ReloadEffects:
                    {
                        MyRender.RootDirectoryEffects = MyRender.RootDirectoryDebug;
                        //MyRender.RootDirectoryEffects = MyRender.RootDirectory;
                        MyRender.LoadEffects();



                        break;
                    }


                case MyRenderMessageEnum.ReloadModels:
                    {
                        MyRenderModels.ReloadModels();



                        break;
                    }

                case MyRenderMessageEnum.ReloadTextures:
                    {
                        MyTextureManager.ReloadTextures(false);



                        break;
                    }

                case MyRenderMessageEnum.CreateRenderVoxelMaterials:
                    {
                        MyRenderVoxelMaterials.Clear();

                        var rMessage = (MyRenderMessageCreateRenderVoxelMaterials)message;

                        for (int i = 0; i < rMessage.Materials.Length; ++i)
                            MyRenderVoxelMaterials.Add(ref rMessage.Materials[i]);

                        rMessage.Materials = null;


                        break;
                    }

                case MyRenderMessageEnum.UpdateRenderVoxelMaterials:
                    {
                        MyRenderVoxelMaterials.Clear();

                        var rMessage = (MyRenderMessageUpdateRenderVoxelMaterials)message;

                        MyRenderVoxelMaterials.Add(ref rMessage.Materials[0]);

                        rMessage.Materials = null;


                        break;
                    }

                case MyRenderMessageEnum.CreateRenderVoxelDebris:
                    {
                        var rMessage = (MyRenderMessageCreateRenderVoxelDebris)message;

                        MyRenderVoxelDebris renderVoxelDebris = new MyRenderVoxelDebris(
                            rMessage.ID,
                            rMessage.DebugName,
                            rMessage.Model,
                            (MatrixD)rMessage.WorldMatrix,
                            rMessage.TextureCoordOffset,
                            rMessage.TextureCoordScale,
                            rMessage.TextureColorMultiplier,
                            rMessage.VoxelMaterialIndex
                            );

                        AddRenderObjectFromProxy(renderVoxelDebris);



                        break;
                    }


                case MyRenderMessageEnum.CreateRenderCharacter:
                    {
                        var rMessage = (MyRenderMessageCreateRenderCharacter)message;

                        MyRenderCharacter renderCharacter = new MyRenderCharacter(
                            rMessage.ID,
                            rMessage.DebugName,
                            rMessage.Model,
                            (MatrixD)rMessage.WorldMatrix,
                            rMessage.Flags
                            );

                        AddRenderObjectFromProxy(renderCharacter);



                        break;
                    }

                case MyRenderMessageEnum.UpdateModelProperties:
                    {
                        var rMessage = (MyRenderMessageUpdateModelProperties)message;

                        if (rMessage.ID == MyRenderProxy.RENDER_ID_UNASSIGNED)
                        {
                            MyRenderModel model = MyRenderModels.GetModel(rMessage.Model);
                            MyRenderMesh mesh = null;

                            if (rMessage.MaterialName != null)
                            {
                                foreach (var rMesh in model.GetMeshList())
                                {
                                    if (rMesh.Material.MaterialName == rMessage.MaterialName)
                                    {
                                        mesh = rMesh;
                                        break;
                                    }
                                }
                            }
                            else
                                mesh = model.GetMeshList()[rMessage.MeshIndex];

                            if (mesh != null)
                            {
                                MyRenderMeshMaterial material = mesh.Material;

                                if (rMessage.Enabled.HasValue)
                                    material.Enabled = rMessage.Enabled.Value;

                                if (rMessage.DiffuseColor.HasValue)
                                    material.DiffuseColor = rMessage.DiffuseColor.Value.ToVector3();

                                if (rMessage.SpecularIntensity.HasValue)
                                    material.SpecularIntensity = rMessage.SpecularIntensity.Value;

                                if (rMessage.SpecularPower.HasValue)
                                    material.SpecularPower = rMessage.SpecularPower.Value;

                                if (rMessage.Emissivity.HasValue)
                                    material.Emissivity = rMessage.Emissivity.Value;
                            }

                            model.HasSharedMaterials = true;
                        }
                        else
                        {
                            MyRenderObject renderObject;
                            if (m_renderObjects.TryGetValue(rMessage.ID, out renderObject))
                            {
                                MyRenderEntity renderEntity = renderObject as MyRenderEntity;
                                List<MyRenderMeshMaterial> materials = renderEntity.Lods[rMessage.LOD].MeshMaterials;
                                MyRenderModel model = renderEntity.Lods[rMessage.LOD].Model;
                                MyRenderMeshMaterial material = null;

                                model.HasSharedMaterials = false;

                                if (rMessage.MaterialName != null)
                                {
                                    foreach (var rMaterial in materials)
                                    {
                                        if (rMaterial.MaterialName == rMessage.MaterialName)
                                        {
                                            material = rMaterial;
                                            break;
                                        }
                                    }
                                }
                                else
                                    material = materials[rMessage.MeshIndex];

                                if (material != null)
                                {
                                    if (rMessage.Enabled.HasValue)
                                        material.Enabled = rMessage.Enabled.Value;

                                    if (rMessage.DiffuseColor.HasValue)
                                        material.DiffuseColor = rMessage.DiffuseColor.Value.ToVector3();

                                    if (rMessage.SpecularIntensity.HasValue)
                                        material.SpecularIntensity = rMessage.SpecularIntensity.Value;

                                    if (rMessage.SpecularPower.HasValue)
                                        material.SpecularPower = rMessage.SpecularPower.Value;

                                    if (rMessage.Emissivity.HasValue)
                                        material.Emissivity = rMessage.Emissivity.Value;
                                }
                            }
                        }



                        break;
                    }
                case MyRenderMessageEnum.UpdateColorEmissivity:
                    {
                        var rMessage = (MyRenderMessageUpdateColorEmissivity)message;

                        MyRenderObject renderObject;
                        if (m_renderObjects.TryGetValue(rMessage.ID, out renderObject))
                        {
                            MyRenderEntity renderEntity = renderObject as MyRenderEntity;
                            List<MyRenderMeshMaterial> materials = renderEntity.Lods[rMessage.LOD].MeshMaterials;
                            MyRenderModel model = renderEntity.Lods[rMessage.LOD].Model;
                            MyRenderMeshMaterial material = null;

                            model.HasSharedMaterials = false;

                            if (rMessage.MaterialName != null)
                            {
                                foreach (var rMaterial in materials)
                                {
                                    if (rMaterial.MaterialName == rMessage.MaterialName)
                                    {
                                        material = rMaterial;
                                        break;
                                    }
                                }
                            }

                            if (material != null)
                            {
                                material.DiffuseColor = rMessage.DiffuseColor.ToVector3();
                                material.Emissivity = rMessage.Emissivity;
                            }
                        }

                        break;
                    }

                case MyRenderMessageEnum.ChangeModel:
                    {
                        var rMessage = (MyRenderMessageChangeModel)message;

                        MyRenderObject renderObject;
                        if (m_renderObjects.TryGetValue(rMessage.ID, out renderObject))
                        {
                            MyRenderEntity entity = renderObject as MyRenderEntity;
                            if (rMessage.UseForShadow)
                            {
                                entity.ChangeShadowModels(rMessage.LOD, rMessage.Model);
                                entity.ChangeModels(rMessage.LOD, rMessage.Model);
                            }
                            else
                            {
                                entity.ChangeShadowModels(rMessage.LOD, entity.Lods[rMessage.LOD].Model.AssetName);
                                entity.ChangeModels(rMessage.LOD, rMessage.Model);
                            }
                        }




                        break;
                    }

                case MyRenderMessageEnum.UpdateGameplayFrame:
                    {
                        var rMessage = (MyRenderMessageUpdateGameplayFrame)message;

                        Settings.GameplayFrame = rMessage.GameplayFrame;

                        break;
                    }

                case MyRenderMessageEnum.UpdateVoxelMaterialsProperties:
                    {
                        var rMessage = (MyRenderMessageUpdateVoxelMaterialsProperties)message;

                        var material = MyRenderVoxelMaterials.Get(rMessage.MaterialIndex);

                        material.SpecularIntensity = rMessage.SpecularIntensity;
                        material.SpecularPower = rMessage.SpecularPower;



                        break;
                    }

                case MyRenderMessageEnum.ChangeMaterialTexture:
                    {
                        var rMessage = (MyRenderMessageChangeMaterialTexture)message;
                        MyRenderMeshMaterial material = GetMeshMaterial(rMessage.RenderObjectID, rMessage.MaterialName);
                        if (material != null)
                        {
                            material.DiffuseTexture = MyTextureManager.GetTexture<MyTexture2D>(rMessage.Changes[0].TextureName, "", null, LoadingMode.Immediate);
                        }
                        rMessage.Changes.Clear();

                        break;
                    }

                case MyRenderMessageEnum.DrawTextToMaterial:
                    {
                        var rMessage = (MyRenderMessageDrawTextToMaterial)message;
                        MyRenderMeshMaterial material = GetMeshMaterial(rMessage.RenderObjectID, rMessage.MaterialName);
                        if (material != null)
                        {
                            var id = new MyRenderTextureId();
                            id.EntityId = rMessage.EntityId;
                            id.RenderObjectId = rMessage.RenderObjectID;

                            material.DiffuseTexture = MyRender.RenderTextToTexture(id, rMessage.Text, rMessage.TextScale , rMessage.FontColor, rMessage.BackgroundColor, rMessage.TextureResolution, rMessage.TextureAspectRatio);
                            if (material.DiffuseTexture == null)
                            {
                                MyRenderProxy.TextNotDrawnToTexture(rMessage.EntityId);
                            }
                        }
                        break;
                    }
                case MyRenderMessageEnum.ReleaseRenderTexture:
                    {
                        var rMessage = (MyRenderMessageReleaseRenderTexture)message;
                        var id = new MyRenderTextureId();
                        id.EntityId = rMessage.EntityId;
                        id.RenderObjectId = rMessage.RenderObjectID;
                        if (MyRenderTexturePool.ReleaseRenderTexture(id))
                        {
                            MyRenderProxy.RenderTextureFreed(MyRenderTexturePool.FreeResourcesCount());
                        }
                        break;
                    }
                #endregion

                #region Lights

                case MyRenderMessageEnum.CreateRenderLight:
                    {
                        var rMessage = (MyRenderMessageCreateRenderLight)message;

                        MyRenderLight renderLight = new MyRenderLight(
                            rMessage.ID
                            );

                        AddRenderObjectFromProxy(renderLight);



                        break;
                    }

                case MyRenderMessageEnum.UpdateRenderLight:
                    {
                        var rMessage = (MyRenderMessageUpdateRenderLight)message;

                        MyRenderObject renderObject;
                        if (m_renderObjects.TryGetValue(rMessage.ID, out renderObject))
                        {
                            MyRenderLight renderLight = renderObject as MyRenderLight;
                            if (renderLight != null)
                            {
                                bool dirtyAABB = false;
                                if (renderLight.m_parentID != rMessage.ParentID)
                                    dirtyAABB = true;

                                if (renderLight.m_position != rMessage.Position)
                                    dirtyAABB = true;

                                renderLight.UpdateParameters(
                                    rMessage.Type,
                                    rMessage.Position,
                                    rMessage.ParentID,
                                    rMessage.Offset,
                                    rMessage.Color,
                                    rMessage.SpecularColor,
                                    rMessage.Falloff,
                                    rMessage.Range,
                                    rMessage.Intensity,
                                    rMessage.LightOn,
                                    rMessage.UseInForwardRender,
                                    rMessage.ReflectorIntensity,
                                    rMessage.ReflectorOn,
                                    rMessage.ReflectorDirection,
                                    rMessage.ReflectorUp,
                                    rMessage.ReflectorConeMaxAngleCos,
                                    rMessage.ReflectorColor,
                                    rMessage.ReflectorRange,
                                    rMessage.ReflectorFalloff,
                                    rMessage.ReflectorTexture,
                                    rMessage.ShadowDistance,
                                    rMessage.CastShadows,
                                    rMessage.GlareOn,
                                    rMessage.GlareType,
                                    rMessage.GlareSize,
                                    rMessage.GlareQuerySize,
                                    rMessage.GlareIntensity,
                                    rMessage.GlareMaterial,
                                    rMessage.GlareMaxDistance
                                    );

                                if (dirtyAABB)
                                    UpdateRenderObject(renderLight, false);
                            }
                        }



                        break;
                    }


                case MyRenderMessageEnum.SetLightShadowIgnore:
                    {
                        var rMessage = (MyRenderMessageSetLightShadowIgnore)message;

                        MyRenderObject renderObject;
                        if (m_renderObjects.TryGetValue(rMessage.ID, out renderObject))
                        {
                            MyRenderLight renderLight = (MyRenderLight)renderObject;
                            renderLight.ShadowIgnoreObjects.Add(rMessage.ID2);
                        }



                        break;
                    }


                case MyRenderMessageEnum.ClearLightShadowIgnore:
                    {
                        var rMessage = (MyRenderMessageClearLightShadowIgnore)message;

                        MyRenderObject renderObject;
                        if (m_renderObjects.TryGetValue(rMessage.ID, out renderObject))
                        {
                            MyRenderLight renderLight = (MyRenderLight)renderObject;
                            renderLight.ShadowIgnoreObjects.Clear();
                        }



                        break;
                    }

                case MyRenderMessageEnum.UpdateRenderEnvironment:
                    {
                        var rMessage = (MyRenderMessageUpdateRenderEnvironment)message;

                        float DX9Rescaling = 0.1195f;

                        Sun.Direction = rMessage.SunDirection;
                        Sun.Color = rMessage.SunColor;
                        Sun.BackColor = rMessage.AdditionalSunColors[0];
                        Sun.BackIntensity = rMessage.AdditionalSunIntensities[0] * DX9Rescaling;
                        Sun.Intensity = rMessage.SunIntensity;
                        Sun.LightOn = rMessage.SunLightOn;
                        Sun.SpecularColor = rMessage.SunSpecularColor;
                        Sun.SunSizeMultiplier = rMessage.SunSizeMultiplier;
                        Sun.DistanceToSun = rMessage.DistanceToSun;

                        MyRender.AmbientColor = rMessage.AmbientColor;
                        MyRender.AmbientMultiplier = rMessage.AmbientMultiplier;
                        MyRender.EnvAmbientIntensity = rMessage.EnvAmbientIntensity;

                        MyBackgroundCube.Filename = rMessage.BackgroundTexture;
                        MyBackgroundCube.BackgroundColor = rMessage.BackgroundColor;
                        MyBackgroundCube.BackgroundOrientation = rMessage.BackgroundOrientation;
                        Sun.SunMaterial = rMessage.SunMaterial;

                        MyBackgroundCube.Static.ReloadContent();

                        break;
                    }
                #endregion

                #region Post processes

                case MyRenderMessageEnum.UpdateHDRSettings:
                    {
                        var rMessage = (MyRenderMessageUpdateHDRSettings)message;

                        MyPostProcessHDR postProcessHDR = MyRender.GetPostProcess(MyPostProcessEnum.HDR) as MyPostProcessHDR;

                        postProcessHDR.Enabled = rMessage.Enabled;
                        postProcessHDR.Exposure = rMessage.Exposure;
                        postProcessHDR.Threshold = rMessage.Threshold;
                        postProcessHDR.BloomIntensity = rMessage.BloomIntensity;
                        postProcessHDR.BloomIntensityBackground = rMessage.BloomIntensityBackground;
                        postProcessHDR.VerticalBlurAmount = rMessage.VerticalBlurAmount;
                        postProcessHDR.HorizontalBlurAmount = rMessage.HorizontalBlurAmount;
                        postProcessHDR.NumberOfBlurPasses = rMessage.NumberOfBlurPasses;



                        break;
                    }

                case MyRenderMessageEnum.UpdateAntiAliasSettings:
                    {
                        var rMessage = (MyRenderMessageUpdateAntiAliasSettings)message;

                        var postProcess = MyRender.GetPostProcess(MyPostProcessEnum.FXAA) as MyPostProcessAntiAlias;

                        postProcess.Enabled = rMessage.Enabled;



                        break;
                    }

                case MyRenderMessageEnum.UpdateVignettingSettings:
                    {
                        var rMessage = (MyRenderMessageUpdateVignettingSettings)message;

                        var postProcess = MyRender.GetPostProcess(MyPostProcessEnum.Vignetting) as MyPostProcessVignetting;

                        postProcess.Enabled = rMessage.Enabled;
                        postProcess.VignettingPower = rMessage.VignettingPower;



                        break;
                    }

                case MyRenderMessageEnum.UpdateColorMappingSettings:
                    {
                        var rMessage = (MyRenderMessageUpdateColorMappingSettings)message;

                        var postProcess = MyRender.GetPostProcess(MyPostProcessEnum.ColorMapping) as MyPostProcessColorMapping;

                        postProcess.Enabled = rMessage.Enabled;



                        break;
                    }

                case MyRenderMessageEnum.UpdateContrastSettings:
                    {
                        var rMessage = (MyRenderMessageUpdateContrastSettings)message;
                        var postProcess = MyRender.GetPostProcess(MyPostProcessEnum.Contrast) as MyPostProcessContrast;

                        postProcess.Enabled = rMessage.Enabled;
                        postProcess.Contrast = rMessage.Contrast;
                        postProcess.Hue = rMessage.Hue;
                        postProcess.Saturation = rMessage.Saturation;



                        break;
                    }

                case MyRenderMessageEnum.UpdateChromaticAberrationSettings:
                    {
                        var rMessage = (MyRenderMessageUpdateChromaticAberrationSettings)message;
                        var postProcess = MyRender.GetPostProcess(MyPostProcessEnum.ChromaticAberration) as MyPostProcessChromaticAberration;

                        postProcess.Enabled = rMessage.Enabled;
                        postProcess.DistortionLens = rMessage.DistortionLens;
                        postProcess.DistortionCubic = rMessage.DistortionCubic;
                        postProcess.DistortionWeights = rMessage.DistortionWeights;



                        break;
                    }

                case MyRenderMessageEnum.UpdateSSAOSettings:
                    {
                        var rMessage = (MyRenderMessageUpdateSSAOSettings)message;

                        var postProcess = MyRender.GetPostProcess(MyPostProcessEnum.VolumetricSSAO2) as MyPostProcessVolumetricSSAO2;

                        postProcess.Enabled = rMessage.Enabled;

                        postProcess.ShowOnlySSAO = rMessage.ShowOnlySSAO;
                        postProcess.UseBlur = rMessage.UseBlur;

                        postProcess.MinRadius = rMessage.MinRadius;
                        postProcess.MaxRadius = rMessage.MaxRadius;
                        postProcess.RadiusGrowZScale = rMessage.RadiusGrowZScale;
                        postProcess.CameraZFar = rMessage.CameraZFar;

                        postProcess.Bias = rMessage.Bias;
                        postProcess.Falloff = rMessage.Falloff;
                        postProcess.NormValue = rMessage.NormValue;
                        postProcess.Contrast = rMessage.Contrast;



                        break;
                    }

                case MyRenderMessageEnum.UpdateFogSettings:
                    {
                        var rMessage = (MyRenderMessageUpdateFogSettings)message;

                        var postProcess = MyRender.GetPostProcess(MyPostProcessEnum.VolumetricFog) as MyPostProcessVolumetricFog;

                        postProcess.Enabled = rMessage.Settings.Enabled;
                        FogProperties.FogNear = rMessage.Settings.FogNear;
                        FogProperties.FogFar = rMessage.Settings.FogFar;
                        FogProperties.FogMultiplier = rMessage.Settings.FogMultiplier;
                        FogProperties.FogBacklightMultiplier = rMessage.Settings.FogBacklightMultiplier;
                        FogProperties.FogColor = rMessage.Settings.FogColor;



                        break;
                    }

                case MyRenderMessageEnum.UpdateGodRaysSettings:
                    {
                        var rMessage = (MyRenderMessageUpdateGodRaysSettings)message;

                        var postProcess = MyRender.GetPostProcess(MyPostProcessEnum.GodRays) as MyPostProcessGodRays;

                        postProcess.Enabled = rMessage.Enabled;
                        postProcess.Density = rMessage.Density;
                        postProcess.Weight = rMessage.Weight;
                        postProcess.Decay = rMessage.Decay;
                        postProcess.Exposition = rMessage.Exposition;
                        postProcess.ApplyBlur = rMessage.ApplyBlur;



                        break;
                    }

                #endregion

                #region Environment

                case MyRenderMessageEnum.UpdateEnvironmentMap:
                    {
                        EnqueueDrawMessage(message);
                        break;
                    }

                #endregion

                #region Video

                case MyRenderMessageEnum.PlayVideo:
                    {
                        var rMessage = (MyRenderMessagePlayVideo)message;

                        MyRender.PlayVideo(rMessage.ID, rMessage.VideoFile, rMessage.Volume);



                        break;
                    }

                case MyRenderMessageEnum.UpdateVideo:
                    {
                        var rMessage = (MyRenderMessageUpdateVideo)message;

                        MyRender.UpdateVideo(rMessage.ID);



                        break;
                    }

                case MyRenderMessageEnum.DrawVideo:
                    {
                        var rMessage = (MyRenderMessageDrawVideo)message;

                        EnqueueDrawMessage(rMessage);

                        break;
                    }

                case MyRenderMessageEnum.CloseVideo:
                    {
                        var rMessage = (MyRenderMessageCloseVideo)message;

                        MyRender.CloseVideo(rMessage.ID);



                        break;
                    }

                case MyRenderMessageEnum.SetVideoVolume:
                    {
                        var rMessage = (MyRenderMessageSetVideoVolume)message;

                        MyRender.SetVideoVolume(rMessage.ID, rMessage.Volume);



                        break;
                    }


                #endregion

                #region Secondary camera

                case MyRenderMessageEnum.DrawSecondaryCamera:
                    {
                        var rMessage = (MyRenderMessageDrawSecondaryCamera)message;

                        EnqueueDrawMessage(rMessage);

                        break;
                    }

                case MyRenderMessageEnum.DrawSecondaryCameraSprite:
                    {
                        var rMessage = (MyRenderMessageDrawSecondaryCameraSprite)message;
                        EnqueueDrawMessage(rMessage);
                        break;
                    }

                #endregion

                #region Decals

                case MyRenderMessageEnum.CreateDecal:
                    {
                        var rMessage = (MyRenderMessageCreateDecal)message;

                        MyRenderObject renderObject;
                        if (m_renderObjects.TryGetValue(rMessage.ID, out renderObject))
                        {
                            MyDecals.AddDecal(
                                renderObject,
                                ref rMessage.Triangle,
                                rMessage.TrianglesToAdd,
                                rMessage.Texture,
                                (Vector3D)rMessage.Position,
                                rMessage.LightSize,
                                rMessage.Emissivity
                               );
                        }



                        break;
                    }


                case MyRenderMessageEnum.HideDecals:
                    {
                        var rMessage = (MyRenderMessageHideDecals)message;

                        MyRenderObject renderObject;
                        if (m_renderObjects.TryGetValue(rMessage.ID, out renderObject))
                        {
                            if (rMessage.Radius == 0 && renderObject is MyRenderTransformObject)
                            {
                                MyDecals.RemoveModelDecals(renderObject as MyRenderTransformObject);
                            }
                            else
                            {
                                if (renderObject is MyRenderVoxelCell)
                                {
                                    VRageMath.BoundingSphere bs = new VRageMath.BoundingSphere(rMessage.Center, rMessage.Radius);
                                    MyDecals.HideTrianglesAfterExplosion(renderObject as MyRenderVoxelCell, ref bs);
                                }
                            }
                        }



                        break;
                    }



                #endregion

                #region Cockpit

                case MyRenderMessageEnum.UpdateCockpitGlass:
                    {
                        var rMessage = (MyRenderMessageUpdateCockpitGlass)message;

                        MyCockpitGlass.Visible = rMessage.Visible;
                        MyCockpitGlass.PlayerHeadForCockpitInteriorWorldMatrix = (MatrixD)rMessage.WorldMatrix;
                        MyCockpitGlass.GlassDirtAlpha = rMessage.DirtAlpha;
                        MyCockpitGlass.Model = rMessage.Model;



                        break;
                    }

                #endregion

                #region Billboards and quality

                case MyRenderMessageEnum.UpdateBillboardsColorize:
                    {
                        var rMessage = (MyRenderMessageUpdateBillboardsColorize)message;

                        EnqueueDrawMessage(rMessage);

                        break;
                    }

                case MyRenderMessageEnum.AddLineBillboardLocal:
                    {
                        var rMessage = (MyRenderMessageAddLineBillboardLocal)message;

                        MyRenderObject renderObject;
                        if (m_renderObjects.TryGetValue(rMessage.RenderObjectID, out renderObject))
                        {
                            renderObject.Billboards.Add(rMessage);
                        }

                        break;
                    }

                case MyRenderMessageEnum.AddPointBillboardLocal:
                    {
                        var rMessage = (MyRenderMessageAddPointBillboardLocal)message;

                        MyRenderObject renderObject;
                        if (m_renderObjects.TryGetValue(rMessage.RenderObjectID, out renderObject))
                        {
                            renderObject.Billboards.Add(rMessage);
                        }

                        break;
                    }

                case MyRenderMessageEnum.UpdateDistantImpostors:
                    {
                        var rMessage = (MyRenderMessageUpdateDistantImpostors)message;

                        MyDistantImpostors.ImpostorProperties = rMessage.ImpostorProperties;
                        MyDistantImpostors.Static.ReloadContent();



                        break;
                    }

                case MyRenderMessageEnum.SetTextureIgnoreQuality:
                    {
                        var rMessage = (MyRenderMessageSetTextureIgnoreQuality)message;

                        MyTextureManager.TexturesWithIgnoredQuality.Add(rMessage.Path);
                        MyTextureManager.UnloadTexture(rMessage.Path);



                        break;
                    }

                case MyRenderMessageEnum.UpdateRenderQuality:
                    {
                        var rMessage = (MyRenderMessageUpdateRenderQuality)message;

                        MyRenderQualityProfile profile = MyRenderConstants.m_renderQualityProfiles[(int)rMessage.RenderQuality];

                        profile.EnableCascadeBlending = rMessage.EnableCascadeBlending;

                        MyRenderTexturePool.RenderQualityChanged(rMessage.RenderQuality);

                        break;
                    }

                case MyRenderMessageEnum.TakeScreenshot:
                    {
                        var rMessage = (MyRenderMessageTakeScreenshot)message;

                        m_screenshot = new MyScreenshot(rMessage.SizeMultiplier, rMessage.PathToSave, rMessage.IgnoreSprites, rMessage.ShowNotification);
                        ScreenshotOnlyFinal = !rMessage.Debug;

                        //Will do before draw
                        //UpdateScreenSize();
                        //MyEnvironmentMap.Reset();



                        break;
                    }
                case MyRenderMessageEnum.RenderColoredTexture:
                    {
                        var rMessage = (MyRenderMessageRenderColoredTexture)message;
                        m_texturesToRender.AddRange(rMessage.texturesToRender);
                        break;
                    }

                #endregion

                #region Characters

                case MyRenderMessageEnum.SetCharacterSkeleton:
                    {
                        var rMessage = (MyRenderMessageSetCharacterSkeleton)message;

                        MyRenderObject renderCharacterObject;
                        if (m_renderObjects.TryGetValue(rMessage.CharacterID, out renderCharacterObject))
                        {
                            MyRenderCharacter renderCharacter = (MyRenderCharacter)renderCharacterObject;
                            renderCharacter.SetSkeleton(rMessage.SkeletonBones, rMessage.SkeletonIndices);
                        }

                        break;
                    }

                case MyRenderMessageEnum.SetCharacterTransforms:
                    {
                        var rMessage = (MyRenderMessageSetCharacterTransforms)message;

                        MyRenderObject renderCharacterObject;
                        if (m_renderObjects.TryGetValue(rMessage.CharacterID, out renderCharacterObject))
                        {
                            MyRenderCharacter renderCharacter = (MyRenderCharacter)renderCharacterObject;
                            renderCharacter.SetAnimationBones(rMessage.RelativeBoneTransforms);
                        }



                        break;
                    }


                #endregion

                #region Debug draw

                case MyRenderMessageEnum.DebugDrawLine3D:
                case MyRenderMessageEnum.DebugDrawLine2D:
                case MyRenderMessageEnum.DebugDrawSphere:
                case MyRenderMessageEnum.DebugDrawAABB:
                case MyRenderMessageEnum.DebugDrawAxis:
                case MyRenderMessageEnum.DebugDrawOBB:
                case MyRenderMessageEnum.DebugDrawTriangle:
                case MyRenderMessageEnum.DebugDrawCapsule:
                case MyRenderMessageEnum.DebugDrawText2D:
                case MyRenderMessageEnum.DebugDrawText3D:
                case MyRenderMessageEnum.DebugDrawModel:
                case MyRenderMessageEnum.DebugDrawTriangles:
                case MyRenderMessageEnum.DebugDrawPlane:
                case MyRenderMessageEnum.DebugDrawCylinder:
                case MyRenderMessageEnum.DebugWaitForPresent:
                    {
                        EnqueueDebugDrawMessage(message);
                    }
                    break;

                case MyRenderMessageEnum.DebugCrashRenderThread:
                    {
                        throw new InvalidOperationException("Forced exception");
                    }
                #endregion

                #region Fonts and text

                case MyRenderMessageEnum.CreateFont:
                    {
                        var createFontMessage = message as MyRenderMessageCreateFont;
                        Debug.Assert(createFontMessage != null);

                        var renderFont = new MyRenderFont(createFontMessage.FontPath);
                        renderFont.LoadContent();
                        AddFont(createFontMessage.FontId, renderFont, createFontMessage.IsDebugFont);

                        break;
                    }

                case MyRenderMessageEnum.DrawString:
                    {
                        EnqueueDrawMessage(message);
                        break;
                    }

                #endregion

                case MyRenderMessageEnum.VideoAdaptersRequest:
                    {
                        MyRenderProxy.SendVideoAdapters(GetAdaptersList());
                        break;
                    }

                case MyRenderMessageEnum.SwitchDeviceSettings:
                    {
                        MyRenderProxy.RenderThread.SwitchSettings((message as MyRenderMessageSwitchDeviceSettings).Settings);
                        break;
                    }

                case MyRenderMessageEnum.SwitchRenderSettings:
                    {
                        // Dx9 Only understands interpolation and render quality.
                        var rMessage = (MyRenderMessageSwitchRenderSettings)message;
                        MyRenderProxy.Settings.EnableObjectInterpolation = rMessage.Settings.InterpolationEnabled;
                        MyRenderProxy.Settings.EnableCameraInterpolation = rMessage.Settings.InterpolationEnabled;
                        MyRenderProxy.RenderThread.SwitchQuality(rMessage.Settings.Dx9Quality);
                        break;
                    }

                case MyRenderMessageEnum.UnloadData:
                    {
                        MyRender.UnloadData();



                        break;
                    }

                case MyRenderMessageEnum.CollectGarbage:
                    {
                        GC.Collect();
                        break;
                    }

                case MyRenderMessageEnum.UpdatePostprocessSettings:
                    {
                        break;
                    }

                default:
                  //  System.Diagnostics.Debug.Assert(false, "Unknown message");
                    break;
            }
        }
        private static void ProcessMessageInternal(MyRenderMessageBase message)
        {
            switch (message.MessageType)
            {
                case MyRenderMessageEnum.SetCameraViewMatrix:
                {
                    var rMessage = (MyRenderMessageSetCameraViewMatrix)message;

                    SetupCameraMatrices(rMessage);

                    break;
                }

                case MyRenderMessageEnum.DrawScene:
                {
                    var rMessage = (MyRenderMessageBase)message;

                    m_drawQueue.Enqueue(rMessage);

                    break;
                }

                case MyRenderMessageEnum.RebuildCullingStructure:
                {

                    break;
                }

                #region Profiler

                case MyRenderMessageEnum.RenderProfiler:
                {
                    var profMessage = (MyRenderMessageRenderProfiler)message;

                    MyRenderProfiler.HandleInput(profMessage.Command, profMessage.Index);

                    break;
                }

                #endregion

                #region Characters

                case MyRenderMessageEnum.CreateRenderCharacter:
                {
                    var rMessage = (MyRenderMessageCreateRenderCharacter)message;

                    var actor = MyActorFactory.CreateCharacter();
                    var renderable = actor.GetRenderable();
                    renderable.SetModel(MyMeshes.GetMeshId(MyStringId.GetOrCompute(rMessage.Model), 1.0f));
                    actor.SetMatrix(ref rMessage.WorldMatrix);

                    if (rMessage.ColorMaskHSV.HasValue)
                    {
                        var color = ColorFromMask(rMessage.ColorMaskHSV.Value);
                        renderable.SetKeyColor(new Vector4(color, 1));
                    }

                    actor.SetID(rMessage.ID);
					renderable.m_additionalFlags |= MyProxiesFactory.GetRenderableProxyFlags(rMessage.Flags);
                    renderable.m_drawFlags = MyDrawSubmesh.MySubmeshFlags.Gbuffer | MyDrawSubmesh.MySubmeshFlags.Depth;

                    break;
                }

                case MyRenderMessageEnum.SetCharacterSkeleton:
                {
                    var rMessage = (MyRenderMessageSetCharacterSkeleton)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.CharacterID);
                    if (actor != null)
                    {
                        actor.GetSkinning().SetSkeleton(rMessage.SkeletonBones, rMessage.SkeletonIndices);
                    }

                    //var entity = MyComponents.GetEntity(rMessage.CharacterID);
                    //MyComponents.SetSkeleton(entity, rMessage.SkeletonBones, rMessage.SkeletonIndices);

                    break;
                };

                case MyRenderMessageEnum.SetCharacterTransforms:
                {
                    var rMessage = (MyRenderMessageSetCharacterTransforms)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.CharacterID);
                    if (actor != null)
                    {
                        actor.GetSkinning().SetAnimationBones(rMessage.BoneAbsoluteTransforms, rMessage.BoneDecalUpdates);
                    }
                    //var entity = MyComponents.GetEntity(rMessage.CharacterID);
                    //MyComponents.SetAnimation(entity, rMessage.RelativeBoneTransforms);

                    break;
                }

                case MyRenderMessageEnum.UpdateRenderEntity:
                {
                    var rMessage = (MyRenderMessageUpdateRenderEntity)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    if (actor == null)
                        break;

                    var renderableComponent = actor.GetRenderable();
                    if (renderableComponent == null)
                        break;

                    if (rMessage.ColorMaskHSV.HasValue)
                    {
                        actor.GetRenderable().SetKeyColor(new Vector4(ColorFromMask(rMessage.ColorMaskHSV.Value), 0));
                    }
                    actor.GetRenderable().SetDithering(rMessage.Dithering);

                    break;
                }

                case MyRenderMessageEnum.ChangeModel:
                {
                    var rMessage = (MyRenderMessageChangeModel)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    if (actor != null && actor.GetRenderable() != null)
                    {
                        var r = actor.GetRenderable();
                        var modelId = MyMeshes.GetMeshId(X.TEXT_(rMessage.Model), rMessage.Scale);
                        if(r.GetModel() != modelId)
                        {
                            r.SetModel(modelId);
                        }
                    }

                    break;
                }

                case MyRenderMessageEnum.ChangeModelMaterial:
                {
                    var rMessage = (MyRenderMessageChangeModelMaterial)message;

                    

                    //var matId = MyMeshMaterialId.NULL;
                    //if (rMessage.Material.ToLower().Contains("debug"))
                    //{
                    //    matId = MyMeshMaterials1.DebugMaterialId;
                    //}
                    //else
                    //{
                    //    matId = MyMeshMaterials1.GetMaterialId(rMessage.Material);
                    //}

                    //MyAssetsLoader.GetModel(rMessage.Model).SetMaterial_SLOW(MyMeshMaterials1.GetProxyId(matId));

                    break;
                }
          
                #endregion

                #region Render objects

                case MyRenderMessageEnum.UpdateCockpitGlass:
                {
                    var rMessage = (MyRenderMessageUpdateCockpitGlass)message;

                    //if (MyRender11.Environment.CockpitGlass == null)
                    //{
                    //    MyRender11.Environment.CockpitGlass = MyActorFactory.CreateSceneObject();
                    //}

                    //MyRender11.Environment.CockpitGlass.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(rMessage.Model)));
                    //MyRender11.Environment.CockpitGlass.SetVisibility(rMessage.Visible);
                    //MyRender11.Environment.CockpitGlass.MarkRenderDirty();

                    //var matrix = (Matrix)rMessage.WorldMatrix;
                    //MyRender11.Environment.CockpitGlass.SetMatrix(ref matrix);


                    break;
                }

                case MyRenderMessageEnum.CreateRenderVoxelDebris:
                {
                    var rMessage = (MyRenderMessageCreateRenderVoxelDebris)message;

                    Matrix m = (Matrix)rMessage.WorldMatrix;

                    var actor = MyActorFactory.CreateSceneObject();
                    if (rMessage.Model != null)
                    {
                        actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT_(rMessage.Model), 1.0f));
                    }

                    actor.SetID(rMessage.ID);
                    actor.SetMatrix(ref rMessage.WorldMatrix);

                    MyRenderableComponent.DebrisEntityVoxelMaterial[rMessage.ID] = rMessage.VoxelMaterialIndex;

                    break;
                }

                case MyRenderMessageEnum.CreateScreenDecal:
                {
                    var rMessage = (MyRenderMessageCreateScreenDecal)message;

                    MyScreenDecals.AddDecal(rMessage.ID, rMessage.ParentID, ref rMessage.TopoData, rMessage.Flags, rMessage.SourceTarget, rMessage.Material, rMessage.MaterialIndex);

                    break;
                }

                case MyRenderMessageEnum.UpdateScreenDecal:
                {
                    var rMessage = (MyRenderMessageUpdateScreenDecal)message;

                    MyScreenDecals.UpdateDecals(rMessage.Decals);

                    break;
                }

				case MyRenderMessageEnum.CreateRenderEntity:
				{
					var rMessage = (MyRenderMessageCreateRenderEntity)message;

					var actor = MyActorFactory.CreateSceneObject();
					if (rMessage.Model != null)
					{
						var model = MyAssetsLoader.ModelRemap.Get(rMessage.Model, rMessage.Model);

                        actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT_(model), rMessage.Rescale));
					}

					actor.SetID(rMessage.ID);
					actor.SetMatrix(ref rMessage.WorldMatrix);
                    var renderable = actor.GetRenderable();

					renderable.m_additionalFlags |= MyProxiesFactory.GetRenderableProxyFlags(rMessage.Flags);
                    renderable.m_depthBias = rMessage.DepthBias;

					break;
				}

				case MyRenderMessageEnum.CreateRenderEntityClouds:
				{
					var rMessage = (MyRenderMessageCreateRenderEntityClouds)message;

					if (rMessage.Technique == MyMeshDrawTechnique.CLOUD_LAYER)
					{
						MyCloudRenderer.CreateCloudLayer(
							rMessage.ID,
							rMessage.CenterPoint,
							rMessage.Altitude,
							rMessage.MinScaledAltitude,
							rMessage.ScalingEnabled,
							rMessage.FadeOutRelativeAltitudeStart,
							rMessage.FadeOutRelativeAltitudeEnd,
							rMessage.ApplyFogRelativeDistance,
							rMessage.MaxPlanetHillRadius,
							rMessage.Model,
                            rMessage.Textures,
							rMessage.RotationAxis,
							rMessage.AngularVelocity,
							rMessage.InitialRotation);
					}

					break;
				}

                case MyRenderMessageEnum.CreateRenderEntityAtmosphere:
                {
                    var rMessage = (MyRenderMessageCreateRenderEntityAtmosphere)message;

                    if (rMessage.Technique == MyMeshDrawTechnique.ATMOSPHERE) 
                    {
                        float earthPlanetRadius = 6360000f;
                        float earthAtmosphereRadius = 6420000f;

                        float earthAtmosphereToPlanetRatio = earthAtmosphereRadius / earthPlanetRadius;
                        float targetAtmosphereToPlanetRatio = rMessage.AtmosphereRadius / rMessage.PlanetRadius;
                        float targetToEarthRatio = (targetAtmosphereToPlanetRatio - 1) / (earthAtmosphereToPlanetRatio - 1);
                        earthAtmosphereRadius = earthPlanetRadius * targetAtmosphereToPlanetRatio;

                        float planetScaleFactor = (rMessage.PlanetRadius) / earthPlanetRadius;
                        float atmosphereScaleFactor = (rMessage.AtmosphereRadius - rMessage.PlanetRadius) / (rMessage.PlanetRadius * 0.5f);
                        
                        Vector3 rayleighScattering = new Vector3(5.8e-6f, 13.5e-6f, 33.1e-6f);
                        Vector3 mieScattering = new Vector3(2e-5f, 2e-5f, 2e-5f);
                        float rayleighHeightScale = 8000f;
                        float mieHeightScale = 1200f;

                        MyAtmosphereRenderer.CreateAtmosphere(rMessage.ID, rMessage.WorldMatrix, earthPlanetRadius, earthAtmosphereRadius, 
                            rayleighScattering, rayleighHeightScale, mieScattering, mieHeightScale,
                            planetScaleFactor, atmosphereScaleFactor);
                    }
                    break;
                }

                case MyRenderMessageEnum.RemoveDecal:
                {
                    var rMessage = (MyRenderMessageRemoveDecal)message;

                    MyScreenDecals.RemoveDecal(rMessage.ID);
                    break;
                }

                case MyRenderMessageEnum.SetDecalGlobals:
                {
                    var rMessage = (MyRenderMessageSetDecalGlobals)message;

                    MyScreenDecals.SetDecalGlobals(rMessage.Globals);

                    break;
                }

                case MyRenderMessageEnum.RegisterDecalsMaterials:
                {
                    var rMessage = (MyRenderMessageRegisterScreenDecalsMaterials)message;

                    MyScreenDecals.RegisterMaterials(rMessage.MaterialDescriptions);


                    break;
                }

                case MyRenderMessageEnum.ClearDecals:
                {
                    var rMessage = (MyRenderMessageClearScreenDecals)message;
                    MyScreenDecals.ClearDecals();
                    break;
                }

                case MyRenderMessageEnum.UpdateRenderObject:
                { 
                    var rMessage = (MyRenderMessageUpdateRenderObject)message;

                    MyRenderProxy.Assert(rMessage.ID != MyRenderProxy.RENDER_ID_UNASSIGNED);

                    MyRenderProxy.ObjectType objectType;
                    if (MyRenderProxy.ObjectTypes.TryGetValue(rMessage.ID, out objectType))
                    {
                        switch (objectType)
                        {
                            case MyRenderProxy.ObjectType.Entity:
                                var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                                if (actor != null)
                                {
                                    if (rMessage.LastMomentUpdateIndex != -1 && MyOpenVR.LmuDebugOnOff)
                                        MyOpenVR.LMUMatrixUpdate(ref rMessage.WorldMatrix, rMessage.LastMomentUpdateIndex);

                                    actor.SetMatrix(ref rMessage.WorldMatrix);
                                    if (rMessage.AABB.HasValue)
                                    {
                                        actor.SetAabb(rMessage.AABB.Value);
                                    }
                                }
                                break;
                            case MyRenderProxy.ObjectType.Clipmap:
                                if (MyClipmapFactory.ClipmapByID.ContainsKey(rMessage.ID))
                                {
                                    MyClipmapFactory.ClipmapByID[rMessage.ID].UpdateWorldMatrix(ref rMessage.WorldMatrix);
                                }
                                break;
                            default:
                                MyRenderProxy.Assert(false);
                                break;
                        }
                    }
                    else MyRenderProxy.Assert(false);
                    break;
                }

                case MyRenderMessageEnum.RemoveRenderObject:
                {
                    var rMessage = (MyRenderMessageRemoveRenderObject)message;

                    MyRenderProxy.Assert(rMessage.ID != MyRenderProxy.RENDER_ID_UNASSIGNED);

                    MyRenderProxy.ObjectType objectType;
                    if (MyRenderProxy.ObjectTypes.TryGetValue(rMessage.ID, out objectType))
                    {
                        switch (objectType)
                        {
                            case MyRenderProxy.ObjectType.Entity:
                                var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                                if (actor != null)
                                {
                                    if (actor.GetRenderable() != null && actor.GetRenderable().GetModel().Info.Dynamic)
                                    {
                                        MyMeshes.RemoveMesh(actor.GetRenderable().GetModel());
                                    }

                                    actor.Destruct();
                                    MyScreenDecals.RemoveEntityDecals(rMessage.ID);
                                }
                                else MyRenderProxy.Assert(false);
                                break;
                            case MyRenderProxy.ObjectType.InstanceBuffer:
                                MyInstancing.Remove(rMessage.ID);
                                break;
                            case MyRenderProxy.ObjectType.Light:
                                MyLights.Remove(rMessage.ID);
                                break;
                            case MyRenderProxy.ObjectType.Clipmap:
                                MyClipmapFactory.Remove(rMessage.ID);
                                break;

                            case MyRenderProxy.ObjectType.GPUEmitter:
                                MyGPUEmitters.Remove(rMessage.ID);
                                break;
                            case MyRenderProxy.ObjectType.Atmosphere:
                                MyAtmosphereRenderer.RemoveAtmosphere(rMessage.ID);
                                break;
                            case MyRenderProxy.ObjectType.Cloud:
                                MyCloudRenderer.RemoveCloud(rMessage.ID);
                                break;

                            case MyRenderProxy.ObjectType.DebugDrawMesh:
                                MyPrimitivesRenderer.RemoveDebugMesh(rMessage.ID);
                                break;

                            case MyRenderProxy.ObjectType.Video:
                                MyVideoFactory.Remove(rMessage.ID);
                                break;

                            default:
                                MyRenderProxy.Assert(false);
                                break;
                        }
                        MyRenderProxy.RemoveMessageId(rMessage.ID, objectType);
                    }
                    else MyRenderProxy.Assert(false);
                    break;
                }

                case MyRenderMessageEnum.UpdateRenderObjectVisibility:
                {
                    var rMessage = (MyRenderMessageUpdateRenderObjectVisibility)message;

                    MyRenderProxy.Assert(rMessage.ID != MyRenderProxy.RENDER_ID_UNASSIGNED);

                    MyRenderProxy.ObjectType objectType;
                    if (MyRenderProxy.ObjectTypes.TryGetValue(rMessage.ID, out objectType))
                    {
                        switch (objectType)
                        {
                            case MyRenderProxy.ObjectType.Entity:
                                var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                                if (actor != null)
                                {
                                    actor.SetVisibility(rMessage.Visible);
                                }
                                break;
                        }
                    }
                    else MyRenderProxy.Assert(false);
                    break;
                }


                case MyRenderMessageEnum.CreateRenderInstanceBuffer:
                {
                    var rMessage = (MyRenderMessageCreateRenderInstanceBuffer)message;

                    //var instancing = MyComponentFactory<MyInstancingComponent>.Create();
                    //instancing.SetID(rMessage.ID);
                    //instancing.Init(rMessage.Type);
                    //instancing.SetDebugName(rMessage.DebugName);

                    MyInstancing.Create(rMessage.ID, rMessage.ParentID, rMessage.Type, rMessage.DebugName);

                    break;
                }

                case MyRenderMessageEnum.UpdateRenderInstanceBufferSettings:
                {
                    var rMessage = (MyRenderMessageUpdateRenderInstanceBufferSettings)message;

                    //var instancing = MyIDTracker<MyInstancingComponent>.FindByID(rMessage.ID);
                    //if(instancing != null)
                    //{
                    //    instancing.UpdateGeneric(rMessage.InstanceData, rMessage.Capacity);
                    //}

                    var handle = MyInstancing.Get(rMessage.ID);

                    if (handle != InstancingId.NULL)
                    {
                        // TODO: Do something :P
                        MyInstancing.UpdateGenericSettings(handle, rMessage.SetPerInstanceLod);

                    }
                    else
                    {
                        // MyRenderProxy.Assert(handle != InstancingId.NULL, "No instance buffer with ID " + rMessage.ID);
                    }

                    break;
                }

                case MyRenderMessageEnum.UpdateRenderInstanceBufferRange:
                {
                    var rMessage = (MyRenderMessageUpdateRenderInstanceBufferRange)message;

                    //var instancing = MyIDTracker<MyInstancingComponent>.FindByID(rMessage.ID);
                    //if(instancing != null)
                    //{
                    //    instancing.UpdateGeneric(rMessage.InstanceData, rMessage.Capacity);
                    //}

                    // TODO: Turn this into partial update.
                    var handle = MyInstancing.Get(rMessage.ID);

                    if (handle != InstancingId.NULL)
                    {
                        MyInstancing.UpdateGeneric(handle, rMessage.InstanceData, rMessage.InstanceData.Length);
                    }
                    else
                    {
                        // Debug.Assert(handle != InstancingId.NULL, "No instance buffer with ID " + rMessage.ID);
                    }

                    break;
                }

                case MyRenderMessageEnum.UpdateRenderCubeInstanceBuffer:
                {
                    var rMessage = (MyRenderMessageUpdateRenderCubeInstanceBuffer)message;

                    //var instancing = MyIDTracker<MyInstancingComponent>.FindByID(rMessage.ID);
                    //if (instancing != null)
                    //{
                    //    instancing.UpdateCube(rMessage.InstanceData, rMessage.Capacity);
                    //}

                    var handle = MyInstancing.Get(rMessage.ID);

                    if (handle != InstancingId.NULL)
                    {
                        MyInstancing.UpdateCube(MyInstancing.Get(rMessage.ID), rMessage.InstanceData, rMessage.DecalsData, rMessage.Capacity);
                    }
                    else
                        Debug.Fail("No instance buffer with ID " + rMessage.ID);

                    break;
                }

                case MyRenderMessageEnum.SetInstanceBuffer:
                {
                    var rMessage = (MyRenderMessageSetInstanceBuffer)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    //var instancing = MyIDTracker<MyInstancingComponent>.FindByID(rMessage.InstanceBufferId);

                    if (actor != null)
                    {
                        //if (actor.GetComponent(MyActorComponentEnum.Instancing) != instancing)
                        //{
                        //    actor.AddComponent(instancing);
                        //}
                        //actor.SetLocalAabb(rMessage.LocalAabb);
                        //actor.GetRenderable().SetInstancingCounters(rMessage.InstanceCount, rMessage.InstanceStart);

                        actor.GetRenderable().SetInstancing(MyInstancing.Get(rMessage.InstanceBufferId));
                        actor.SetLocalAabb(rMessage.LocalAabb);
                        actor.GetRenderable().SetInstancingCounters(rMessage.InstanceCount, rMessage.InstanceStart);
                    }

                    break;
                }

                   
                case MyRenderMessageEnum.CreateManualCullObject:
                {
                    var rMessage = (MyRenderMessageCreateManualCullObject)message;

                    var actor = MyActorFactory.CreateGroup();
                    actor.SetID(rMessage.ID);
                    Matrix m = (Matrix)rMessage.WorldMatrix;
                    actor.SetMatrix(ref rMessage.WorldMatrix);

                    break;
                }

                case MyRenderMessageEnum.SetParentCullObject:
                {
                    var rMessage = (MyRenderMessageSetParentCullObject)message;

                    var child = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    var parent = MyIDTracker<MyActor>.FindByID(rMessage.CullObjectID);
                    if (child != null && parent != null && parent.GetGroupRoot() != null && child.GetGroupLeaf() == null)
                    {
                        child.SetRelativeTransform(rMessage.ChildToParent);
                        parent.GetGroupRoot().Add(child);
                    }

                    break;
                }

                case MyRenderMessageEnum.CreateLineBasedObject:
                {
                    var rMessage = (MyRenderMessageCreateLineBasedObject)message;

                    var actor = MyActorFactory.CreateSceneObject();
                    //actor.GetRenderable().SetModel(new MyDynamicMesh());

                    actor.SetID(rMessage.ID);
                    actor.SetMatrix(ref MatrixD.Identity);

                    MyMeshMaterials1.GetMaterialId("__ROPE_MATERIAL", null, rMessage.ColorMetalTexture, rMessage.NormalGlossTexture, rMessage.ExtensionTexture, MyMesh.DEFAULT_MESH_TECHNIQUE);
                    actor.GetRenderable().SetModel(MyMeshes.CreateRuntimeMesh(X.TEXT_("LINE" + rMessage.ID), 1, true));

                    break;
                }

                case MyRenderMessageEnum.UpdateLineBasedObject:
                {
                    var rMessage = (MyRenderMessageUpdateLineBasedObject)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    if (actor != null)
                    {
                        //var mesh = actor.GetRenderable().GetMesh() as MyDynamicMesh;

                        MyVertexFormatPositionH4 [] stream0;
                        MyVertexFormatTexcoordNormalTangentTexindices[] stream1;

                        MyLineHelpers.GenerateVertexData(ref rMessage.WorldPointA, ref rMessage.WorldPointB, 
                            out stream0, out stream1);

                        var indices = MyLineHelpers.GenerateIndices(stream0.Length);
                        var sections = new MyRuntimeSectionInfo[] 
                        { 
                            new MyRuntimeSectionInfo { TriCount = indices.Length / 3, IndexStart = 0, MaterialName = "__ROPE_MATERIAL" } 
                        };

                        MyMeshes.UpdateRuntimeMesh(MyMeshes.GetMeshId(X.TEXT_("LINE" + rMessage.ID), 1.0f), 
                            indices, 
                            stream0, 
                            stream1, 
                            sections,
                            (BoundingBox)MyLineHelpers.GetBoundingBox(ref rMessage.WorldPointA, ref rMessage.WorldPointB));

                        //actor.SetAabb((BoundingBox)MyLineHelpers.GetBoundingBox(ref rMessage.WorldPointA, ref rMessage.WorldPointB));
                        actor.MarkRenderDirty();

                        var matrix = MatrixD.CreateTranslation((Vector3)(rMessage.WorldPointA + rMessage.WorldPointB) * 0.5f);
                        actor.SetMatrix(ref matrix);
                    }

                    break;
                }

                case MyRenderMessageEnum.SetRenderEntityData:
                {
                    var rMessage = (MyRenderMessageSetRenderEntityData)message;

                    MyRenderProxy.Assert(false, "MyRenderMessageSetRenderEntityData is deprecated!");

                    break;
                }

                case MyRenderMessageEnum.AddRuntimeModel:
                {
                    var rMessage = (MyRenderMessageAddRuntimeModel)message;

                    //MyDestructionMesh mesh = MyDestructionMesh.ModelsDictionary.Get(rMessage.Name);
                    //if (mesh == null)
                    //{
                        //mesh = new MyDestructionMesh(rMessage.Name);

                        //ProfilerShort.Begin("LoadBuffers");
                        //mesh.Fill(rMessage.ModelData.Indices, rMessage.ModelData.Positions, rMessage.ModelData.Normals, rMessage.ModelData.Tangents, rMessage.ModelData.TexCoords, rMessage.ModelData.Sections, rMessage.ModelData.AABB);
                        //ProfilerShort.End();

                    MyRenderProxy.Assert(!MyMeshes.Exists(rMessage.Name), "It is added already added mesh!");
                    MyRenderProxy.Assert(!MyRenderProxy.Settings.UseGeometryArrayTextures, "Geometry array textures do not fully support runtimer models, please add support");
                    if(!MyMeshes.Exists(rMessage.Name))
                    {
                        {
                            ushort[] indices = new ushort[rMessage.ModelData.Indices.Count];
                            for (int i = 0; i < rMessage.ModelData.Indices.Count; i++)
                            {
                                indices[i] = (ushort)rMessage.ModelData.Indices[i];
                            }
                            var verticesNum = rMessage.ModelData.Positions.Count;
                            MyVertexFormatPositionH4[] stream0 = new MyVertexFormatPositionH4[verticesNum];
                            MyVertexFormatTexcoordNormalTangentTexindices[] stream1 = new MyVertexFormatTexcoordNormalTangentTexindices[verticesNum];

                            Vector4I[] arrayTexIndices = MyManagers.GeometryTextureSystem.CreateTextureIndices(rMessage.ModelData.Sections, rMessage.ModelData.Indices, rMessage.ModelData.Positions.Count);
                            for (int i = 0; i < verticesNum; i++)
                            {
                                stream0[i] = new MyVertexFormatPositionH4(rMessage.ModelData.Positions[i]);
                                stream1[i] = new MyVertexFormatTexcoordNormalTangentTexindices(
                                    rMessage.ModelData.TexCoords[i], rMessage.ModelData.Normals[i], rMessage.ModelData.Tangents[i], (Byte4) arrayTexIndices[i]);
                            }
                            var id = MyMeshes.CreateRuntimeMesh(X.TEXT_(rMessage.Name), rMessage.ModelData.Sections.Count, false);
                            MyMeshes.UpdateRuntimeMesh(id, indices, stream0, stream1, rMessage.ModelData.Sections.ToArray(), rMessage.ModelData.AABB);
                        }

                        if (rMessage.ReplacedModel != null)
                        {
                            //MyAssetsLoader.ModelRemap[rMessage.ReplacedModel] = rMessage.Name;
                            MyAssetsLoader.ModelRemap[rMessage.Name] = rMessage.ReplacedModel;
                        }

                        //if (MyAssetsLoader.LOG_MESH_STATISTICS)
                        //{
                        //    mesh.DebugWriteInfo();
                        //}
                    }
                    
                    break;
                }

                case MyRenderMessageEnum.UpdateModelProperties:
                {
                    var rMessage = (MyRenderMessageUpdateModelProperties)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    if (actor != null)
                    {
                        // careful, lod is ignored after all (properties apply to all lods)
                        var key = new MyEntityMaterialKey { LOD = rMessage.LOD, Material = X.TEXT_(rMessage.MaterialName) };

                        if(rMessage.Enabled.HasValue)
                        {
                            if (!MyScene.EntityDisabledMaterials.ContainsKey(rMessage.ID))
                            {
                                MyScene.EntityDisabledMaterials.Add(rMessage.ID, new HashSet<MyEntityMaterialKey>());
                            }

                            if (!rMessage.Enabled.Value)
                            {
                                MyScene.EntityDisabledMaterials[rMessage.ID].Add(key);
                            }
                            else
                            {
                                MyScene.EntityDisabledMaterials[rMessage.ID].Remove(key);
                            }
                        }

                        var renderableComponent = actor.GetRenderable();

                        if ((rMessage.Emissivity.HasValue || rMessage.DiffuseColor.HasValue) && !renderableComponent.ModelProperties.ContainsKey(key))
                        {
                            renderableComponent.ModelProperties[key] = new MyModelProperties();
                        }

                        if(rMessage.Emissivity.HasValue)
                        {
                            renderableComponent.ModelProperties[key].Emissivity = rMessage.Emissivity.Value;
                        }

                        if(rMessage.DiffuseColor.HasValue)
                        {
                            renderableComponent.ModelProperties[key].ColorMul = rMessage.DiffuseColor.Value;
                        }

                        actor.MarkRenderDirty();

                        MyHighlight.HandleHighlight(rMessage.ID, rMessage.MeshIndex, rMessage.OutlineColor, rMessage.OutlineThickness, rMessage.PulseTimeInFrames);
                    }

                    break;
                }

                case MyRenderMessageEnum.UpdateModelHighlight:
                {
                    var rMessage = (MyRenderMessageUpdateModelHighlight)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    if (actor != null)
                    {
                        MyHighlight.HandleHighlight(rMessage.ID, rMessage.SectionIndices, rMessage.OutlineColor, rMessage.Thickness, rMessage.PulseTimeInFrames, rMessage.InstanceIndex);
                        if (rMessage.SubpartIndices != null)
                            foreach (uint index in rMessage.SubpartIndices)
                                if (index != -1)
                                {
                                    MyHighlight.HandleHighlight(index, null, rMessage.OutlineColor, rMessage.Thickness,
                                        rMessage.PulseTimeInFrames, -1);
                                }
                    }

                    break;
                }

                case MyRenderMessageEnum.UpdateColorEmissivity:
                {
                    var rMessage = (MyRenderMessageUpdateColorEmissivity)message;
                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    if (actor != null)
                    {
                        actor.GetRenderable().UpdateColorEmissivity(rMessage.LOD, rMessage.MaterialName, rMessage.DiffuseColor, rMessage.Emissivity);
                    }

                    break;
                }

                case MyRenderMessageEnum.PreloadModel:
                {
                    var rMessage = (MyRenderMessagePreloadModel) message;

                    //MyAssetsLoader.GetModel(rMessage.Name);
                    MyMeshes.GetMeshId(X.TEXT_(rMessage.Name), rMessage.Rescale);

                    break;
                }

                case MyRenderMessageEnum.ChangeMaterialTexture:
                {
                    var rMessage = (MyRenderMessageChangeMaterialTexture)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.RenderObjectID);
                    if (actor != null)
                    {
                        var r = actor.GetRenderable();
                        var key = new MyEntityMaterialKey { LOD = 0, Material = X.TEXT_(rMessage.MaterialName) };

                        MyModelProperties properties;
                        if (!r.ModelProperties.TryGetValue(key, out properties))
                        {
                            properties = new MyModelProperties();
                            r.ModelProperties[key] = properties;
                        }

                        properties.AddTextureChanges(rMessage.Changes);

                        actor.MarkRenderDirty();
                    }

                    rMessage.Changes.Clear();
                   
                    break;
                }

                case MyRenderMessageEnum.RenderOffscreenTextureToMaterial:
                {
                    var rMessage = (MyRenderMessageRenderOffscreenTextureToMaterial)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.RenderObjectID);
                    if (actor != null)
                    {
                        var manager = MyManagers.FileTextures;
                        IUserGeneratedTexture handle;
                        if (!manager.TryGetTexture(rMessage.OffscreenTexture, out handle))
                        {
                            var material = MyMeshMaterials1.GetMaterialId(rMessage.MaterialName).Info;

                            ITexture materialTexture;
                            switch (rMessage.TextureType)
                        {
                                case MyTextureType.ColorMetal:
                                    materialTexture = manager.GetTexture(material.ColorMetal_Texture, MyFileTextureEnum.COLOR_METAL, true);
                                    break;
                                case MyTextureType.NormalGloss:
                                    materialTexture = manager.GetTexture(material.NormalGloss_Texture, MyFileTextureEnum.NORMALMAP_GLOSS, true);
                                    break;
                                case MyTextureType.Extensions:
                                    materialTexture = manager.GetTexture(material.Extensions_Texture, MyFileTextureEnum.EXTENSIONS, true);
                                    break;
                                case MyTextureType.Alphamask:
                                    materialTexture = manager.GetTexture(material.Alphamask_Texture, MyFileTextureEnum.ALPHAMASK, true);
                                    break;
                                default:
                                    throw new Exception();
                        }

                            handle = manager.CreateGeneratedTexture(rMessage.OffscreenTexture, materialTexture.Size.X, materialTexture.Size.Y, rMessage.TextureType, 1);
                        }

                        handle.Reset();

                        SharpDX.Color? backgroundColor = null;
                        if (rMessage.BackgroundColor != null)
                            backgroundColor = new SharpDX.Color(rMessage.BackgroundColor.Value.PackedValue);

                        var texture = MyRender11.DrawSpritesOffscreen(rMessage.OffscreenTexture,
                            handle.Size.X, handle.Size.Y, handle.Format, backgroundColor);

                        var texture2 = MyManagers.RwTexturesPool.BorrowRtv("RenderOffscreenTextureBlend",
                            handle.Size.X, handle.Size.Y, handle.Format);

                        IBlendState blendState = rMessage.BlendAlphaChannel ? MyBlendStateManager.BlendAlphaPremult : MyBlendStateManager.BlendAlphaPremultNoAlphaChannel;

                        MyBlendTargets.RunWithStencil(texture2, texture, blendState);
                        texture.Release();
                        texture = texture2;

                        MyImmediateRC.RC.CopyResource(texture, handle);
                        texture.Release();

                        var renderableComponent = actor.GetRenderable();
                        var key = new MyEntityMaterialKey { LOD = 0, Material = X.TEXT_(rMessage.MaterialName) };

                        MyModelProperties modelProperty;
                        if (!renderableComponent.ModelProperties.TryGetValue(key, out modelProperty))
                            renderableComponent.ModelProperties[key] = new MyModelProperties();

                        modelProperty.AddTextureChange(new MyTextureChange() { TextureName = rMessage.OffscreenTexture, TextureType = rMessage.TextureType });

                            actor.MarkRenderDirty();
                        }
                        else
                        {
                        Debug.Assert(false, "Actor not found");
                        }

                    break;
                }

                case MyRenderMessageEnum.PreloadMaterials:
                {
                    var rMessage = (MyRenderMessagePreloadMaterials)message;

                    //MyAssetsLoader.GetMaterials(rMessage.Name);
                    MyMeshes.GetMeshId(X.TEXT_(rMessage.Name), 1.0f);

                    break;
                }

                #endregion

                #region Voxels

                case MyRenderMessageEnum.CreateClipmap:
                {
                    var rMessage = (MyRenderMessageCreateClipmap)message;

                    var clipmap = new MyClipmapHandler(rMessage.ClipmapId, rMessage.ScaleGroup, rMessage.WorldMatrix, rMessage.SizeLod0, rMessage.Position, rMessage.PlanetRadius, rMessage.SpherizeWithDistance, rMessage.AdditionalRenderFlags, rMessage.PrunningFunc);
                    MyClipmapFactory.ClipmapByID[rMessage.ClipmapId] = clipmap;
                    clipmap.Base.LoadContent();

                    break;
                }

                case MyRenderMessageEnum.UpdateClipmapCell:
                {
                    var rMessage = (MyRenderMessageUpdateClipmapCell)message;

                    var clipmap = MyClipmapFactory.ClipmapByID.Get(rMessage.ClipmapId);

                    MyRenderProxy.Assert(clipmap != null);

                    if (clipmap != null)
                    {
                        clipmap.Base.UpdateCell(rMessage);
                    }
                    break;
                }

                case MyRenderMessageEnum.UpdateMergedVoxelMesh:
                {
                    var rMessage = (MyRenderMessageUpdateMergedVoxelMesh)message;

                    MyClipmapHandler clipmap = MyClipmapFactory.ClipmapByID.Get(rMessage.ClipmapId);
                        if (clipmap != null)
                            clipmap.UpdateMergedMesh(rMessage);
                        break;
                    }

                case MyRenderMessageEnum.ResetMergedVoxels:
                    {
                        var rMessage = (MyRenderMessageResetMergedVoxels)message;

                        foreach(var clipmapHandler in MyClipmapFactory.ClipmapByID.Values)
                        {
                            if (clipmapHandler != null)
                                clipmapHandler.ResetMergedMeshes();
                        }
                        break;
                    }

                case MyRenderMessageEnum.InvalidateClipmapRange:
                {
                    var rMessage = (MyRenderMessageInvalidateClipmapRange)message;

                    var clipmap = MyClipmapFactory.ClipmapByID.Get(rMessage.ClipmapId);
                    if (clipmap != null)
                    {
                        clipmap.Base.InvalidateRange(rMessage.MinCellLod0, rMessage.MaxCellLod0);
                    }

                    break;
                }

                case MyRenderMessageEnum.CreateRenderVoxelMaterials:
                {
                    var rMessage = (MyRenderMessageCreateRenderVoxelMaterials)message;

                    MyRenderProxy.Assert(MyVoxelMaterials1.CheckIndices(rMessage.Materials));
                    MyVoxelMaterials1.Set(rMessage.Materials);

                    rMessage.Materials = null;

                    break;
                }


                case MyRenderMessageEnum.UpdateRenderVoxelMaterials:
                {
                    var rMessage = (MyRenderMessageUpdateRenderVoxelMaterials)message;

                    MyVoxelMaterials1.Set(rMessage.Materials, true);

                    rMessage.Materials = null;

                    break;
                }

                #endregion

                #region Lights

                case MyRenderMessageEnum.CreateRenderLight:
                {
                    var rMessage = (MyRenderMessageCreateRenderLight)message;

                    MyLights.Create(rMessage.ID);
                    break;
                }

                case MyRenderMessageEnum.UpdateRenderLight:
                {
                    var rMessage = (MyRenderMessageUpdateRenderLight)message;

                    var light = MyLights.Get(rMessage.Data.ID);

                    if(light != LightId.NULL)
                    {
                        var lightInfo = new MyLightInfo
                        {
                            FlareId = FlareId.NULL,
                            SpotPosition = rMessage.Data.Position,
                            PointPosition = rMessage.Data.Position + rMessage.Data.PointPositionOffset * rMessage.Data.PointLight.Range * rMessage.Data.SpotLight.Direction,
                            CastsShadows = rMessage.Data.CastShadows,
                            ShadowsDistance = rMessage.Data.ShadowDistance,
                            ParentGID = rMessage.Data.ParentID,
                            UsedInForward = rMessage.Data.UseInForwardRender
                        };

                        MyLights.UpdateEntity(light, ref lightInfo);

                        if (rMessage.Data.Type.HasFlag(LightTypeEnum.PointLight))
                        {
                            MyLights.UpdatePointlight(light, rMessage.Data.PointLightOn,
                                rMessage.Data.PointLightIntensity, rMessage.Data.PointLight);
                        }

                        if (rMessage.Data.Type.HasFlag(LightTypeEnum.Spotlight))
                        {
                            MyLights.UpdateSpotlight(light, rMessage.Data.SpotLightOn, rMessage.Data.SpotLightIntensity, rMessage.Data.ReflectorConeMaxAngleCos,
                                rMessage.Data.SpotLight, MyManagers.FileTextures.GetTexture(rMessage.Data.ReflectorTexture, MyFileTextureEnum.CUSTOM));
                        }

                        light.FlareId = MyFlareRenderer.Update(rMessage.Data.ParentID, light.FlareId, rMessage.Data.Glare);
                    }

                    break;
                }

                case MyRenderMessageEnum.SetLightShadowIgnore:
                {
                    var rMessage = (MyRenderMessageSetLightShadowIgnore)message;

                    var light = MyLights.Get(rMessage.ID);
                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID2);

                    if(light != LightId.NULL && actor != null)
                    {
                        if(!MyLights.IgnoredEntitites.ContainsKey(light))
                        {
                            MyLights.IgnoredEntitites[light] = new HashSet<uint>();
                        }
                        MyLights.IgnoredEntitites[light].Add(rMessage.ID2);
                    }

                    break;
                }


                case MyRenderMessageEnum.ClearLightShadowIgnore:
                {
                    var rMessage = (MyRenderMessageClearLightShadowIgnore)message;

                    var light = MyLights.Get(rMessage.ID);
                    if(light != LightId.NULL)
                    {
                        MyLights.IgnoredEntitites.Remove(light);
                    }

                    break;
                }

                case MyRenderMessageEnum.UpdateShadowSettings:
                {
                    var rMessage = (MyRenderMessageUpdateShadowSettings)message;
                    MyShadowCascades.Settings.CopyFrom(rMessage.Settings);
                    MyManagers.Shadow.SetSettings(rMessage.Settings);
                    break;
                }

                case MyRenderMessageEnum.UpdateMaterialsSettings:
                {
                    var rMessage = (MyRenderMessageUpdateMaterialsSettings)message;
                    MyManagers.GeometryTextureSystem.SetMaterialsSettings(rMessage.Settings);
                    break;
                }

                case MyRenderMessageEnum.UpdateFogSettings:
                {
                    var rMessage = (MyRenderMessageUpdateFogSettings)message;

                    if (m_debugOverrides.Fog)
                        MyRender11.Environment.Fog = rMessage.Settings;
                    else MyRender11.Environment.Fog.FogDensity = 0;

                    break;
                }


                case MyRenderMessageEnum.UpdateAtmosphereSettings:
                {
                    var rMessage = (MyRenderMessageUpdateAtmosphereSettings)message;

                    MyAtmosphereRenderer.UpdateSettings(rMessage.ID, rMessage.Settings);

                    break;
                }

                case MyRenderMessageEnum.EnableAtmosphere:
                {
                    var rMessage = (MyRenderMessageEnableAtmosphere)message;
                    MyAtmosphereRenderer.Enabled = rMessage.Enabled;
                    break;
                }

				case MyRenderMessageEnum.UpdateCloudLayerFogFlag:
				{
					var rMessage = (MyRenderMessageUpdateCloudLayerFogFlag)message;
					MyCloudRenderer.DrawFog = rMessage.ShouldDrawFog;
					break;
				}

                case MyRenderMessageEnum.UpdateRenderEnvironment:
                {
                    var rMessage = (MyRenderMessageUpdateRenderEnvironment)message;
                    MyRender11.Environment.Data = rMessage.Data;
                    m_resetEyeAdaptation |= rMessage.ResetEyeAdaptation;

                    /*MyRender11.Environment.DirectionalLightDir = VRageMath.Vector3.Normalize(rMessage.SunDirection);
                    if (rMessage.SunLightOn && m_debugOverrides.Sun)
                        MyRender11.Environment.DirectionalLightIntensity = rMessage.SunColor;
                    else MyRender11.Environment.DirectionalLightIntensity = new Vector3(0, 0, 0);

                    for (int lightIndex = 0; lightIndex < MyRender11.Environment.AdditionalSunIntensities.Length; ++lightIndex)
                    {
                        MyRender11.Environment.AdditionalSunIntensities[lightIndex] = rMessage.AdditionalSunIntensities[lightIndex];
                        MyRender11.Environment.AdditionalSunColors[lightIndex] = rMessage.AdditionalSunColors[lightIndex];
                        MyRender11.Environment.AdditionalSunDirections[lightIndex] = rMessage.AdditionalSunDirections[lightIndex];
                    }

                    MyRender11.Environment.DayTime = (float)(rMessage.DayTime - Math.Truncate(rMessage.DayTime));
                    MyRender11.Environment.SunDistance = rMessage.DistanceToSun;
                    MyRender11.Environment.SunColor = rMessage.SunColor;
                    MyRender11.Environment.SunMaterial = rMessage.SunMaterial;
                    MyRender11.Environment.SunSizeMultiplier = rMessage.SunSizeMultiplier;
                    MyRender11.Environment.SunBillboardEnabled = rMessage.SunBillboardEnabled;
                    MyRender11.Environment.PlanetFactor = rMessage.PlanetFactor;
                    MyRender11.Environment.Skybox = rMessage.DayBackgroundTexture;
                    MyRender11.Environment.NightSkybox = rMessage.NightBackgroundTexture;
                    MyRender11.Environment.NightSkyboxPrefiltered = rMessage.NightBackgroundPrefilteredTexture;
                    MyRender11.Environment.BackgroundOrientation = rMessage.BackgroundOrientation;
                    MyRender11.Environment.BackgroundColor = rMessage.BackgroundColor;

                    m_resetEyeAdaptation |= rMessage.ResetEyeAdaptation;*/

                    break;
                }

                case MyRenderMessageEnum.UpdateEnvironmentMap:
                {   
                    break;
                }

                case MyRenderMessageEnum.UpdateDebugOverrides:
                {
                    var rMessage = (MyRenderMessageUpdateDebugOverrides)message;

                    bool oldFXAA = FxaaEnabled;
                    m_debugOverrides = rMessage.Overrides;
                    bool newFXAA = FxaaEnabled;

                    if (oldFXAA != newFXAA)
                        UpdateAntialiasingMode(m_renderSettings.AntialiasingMode, m_renderSettings.AntialiasingMode);
                    break;
                }
                case MyRenderMessageEnum.UpdatePostprocessSettings:
                {
                    var rMessage = (MyRenderMessageUpdatePostprocessSettings)message;

                    Postprocess = rMessage.Settings;

                    if (Postprocess.EnableEyeAdaptation != rMessage.Settings.EnableEyeAdaptation)
                        m_resetEyeAdaptation = true;

                    break;
                }

                case MyRenderMessageEnum.UpdateSSAOSettings:
                {
                    var rMessage = (MyRenderMessageUpdateSSAOSettings)message;
                    MySSAO.Params = rMessage.Settings;
                    break;
                }

                case MyRenderMessageEnum.UpdateHBAO:
                {
                    var rMessage = (MyRenderMessageUpdateHBAO)message;
                    MyHBAO.Params = rMessage.Settings;
                    break;
                }

                #endregion

                #region Sprites

                case MyRenderMessageEnum.DrawSprite:
                case MyRenderMessageEnum.DrawSpriteNormalized:
                case MyRenderMessageEnum.DrawSpriteAtlas:
                case MyRenderMessageEnum.SpriteScissorPush:
                case MyRenderMessageEnum.SpriteScissorPop:
                case MyRenderMessageEnum.DrawString:
                {
                    m_drawQueue.Enqueue(message);
                    break;
                }

                #endregion

                #region Fonts and text

                case MyRenderMessageEnum.CreateFont:
                {
                    var createFontMessage = message as MyRenderMessageCreateFont;
                    MyRenderProxy.Assert(createFontMessage != null);

                    var renderFont = new MyRenderFont(createFontMessage.FontPath);
                    renderFont.LoadContent();
                    AddFont(createFontMessage.FontId, renderFont, createFontMessage.IsDebugFont);

                    break;
                }

                #endregion

                #region Textures
                // TODO: these messages need to be reviewed:
                case MyRenderMessageEnum.PreloadTextures:
                    {
                        var preloadMsg = message as MyRenderMessagePreloadTextures;

                        //MyFileTextureManager.Load(preloadMsg.Texture);
                        //MyTextureManager.PreloadTextures(preloadMsg.InDirectory, preloadMsg.Recursive);
                        //MyTextures.UnloadTexture(texMessage.Texture);

                        break;
                    }
                    
                case MyRenderMessageEnum.UnloadTexture:
                    {
                        var texMessage = (MyRenderMessageUnloadTexture)message;

                        MyFileTextureManager texManager = MyManagers.FileTextures;
                        texManager.DisposeTex(texMessage.Texture, true); // Ignore failures, the game can't know weather a texture is loaded.

                        break;
                    }

                case MyRenderMessageEnum.CreateGeneratedTexture:
                    {
                        var texMessage = (MyRenderMessageCreateGeneratedTexture)message;

                        MyFileTextureManager texManager = MyManagers.FileTextures;
                        texManager.CreateGeneratedTexture(texMessage.TextureName, texMessage.Width, texMessage.Height, texMessage.Type, texMessage.NumMipLevels);

                        break;
                    }

                case MyRenderMessageEnum.ResetGeneratedTexture:
                    {
                        var texMessage = (MyRenderMessageResetGeneratedTexture)message;

                        MyFileTextureManager texManager = MyManagers.FileTextures;
                        texManager.ResetGeneratedTexture(texMessage.TextureName, texMessage.Data);

                        break;
                    }

                case MyRenderMessageEnum.ReloadTextures:
                    {
                        var reloadMsg = (MyRenderMessageReloadTextures)message;

                        MyVoxelMaterials1.InvalidateMaterials();
                        MyMeshMaterials1.InvalidateMaterials();
                        MyManagers.FileTextures.DisposeTex(MyFileTextureManager.MyFileTextureHelper.IsAssetTextureFilter);
                        MyManagers.DynamicFileArrayTextures.ReloadAll();
                        MyGPUEmitters.ReloadTextures();
                        MyRender11.ReloadFonts();

                        break;
                    }

                case MyRenderMessageEnum.ReloadModels:
                    {
                        var reloadMsg = (MyRenderMessageReloadModels)message;

                        //MyMaterials.Clear();
                        MyAssetsLoader.ReloadMeshes();
                        MyRenderableComponent.MarkAllDirty();

                        break;
                    }
       
                #endregion

                case MyRenderMessageEnum.TakeScreenshot:
                {
                    var rMessage = (MyRenderMessageTakeScreenshot)message;

                    m_screenshot = new MyScreenshot(rMessage.PathToSave, rMessage.SizeMultiplier, rMessage.IgnoreSprites, rMessage.ShowNotification);

                    break;
                }

                case MyRenderMessageEnum.ReloadEffects:
                {
                    //MyShaderBundleFactory.ClearCache();
                    //MyShaderMaterial.ClearCache();
                    //MyShaderPass.ClearCache();

                    MyShaders.Recompile();
                    MyMaterialShaders.Recompile();

                    MyAtmosphereRenderer.RecomputeAtmospheres();

                    MyRenderableComponent.MarkAllDirty();

                    foreach (var f in MyComponentFactory<MyFoliageComponent>.GetAll())
                    {
                        f.Dispose();
                    }

                    break;
                }

                case MyRenderMessageEnum.ReloadGrass:
                {
                    MyRenderProxy.ReloadEffects();  // Need some delay
                    break;
                }

                case MyRenderMessageEnum.PlayVideo:
                {
                    var rMessage = (MyRenderMessagePlayVideo)message;

                    MyVideoFactory.Create(rMessage.ID, rMessage.VideoFile);
                    var video = MyVideoFactory.Videos.Get(rMessage.ID);
                    if (video != null)
                    {
                        video.Volume = rMessage.Volume;
                    }

                    break;
                }

                case MyRenderMessageEnum.CloseVideo:
                {
                    var rMessage = (MyRenderMessageCloseVideo)message;
                    MyVideoFactory.Remove(rMessage.ID);
                    MyRenderProxy.RemoveMessageId(rMessage.ID, MyRenderProxy.ObjectType.Video);
                    break;
                }

                case MyRenderMessageEnum.UpdateGameplayFrame:
                {
                    var rMessage = (MyRenderMessageUpdateGameplayFrame)message;

                    GameplayFrameCounter = rMessage.GameplayFrame;

                    break;
                }

                case MyRenderMessageEnum.DrawVideo:
                {
                    var rMessage = (MyRenderMessageDrawVideo)message;

                    var video = MyVideoFactory.Videos.Get(rMessage.ID);
                    if (video != null)
                    {
                        video.Draw(rMessage.Rectangle, rMessage.Color, rMessage.FitMode);
                    }

                    break;
                }

                case MyRenderMessageEnum.UpdateVideo:
                {
                    var rMessage = (MyRenderMessageUpdateVideo)message;

                    var video = MyVideoFactory.Videos.Get(rMessage.ID);
                    if(video != null)
                    {
                        video.Update();
                    }

                    break;
                }

                case MyRenderMessageEnum.SetVideoVolume:
                {
                    var rMessage = (MyRenderMessageSetVideoVolume)message;

                    var video = MyVideoFactory.Videos.Get(rMessage.ID);
                    if (video != null)
                    {
                        video.Volume = rMessage.Volume;
                    }

                    break;
                }

                case MyRenderMessageEnum.VideoAdaptersRequest:
                {
                    MyRenderProxy.SendVideoAdapters(GetAdaptersList());
                    break;
                }

                case MyRenderMessageEnum.SwitchDeviceSettings:
                {
                    MyRenderProxy.RenderThread.SwitchSettings((message as MyRenderMessageSwitchDeviceSettings).Settings);
                    break;
                }

                case MyRenderMessageEnum.SwitchRenderSettings:
                {
                    var rMessage = (MyRenderMessageSwitchRenderSettings)message;
                    if (rMessage.Settings.HasValue)
                        UpdateRenderSettings(rMessage.Settings.Value);

                    if (rMessage.SettingsOld.HasValue)
                        MyRender11.Settings = rMessage.SettingsOld.Value;

                    break;
                }

                case MyRenderMessageEnum.SetMouseCapture:
                {
                    var umc = message as MyRenderMessageSetMouseCapture;

                    MyRenderProxy.RenderThread.SetMouseCapture(umc.Capture);
                    break;
                }

                case MyRenderMessageEnum.UnloadData:
                {
                    MyRender11.UnloadData();

                    // FIXME: Move this to MyRenderProxy.UnloadData() when decals (and maybe other subsystems)
                    // moved lifetime of render object ids entirely to render thread
                    MyRenderProxy.CheckRenderObjectIds();
                    break;
                }

                case MyRenderMessageEnum.CollectGarbage:
                {
                    GC.Collect();
                    break;
                }

                case MyRenderMessageEnum.SetFrameTimeStep:
                {
                    var rMessage = message as MyRenderMessageSetFrameTimeStep;
                    MyCommon.SetFrameTimeStep(rMessage.TimeStep);
                    break;
                }

                case MyRenderMessageEnum.ResetRandomness:
                {
                    var rMessage = message as MyRenderMessageResetRandomness;
                    MyCommon.SetRandomSeed(rMessage.Seed);
                    break;
                }

                case MyRenderMessageEnum.RenderColoredTexture:
                {
                    var rMessage = (MyRenderMessageRenderColoredTexture)message;
                    m_texturesToRender.AddRange(rMessage.texturesToRender);
                    break;
                }

                case MyRenderMessageEnum.CreateGPUEmitter:
                {
                    var rMessage = (MyRenderMessageCreateGPUEmitter)message;

                    //MyLight.Create(rMessage.ID);

                    MyGPUEmitters.Create(rMessage.ID);

                    break;
                }
                case MyRenderMessageEnum.UpdateGPUEmitters:
                {
                    var rMessage = (MyRenderMessageUpdateGPUEmitters)message;
                    MyGPUEmitters.UpdateData(rMessage.Emitters);
                    break;
                }
                case MyRenderMessageEnum.UpdateGPUEmittersTransform:
                {
                    var rMessage = (MyRenderMessageUpdateGPUEmittersTransform)message;
                    MyGPUEmitters.UpdateTransforms(rMessage.Emitters);
                    break;
                }
                case MyRenderMessageEnum.UpdateGPUEmittersLight:
                {
                    var rMessage = (MyRenderMessageUpdateGPUEmittersLight)message;
                    MyGPUEmitters.UpdateLight(rMessage.Emitters);
                    break;
                }
                case MyRenderMessageEnum.RemoveGPUEmitter:
                {
                    var rMessage = (MyRenderMessageRemoveGPUEmitter)message;
                    MyGPUEmitters.Remove(rMessage.GID, rMessage.Instant, false);
                    MyRenderProxy.RemoveMessageId(rMessage.GID, MyRenderProxy.ObjectType.GPUEmitter);
                    break;
                }

                #region Debug

                case MyRenderMessageEnum.DebugDrawPoint:
                case MyRenderMessageEnum.DebugDrawLine3D:
                case MyRenderMessageEnum.DebugDrawLine2D:
                case MyRenderMessageEnum.DebugDrawSphere:
                case MyRenderMessageEnum.DebugDrawAABB:
                case MyRenderMessageEnum.DebugDrawAxis:
                case MyRenderMessageEnum.DebugDrawOBB:
                case MyRenderMessageEnum.DebugDraw6FaceConvex:
                case MyRenderMessageEnum.DebugDrawCone:
                case MyRenderMessageEnum.DebugDrawTriangle:
                case MyRenderMessageEnum.DebugDrawCapsule:
                case MyRenderMessageEnum.DebugDrawText2D:
                case MyRenderMessageEnum.DebugDrawText3D:
                case MyRenderMessageEnum.DebugDrawModel:
                case MyRenderMessageEnum.DebugDrawTriangles:
                case MyRenderMessageEnum.DebugDrawPlane:
                case MyRenderMessageEnum.DebugDrawCylinder:
                case MyRenderMessageEnum.DebugDrawFrustrum:
                case MyRenderMessageEnum.DebugDrawMesh:
                case MyRenderMessageEnum.DebugWaitForPresent:
                case MyRenderMessageEnum.DebugClearPersistentMessages:
                {
                    m_debugDrawMessages.Enqueue(message);
                }
                break;

                case MyRenderMessageEnum.DebugCrashRenderThread:
                {
                    throw new InvalidOperationException("Forced exception");
                }

                case MyRenderMessageEnum.DebugPrintAllFileTexturesIntoLog:
                {
                    MyRender11.Log.WriteLine(MyManagers.FileTextures.GetFileTexturesDesc().ToString());;
                    MyRender11.Log.WriteLine(MyManagers.FileArrayTextures.GetFileTexturesDesc().ToString());
                    break;
                }
                #endregion
            }
        }
        private static void ProcessMessageInternal(IMyRenderMessage message)
        {
            switch (message.MessageType)
            {
                case MyRenderMessageEnum.SetCameraViewMatrix:
                {
                    var rMessage = (MyRenderMessageSetCameraViewMatrix)message;

                    SetupCameraMatrices(rMessage);

                    break;
                }

                case MyRenderMessageEnum.DrawScene:
                {
                    var rMessage = (IMyRenderMessage)message;

                    m_drawQueue.Enqueue(rMessage);

                    m_messageTracker.Clear();

                    break;
                }

                case MyRenderMessageEnum.RebuildCullingStructure:
                {

                    break;
                }

                #region Profiler

                case MyRenderMessageEnum.RenderProfiler:
                {
                    var profMessage = (MyRenderMessageRenderProfiler)message;

                    MyRenderProfiler.HandleInput(profMessage.Command, profMessage.Index);

                    break;
                }

                #endregion

                #region Characters

                case MyRenderMessageEnum.CreateRenderCharacter:
                {
                    var rMessage = (MyRenderMessageCreateRenderCharacter)message;

                    var actor = MyActorFactory.CreateCharacter();
                    //actor.GetRenderable().SetModel(MyAssetsLoader.GetModel(rMessage.Model));
                    actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(rMessage.Model)));
                    actor.SetMatrix(ref rMessage.WorldMatrix);

                    if (rMessage.ColorMaskHSV.HasValue)
                    {
                        var color = ColorFromMask(rMessage.ColorMaskHSV.Value);
                        actor.GetRenderable().SetKeyColor(new Vector4(color, 1));
                    }

                    actor.SetID(rMessage.ID);

                    //var entity = MyComponents.CreateEntity(rMessage.ID);
                    //MyComponents.CreateRenderable(
                    //    entity,
                    //    MyMeshes.GetMeshId(X.TEXT(rMessage.Model)),
                    //    rMessage.ColorMaskHSV.HasValue ? rMessage.ColorMaskHSV.Value : Vector3.One);
                    //MyComponents.SetMatrix(entity, ref rMessage.WorldMatrix);

                    break;
                }

                case MyRenderMessageEnum.SetCharacterSkeleton:
                {
                    var rMessage = (MyRenderMessageSetCharacterSkeleton)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.CharacterID);
                    if (actor != null)
                    {
                        actor.GetSkinning().SetSkeleton(rMessage.SkeletonBones, rMessage.SkeletonIndices);
                    }

                    //var entity = MyComponents.GetEntity(rMessage.CharacterID);
                    //MyComponents.SetSkeleton(entity, rMessage.SkeletonBones, rMessage.SkeletonIndices);

                    break;
                };

                case MyRenderMessageEnum.SetCharacterTransforms:
                {
                    var rMessage = (MyRenderMessageSetCharacterTransforms)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.CharacterID);
                    if (actor != null)
                    {
                        actor.GetSkinning().SetAnimationBones(rMessage.RelativeBoneTransforms);
                    }
                    //var entity = MyComponents.GetEntity(rMessage.CharacterID);
                    //MyComponents.SetAnimation(entity, rMessage.RelativeBoneTransforms);

                    break;
                }

                case MyRenderMessageEnum.UpdateRenderEntity:
                {
                    var rMessage = (MyRenderMessageUpdateRenderEntity)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    if (actor != null && actor.GetRenderable() != null)
                    {
                        if(rMessage.ColorMaskHSV.HasValue)
                        {
                            actor.GetRenderable().SetKeyColor(new Vector4(ColorFromMask(rMessage.ColorMaskHSV.Value), 0));
                        }
                        actor.GetRenderable().SetDithering(rMessage.Dithering);
                    }

                    break;
                }

                case MyRenderMessageEnum.ChangeModel:
                {
                    var rMessage = (MyRenderMessageChangeModel)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    if (actor != null && actor.GetRenderable() != null)
                    {
                        var r = actor.GetRenderable();

                        var modelId = MyMeshes.GetMeshId(X.TEXT(rMessage.Model));
                        if(r.GetModel() != modelId)
                        {
                            r.SetModel(modelId);
                        }
                    }

                    break;
                }

                case MyRenderMessageEnum.ChangeModelMaterial:
                {
                    var rMessage = (MyRenderMessageChangeModelMaterial)message;

                    

                    //var matId = MyMeshMaterialId.NULL;
                    //if (rMessage.Material.ToLower().Contains("debug"))
                    //{
                    //    matId = MyMeshMaterials1.DebugMaterialId;
                    //}
                    //else
                    //{
                    //    matId = MyMeshMaterials1.GetMaterialId(rMessage.Material);
                    //}

                    //MyAssetsLoader.GetModel(rMessage.Model).SetMaterial_SLOW(MyMeshMaterials1.GetProxyId(matId));

                    break;
                }

                #endregion

                #region Render objects

                case MyRenderMessageEnum.CreateRenderEntity:
                {
                    var rMessage = (MyRenderMessageCreateRenderEntity)message;

                    Matrix m = (Matrix)rMessage.WorldMatrix;

                    var actor = MyActorFactory.CreateSceneObject();
                    if (rMessage.Model != null) 
                    {
                        var model = MyAssetsLoader.ModelRemap.Get(rMessage.Model, rMessage.Model);

                        actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(model)));
                        //if (MyDestructionMesh.ModelsDictionary.ContainsKey(model))
                        //{
                        //    //actor.GetRenderable().SetModel(MyDestructionMesh.ModelsDictionary.Get(model));
                        //    actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(model)));
                        //}
                        //else
                        //{
                        //    //actor.GetRenderable().SetModel(MyAssetsLoader.GetModel(model));
                        //    actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(model)));
                        //}
                    }

                    actor.SetID(rMessage.ID);
                    actor.SetMatrix(ref rMessage.WorldMatrix);

                    break;
                }

                case MyRenderMessageEnum.UpdateCockpitGlass:
                {
                    var rMessage = (MyRenderMessageUpdateCockpitGlass)message;

                    //if (MyEnvironment.CockpitGlass == null)
                    //{
                    //    MyEnvironment.CockpitGlass = MyActorFactory.CreateSceneObject();
                    //}

                    //MyEnvironment.CockpitGlass.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(rMessage.Model)));
                    //MyEnvironment.CockpitGlass.SetVisibility(rMessage.Visible);
                    //MyEnvironment.CockpitGlass.MarkRenderDirty();

                    //var matrix = (Matrix)rMessage.WorldMatrix;
                    //MyEnvironment.CockpitGlass.SetMatrix(ref matrix);


                    break;
                }

                case MyRenderMessageEnum.CreateRenderVoxelDebris:
                {
                    var rMessage = (MyRenderMessageCreateRenderVoxelDebris)message;

                    Matrix m = (Matrix)rMessage.WorldMatrix;

                    var actor = MyActorFactory.CreateSceneObject();
                    if (rMessage.Model != null)
                    {
                        actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(rMessage.Model)));
                    }

                    actor.SetID(rMessage.ID);
                    actor.SetMatrix(ref rMessage.WorldMatrix);

                    MyRenderableComponent.DebrisEntityVoxelMaterial[rMessage.ID] = rMessage.VoxelMaterialIndex;

                    break;
                }

                case MyRenderMessageEnum.CreateScreenDecal:
                {
                    var rMessage = (MyRenderMessageCreateScreenDecal)message;

                    MyScreenDecals.AddDecal(rMessage.ID, rMessage.ParentID, rMessage.LocalOBB, rMessage.DecalMaterial);

                    break;
                }

                case MyRenderMessageEnum.CreateRenderEntityAtmosphere:
                {
                    var rMessage = (MyRenderMessageCreateRenderEntityAtmosphere)message;

                    if (rMessage.Technique == VRage.Import.MyMeshDrawTechnique.ATMOSPHERE) {

                        //rMessage = (rMessage.AtmosphereRadius - rMessage.PlanetRadius) * 5 + rMessage.PlanetRadius;

                        //rMessage.AtmosphereRadius *= 1.5f;
                        //rMessage.WorldMatrix = MatrixD.CreateScale(1.5, 1.5, 1.5) * rMessage.WorldMatrix;

                        float rescaleFactor = (rMessage.AtmosphereRadius - rMessage.PlanetRadius) / (6420 - 6360); // ratio of planet to earth radius
                        Vector3 rayleighScattering = new Vector3(1.8e-3f, 1.35e-2f, 3.31e-2f) / rescaleFactor;
                        Vector3 mieScattering = new Vector3(4e-3f, 4e-3f, 4e-3f) / rescaleFactor;
                        float rayleighHeightScale = 8 * rescaleFactor;
                        float mieHeightScale = 1.2f * rescaleFactor;
                        
                        MyAtmosphereRenderer.CreateAtmosphere(rMessage.ID, rMessage.WorldMatrix, rMessage.PlanetRadius, rMessage.AtmosphereRadius, rayleighScattering, rayleighHeightScale, mieScattering, mieHeightScale);
                    }

                    break;
                }

                case MyRenderMessageEnum.RemoveDecal:
                {
                    var rMessage = (MyRenderMessageRemoveDecal)message;

                    MyScreenDecals.RemoveDecal(rMessage.ID);

                    break;
                }

                case MyRenderMessageEnum.RegisterDecalsMaterials:
                {
                    var rMessage = (MyRenderMessageRegisterScreenDecalsMaterials)message;

                    MyScreenDecals.RegisterMaterials(rMessage.MaterialsNames, rMessage.MaterialsDescriptions);


                    break;
                }

                case MyRenderMessageEnum.UpdateRenderObject:
                { 
                    var rMessage = (MyRenderMessageUpdateRenderObject)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    if (actor != null)
                    {
                        actor.SetMatrix(ref rMessage.WorldMatrix);
                        if(rMessage.AABB.HasValue)
                        { 
                            actor.SetAabb(rMessage.AABB.Value);
                        }
                        
                    }
                    else
                    {
                        if (MyClipmapFactory.ClipmapByID.ContainsKey(rMessage.ID))
                        {
                            MyClipmapFactory.ClipmapByID[rMessage.ID].UpdateWorldMatrix(ref rMessage.WorldMatrix);
                        }
                    }

                    //var entity = MyComponents.GetEntity(rMessage.ID);
                    //if(entity != EntityId.NULL)
                    //{
                    //    MyComponents.SetMatrix(entity, ref rMessage.WorldMatrix);
                    //    if (rMessage.AABB.HasValue)
                    //    {
                    //        var aabb = rMessage.AABB.Value;
                    //        MyComponents.SetAabb(entity, ref aabb);
                    //    }
                    //}

                    break;
                }

                case MyRenderMessageEnum.RemoveRenderObject:
                {
                    var rMessage = (MyRenderMessageRemoveRenderObject)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    if (actor != null)
                    {
                        if (actor.GetRenderable() != null && actor.GetRenderable().GetModel().Info.Dynamic)
                        {
                            MyMeshes.RemoveMesh(actor.GetRenderable().GetModel());
                        }

                        actor.Destruct();
                        MyScreenDecals.RemoveEntityDecals(rMessage.ID);

                        break;
                    }

                    var instancing = MyInstancing.Get(rMessage.ID);
                    if(instancing != InstancingId.NULL)
                    {
                        MyInstancing.Remove(rMessage.ID, instancing);
                        break;
                    }

                    var light = MyLights.Get(rMessage.ID);
                    if(light != LightId.NULL)
                    {
                        MyLights.Remove(rMessage.ID, light);
                        break;
                    }

                    var clipmap = MyClipmapFactory.ClipmapByID.Get(rMessage.ID);
                    if(clipmap != null)
                    {
                        clipmap.RemoveFromUpdate();
                        break;
                    }

                    MyAtmosphereRenderer.RemoveAtmosphere(rMessage.ID);


                    break;
                }

                case MyRenderMessageEnum.UpdateRenderObjectVisibility:
                {
                    var rMessage = (MyRenderMessageUpdateRenderObjectVisibility)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    if (actor != null)
                    {
                        actor.SetVisibility(rMessage.Visible);

                        //if(rMessage.NearFlag)
                        //{
                        //    actor.GetRenderable().m_additionalFlags = MyRenderableProxyFlags.InvertFaceCulling;
                        //    actor.MarkRenderDirty();
                        //}
                        //else
                        //{
                        //    actor.GetRenderable().m_additionalFlags = 0;
                        //    actor.MarkRenderDirty();
                        //}
                    }

                    break;
                }


                case MyRenderMessageEnum.CreateRenderInstanceBuffer:
                {
                    var rMessage = (MyRenderMessageCreateRenderInstanceBuffer)message;

                    //var instancing = MyComponentFactory<MyInstancingComponent>.Create();
                    //instancing.SetID(rMessage.ID);
                    //instancing.Init(rMessage.Type);
                    //instancing.SetDebugName(rMessage.DebugName);

                    MyInstancing.Create(rMessage.ID, rMessage.Type, rMessage.DebugName);

                    break;
                }

                case MyRenderMessageEnum.UpdateRenderInstanceBuffer:
                {
                    var rMessage = (MyRenderMessageUpdateRenderInstanceBuffer)message;

                    //var instancing = MyIDTracker<MyInstancingComponent>.FindByID(rMessage.ID);
                    //if(instancing != null)
                    //{
                    //    instancing.UpdateGeneric(rMessage.InstanceData, rMessage.Capacity);
                    //}

                    var handle = MyInstancing.Get(rMessage.ID);

                    if (handle != InstancingId.NULL)
                    {
                        MyInstancing.UpdateGeneric(handle, rMessage.InstanceData, rMessage.Capacity);
                    }
                    else
                    {
                        Debug.Assert(handle != InstancingId.NULL, "No instance buffer with ID " + rMessage.ID);
                    }

                    rMessage.InstanceData.Clear();

                    break;
                }

                case MyRenderMessageEnum.UpdateRenderCubeInstanceBuffer:
                {
                    var rMessage = (MyRenderMessageUpdateRenderCubeInstanceBuffer)message;

                    //var instancing = MyIDTracker<MyInstancingComponent>.FindByID(rMessage.ID);
                    //if (instancing != null)
                    //{
                    //    instancing.UpdateCube(rMessage.InstanceData, rMessage.Capacity);
                    //}

                    var handle = MyInstancing.Get(rMessage.ID);

                    if (handle != InstancingId.NULL)
                    {
                        MyInstancing.UpdateCube(MyInstancing.Get(rMessage.ID), rMessage.InstanceData, rMessage.Capacity);
                    }
                    else
                    {
                        Debug.Assert(handle != InstancingId.NULL, "No instance buffer with ID " + rMessage.ID);
                    }

                    rMessage.InstanceData.Clear();

                    break;
                }

                case MyRenderMessageEnum.SetInstanceBuffer:
                {
                    var rMessage = (MyRenderMessageSetInstanceBuffer)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    //var instancing = MyIDTracker<MyInstancingComponent>.FindByID(rMessage.InstanceBufferId);

                    if (actor != null)
                    {
                        //if (actor.GetComponent(MyActorComponentEnum.Instancing) != instancing)
                        //{
                        //    actor.AddComponent(instancing);
                        //}
                        //actor.SetLocalAabb(rMessage.LocalAabb);
                        //actor.GetRenderable().SetInstancingCounters(rMessage.InstanceCount, rMessage.InstanceStart);

                        actor.GetRenderable().SetInstancing(MyInstancing.Get(rMessage.InstanceBufferId));
                        actor.SetLocalAabb(rMessage.LocalAabb);
                        actor.GetRenderable().SetInstancingCounters(rMessage.InstanceCount, rMessage.InstanceStart);
                    }

                    break;
                }
                    
                case MyRenderMessageEnum.CreateManualCullObject:
                {
                    var rMessage = (MyRenderMessageCreateManualCullObject)message;

                    var actor = MyActorFactory.CreateGroup();
                    actor.SetID(rMessage.ID);
                    Matrix m = (Matrix)rMessage.WorldMatrix;
                    actor.SetMatrix(ref rMessage.WorldMatrix);

                    break;
                }

                case MyRenderMessageEnum.SetParentCullObject:
                {
                    var rMessage = (MyRenderMessageSetParentCullObject)message;

                    var child = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    var parent = MyIDTracker<MyActor>.FindByID(rMessage.CullObjectID);
                    if (child != null && parent != null && parent.GetGroupRoot() != null && child.GetGroupLeaf() == null)
                    {
                        child.SetRelativeTransform(rMessage.ChildToParent);
                        parent.GetGroupRoot().Add(child);
                    }

                    break;
                }

                case MyRenderMessageEnum.CreateLineBasedObject:
                {
                    var rMessage = (MyRenderMessageCreateLineBasedObject)message;

                    var actor = MyActorFactory.CreateSceneObject();
                    //actor.GetRenderable().SetModel(new MyDynamicMesh());

                    actor.SetID(rMessage.ID);
                    actor.SetMatrix(ref MatrixD.Identity);

                    MyMeshMaterials1.GetMaterialId("__ROPE_MATERIAL", null, rMessage.ColorMetalTexture, rMessage.NormalGlossTexture, rMessage.ExtensionTexture, MyMesh.DEFAULT_MESH_TECHNIQUE);
                    actor.GetRenderable().SetModel(MyMeshes.CreateRuntimeMesh(X.TEXT("LINE" + rMessage.ID), 1, true));

                    break;
                }

                case MyRenderMessageEnum.UpdateLineBasedObject:
                {
                    var rMessage = (MyRenderMessageUpdateLineBasedObject)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    if (actor != null)
                    {
                        //var mesh = actor.GetRenderable().GetMesh() as MyDynamicMesh;

                        MyVertexFormatPositionH4 [] stream0;
                        MyVertexFormatTexcoordNormalTangent [] stream1;

                        MyLineHelpers.GenerateVertexData(ref rMessage.WorldPointA, ref rMessage.WorldPointB, 
                            out stream0, out stream1);

                        var indices = MyLineHelpers.GenerateIndices(stream0.Length);
                        var sections = new MySectionInfo[] 
                        { 
                            new MySectionInfo { TriCount = indices.Length / 3, IndexStart = 0, MaterialName = "__ROPE_MATERIAL" } 
                        };

                        MyMeshes.UpdateRuntimeMesh(MyMeshes.GetMeshId(X.TEXT("LINE" + rMessage.ID)), 
                            indices, 
                            stream0, 
                            stream1, 
                            sections,
                            (BoundingBox)MyLineHelpers.GetBoundingBox(ref rMessage.WorldPointA, ref rMessage.WorldPointB));

                        //actor.SetAabb((BoundingBox)MyLineHelpers.GetBoundingBox(ref rMessage.WorldPointA, ref rMessage.WorldPointB));
                        actor.MarkRenderDirty();

                        var matrix = MatrixD.CreateTranslation((Vector3)(rMessage.WorldPointA + rMessage.WorldPointB) * 0.5f);
                        actor.SetMatrix(ref matrix);
                    }

                    break;
                }

                case MyRenderMessageEnum.SetRenderEntityData:
                {
                    var rMessage = (MyRenderMessageSetRenderEntityData)message;

                    Debug.Assert(false, "MyRenderMessageSetRenderEntityData is deprecated!");

                    break;
                }

                case MyRenderMessageEnum.AddRuntimeModel:
                {
                    var rMessage = (MyRenderMessageAddRuntimeModel)message;

                    //MyDestructionMesh mesh = MyDestructionMesh.ModelsDictionary.Get(rMessage.Name);
                    //if (mesh == null)
                    //{
                        //mesh = new MyDestructionMesh(rMessage.Name);

                        //ProfilerShort.Begin("LoadBuffers");
                        //mesh.Fill(rMessage.ModelData.Indices, rMessage.ModelData.Positions, rMessage.ModelData.Normals, rMessage.ModelData.Tangents, rMessage.ModelData.TexCoords, rMessage.ModelData.Sections, rMessage.ModelData.AABB);
                        //ProfilerShort.End();

                    if(!MyMeshes.Exists(rMessage.Name))
                    {
                        {
                            ushort[] indices = new ushort[rMessage.ModelData.Indices.Count];
                            for (int i = 0; i < rMessage.ModelData.Indices.Count; i++)
                            {
                                indices[i] = (ushort)rMessage.ModelData.Indices[i];
                            }
                            var verticesNum = rMessage.ModelData.Positions.Count;
                            MyVertexFormatPositionH4[] stream0 = new MyVertexFormatPositionH4[verticesNum];
                            MyVertexFormatTexcoordNormalTangent[] stream1 = new MyVertexFormatTexcoordNormalTangent[verticesNum];
                            for (int i = 0; i < verticesNum; i++)
                            {
                                stream0[i] = new MyVertexFormatPositionH4(rMessage.ModelData.Positions[i]);
                                stream1[i] = new MyVertexFormatTexcoordNormalTangent(
                                    rMessage.ModelData.TexCoords[i], rMessage.ModelData.Normals[i], rMessage.ModelData.Tangents[i]);
                            }
                            var id = MyMeshes.CreateRuntimeMesh(X.TEXT(rMessage.Name), rMessage.ModelData.Sections.Count, false);
                            MyMeshes.UpdateRuntimeMesh(id, indices, stream0, stream1, rMessage.ModelData.Sections.ToArray(), rMessage.ModelData.AABB);
                        }

                        if (rMessage.ReplacedModel != null)
                        {
                            //MyAssetsLoader.ModelRemap[rMessage.ReplacedModel] = rMessage.Name;
                            MyAssetsLoader.ModelRemap[rMessage.Name] = rMessage.ReplacedModel;
                        }

                        //if (MyAssetsLoader.LOG_MESH_STATISTICS)
                        //{
                        //    mesh.DebugWriteInfo();
                        //}
                    }
                    
                    break;
                }

                case MyRenderMessageEnum.UpdateModelProperties:
                {
                    var rMessage = (MyRenderMessageUpdateModelProperties)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID);
                    if (actor != null)
                    {
                        // careful, lod is ignored after all (properties apply to all lods)
                        var key = new MyEntityMaterialKey { LOD = rMessage.LOD, Material = X.TEXT(rMessage.MaterialName) };

                        if(rMessage.Enabled.HasValue)
                        {
                            if (!MyScene.EntityDisabledMaterials.ContainsKey(rMessage.ID))
                            {
                                MyScene.EntityDisabledMaterials.Add(rMessage.ID, new HashSet<MyEntityMaterialKey>());
                            }

                            if (!rMessage.Enabled.Value)
                            {
                                MyScene.EntityDisabledMaterials[rMessage.ID].Add(key);
                            }
                            else
                            {
                                MyScene.EntityDisabledMaterials[rMessage.ID].Remove(key);
                            }
                        }

                        var r = actor.GetRenderable();

                        if ((rMessage.Emissivity.HasValue || rMessage.DiffuseColor.HasValue) && !r.ModelProperties.ContainsKey(key))
                        {
                            r.ModelProperties[key] = new MyModelProperties();
                        }

                        if(rMessage.Emissivity.HasValue)
                        {
                            r.ModelProperties[key].Emissivity = rMessage.Emissivity.Value;
                        }

                        if(rMessage.DiffuseColor.HasValue)
                        {
                            r.ModelProperties[key].ColorMul = rMessage.DiffuseColor.Value;
                        }

                        actor.MarkRenderDirty();
                    }

                    break;
                }

                case MyRenderMessageEnum.PreloadModel:
                {
                    var rMessage = (MyRenderMessagePreloadModel) message;

                    //MyAssetsLoader.GetModel(rMessage.Name);
                    MyMeshes.GetMeshId(X.TEXT(rMessage.Name));

                    break;
                }

                case MyRenderMessageEnum.ChangeMaterialTexture:
                {
                    var rMessage = (MyRenderMessageChangeMaterialTexture)message;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.RenderObjectID);
                    if (actor != null)
                    {
                        var r = actor.GetRenderable();
                        var key = new MyEntityMaterialKey { LOD = 0, Material = X.TEXT(rMessage.MaterialName) };

                        if (!r.ModelProperties.ContainsKey(key))
                        {
                            r.ModelProperties[key] = new MyModelProperties();
                        }

                        if (r.ModelProperties[key].TextureSwaps == null)
                        {
                            r.ModelProperties[key].TextureSwaps = new List<MyMaterialTextureSwap>();

                            foreach(var s in rMessage.Changes)
                            {
                                r.ModelProperties[key].TextureSwaps.Add(new MyMaterialTextureSwap { 
                                    TextureName = X.TEXT(s.TextureName), 
                                    MaterialSlot = s.MaterialSlot
                                });
                            }
                        }
                        else
                        {
                            foreach (var s in rMessage.Changes)
                            {
                                bool swapped = false;
                                for(int i=0; i<r.ModelProperties[key].TextureSwaps.Count; ++i)
                                {
                                    if(r.ModelProperties[key].TextureSwaps[i].MaterialSlot == s.MaterialSlot)
                                    {
                                        r.ModelProperties[key].TextureSwaps[i] = new MyMaterialTextureSwap
                                        {
                                            TextureName = X.TEXT(s.TextureName),
                                            MaterialSlot = s.MaterialSlot
                                        };
                                        swapped = true;
                                        break;
                                    }
                                }

                                if(!swapped)
                                {
                                    r.ModelProperties[key].TextureSwaps.Add(new MyMaterialTextureSwap
                                        {
                                            TextureName = X.TEXT(s.TextureName),
                                            MaterialSlot = s.MaterialSlot
                                        });
                                }
                            }
                        }

                        r.FreeCustomRenderTextures(key);

                        actor.MarkRenderDirty();
                    }

                    rMessage.Changes.Clear();
                   
                    break;
                }

                case MyRenderMessageEnum.DrawTextToMaterial:
                {
                    var rMessage = (MyRenderMessageDrawTextToMaterial)message;

                    //rMessage.EntityId
                    //rMessage.FontColor
                    //rMessage.MaterialName
                    //rMessage.Text;
                    //rMessage.TextScale;

                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.RenderObjectID);
                    if (actor != null)
                    {
                        var r = actor.GetRenderable();
                        var key = new MyEntityMaterialKey { LOD = 0, Material = X.TEXT(rMessage.MaterialName) };

                        if (!r.ModelProperties.ContainsKey(key))
                        {
                            r.ModelProperties[key] = new MyModelProperties();
                        }
                        else
                        {
                            r.ModelProperties[key].TextureSwaps = null;
                        }

                        RwTexId handle = r.ModelProperties[key].CustomRenderedTexture;
                        if (handle == RwTexId.NULL && MyModelProperties.CustomTextures < MyModelProperties.MaxCustomTextures)
                        {
                           handle = MyRwTextures.CreateRenderTarget(rMessage.TextureResolution * rMessage.TextureAspectRatio, rMessage.TextureResolution, SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, true);
                           r.ModelProperties[key].CustomRenderedTexture = handle;
                           ++MyModelProperties.CustomTextures;
                        }

                        if (handle != RwTexId.NULL)
                        {
                            var clearColor = new SharpDX.Color4(rMessage.BackgroundColor.PackedValue);
                            clearColor.Alpha = 0;
                            MyRender11.ImmediateContext.ClearRenderTargetView(handle.Rtv, clearColor);

                            // my sprites renderer -> push state
                            MySpritesRenderer.PushState(new Vector2(rMessage.TextureResolution * rMessage.TextureAspectRatio, rMessage.TextureResolution));


                            MySpritesRenderer.DrawText(Vector2.Zero, new StringBuilder(rMessage.Text), rMessage.FontColor, rMessage.TextScale);
                            // render text with fonts to rt
                            // update texture of proxy
                            MySpritesRenderer.Draw(handle.Rtv, new MyViewport(rMessage.TextureResolution * rMessage.TextureAspectRatio, rMessage.TextureResolution));

                            // render to rt
                            // my sprites renderer -> pop state
                            MySpritesRenderer.PopState();
                            

                            MyRender11.ImmediateContext.GenerateMips(handle.ShaderView);

                            actor.MarkRenderDirty();
                        }
                        else
                        {
                            MyRenderProxy.TextNotDrawnToTexture(rMessage.EntityId);
                        }
                    }
                    else
                    {
                        MyRenderProxy.TextNotDrawnToTexture(rMessage.EntityId);
                    }

                    break;
                }

                case MyRenderMessageEnum.PreloadMaterials:
                {
                    var rMessage = (MyRenderMessagePreloadMaterials)message;

                    //MyAssetsLoader.GetMaterials(rMessage.Name);
                    MyMeshes.GetMeshId(X.TEXT(rMessage.Name));

                    break;
                }

                #endregion

                #region Voxels

                case MyRenderMessageEnum.CreateClipmap:
                {
                    var rMessage = (MyRenderMessageCreateClipmap)message;

                    var clipmap = new MyClipmapHandler(rMessage.ClipmapId, rMessage.ScaleGroup, rMessage.WorldMatrix, rMessage.SizeLod0);
                    MyClipmapFactory.ClipmapByID[rMessage.ClipmapId] = clipmap;
                    clipmap.Base.LoadContent();
                    

                    break;
                }

                case MyRenderMessageEnum.UpdateClipmapCell:
                {
                    var rMessage = (MyRenderMessageUpdateClipmapCell)message;

                    var clipmap = MyClipmapFactory.ClipmapByID.Get(rMessage.ClipmapId);
                    if(clipmap != null)
                    {
                        clipmap.Base.UpdateCell(rMessage);
                    }

                    rMessage.Batches.Clear();
                    break;
                }

                case MyRenderMessageEnum.InvalidateClipmapRange:
                {
                    var rMessage = (MyRenderMessageInvalidateClipmapRange)message;

                    var clipmap = MyClipmapFactory.ClipmapByID.Get(rMessage.ClipmapId);
                    if (clipmap != null)
                    {
                        clipmap.Base.InvalidateRange(rMessage.MinCellLod0, rMessage.MaxCellLod0);
                    }

                    break;
                }

                case MyRenderMessageEnum.CreateRenderVoxelMaterials:
                {
                    var rMessage = (MyRenderMessageCreateRenderVoxelMaterials)message;

                    Debug.Assert(MyVoxelMaterials1.CheckIndices(rMessage.Materials));
                    MyVoxelMaterials1.Set(rMessage.Materials);

                    rMessage.Materials = null;

                    break;
                }


                #endregion

                #region Lights

                case MyRenderMessageEnum.CreateRenderLight:
                {
                    var rMessage = (MyRenderMessageCreateRenderLight)message;

                    //MyLight.Create(rMessage.ID);

                    MyLights.Create(rMessage.ID);

                    break;
                }

                case MyRenderMessageEnum.UpdateRenderLight:
                {
                    var rMessage = (MyRenderMessageUpdateRenderLight)message;

                  
                    var light = MyLights.Get(rMessage.ID);


                    if(light != LightId.NULL)
                    {

                        var lightInfo = new MyLightInfo
                        {
                            Position = rMessage.Position,
                            PositionWithOffset = rMessage.Position + rMessage.Offset * rMessage.Range * rMessage.ReflectorDirection,
                            CastsShadows = rMessage.CastShadows,
                            ShadowsDistance = rMessage.ShadowDistance,
                            ParentGID = rMessage.ParentID,
                            UsedInForward = rMessage.UseInForwardRender
                        };

                        MyLights.UpdateEntity(light, ref lightInfo);

                        if ((rMessage.Type & LightTypeEnum.PointLight) > 0)
                        {
                            MyLights.UpdatePointlight(light, rMessage.LightOn, rMessage.Range, new Vector3(rMessage.Color.R, rMessage.Color.G, rMessage.Color.B) / 255.0f * rMessage.Intensity, rMessage.Falloff);
                        }
                        if ((rMessage.Type & LightTypeEnum.Hemisphere) > 0)
                        {
                            //rMessage.Color;
                            //rMessage.Falloff;
                            //rMessage.Intensity;
                            //rMessage.LightOn;
                            //rMessage.ReflectorDirection;
                            //rMessage.ReflectorUp;
                        }
                        if ((rMessage.Type & LightTypeEnum.Spotlight) > 0)
                        {
                            // because it's so in dx9...
                            float coneMaxAngleCos = 1 - rMessage.ReflectorConeMaxAngleCos;
                            coneMaxAngleCos = (float)Math.Min(Math.Max(coneMaxAngleCos, 0.01), 0.99f);
                            MyLights.UpdateSpotlight(light, rMessage.ReflectorOn,
                                rMessage.ReflectorDirection, rMessage.ReflectorRange, coneMaxAngleCos, rMessage.ReflectorUp,
                                new Vector3(rMessage.ReflectorColor.R, rMessage.ReflectorColor.G, rMessage.ReflectorColor.B) / 255.0f * rMessage.Intensity, rMessage.ReflectorFalloff,
                                MyTextures.GetTexture(rMessage.ReflectorTexture, MyTextureEnum.CUSTOM));
                        }

                        MyLights.UpdateGlare(light, new MyGlareDesc
                            {
                                Enabled = rMessage.GlareOn,
                                Material = X.TEXT(rMessage.GlareMaterial),
                                Intensity = rMessage.GlareIntensity,
                                QuerySize = rMessage.GlareQuerySize,
                                Type = rMessage.GlareType,
                                Size = rMessage.GlareSize,
                                MaxDistance = rMessage.GlareMaxDistance,
                                Color = rMessage.Color,
                                Direction = rMessage.ReflectorDirection,
                                Range = rMessage.Range
                            });
                    }

                    break;
                }

                case MyRenderMessageEnum.SetLightShadowIgnore:
                {
                    var rMessage = (MyRenderMessageSetLightShadowIgnore)message;

                    var light = MyLights.Get(rMessage.ID);
                    var actor = MyIDTracker<MyActor>.FindByID(rMessage.ID2);

                    if(light != LightId.NULL && actor != null)
                    {
                        if(!MyLights.IgnoredEntitites.ContainsKey(light))
                        {
                            MyLights.IgnoredEntitites[light] = new HashSet<uint>();
                        }
                        MyLights.IgnoredEntitites[light].Add(rMessage.ID2);
                    }

                    break;
                }


                case MyRenderMessageEnum.ClearLightShadowIgnore:
                {
                    var rMessage = (MyRenderMessageClearLightShadowIgnore)message;

                    var light = MyLights.Get(rMessage.ID);
                    if(light != LightId.NULL)
                    {
                        MyLights.IgnoredEntitites.Remove(light);
                    }

                    break;
                }

                case MyRenderMessageEnum.UpdateFogSettings:
                {
                    var rMessage = (MyRenderMessageUpdateFogSettings)message;

                    MyEnvironment.FogSettings = rMessage.Settings;

                    break;
                }

                case MyRenderMessageEnum.UpdateRenderEnvironment:
                {
                    var rMessage = (MyRenderMessageUpdateRenderEnvironment)message;

                    MyEnvironment.DirectionalLightDir = VRageMath.Vector3.Normalize(rMessage.SunDirection);
                    MyEnvironment.DirectionalLightIntensity = rMessage.SunIntensity * rMessage.SunColor.ToVector3();
                    MyEnvironment.DirectionalLightEnabled = rMessage.SunLightOn;
                    MyEnvironment.DayTime = (float)(rMessage.DayTime - Math.Truncate(rMessage.DayTime));
                    MyEnvironment.SunDistance = rMessage.DistanceToSun;
                    MyEnvironment.SunColor = rMessage.SunColor;
                    MyEnvironment.SunMaterial = rMessage.SunMaterial;
                    MyEnvironment.SunSizeMultiplier = rMessage.SunSizeMultiplier;
                    MyEnvironment.SunBillboardEnabled = rMessage.SunBillboardEnabled;

                    var skybox = rMessage.BackgroundTexture;

                    m_resetEyeAdaptation = m_resetEyeAdaptation || rMessage.ResetEyeAdaptation;

                    break;
                }

                case MyRenderMessageEnum.UpdateEnvironmentMap:
                {   
                    break;
                }

                case MyRenderMessageEnum.UpdatePostprocessSettings:
                {
                    var rMessage = (MyRenderMessageUpdatePostprocessSettings)message;

                    m_postprocessSettings = rMessage.Settings;

                    break;
                }

                case MyRenderMessageEnum.UpdateSSAOSettings:
                {
                    var rMessage = (MyRenderMessageUpdateSSAOSettings)message;


                    MySSAO.Params.MinRadius = rMessage.MinRadius;
                    MySSAO.Params.MaxRadius = rMessage.MaxRadius;
                    MySSAO.Params.RadiusGrow = rMessage.RadiusGrowZScale;

                    MySSAO.Params.RadiusBias = rMessage.Bias;
                    MySSAO.Params.Falloff = rMessage.Falloff;
                    MySSAO.Params.Normalization = rMessage.NormValue;
                    MySSAO.Params.Contrast = rMessage.Contrast;
                    
                    break;
                }

                #endregion

                #region Sprites
                case MyRenderMessageEnum.DrawSprite:
                case MyRenderMessageEnum.DrawSpriteNormalized:
                case MyRenderMessageEnum.DrawSpriteAtlas:
                case MyRenderMessageEnum.SpriteScissorPush:
                case MyRenderMessageEnum.SpriteScissorPop:
                {
                    m_drawQueue.Enqueue(message);
                    break;
                }

                #endregion

                #region Fonts and text

                case MyRenderMessageEnum.CreateFont:
                {
                    var createFontMessage = message as MyRenderMessageCreateFont;
                    Debug.Assert(createFontMessage != null);

                    var renderFont = new MyRenderFont(createFontMessage.FontPath);
                    renderFont.LoadContent();
                    AddFont(createFontMessage.FontId, renderFont, createFontMessage.IsDebugFont);

                    break;
                }

                case MyRenderMessageEnum.DrawString:
                {
                    m_drawQueue.Enqueue(message);
                    break;
                }

                #endregion

                #region Textures

                case MyRenderMessageEnum.PreloadTextures:
                    {
                        var preloadMsg = message as MyRenderMessagePreloadTextures;

                        //MyTextureManager.PreloadTextures(preloadMsg.InDirectory, preloadMsg.Recursive);
                        //MyTextures.UnloadTexture(texMessage.Texture);

                        break;
                    }

                case MyRenderMessageEnum.UnloadTexture:
                    {
                        var texMessage = (MyRenderMessageUnloadTexture)message;

                        //MyTextureManager.UnloadTexture(texMessage.Texture);
                        MyTextures.UnloadTexture(texMessage.Texture);

                        break;
                    }

                case MyRenderMessageEnum.ReloadTextures:
                    {
                        var reloadMsg = (MyRenderMessageReloadTextures)message;

                        MyVoxelMaterials1.InvalidateMaterials();
                        MyMeshMaterials1.InvalidateMaterials();
                        MyTextures.ReloadAssetTextures();

                        //MyTextureManager.UnloadTextures();
                        //MyMaterialProxyFactory.ReloadTextures();

                        break;
                    }

                case MyRenderMessageEnum.ReloadModels:
                    {
                        var reloadMsg = (MyRenderMessageReloadModels)message;

                        //MyMaterials.Clear();
                        MyAssetsLoader.ReloadMeshes();
                        MyRenderableComponent.MarkAllDirty();

                        break;
                    }

                #endregion

                case MyRenderMessageEnum.TakeScreenshot:
                {
                    var rMessage = (MyRenderMessageTakeScreenshot)message;

                    m_screenshot = new MyScreenshot(rMessage.PathToSave, rMessage.SizeMultiplier, rMessage.IgnoreSprites);

                    break;
                }

                case MyRenderMessageEnum.ReloadEffects:
                {
                    m_reloadShaders = true;

                    //MyShaderBundleFactory.ClearCache();
                    //MyShaderMaterial.ClearCache();
                    //MyShaderPass.ClearCache();

                    MyShaders.Recompile();
                    MyMaterialShaders.Recompile();

                    MyAtmosphereRenderer.RecomputeAtmospheres();

                    MyRenderableComponent.MarkAllDirty();

                    foreach (var f in MyComponentFactory<MyFoliageComponent>.GetAll())
                    {
                        f.Dispose();
                    }

                    break;
                }

                case MyRenderMessageEnum.PlayVideo:
                {
                    var rMessage = (MyRenderMessagePlayVideo)message;

                    MyVideoFactory.Create(rMessage.ID, rMessage.VideoFile);
                    var video = MyVideoFactory.Videos.Get(rMessage.ID);
                    if (video != null)
                    {
                        video.Volume = rMessage.Volume;
                    }

                    break;
                }

                case MyRenderMessageEnum.CloseVideo:
                {
                    var rMessage = (MyRenderMessageCloseVideo)message;

                    var video = MyVideoFactory.Videos.Get(rMessage.ID);
                    if (video != null)
                    {
                        video.Stop();
                        video.Dispose();
                        MyVideoFactory.Videos.Remove(rMessage.ID);
                    }

                    break;
                }

                case MyRenderMessageEnum.DrawVideo:
                {
                    var rMessage = (MyRenderMessageDrawVideo)message;

                    var video = MyVideoFactory.Videos.Get(rMessage.ID);
                    if (video != null)
                    {
                        video.Draw(rMessage.Rectangle, rMessage.Color, rMessage.FitMode);
                    }

                    break;
                }

                case MyRenderMessageEnum.UpdateVideo:
                {
                    var rMessage = (MyRenderMessageUpdateVideo)message;

                    var video = MyVideoFactory.Videos.Get(rMessage.ID);
                    if(video != null)
                    {
                        video.Update();
                    }

                    break;
                }

                case MyRenderMessageEnum.SetVideoVolume:
                {
                    var rMessage = (MyRenderMessageSetVideoVolume)message;

                    var video = MyVideoFactory.Videos.Get(rMessage.ID);
                    if (video != null)
                    {
                        video.Volume = rMessage.Volume;
                    }

                    break;
                }

                case MyRenderMessageEnum.VideoAdaptersRequest:
                {
                    MyRenderProxy.SendVideoAdapters(GetAdaptersList());
                    break;
                }

                case MyRenderMessageEnum.SwitchDeviceSettings:
                {
                    MyRenderProxy.RenderThread.SwitchSettings((message as MyRenderMessageSwitchDeviceSettings).Settings);
                    break;
                }

                case MyRenderMessageEnum.SwitchRenderSettings:
                    {
                        UpdateRenderSettings((message as MyRenderMessageSwitchRenderSettings).Settings);
                        break;
                    }

                case MyRenderMessageEnum.UnloadData:
                {
                    MyRender11.UnloadData();
                    break;
                }

                case MyRenderMessageEnum.CollectGarbage:
                {
                    GC.Collect();
                    break;
                }

                #region Debug draw

                case MyRenderMessageEnum.DebugDrawPoint:
                case MyRenderMessageEnum.DebugDrawLine3D:
                case MyRenderMessageEnum.DebugDrawLine2D:
                case MyRenderMessageEnum.DebugDrawSphere:
                case MyRenderMessageEnum.DebugDrawAABB:
                case MyRenderMessageEnum.DebugDrawAxis:
                case MyRenderMessageEnum.DebugDrawOBB:
                case MyRenderMessageEnum.DebugDrawCone:
                case MyRenderMessageEnum.DebugDrawTriangle:
                case MyRenderMessageEnum.DebugDrawCapsule:
                case MyRenderMessageEnum.DebugDrawText2D:
                case MyRenderMessageEnum.DebugDrawText3D:
                case MyRenderMessageEnum.DebugDrawModel:
                case MyRenderMessageEnum.DebugDrawTriangles:
                case MyRenderMessageEnum.DebugDrawPlane:
                case MyRenderMessageEnum.DebugDrawCylinder:
                {
                    m_debugDrawMessages.Enqueue(message);
                }
                break;

                case MyRenderMessageEnum.DebugCrashRenderThread:
                {
                    throw new InvalidOperationException("Forced exception");
                }
                #endregion
            }
        }
        private static void ProcessMessageInternal(IMyRenderMessage message)
        {
            switch (message.MessageType)
            {
            case MyRenderMessageEnum.SetCameraViewMatrix:
            {
                var rMessage = (MyRenderMessageSetCameraViewMatrix)message;

                SetupCameraMatrices(rMessage);

                break;
            }

            case MyRenderMessageEnum.DrawScene:
            {
                var rMessage = (IMyRenderMessage)message;

                m_drawQueue.Enqueue(rMessage);

                m_messageTracker.Clear();

                break;
            }

            case MyRenderMessageEnum.RebuildCullingStructure:
            {
                break;
            }

                #region Profiler

            case MyRenderMessageEnum.RenderProfiler:
            {
                var profMessage = (MyRenderMessageRenderProfiler)message;

                MyRenderProfiler.HandleInput(profMessage.Command, profMessage.Index);

                break;
            }

                #endregion

                #region Characters

            case MyRenderMessageEnum.CreateRenderCharacter:
            {
                var rMessage = (MyRenderMessageCreateRenderCharacter)message;

                var    actor        = MyActorFactory.CreateCharacter();
                Matrix worldMatrixF = rMessage.WorldMatrix;
                //actor.GetRenderable().SetModel(MyAssetsLoader.GetModel(rMessage.Model));
                actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(rMessage.Model)));
                actor.SetMatrix(ref worldMatrixF);

                if (rMessage.ColorMaskHSV.HasValue)
                {
                    var color = ColorFromMask(rMessage.ColorMaskHSV.Value);
                    actor.GetRenderable().SetKeyColor(new Vector4(color, 1));
                }

                actor.SetID(rMessage.ID);

                //var entity = MyComponents.CreateEntity(rMessage.ID);
                //MyComponents.CreateRenderable(
                //    entity,
                //    MyMeshes.GetMeshId(X.TEXT(rMessage.Model)),
                //    rMessage.ColorMaskHSV.HasValue ? rMessage.ColorMaskHSV.Value : Vector3.One);
                //MyComponents.SetMatrix(entity, ref rMessage.WorldMatrix);

                break;
            }

            case MyRenderMessageEnum.SetCharacterSkeleton:
            {
                var rMessage = (MyRenderMessageSetCharacterSkeleton)message;

                var actor = MyIDTracker <MyActor> .FindByID(rMessage.CharacterID);

                if (actor != null)
                {
                    actor.GetSkinning().SetSkeleton(rMessage.SkeletonBones, rMessage.SkeletonIndices);
                }

                //var entity = MyComponents.GetEntity(rMessage.CharacterID);
                //MyComponents.SetSkeleton(entity, rMessage.SkeletonBones, rMessage.SkeletonIndices);

                break;
            };

            case MyRenderMessageEnum.SetCharacterTransforms:
            {
                var rMessage = (MyRenderMessageSetCharacterTransforms)message;

                var actor = MyIDTracker <MyActor> .FindByID(rMessage.CharacterID);

                if (actor != null)
                {
                    actor.GetSkinning().SetAnimationBones(rMessage.RelativeBoneTransforms);
                }
                //var entity = MyComponents.GetEntity(rMessage.CharacterID);
                //MyComponents.SetAnimation(entity, rMessage.RelativeBoneTransforms);

                break;
            }

            case MyRenderMessageEnum.UpdateRenderEntity:
            {
                var rMessage = (MyRenderMessageUpdateRenderEntity)message;

                var actor = MyIDTracker <MyActor> .FindByID(rMessage.ID);

                if (actor != null && actor.GetRenderable() != null)
                {
                    if (rMessage.ColorMaskHSV.HasValue)
                    {
                        actor.GetRenderable().SetKeyColor(new Vector4(ColorFromMask(rMessage.ColorMaskHSV.Value), 1));
                    }
                    actor.GetRenderable().SetDithering(rMessage.Dithering);

                    if (rMessage.Dithering < 0)
                    {
                    }
                }

                break;
            }

            case MyRenderMessageEnum.ChangeModelMaterial:
            {
                var rMessage = (MyRenderMessageChangeModelMaterial)message;



                //var matId = MyMeshMaterialId.NULL;
                //if (rMessage.Material.ToLower().Contains("debug"))
                //{
                //    matId = MyMeshMaterials1.DebugMaterialId;
                //}
                //else
                //{
                //    matId = MyMeshMaterials1.GetMaterialId(rMessage.Material);
                //}

                //MyAssetsLoader.GetModel(rMessage.Model).SetMaterial_SLOW(MyMeshMaterials1.GetProxyId(matId));

                break;
            }

                #endregion

                #region Render objects

            case MyRenderMessageEnum.CreateRenderEntity:
            {
                var rMessage = (MyRenderMessageCreateRenderEntity)message;

                Matrix m = (Matrix)rMessage.WorldMatrix;

                var actor = MyActorFactory.CreateSceneObject();
                if (rMessage.Model != null)
                {
                    var model = MyAssetsLoader.ModelRemap.Get(rMessage.Model, rMessage.Model);

                    actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(model)));
                    //if (MyDestructionMesh.ModelsDictionary.ContainsKey(model))
                    //{
                    //    //actor.GetRenderable().SetModel(MyDestructionMesh.ModelsDictionary.Get(model));
                    //    actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(model)));
                    //}
                    //else
                    //{
                    //    //actor.GetRenderable().SetModel(MyAssetsLoader.GetModel(model));
                    //    actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(model)));
                    //}
                }

                actor.SetID(rMessage.ID);
                actor.SetMatrix(ref m);

                break;
            }

            case MyRenderMessageEnum.CreateRenderVoxelDebris:
            {
                var rMessage = (MyRenderMessageCreateRenderVoxelDebris)message;

                Matrix m = (Matrix)rMessage.WorldMatrix;

                var actor = MyActorFactory.CreateSceneObject();
                if (rMessage.Model != null)
                {
                    actor.GetRenderable().SetModel(MyMeshes.GetMeshId(X.TEXT(rMessage.Model)));
                }

                actor.SetID(rMessage.ID);
                actor.SetMatrix(ref m);

                MyRenderableComponent.DebrisEntityVoxelMaterial[rMessage.ID] = rMessage.VoxelMaterialIndex;

                break;
            }

            case MyRenderMessageEnum.UpdateRenderObject:
            {
                var rMessage = (MyRenderMessageUpdateRenderObject)message;

                var actor = MyIDTracker <MyActor> .FindByID(rMessage.ID);

                if (actor != null)
                {
                    Matrix m = (Matrix)rMessage.WorldMatrix;
                    actor.SetMatrix(ref m);
                    if (rMessage.AABB.HasValue)
                    {
                        actor.SetAabb((BoundingBox)rMessage.AABB.Value);
                    }
                }

                var entity = MyComponents.GetEntity(rMessage.ID);
                if (entity != EntityId.NULL)
                {
                    MyComponents.SetMatrix(entity, ref rMessage.WorldMatrix);
                    if (rMessage.AABB.HasValue)
                    {
                        var aabb = rMessage.AABB.Value;
                        MyComponents.SetAabb(entity, ref aabb);
                    }
                }

                break;
            }

            case MyRenderMessageEnum.RemoveRenderObject:
            {
                var rMessage = (MyRenderMessageRemoveRenderObject)message;

                var actor = MyIDTracker <MyActor> .FindByID(rMessage.ID);

                if (actor != null)
                {
                    if (actor.GetRenderable() != null && actor.GetRenderable().GetModel().Info.Dynamic)
                    {
                        MyMeshes.RemoveMesh(actor.GetRenderable().GetModel());
                    }

                    actor.Destruct();
                }

                var instancing = MyInstancing.Get(rMessage.ID);
                if (instancing != InstancingId.NULL)
                {
                    MyInstancing.Remove(rMessage.ID, instancing);
                }

                var light = MyLights.Get(rMessage.ID);
                if (light != LightId.NULL)
                {
                    MyLights.Remove(rMessage.ID, light);
                }

                var clipmap = MyClipmapFactory.ClipmapByID.Get(rMessage.ID);
                if (clipmap != null)
                {
                    clipmap.RemoveFromUpdate();
                }

                break;
            }

            case MyRenderMessageEnum.UpdateRenderObjectVisibility:
            {
                var rMessage = (MyRenderMessageUpdateRenderObjectVisibility)message;

                var actor = MyIDTracker <MyActor> .FindByID(rMessage.ID);

                if (actor != null)
                {
                    actor.SetVisibility(rMessage.Visible);
                }

                break;
            }


            case MyRenderMessageEnum.CreateRenderInstanceBuffer:
            {
                var rMessage = (MyRenderMessageCreateRenderInstanceBuffer)message;

                //var instancing = MyComponentFactory<MyInstancingComponent>.Create();
                //instancing.SetID(rMessage.ID);
                //instancing.Init(rMessage.Type);
                //instancing.SetDebugName(rMessage.DebugName);

                MyInstancing.Create(rMessage.ID, rMessage.Type, rMessage.DebugName);

                break;
            }

            case MyRenderMessageEnum.UpdateRenderInstanceBuffer:
            {
                var rMessage = (MyRenderMessageUpdateRenderInstanceBuffer)message;

                //var instancing = MyIDTracker<MyInstancingComponent>.FindByID(rMessage.ID);
                //if(instancing != null)
                //{
                //    instancing.UpdateGeneric(rMessage.InstanceData, rMessage.Capacity);
                //}

                MyInstancing.UpdateGeneric(MyInstancing.Get(rMessage.ID), rMessage.InstanceData, rMessage.Capacity);

                rMessage.InstanceData.Clear();

                break;
            }

            case MyRenderMessageEnum.UpdateRenderCubeInstanceBuffer:
            {
                var rMessage = (MyRenderMessageUpdateRenderCubeInstanceBuffer)message;

                //var instancing = MyIDTracker<MyInstancingComponent>.FindByID(rMessage.ID);
                //if (instancing != null)
                //{
                //    instancing.UpdateCube(rMessage.InstanceData, rMessage.Capacity);
                //}
                MyInstancing.UpdateCube(MyInstancing.Get(rMessage.ID), rMessage.InstanceData, rMessage.Capacity);

                rMessage.InstanceData.Clear();

                break;
            }

            case MyRenderMessageEnum.SetInstanceBuffer:
            {
                var rMessage = (MyRenderMessageSetInstanceBuffer)message;

                var actor = MyIDTracker <MyActor> .FindByID(rMessage.ID);

                //var instancing = MyIDTracker<MyInstancingComponent>.FindByID(rMessage.InstanceBufferId);

                if (actor != null)
                {
                    //if (actor.GetComponent(MyActorComponentEnum.Instancing) != instancing)
                    //{
                    //    actor.AddComponent(instancing);
                    //}
                    //actor.SetLocalAabb(rMessage.LocalAabb);
                    //actor.GetRenderable().SetInstancingCounters(rMessage.InstanceCount, rMessage.InstanceStart);

                    actor.GetRenderable().SetInstancing(MyInstancing.Get(rMessage.InstanceBufferId));
                    actor.SetLocalAabb(rMessage.LocalAabb);
                    actor.GetRenderable().SetInstancingCounters(rMessage.InstanceCount, rMessage.InstanceStart);
                }

                break;
            }

            case MyRenderMessageEnum.CreateManualCullObject:
            {
                var rMessage = (MyRenderMessageCreateManualCullObject)message;

                var actor = MyActorFactory.CreateGroup();
                actor.SetID(rMessage.ID);
                Matrix m = (Matrix)rMessage.WorldMatrix;
                actor.SetMatrix(ref m);

                break;
            }

            case MyRenderMessageEnum.SetParentCullObject:
            {
                var rMessage = (MyRenderMessageSetParentCullObject)message;

                var child = MyIDTracker <MyActor> .FindByID(rMessage.ID);

                var parent = MyIDTracker <MyActor> .FindByID(rMessage.CullObjectID);

                if (child != null && parent != null && parent.GetGroupRoot() != null && child.GetGroupLeaf() == null)
                {
                    child.SetRelativeTransform(rMessage.ChildToParent);
                    parent.GetGroupRoot().Add(child);
                }

                break;
            }

            case MyRenderMessageEnum.CreateLineBasedObject:
            {
                var rMessage = (MyRenderMessageCreateLineBasedObject)message;

                var actor = MyActorFactory.CreateSceneObject();
                //actor.GetRenderable().SetModel(new MyDynamicMesh());

                actor.SetID(rMessage.ID);
                actor.SetMatrix(ref Matrix.Identity);

                MyMeshMaterials1.GetMaterialId("__ROPE_MATERIAL", null, "Textures/rope_cm.dds", "Textures/rope_ng.dds", "Textures/rope_add.dds", MyMesh.DEFAULT_MESH_TECHNIQUE);
                actor.GetRenderable().SetModel(MyMeshes.CreateRuntimeMesh(X.TEXT("LINE" + rMessage.ID), 1, true));

                break;
            }

            case MyRenderMessageEnum.UpdateLineBasedObject:
            {
                var rMessage = (MyRenderMessageUpdateLineBasedObject)message;

                var actor = MyIDTracker <MyActor> .FindByID(rMessage.ID);

                if (actor != null)
                {
                    //var mesh = actor.GetRenderable().GetMesh() as MyDynamicMesh;

                    MyVertexFormatPositionH4 []            stream0;
                    MyVertexFormatTexcoordNormalTangent [] stream1;

                    MyLineHelpers.GenerateVertexData(ref rMessage.WorldPointA, ref rMessage.WorldPointB,
                                                     out stream0, out stream1);

                    var indices  = MyLineHelpers.GenerateIndices(stream0.Length);
                    var sections = new MySectionInfo[]
                    {
                        new MySectionInfo {
                            TriCount = indices.Length / 3, IndexStart = 0, MaterialName = "__ROPE_MATERIAL"
                        }
                    };

                    MyMeshes.UpdateRuntimeMesh(MyMeshes.GetMeshId(X.TEXT("LINE" + rMessage.ID)),
                                               indices,
                                               stream0,
                                               stream1,
                                               sections,
                                               (BoundingBox)MyLineHelpers.GetBoundingBox(ref rMessage.WorldPointA, ref rMessage.WorldPointB));

                    //actor.SetAabb((BoundingBox)MyLineHelpers.GetBoundingBox(ref rMessage.WorldPointA, ref rMessage.WorldPointB));
                    actor.MarkRenderDirty();

                    var matrix = Matrix.CreateTranslation((Vector3)(rMessage.WorldPointA + rMessage.WorldPointB) * 0.5f);
                    actor.SetMatrix(ref matrix);
                }

                break;
            }

            case MyRenderMessageEnum.SetRenderEntityData:
            {
                var rMessage = (MyRenderMessageSetRenderEntityData)message;

                Debug.Assert(false, "MyRenderMessageSetRenderEntityData is deprecated!");

                break;
            }

            case MyRenderMessageEnum.AddRuntimeModel:
            {
                var rMessage = (MyRenderMessageAddRuntimeModel)message;

                //MyDestructionMesh mesh = MyDestructionMesh.ModelsDictionary.Get(rMessage.Name);
                //if (mesh == null)
                //{
                //mesh = new MyDestructionMesh(rMessage.Name);

                //ProfilerShort.Begin("LoadBuffers");
                //mesh.Fill(rMessage.ModelData.Indices, rMessage.ModelData.Positions, rMessage.ModelData.Normals, rMessage.ModelData.Tangents, rMessage.ModelData.TexCoords, rMessage.ModelData.Sections, rMessage.ModelData.AABB);
                //ProfilerShort.End();

                if (!MyMeshes.Exists(rMessage.Name))
                {
                    {
                        ushort[] indices = new ushort[rMessage.ModelData.Indices.Count];
                        for (int i = 0; i < rMessage.ModelData.Indices.Count; i++)
                        {
                            indices[i] = (ushort)rMessage.ModelData.Indices[i];
                        }
                        var verticesNum = rMessage.ModelData.Positions.Count;
                        MyVertexFormatPositionH4[]            stream0 = new MyVertexFormatPositionH4[verticesNum];
                        MyVertexFormatTexcoordNormalTangent[] stream1 = new MyVertexFormatTexcoordNormalTangent[verticesNum];
                        for (int i = 0; i < verticesNum; i++)
                        {
                            stream0[i] = new MyVertexFormatPositionH4(rMessage.ModelData.Positions[i]);
                            stream1[i] = new MyVertexFormatTexcoordNormalTangent(
                                rMessage.ModelData.TexCoords[i], rMessage.ModelData.Normals[i], rMessage.ModelData.Tangents[i]);
                        }
                        var id = MyMeshes.CreateRuntimeMesh(X.TEXT(rMessage.Name), rMessage.ModelData.Sections.Count, false);
                        MyMeshes.UpdateRuntimeMesh(id, indices, stream0, stream1, rMessage.ModelData.Sections.ToArray(), rMessage.ModelData.AABB);
                    }

                    if (rMessage.ReplacedModel != null)
                    {
                        //MyAssetsLoader.ModelRemap[rMessage.ReplacedModel] = rMessage.Name;
                        MyAssetsLoader.ModelRemap[rMessage.Name] = rMessage.ReplacedModel;
                    }

                    //if (MyAssetsLoader.LOG_MESH_STATISTICS)
                    //{
                    //    mesh.DebugWriteInfo();
                    //}
                }

                break;
            }

            case MyRenderMessageEnum.UpdateModelProperties:
            {
                var rMessage = (MyRenderMessageUpdateModelProperties)message;

                var actor = MyIDTracker <MyActor> .FindByID(rMessage.ID);

                if (actor != null)
                {
                    var key = new MyEntityMaterialKey {
                        LOD = rMessage.LOD, Material = X.TEXT(rMessage.MaterialName)
                    };

                    if (rMessage.Enabled.HasValue)
                    {
                        if (!MyScene.EntityDisabledMaterials.ContainsKey(rMessage.ID))
                        {
                            MyScene.EntityDisabledMaterials.Add(rMessage.ID, new HashSet <MyEntityMaterialKey>());
                        }

                        if (!rMessage.Enabled.Value)
                        {
                            MyScene.EntityDisabledMaterials[rMessage.ID].Add(key);
                        }
                        else
                        {
                            MyScene.EntityDisabledMaterials[rMessage.ID].Remove(key);
                        }
                    }

                    var r = actor.GetRenderable();

                    if ((rMessage.Emissivity.HasValue || rMessage.DiffuseColor.HasValue) && !r.ModelProperties.ContainsKey(key))
                    {
                        r.ModelProperties[key] = new MyModelProperties();
                    }

                    if (rMessage.Emissivity.HasValue)
                    {
                        r.ModelProperties[key].Emissivity = rMessage.Emissivity.Value;
                    }

                    if (rMessage.DiffuseColor.HasValue)
                    {
                        r.ModelProperties[key].ColorMul = rMessage.DiffuseColor.Value;
                    }

                    actor.MarkRenderDirty();
                }

                break;
            }

            case MyRenderMessageEnum.PreloadModel:
            {
                var rMessage = (MyRenderMessagePreloadModel)message;

                //MyAssetsLoader.GetModel(rMessage.Name);
                MyMeshes.GetMeshId(X.TEXT(rMessage.Name));

                break;
            }

            case MyRenderMessageEnum.ChangeMaterialTexture:
            {
                var rMessage = (MyRenderMessageChangeMaterialTexture)message;

                var actor = MyIDTracker <MyActor> .FindByID(rMessage.RenderObjectID);

                if (actor != null)
                {
                    var r   = actor.GetRenderable();
                    var key = new MyEntityMaterialKey {
                        LOD = 0, Material = X.TEXT(rMessage.MaterialName)
                    };

                    if (!r.ModelProperties.ContainsKey(key))
                    {
                        r.ModelProperties[key] = new MyModelProperties();
                    }
                    r.ModelProperties[key].TextureSwap = new MyMaterialTextureSwap {
                        TextureName = X.TEXT(rMessage.TextureName)
                    };

                    r.FreeCustomRenderTextures(key);

                    actor.MarkRenderDirty();
                }

                break;
            }

            case MyRenderMessageEnum.DrawTextToMaterial:
            {
                var rMessage = (MyRenderMessageDrawTextToMaterial)message;

                //rMessage.EntityId
                //rMessage.FontColor
                //rMessage.MaterialName
                //rMessage.Text;
                //rMessage.TextScale;

                var actor = MyIDTracker <MyActor> .FindByID(rMessage.RenderObjectID);

                if (actor != null)
                {
                    var r   = actor.GetRenderable();
                    var key = new MyEntityMaterialKey {
                        LOD = 0, Material = X.TEXT(rMessage.MaterialName)
                    };

                    if (!r.ModelProperties.ContainsKey(key))
                    {
                        r.ModelProperties[key] = new MyModelProperties();
                    }
                    else
                    {
                        r.ModelProperties[key].TextureSwap = null;
                    }

                    RwTexId handle = r.ModelProperties[key].CustomRenderedTexture;
                    if (handle == RwTexId.NULL && MyModelProperties.CustomTextures < MyModelProperties.MaxCustomTextures)
                    {
                        handle = MyRwTextures.CreateRenderTarget(rMessage.TextureResolution * rMessage.TextureAspectRatio, rMessage.TextureResolution, SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, true);
                        r.ModelProperties[key].CustomRenderedTexture = handle;
                        ++MyModelProperties.CustomTextures;
                    }

                    if (handle != RwTexId.NULL)
                    {
                        var clearColor = new SharpDX.Color4(rMessage.BackgroundColor.PackedValue);
                        clearColor.Alpha = 0;
                        MyRender11.ImmediateContext.ClearRenderTargetView(handle.Rtv, clearColor);

                        // my sprites renderer -> push state
                        MySpritesRenderer.PushState(new Vector2(rMessage.TextureResolution * rMessage.TextureAspectRatio, rMessage.TextureResolution));


                        MySpritesRenderer.DrawText(Vector2.Zero, new StringBuilder(rMessage.Text), rMessage.FontColor, rMessage.TextScale);
                        // render text with fonts to rt
                        // update texture of proxy
                        MySpritesRenderer.Draw(handle.Rtv, new MyViewport(rMessage.TextureResolution * rMessage.TextureAspectRatio, rMessage.TextureResolution));

                        // render to rt
                        // my sprites renderer -> pop state
                        MySpritesRenderer.PopState();


                        MyRender11.ImmediateContext.GenerateMips(handle.ShaderView);

                        actor.MarkRenderDirty();
                    }
                    else
                    {
                        MyRenderProxy.TextNotDrawnToTexture(rMessage.EntityId);
                    }
                }
                else
                {
                    MyRenderProxy.TextNotDrawnToTexture(rMessage.EntityId);
                }

                break;
            }

            case MyRenderMessageEnum.PreloadMaterials:
            {
                var rMessage = (MyRenderMessagePreloadMaterials)message;

                //MyAssetsLoader.GetMaterials(rMessage.Name);
                MyMeshes.GetMeshId(X.TEXT(rMessage.Name));

                break;
            }

                #endregion

                #region Voxels

            case MyRenderMessageEnum.CreateClipmap:
            {
                var rMessage = (MyRenderMessageCreateClipmap)message;

                var clipmap = new MyClipmapHandler(rMessage.ClipmapId, rMessage.ScaleGroup, rMessage.WorldMatrix, rMessage.SizeLod0);
                MyClipmapFactory.ClipmapByID[rMessage.ClipmapId] = clipmap;
                clipmap.Base.LoadContent();


                break;
            }

            case MyRenderMessageEnum.UpdateClipmapCell:
            {
                var rMessage = (MyRenderMessageUpdateClipmapCell)message;

                var clipmap = MyClipmapFactory.ClipmapByID.Get(rMessage.ClipmapId);
                if (clipmap != null)
                {
                    clipmap.Base.UpdateCell(rMessage);
                }

                rMessage.Batches.Clear();
                break;
            }

            case MyRenderMessageEnum.InvalidateClipmapRange:
            {
                var rMessage = (MyRenderMessageInvalidateClipmapRange)message;

                var clipmap = MyClipmapFactory.ClipmapByID.Get(rMessage.ClipmapId);
                if (clipmap != null)
                {
                    clipmap.Base.InvalidateRange(rMessage.MinCellLod0, rMessage.MaxCellLod0);
                }

                break;
            }

            case MyRenderMessageEnum.CreateRenderVoxelMaterials:
            {
                var rMessage = (MyRenderMessageCreateRenderVoxelMaterials)message;

                Debug.Assert(MyVoxelMaterials1.CheckIndices(rMessage.Materials));
                MyVoxelMaterials1.Set(rMessage.Materials);

                rMessage.Materials = null;

                break;
            }


                #endregion

                #region Lights

            case MyRenderMessageEnum.CreateRenderLight:
            {
                var rMessage = (MyRenderMessageCreateRenderLight)message;

                //MyLight.Create(rMessage.ID);

                MyLights.Create(rMessage.ID);

                break;
            }

            case MyRenderMessageEnum.UpdateRenderLight:
            {
                var rMessage = (MyRenderMessageUpdateRenderLight)message;


                var light = MyLights.Get(rMessage.ID);

                if (light != LightId.NULL)
                {
                    var lightInfo = new MyLightInfo
                    {
                        Position           = rMessage.Position,
                        PositionWithOffset = rMessage.Position + rMessage.Offset * rMessage.Range * rMessage.ReflectorDirection,
                        CastsShadows       = rMessage.CastShadows,
                        ShadowsDistance    = rMessage.ShadowDistance,
                        ParentGID          = rMessage.ParentID,
                        UsedInForward      = rMessage.UseInForwardRender
                    };

                    MyLights.UpdateEntity(light, ref lightInfo);

                    if ((rMessage.Type & LightTypeEnum.PointLight) > 0)
                    {
                        MyLights.UpdatePointlight(light, rMessage.LightOn, rMessage.Range, new Vector3(rMessage.Color.R, rMessage.Color.G, rMessage.Color.B) / 255.0f * rMessage.Intensity, rMessage.Falloff);
                    }
                    if ((rMessage.Type & LightTypeEnum.Hemisphere) > 0)
                    {
                        //rMessage.Color;
                        //rMessage.Falloff;
                        //rMessage.Intensity;
                        //rMessage.LightOn;
                        //rMessage.ReflectorDirection;
                        //rMessage.ReflectorUp;
                    }
                    if ((rMessage.Type & LightTypeEnum.Spotlight) > 0)
                    {
                        // because it's so in dx9...
                        float coneMaxAngleCos = 1 - rMessage.ReflectorConeMaxAngleCos;
                        coneMaxAngleCos = (float)Math.Min(Math.Max(coneMaxAngleCos, 0.01), 0.99f);
                        MyLights.UpdateSpotlight(light, rMessage.ReflectorOn,
                                                 rMessage.ReflectorDirection, rMessage.ReflectorRange, coneMaxAngleCos, rMessage.ReflectorUp,
                                                 new Vector3(rMessage.ReflectorColor.R, rMessage.ReflectorColor.G, rMessage.ReflectorColor.B) / 255.0f * rMessage.Intensity, rMessage.ReflectorFalloff,
                                                 MyTextures.GetTexture(rMessage.ReflectorTexture, MyTextureEnum.CUSTOM));
                    }

                    if (rMessage.GlareOn)
                    {
                        MyLights.UpdateGlare(light, new MyGlareDesc
                            {
                                Enabled     = rMessage.GlareOn,
                                Material    = X.TEXT(rMessage.GlareMaterial),
                                Intensity   = rMessage.GlareIntensity,
                                QuerySize   = rMessage.GlareQuerySize,
                                Type        = rMessage.GlareType,
                                Size        = rMessage.GlareSize,
                                MaxDistance = rMessage.GlareMaxDistance,
                                Color       = rMessage.Color,
                                Direction   = rMessage.ReflectorDirection,
                                Range       = rMessage.Range
                            });
                    }
                }

                break;
            }

            case MyRenderMessageEnum.SetLightShadowIgnore:
            {
                var rMessage = (MyRenderMessageSetLightShadowIgnore)message;

                var light = MyLights.Get(rMessage.ID);
                var actor = MyIDTracker <MyActor> .FindByID(rMessage.ID2);

                if (light != LightId.NULL && actor != null)
                {
                    if (!MyLights.IgnoredEntitites.ContainsKey(light))
                    {
                        MyLights.IgnoredEntitites[light] = new HashSet <uint>();
                    }
                    MyLights.IgnoredEntitites[light].Add(rMessage.ID2);
                }

                break;
            }


            case MyRenderMessageEnum.ClearLightShadowIgnore:
            {
                var rMessage = (MyRenderMessageClearLightShadowIgnore)message;

                var light = MyLights.Get(rMessage.ID);
                if (light != LightId.NULL)
                {
                    MyLights.IgnoredEntitites.Remove(light);
                }

                break;
            }

            case MyRenderMessageEnum.UpdateFogSettings:
            {
                var rMessage = (MyRenderMessageUpdateFogSettings)message;

                MyEnvironment.FogSettings = rMessage.Settings;

                break;
            }

            case MyRenderMessageEnum.UpdateRenderEnvironment:
            {
                var rMessage = (MyRenderMessageUpdateRenderEnvironment)message;

                MyEnvironment.DirectionalLightDir       = VRageMath.Vector3.Normalize(rMessage.SunDirection);
                MyEnvironment.DirectionalLightIntensity = rMessage.SunIntensity * rMessage.SunColor.ToVector3();
                MyEnvironment.DirectionalLightEnabled   = rMessage.SunLightOn;
                MyEnvironment.DayTime           = (float)(rMessage.DayTime - Math.Truncate(rMessage.DayTime));
                MyEnvironment.SunDistance       = rMessage.DistanceToSun;
                MyEnvironment.SunColor          = rMessage.SunColor;
                MyEnvironment.SunMaterial       = rMessage.SunMaterial;
                MyEnvironment.SunSizeMultiplier = rMessage.SunSizeMultiplier;

                var skybox = rMessage.BackgroundTexture;

                m_resetEyeAdaptation = m_resetEyeAdaptation || rMessage.ResetEyeAdaptation;

                break;
            }

            case MyRenderMessageEnum.UpdateEnvironmentMap:
            {
                break;
            }

            case MyRenderMessageEnum.UpdatePostprocessSettings:
            {
                var rMessage = (MyRenderMessageUpdatePostprocessSettings)message;

                m_postprocessSettings = rMessage.Settings;

                break;
            }

            case MyRenderMessageEnum.UpdateSSAOSettings:
            {
                var rMessage = (MyRenderMessageUpdateSSAOSettings)message;


                MySSAO.Params.MinRadius  = rMessage.MinRadius;
                MySSAO.Params.MaxRadius  = rMessage.MaxRadius;
                MySSAO.Params.RadiusGrow = rMessage.RadiusGrowZScale;

                MySSAO.Params.RadiusBias    = rMessage.Bias;
                MySSAO.Params.Falloff       = rMessage.Falloff;
                MySSAO.Params.Normalization = rMessage.NormValue;
                MySSAO.Params.Contrast      = rMessage.Contrast;

                break;
            }

                #endregion

                #region Sprites
            case MyRenderMessageEnum.DrawSprite:
            case MyRenderMessageEnum.DrawSpriteNormalized:
            case MyRenderMessageEnum.DrawSpriteAtlas:
            case MyRenderMessageEnum.SpriteScissorPush:
            case MyRenderMessageEnum.SpriteScissorPop:
            {
                m_drawQueue.Enqueue(message);
                break;
            }

                #endregion

                #region Fonts and text

            case MyRenderMessageEnum.CreateFont:
            {
                var createFontMessage = message as MyRenderMessageCreateFont;
                Debug.Assert(createFontMessage != null);

                var renderFont = new MyRenderFont(createFontMessage.FontPath);
                renderFont.LoadContent();
                AddFont(createFontMessage.FontId, renderFont, createFontMessage.IsDebugFont);

                break;
            }

            case MyRenderMessageEnum.DrawString:
            {
                m_drawQueue.Enqueue(message);
                break;
            }

                #endregion

                #region Textures

            case MyRenderMessageEnum.PreloadTextures:
            {
                var preloadMsg = message as MyRenderMessagePreloadTextures;

                //MyTextureManager.PreloadTextures(preloadMsg.InDirectory, preloadMsg.Recursive);
                //MyTextures.UnloadTexture(texMessage.Texture);

                break;
            }

            case MyRenderMessageEnum.UnloadTexture:
            {
                var texMessage = (MyRenderMessageUnloadTexture)message;

                //MyTextureManager.UnloadTexture(texMessage.Texture);
                MyTextures.UnloadTexture(texMessage.Texture);

                break;
            }

            case MyRenderMessageEnum.ReloadTextures:
            {
                var reloadMsg = (MyRenderMessageReloadTextures)message;

                MyVoxelMaterials1.InvalidateMaterials();
                MyMeshMaterials1.InvalidateMaterials();
                MyTextures.ReloadAssetTextures();

                //MyTextureManager.UnloadTextures();
                //MyMaterialProxyFactory.ReloadTextures();

                break;
            }

            case MyRenderMessageEnum.ReloadModels:
            {
                var reloadMsg = (MyRenderMessageReloadModels)message;

                //MyMaterials.Clear();
                MyAssetsLoader.ReloadMeshes();
                MyRenderableComponent.MarkAllDirty();

                break;
            }

                #endregion

            case MyRenderMessageEnum.TakeScreenshot:
            {
                var rMessage = (MyRenderMessageTakeScreenshot)message;

                m_screenshot = new MyScreenshot(rMessage.PathToSave, rMessage.SizeMultiplier, rMessage.IgnoreSprites);

                break;
            }

            case MyRenderMessageEnum.ReloadEffects:
            {
                m_reloadShaders = true;

                //MyShaderBundleFactory.ClearCache();
                //MyShaderMaterial.ClearCache();
                //MyShaderPass.ClearCache();

                MyShaders.Recompile();
                MyMaterialShaders.Recompile();

                MyRenderableComponent.MarkAllDirty();

                foreach (var f in MyComponentFactory <MyFoliageComponent> .GetAll())
                {
                    f.Dispose();
                }

                break;
            }

            case MyRenderMessageEnum.PlayVideo:
            {
                var rMessage = (MyRenderMessagePlayVideo)message;

                MyVideoFactory.Create(rMessage.ID, rMessage.VideoFile);
                var video = MyVideoFactory.Videos.Get(rMessage.ID);
                if (video != null)
                {
                    video.Volume = rMessage.Volume;
                }

                break;
            }

            case MyRenderMessageEnum.CloseVideo:
            {
                var rMessage = (MyRenderMessageCloseVideo)message;

                var video = MyVideoFactory.Videos.Get(rMessage.ID);
                if (video != null)
                {
                    video.Stop();
                    video.Dispose();
                    MyVideoFactory.Videos.Remove(rMessage.ID);
                }

                break;
            }

            case MyRenderMessageEnum.DrawVideo:
            {
                var rMessage = (MyRenderMessageDrawVideo)message;

                var video = MyVideoFactory.Videos.Get(rMessage.ID);
                if (video != null)
                {
                    video.Draw(rMessage.Rectangle, rMessage.Color, rMessage.FitMode);
                }

                break;
            }

            case MyRenderMessageEnum.UpdateVideo:
            {
                var rMessage = (MyRenderMessageUpdateVideo)message;

                var video = MyVideoFactory.Videos.Get(rMessage.ID);
                if (video != null)
                {
                    video.Update();
                }

                break;
            }

            case MyRenderMessageEnum.SetVideoVolume:
            {
                var rMessage = (MyRenderMessageSetVideoVolume)message;

                var video = MyVideoFactory.Videos.Get(rMessage.ID);
                if (video != null)
                {
                    video.Volume = rMessage.Volume;
                }

                break;
            }

            case MyRenderMessageEnum.VideoAdaptersRequest:
            {
                MyRenderProxy.SendVideoAdapters(GetAdaptersList());
                break;
            }

            case MyRenderMessageEnum.SwitchDeviceSettings:
            {
                MyRenderProxy.RenderThread.SwitchSettings((message as MyRenderMessageSwitchDeviceSettings).Settings);
                break;
            }

            case MyRenderMessageEnum.SwitchRenderSettings:
                break;         // Can be ignored as we're handling newer version of the message.

            case MyRenderMessageEnum.SwitchRenderSettings1:
            {
                UpdateRenderSettings((message as MyRenderMessageSwitchRenderSettings1).Settings);
                break;
            }

            case MyRenderMessageEnum.UnloadData:
            {
                MyRender11.UnloadData();
                break;
            }

            case MyRenderMessageEnum.CollectGarbage:
            {
                GC.Collect();
                break;
            }

                #region Debug draw

            case MyRenderMessageEnum.DebugDrawPoint:
            case MyRenderMessageEnum.DebugDrawLine3D:
            case MyRenderMessageEnum.DebugDrawLine2D:
            case MyRenderMessageEnum.DebugDrawSphere:
            case MyRenderMessageEnum.DebugDrawAABB:
            case MyRenderMessageEnum.DebugDrawAxis:
            case MyRenderMessageEnum.DebugDrawOBB:
            case MyRenderMessageEnum.DebugDrawCone:
            case MyRenderMessageEnum.DebugDrawTriangle:
            case MyRenderMessageEnum.DebugDrawCapsule:
            case MyRenderMessageEnum.DebugDrawText2D:
            case MyRenderMessageEnum.DebugDrawText3D:
            case MyRenderMessageEnum.DebugDrawModel:
            case MyRenderMessageEnum.DebugDrawTriangles:
            case MyRenderMessageEnum.DebugDrawPlane:
            case MyRenderMessageEnum.DebugDrawCylinder:
            {
                m_debugDrawMessages.Enqueue(message);
            }
            break;

            case MyRenderMessageEnum.DebugCrashRenderThread:
            {
                throw new InvalidOperationException("Forced exception");
            }
                #endregion
            }
        }