internal MyTextureArray(TexId[] mergeList)
{
var srcDesc = MyTextures.GetView(mergeList[0]).Description;
Size = MyTextures.GetSize(mergeList[0]);
ArrayLen = mergeList.Length;
Texture2DDescription desc = new Texture2DDescription();
desc.ArraySize = ArrayLen;
desc.BindFlags = BindFlags.ShaderResource;
desc.CpuAccessFlags = CpuAccessFlags.None;
desc.Format = srcDesc.Format;
desc.Height = (int)Size.Y;
desc.Width = (int)Size.X;
desc.MipLevels = 0;
desc.SampleDescription.Count = 1;
desc.SampleDescription.Quality = 0;
desc.Usage = ResourceUsage.Default;
m_resource = new Texture2D(MyRender11.Device, desc);
// foreach mip
var mipmaps = (int)Math.Log(Size.X, 2) + 1;
for (int a = 0; a < ArrayLen; a++)
{
for (int m = 0; m < mipmaps; m++)
{
MyRender11.Context.CopySubresourceRegion(MyTextures.Textures.Data[mergeList[a].Index].Resource, Resource.CalculateSubResourceIndex(m, 0, mipmaps), null, Resource,
Resource.CalculateSubResourceIndex(m, a, mipmaps));
}
}
ShaderView = new ShaderResourceView(MyRender11.Device, Resource);
}
internal void Init()
{
var srcData = MyTextures.Textures.Data[m_mergeList[0].Index];
var srcDesc = MyTextures.GetView(m_mergeList[0]).Description;
Size = MyTextures.GetSize(m_mergeList[0]);
ArrayLen = m_mergeList.Length;
Texture2DDescription desc = new Texture2DDescription();
desc.ArraySize = ArrayLen;
desc.BindFlags = BindFlags.ShaderResource;
desc.CpuAccessFlags = CpuAccessFlags.None;
desc.Format = srcDesc.Format;
desc.Height = (int)Size.Y;
desc.Width = (int)Size.X;
desc.MipLevels = srcDesc.Texture2D.MipLevels;
desc.SampleDescription.Count = 1;
desc.SampleDescription.Quality = 0;
desc.Usage = ResourceUsage.Default;
m_resource = new Texture2D(MyRender11.Device, desc);
m_resource.DebugName = m_debugName;
// foreach mip
var mipmaps = srcDesc.Texture2D.MipLevels;
for (int a = 0; a < ArrayLen; a++)
{
var data = MyTextures.Textures.Data[m_mergeList[a].Index];
var tex2D = data.Resource as Texture2D;
MyRenderProxy.Assert(tex2D != null, "MyTextureArray supports only 2D textures. Inconsistent texture: " + data.Name);
bool consistent = tex2D.Description.Format == desc.Format && tex2D.Description.MipLevels == desc.MipLevels &&
tex2D.Description.Width == desc.Width && tex2D.Description.Height == desc.Height;
if (!consistent)
{
string errorMsg = "All MyTextureArray has to have the same pixel format, width / height and # of mipmaps. Inconsistent textures: " + data.Name + " / " + srcData.Name;
MyRenderProxy.Error(errorMsg);
MyRender11.Log.WriteLine(errorMsg);
}
for (int m = 0; m < mipmaps; m++)
{
MyRender11.DeviceContext.CopySubresourceRegion(tex2D, Resource.CalculateSubResourceIndex(m, 0, mipmaps), null, Resource,
Resource.CalculateSubResourceIndex(m, a, mipmaps));
}
}
m_Srv = new ShaderResourceView(MyRender11.Device, Resource);
}
internal MyTextureArray(TexId[] mergeList, string debugName)
{
var srcDesc = MyTextures.GetView(mergeList[0]).Description;
Size = MyTextures.GetSize(mergeList[0]);
ArrayLen = mergeList.Length;
Texture2DDescription desc = new Texture2DDescription();
desc.ArraySize = ArrayLen;
desc.BindFlags = BindFlags.ShaderResource;
desc.CpuAccessFlags = CpuAccessFlags.None;
desc.Format = srcDesc.Format;
desc.Height = (int)Size.Y;
desc.Width = (int)Size.X;
desc.MipLevels = srcDesc.Texture2D.MipLevels;
desc.SampleDescription.Count = 1;
desc.SampleDescription.Quality = 0;
desc.Usage = ResourceUsage.Default;
m_resource = new Texture2D(MyRender11.Device, desc);
m_resource.DebugName = debugName;
// foreach mip
var mipmaps = desc.MipLevels;// (int)Math.Log(Size.X, 2) + 1;
for (int a = 0; a < ArrayLen; a++)
{
var tex2D = MyTextures.Textures.Data[mergeList[a].Index].Resource as Texture2D;
MyRenderProxy.Assert(tex2D != null, "MyTextureArray supports only 2D textures");
MyRenderProxy.Assert(tex2D.Description.Format == desc.Format && tex2D.Description.MipLevels == desc.MipLevels &&
tex2D.Description.Width == desc.Width && tex2D.Description.Height == desc.Height,
"All MyTextureArray has to have the same pixel format, width / height and # of mipmaps.");
for (int m = 0; m < mipmaps; m++)
{
if (((Texture2D)MyTextures.Textures.Data[mergeList[a].Index].Resource).Description.Format != ((Texture2D)Resource).Description.Format)
{
MyRender11.Log.WriteLine(String.Format("Inconsistent format in textures array {0}", MyTextures.Textures.Data[mergeList[a].Index].Name));
}
MyRender11.DeviceContext.CopySubresourceRegion(MyTextures.Textures.Data[mergeList[a].Index].Resource, Resource.CalculateSubResourceIndex(m, 0, mipmaps), null, Resource,
Resource.CalculateSubResourceIndex(m, a, mipmaps));
}
}
ShaderView = new ShaderResourceView(MyRender11.Device, Resource);
}
internal static void AddSingleSprite(TexId texId, Color color, Vector2 origin, Vector2 tangent, Rectangle?sourceRect, RectangleF destinationRect)
{
AddSingleSprite(MyTextures.Views[texId.Index], MyTextures.GetSize(texId), color, origin, tangent, sourceRect, destinationRect);
}
private static void ProcessDrawMessage(MyRenderMessageBase drawMessage)
{
switch (drawMessage.MessageType)
{
case MyRenderMessageEnum.SpriteScissorPush:
{
var msg = drawMessage as MyRenderMessageSpriteScissorPush;
MySpritesRenderer.ScissorStackPush(msg.ScreenRectangle);
break;
}
case MyRenderMessageEnum.SpriteScissorPop:
{
MySpritesRenderer.ScissorStackPop();
break;
}
case MyRenderMessageEnum.DrawSprite:
{
MyRenderMessageDrawSprite sprite = (MyRenderMessageDrawSprite)drawMessage;
MySpritesRenderer.AddSingleSprite(MyTextures.GetTexture(sprite.Texture, MyTextureEnum.GUI, waitTillLoaded: sprite.WaitTillLoaded), sprite.Color, sprite.Origin, sprite.RightVector, sprite.SourceRectangle, sprite.DestinationRectangle);
break;
}
case MyRenderMessageEnum.DrawSpriteNormalized:
{
MyRenderMessageDrawSpriteNormalized sprite = (MyRenderMessageDrawSpriteNormalized)drawMessage;
var rotation = sprite.Rotation;
if (sprite.RotationSpeed != 0)
{
rotation += sprite.RotationSpeed * (float)(MyRender11.CurrentDrawTime - MyRender11.CurrentUpdateTime).Seconds;
}
Vector2 rightVector = rotation != 0f ? new Vector2((float)Math.Cos(rotation), (float)Math.Sin(rotation)) : sprite.RightVector;
int safeGuiSizeY = MyRender11.ResolutionI.Y;
int safeGuiSizeX = (int)(safeGuiSizeY * 1.3333f); // This will mantain same aspect ratio for GUI elements
var safeGuiRectangle = new VRageMath.Rectangle(MyRender11.ResolutionI.X / 2 - safeGuiSizeX / 2, 0, safeGuiSizeX, safeGuiSizeY);
var safeScreenScale = (float)safeGuiSizeY / MyRenderGuiConstants.REFERENCE_SCREEN_HEIGHT;
float fixedScale = sprite.Scale * safeScreenScale;
var tex = MyTextures.GetTexture(sprite.Texture, MyTextureEnum.GUI, true);
var normalizedCoord = sprite.NormalizedCoord;
var screenCoord = new Vector2(safeGuiRectangle.Left + safeGuiRectangle.Width * normalizedCoord.X,
safeGuiRectangle.Top + safeGuiRectangle.Height * normalizedCoord.Y);
var sizeInPixels = MyTextures.GetSize(tex);
var sizeInPixelsScaled = sizeInPixels * fixedScale;
Vector2 alignedScreenCoord = screenCoord;
var drawAlign = sprite.DrawAlign;
if (drawAlign == MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_TOP)
{
// Nothing to do as position is already at this point
}
else if (drawAlign == MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER)
{
// Move position to the texture center
alignedScreenCoord -= sizeInPixelsScaled / 2.0f;
}
else if (drawAlign == MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_TOP)
{
alignedScreenCoord.X -= sizeInPixelsScaled.X / 2.0f;
}
else if (drawAlign == MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_BOTTOM)
{
alignedScreenCoord.X -= sizeInPixelsScaled.X / 2.0f;
alignedScreenCoord.Y -= sizeInPixelsScaled.Y;
}
else if (drawAlign == MyGuiDrawAlignEnum.HORISONTAL_RIGHT_AND_VERTICAL_BOTTOM)
{
alignedScreenCoord -= sizeInPixelsScaled;
}
else if (drawAlign == MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_CENTER)
{
alignedScreenCoord.Y -= sizeInPixelsScaled.Y / 2.0f;
}
else if (drawAlign == MyGuiDrawAlignEnum.HORISONTAL_RIGHT_AND_VERTICAL_CENTER)
{
alignedScreenCoord.X -= sizeInPixelsScaled.X;
alignedScreenCoord.Y -= sizeInPixelsScaled.Y / 2.0f;
}
else if (drawAlign == MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_BOTTOM)
{
alignedScreenCoord.Y -= sizeInPixelsScaled.Y; // *0.75f;
}
else if (drawAlign == MyGuiDrawAlignEnum.HORISONTAL_RIGHT_AND_VERTICAL_TOP)
{
alignedScreenCoord.X -= sizeInPixelsScaled.X;
}
screenCoord = alignedScreenCoord;
var rect = new RectangleF(screenCoord.X, screenCoord.Y, fixedScale * sizeInPixels.X, fixedScale * sizeInPixels.Y);
Vector2 origin;
if (sprite.OriginNormalized.HasValue)
{
origin = sprite.OriginNormalized.Value * sizeInPixels;
}
else
{
origin = sizeInPixels / 2;
}
sprite.OriginNormalized = sprite.OriginNormalized ?? new Vector2(0.5f);
MySpritesRenderer.AddSingleSprite(MyTextures.GetTexture(sprite.Texture, MyTextureEnum.GUI, waitTillLoaded: sprite.WaitTillLoaded), sprite.Color, origin, rightVector, null, rect);
break;
}
case MyRenderMessageEnum.DrawSpriteAtlas:
{
MyRenderMessageDrawSpriteAtlas sprite = (MyRenderMessageDrawSpriteAtlas)drawMessage;
var tex = MyTextures.GetTexture(sprite.Texture, MyTextureEnum.GUI, true);
var textureSize = MyTextures.GetSize(tex);
Rectangle?sourceRect = new Rectangle(
(int)(textureSize.X * sprite.TextureOffset.X),
(int)(textureSize.Y * sprite.TextureOffset.Y),
(int)(textureSize.X * sprite.TextureSize.X),
(int)(textureSize.Y * sprite.TextureSize.Y));
VRageMath.RectangleF destRect = new VRageMath.RectangleF(
(sprite.Position.X) * sprite.Scale.X,
(sprite.Position.Y) * sprite.Scale.Y,
sprite.HalfSize.X * sprite.Scale.X * 2,
sprite.HalfSize.Y * sprite.Scale.Y * 2);
Vector2 origin = new Vector2(textureSize.X * sprite.TextureSize.X * 0.5f, textureSize.Y * sprite.TextureSize.Y * 0.5f);
MySpritesRenderer.AddSingleSprite(MyTextures.GetTexture(sprite.Texture, MyTextureEnum.GUI, true), sprite.Color, origin, sprite.RightVector, sourceRect, destRect);
break;
}
case MyRenderMessageEnum.DrawString:
{
var message = drawMessage as MyRenderMessageDrawString;
var font = MyRender11.GetFont(message.FontIndex);
font.DrawString(
message.ScreenCoord,
message.ColorMask,
message.Text,
message.ScreenScale,
message.ScreenMaxWidth);
break;
}
case MyRenderMessageEnum.DrawScene:
{
UpdateSceneFrame();
ProfilerShort.Begin("DrawScene");
DrawGameScene(Backbuffer);
ProfilerShort.Begin("TransferPerformanceStats");
TransferPerformanceStats();
ProfilerShort.End();
ProfilerShort.End();
ProfilerShort.Begin("Draw scene debug");
MyGpuProfiler.IC_BeginBlock("Draw scene debug");
DrawSceneDebug();
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
ProfilerShort.Begin("ProcessDebugMessages");
ProcessDebugMessages();
ProfilerShort.End();
ProfilerShort.Begin("MyDebugRenderer.Draw");
MyGpuProfiler.IC_BeginBlock("MyDebugRenderer.Draw");
MyDebugRenderer.Draw(MyRender11.Backbuffer);
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
var testingDepth = MyRender11.MultisamplingEnabled ? MyScreenDependants.m_resolvedDepth : MyGBuffer.Main.DepthStencil;
ProfilerShort.Begin("MyPrimitivesRenderer.Draw");
MyGpuProfiler.IC_BeginBlock("MyPrimitivesRenderer.Draw");
MyPrimitivesRenderer.Draw(MyRender11.Backbuffer, testingDepth);
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
ProfilerShort.Begin("MyLinesRenderer.Draw");
MyGpuProfiler.IC_BeginBlock("MyLinesRenderer.Draw");
MyLinesRenderer.Draw(MyRender11.Backbuffer, testingDepth);
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
if (m_screenshot.HasValue && m_screenshot.Value.IgnoreSprites)
{
if (m_screenshot.Value.SizeMult == Vector2.One)
{
SaveScreenshotFromResource(Backbuffer.m_resource);
}
else
{
TakeCustomSizedScreenshot(m_screenshot.Value.SizeMult);
}
}
ProfilerShort.Begin("MySpritesRenderer.Draw");
MyGpuProfiler.IC_BeginBlock("MySpritesRenderer.Draw");
MySpritesRenderer.Draw(MyRender11.Backbuffer.m_RTV, new MyViewport(MyRender11.ViewportResolution.X, MyRender11.ViewportResolution.Y));
MyGpuProfiler.IC_EndBlock();
ProfilerShort.End();
if (MyRenderProxy.DRAW_RENDER_STATS)
{
MyRender11.GetRenderProfiler().StartProfilingBlock("MyRenderStatsDraw.Draw");
MyRenderStatsDraw.Draw(MyRenderStats.m_stats, 0.6f, VRageMath.Color.Yellow);
ProfilerShort.End();
}
break;
}
}
}
internal static void RenderColoredTextures(List <renderColoredTextureProperties> texturesToRender)
{
if (texturesToRender.Count == 0)
{
return;
}
if (!m_initialized)
{
Init();
}
const int RENDER_TEXTURE_RESOLUTION = 512;
RC.DeviceContext.OutputMerger.BlendState = null;
RC.SetIL(null);
RC.SetPS(m_ps);
RC.SetCB(0, MyCommon.FrameConstants);
RC.SetCB(1, m_cb);
Dictionary <Vector2I, MyRenderTarget> createdRenderTextureTargets = new Dictionary <Vector2I, MyRenderTarget>();
foreach (var texture in texturesToRender)
{
TexId texId = MyTextures.GetTexture(texture.TextureName, MyTextureEnum.COLOR_METAL, true);
if (texId == TexId.NULL)
{
continue;
}
Vector2 texSize = MyTextures.GetSize(texId);
Vector2I renderTargetResolution = new Vector2I(RENDER_TEXTURE_RESOLUTION, RENDER_TEXTURE_RESOLUTION);
if (texSize.Y > 0)
{
if (texSize.Y < RENDER_TEXTURE_RESOLUTION)
{
renderTargetResolution.X = (int)texSize.X;
renderTargetResolution.Y = (int)texSize.Y;
}
else
{
renderTargetResolution.X *= (int)(texSize.X / texSize.Y);
}
}
MyViewport viewport = new MyViewport(renderTargetResolution.X, renderTargetResolution.Y);
MyRenderTarget renderTexture = null;
if (!createdRenderTextureTargets.TryGetValue(renderTargetResolution, out renderTexture))
{
renderTexture = new MyRenderTarget(renderTargetResolution.X, renderTargetResolution.Y, SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb, 1, 0);
createdRenderTextureTargets[renderTargetResolution] = renderTexture;
}
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, renderTexture);
// Set color
var mapping = MyMapping.MapDiscard(m_cb);
Vector4 color = new Vector4(texture.ColorMaskHSV, 1);
mapping.WriteAndPosition(ref color);
mapping.Unmap();
// Set texture
RC.DeviceContext.PixelShader.SetShaderResource(0, MyTextures.GetView(texId));
// Draw
MyScreenPass.DrawFullscreenQuad(viewport);
// Save to file
MyTextureData.ToFile(renderTexture.GetHWResource(), texture.PathToSave, ImageFileFormat.Png);
}
texturesToRender.Clear();
foreach (var texture in createdRenderTextureTargets)
{
texture.Value.Release();
}
createdRenderTextureTargets.Clear();
RC.BindDepthRT(null, DepthStencilAccess.ReadWrite, null);
RC.BindGBufferForRead(0, MyGBuffer.Main);
}