private static IResource GetResource(string filepath, MyFileTextureEnum type, MyFileArrayTexture referenceArray, int referenceSlice, Vector2I textureSize, out Texture2DDescription description, out int sourceSlice)
{
if (referenceArray != null && referenceSlice < referenceArray.Size3.Z && referenceArray.Size == textureSize && filepath == referenceArray.SubresourceFilenames[referenceSlice])
{
var tex2d = referenceArray.Resource as Texture2D;
description = tex2d.Description;
sourceSlice = referenceSlice;
return(referenceArray);
}
else
{
var texture = MyManagers.FileTextures.GetTexture(filepath, type, true, temporary: true);
var tex2d = texture.Resource as Texture2D;
if (tex2d == null)
{
var tex2D = texture.Resource as Texture2D;
MyRenderProxy.Assert(tex2D != null,
"MyFileArrayTexture supports only 2D textures. Inconsistent texture: " + filepath);
description = new Texture2DDescription();
sourceSlice = -1;
return(null);
}
description = tex2d.Description;
sourceSlice = 0;
return(texture);
}
}
/// <summary>Bind blend states for alpha blending</summary>
public static void BindMaterialTextureBlendStates(MyRenderContext rc, MyFileTextureEnum textures)
{
textures &= ~MyFileTextureEnum.ALPHAMASK;
switch (textures)
{
case MyFileTextureEnum.COLOR_METAL:
rc.SetBlendState(MyBlendStateManager.BlendDecalNormal);
break;
case MyFileTextureEnum.NORMALMAP_GLOSS:
rc.SetBlendState(MyBlendStateManager.BlendDecalColor);
break;
case MyFileTextureEnum.COLOR_METAL | MyFileTextureEnum.NORMALMAP_GLOSS:
rc.SetBlendState(MyBlendStateManager.BlendDecalNormalColor);
break;
case MyFileTextureEnum.COLOR_METAL | MyFileTextureEnum.NORMALMAP_GLOSS | MyFileTextureEnum.EXTENSIONS:
rc.SetBlendState(MyBlendStateManager.BlendDecalNormalColorExt);
break;
default:
throw new Exception("Unknown texture bundle type");
}
}
static MyFileTextureEnum GetTextureType(MyChannel channel)
{
MyFileTextureEnum type = MyFileTextureEnum.UNSPECIFIED;
switch (channel)
{
case MyChannel.ColorMetal:
type = MyFileTextureEnum.COLOR_METAL;
break;
case MyChannel.NormalGloss:
type = MyFileTextureEnum.NORMALMAP_GLOSS;
break;
case MyChannel.Extension:
type = MyFileTextureEnum.EXTENSIONS;
break;
case MyChannel.Alphamask:
type = MyFileTextureEnum.ALPHAMASK;
break;
default:
MyRenderProxy.Assert(false, "Channel is not recognised");
break;
}
return(type);
}
public static MyFileTextureEnum GetMaterialTextureTypes(string colorMetalTexture,
string normalGlossTexture, string extensionTexture, string alphamaskTexture)
{
MyFileTextureEnum ret = MyFileTextureEnum.UNSPECIFIED;
if (!string.IsNullOrEmpty(colorMetalTexture))
{
ret |= MyFileTextureEnum.COLOR_METAL;
}
if (!string.IsNullOrEmpty(normalGlossTexture))
{
ret |= MyFileTextureEnum.NORMALMAP_GLOSS;
}
if (!string.IsNullOrEmpty(extensionTexture))
{
ret |= MyFileTextureEnum.EXTENSIONS;
}
if (!string.IsNullOrEmpty(alphamaskTexture))
{
ret |= MyFileTextureEnum.ALPHAMASK;
}
return(ret);
}
/// <summary>Get macro bundles for texture types</summary>
public static ShaderMacro[] GetMaterialTextureMacros(MyFileTextureEnum textures)
{
const string USE_COLORMETAL_TEXTURE = "USE_COLORMETAL_TEXTURE";
const string USE_NORMALGLOSS_TEXTURE = "USE_NORMALGLOSS_TEXTURE";
const string USE_EXTENSIONS_TEXTURE = "USE_EXTENSIONS_TEXTURE";
List <ShaderMacro> macros = new List <ShaderMacro>();
if (textures.HasFlag(MyFileTextureEnum.COLOR_METAL))
{
macros.Add(new ShaderMacro(USE_COLORMETAL_TEXTURE, null));
}
if (textures.HasFlag(MyFileTextureEnum.NORMALMAP_GLOSS))
{
macros.Add(new ShaderMacro(USE_NORMALGLOSS_TEXTURE, null));
}
if (textures.HasFlag(MyFileTextureEnum.EXTENSIONS))
{
macros.Add(new ShaderMacro(USE_EXTENSIONS_TEXTURE, null));
}
return(macros.ToArray());
}
public void Init(string name, MyFileTextureEnum type, bool waitTillLoaded, bool skipQualityReduction)
{
m_name = name;
m_type = type;
TextureState = waitTillLoaded ? FileTextureState.Unloaded : FileTextureState.Requested;
m_skipQualityReduction = skipQualityReduction;
}
/// <remarks>On big loops, or whenever recommendable, cache the returned reference</remarks>
public ITexture GetTexture(string name, MyFileTextureEnum type, bool waitTillLoaded = false, bool skipQualityReduction = false)
{
if (name == null || name.Length <= 0)
{
return(ReturnDefaultTexture(type));
}
Uri uri;
if (!MyResourceUtils.NormalizeFileTextureName(ref name, out uri))
{
IGeneratedTexture texture;
if (m_generatedTextures.TryGetValue(name, out texture))
{
return(texture);
}
else
{
MyRenderProxy.Assert(false, "Can't find generated texture with name \"" + name + "\"");
return(ReturnDefaultTexture(type));
}
}
MyFileTexture texOut;
if (!m_textures.TryGetValue(name, out texOut))
{
if (uri.Scheme != FILE_SCHEME)
{
Debug.Assert(false, "Cannot initialize a non file texture");
return(ReturnDefaultTexture(type));
}
m_texturesPool.AllocateOrCreate(out texOut);
texOut.Init(name, uri.LocalPath, type, waitTillLoaded, skipQualityReduction);
m_textures.Add(name, texOut);
}
switch (texOut.TextureState)
{
case FileTextureState.Unloaded:
case FileTextureState.Requested:
if (waitTillLoaded)
{
LoadInternal(name);
}
else
{
texOut.TextureState = FileTextureState.Requested;
m_requestedTextures.Add(name);
}
break;
case FileTextureState.Loaded:
break;
}
return(texOut);
}
public void Init(string name, string localPath, MyFileTextureEnum type, bool waitTillLoaded, bool skipQualityReduction)
{
Debug.Assert(System.IO.Path.IsPathRooted(localPath), "Path must be rooted");
m_name = name;
m_path = System.IO.Path.GetFullPath(localPath);
m_type = type;
TextureState = waitTillLoaded ? FileTextureState.Unloaded : FileTextureState.Requested;
m_skipQualityReduction = skipQualityReduction;
}
public void Init(string name, MyFileTextureEnum type, byte[] errorBytePattern, Format formatBytePattern)
{
m_name = name;
m_type = type;
m_arrayTexture = null;
m_dirtyFlag = false;
m_numRefs = 1;
m_errorBytePattern = errorBytePattern;
m_formatBytePattern = formatBytePattern;
}
public IDynamicFileArrayTexture CreateTexture(string name, MyFileTextureEnum type, byte[] bytePattern, Format bytePatternFormat)
{
MyDynamicFileArrayTexture tex;
m_objectsPool.AllocateOrCreate(out tex);
tex.Init(name, type, bytePattern, bytePatternFormat);
//if (destroyOnUnloadSession)
// m_texarraysAutodestroyed.Add(tex);
return(tex);
}
public void Load(string resourceName, string[] filePaths, MyFileTextureEnum type)
{
m_resourceName = resourceName;
if (m_listSubresourceFilenames == null)
m_objectsPoolOfStringLists.AllocateOrCreate(out m_listSubresourceFilenames);
m_listSubresourceFilenames.Clear();
foreach (string path in filePaths)
m_listSubresourceFilenames.Add(path);
m_type = type;
ISrvBindable tex = MyManagers.FileTextures.GetTexture(filePaths[0], type);
m_size = tex.Size;
TextureFormat = Format.Unknown;
}
public IFileArrayTexture CreateFromFiles(string resourceName, string[] inputFiles,
MyFileTextureEnum type)
{
MyFileArrayTexture array;
m_fileTextureArrays.AllocateOrCreate(out array);
array.Load(resourceName, inputFiles, type);
if (m_isDeviceInit)
{
array.OnDeviceInit();
}
return(array);
}
void FillStreamWithTerrainBatch(int materialId,
int vertexMaterialIndex, int indexCount, int startIndex, int baseVertex)
{
// all necessary data should be same - geometry and input layout
var renderable = Owner.GetRenderable();
var proxy = renderable.Lods[0].RenderableProxies[0];
// get shader for streaming
MyFileTextureEnum textureTypes = proxy.Material == MyMeshMaterialId.NULL ? MyFileTextureEnum.UNSPECIFIED : proxy.Material.Info.TextureTypes;
var bundle = MyMaterialShaders.Get(MyMaterialShaders.MULTI_MATERIAL_TAG,
MyMaterialShaders.FOLIAGE_STREAMING_PASS_ID, MyMeshes.VoxelLayout,
renderable.Lods[0].VertexShaderFlags & ~MyShaderUnifiedFlags.USE_VOXEL_MORPHING, textureTypes);
MyRender11.FoliageGenerator.RecordCommands(proxy, m_streams[materialId], materialId,
bundle.VS, bundle.IL,
vertexMaterialIndex, indexCount, startIndex, baseVertex);
}
IDynamicFileArrayTexture GetArrayTextureFromKey(MyArrayTextureKey key)
{
IDynamicFileArrayTexture arrayTexture;
if (m_dictTextures.TryGetValue(key, out arrayTexture))
{
return(arrayTexture);
}
string name = key.ToString();
MyFileTextureEnum texType = GetTextureType(key.Channel);
byte[] bytePattern = MyGeneratedTexturePatterns.GetBytePattern(key.Channel, key.Format);
arrayTexture = MyManagers.DynamicFileArrayTextures.CreateTexture(name, texType, bytePattern, key.Format);
m_dictTextures[key] = arrayTexture;
return(arrayTexture);
}
private ITexture ReturnDefaultTexture(MyFileTextureEnum type)
{
switch (type)
{
case MyFileTextureEnum.NORMALMAP_GLOSS:
return(MyGeneratedTextureManager.MissingNormalGlossTex);
case MyFileTextureEnum.EXTENSIONS:
return(MyGeneratedTextureManager.MissingExtensionTex);
case MyFileTextureEnum.ALPHAMASK:
return(MyGeneratedTextureManager.MissingAlphamaskTex);
case MyFileTextureEnum.CUBEMAP:
return(MyGeneratedTextureManager.MissingCubeTex);
}
return(MyGeneratedTextureManager.PinkTex);
}
internal static bool IsQualityDependantFilter(IFileTexture texture)
{
MyFileTexture textureInternal = (MyFileTexture)texture;
MyFileTextureEnum type = textureInternal.TextureType;
if (type == MyFileTextureEnum.SYSTEM)
{
return(false);
}
if (type == MyFileTextureEnum.GUI)
{
return(false);
}
if (type == MyFileTextureEnum.GPUPARTICLES)
{
return(false);
}
return(true);
}
public void Load(string resourceName, string[] filePaths, MyFileTextureEnum type)
{
m_resourceName = resourceName;
if (m_listSubresourceFilenames == null)
{
m_objectsPoolOfStringLists.AllocateOrCreate(out m_listSubresourceFilenames);
}
m_listSubresourceFilenames.Clear();
foreach (string path in filePaths)
{
m_listSubresourceFilenames.Add(path);
}
m_type = type;
ISrvBindable tex = MyManagers.FileTextures.GetTexture(filePaths[0], type);
m_size = tex.Size;
TextureFormat = Format.Unknown;
}
public void Load(string resourceName, string[] filePaths, MyFileTextureEnum type, byte[] bytePattern, Format formatBytePattern)
{
m_resourceName = resourceName;
if (m_listSubresourceFilenames == null)
{
m_objectsPoolOfStringLists.AllocateOrCreate(out m_listSubresourceFilenames);
}
m_listSubresourceFilenames.Clear();
foreach (string path in filePaths)
{
m_listSubresourceFilenames.Add(path);
}
m_type = type;
ISrvBindable tex = MyManagers.FileTextures.GetTexture(filePaths[0], type, temporary: true);
m_size = tex.Size;
Format = Format.Unknown;
m_recoverySystem.UseBytePattern = true;
m_recoverySystem.FormatBytePattern = formatBytePattern;
m_recoverySystem.BytePattern = bytePattern;
}
unsafe static void DrawBatches(MyRenderContext rc, MyStringId material, int matIndex, bool transparent)
{
if (m_jobs.Count == 0)
{
return;
}
var matDesc = m_materials[material][matIndex];
rc.PixelShader.SetSrv(0, MyGBuffer.Main.DepthStencil.SrvDepth);
rc.PixelShader.SetSrv(1, MyGlobalResources.Gbuffer1Copy);
if (transparent)
{
rc.PixelShader.Set(m_psColorMapTransparent);
}
else
{
rc.SetRtvs(MyGBuffer.Main, MyDepthStencilAccess.ReadOnly);
MyFileTextureEnum type = matDesc.DecalType;
switch (type)
{
case MyFileTextureEnum.NORMALMAP_GLOSS:
rc.PixelShader.Set(m_psNormalMap);
break;
case MyFileTextureEnum.COLOR_METAL:
rc.PixelShader.Set(m_psColorMap);
break;
case MyFileTextureEnum.COLOR_METAL | MyFileTextureEnum.NORMALMAP_GLOSS:
rc.PixelShader.Set(m_psNormalColorMap);
break;
case MyFileTextureEnum.COLOR_METAL | MyFileTextureEnum.NORMALMAP_GLOSS | MyFileTextureEnum.EXTENSIONS:
rc.PixelShader.Set(m_psNormalColorExtMap);
break;
default:
throw new Exception("Unknown decal type");
}
MyMeshMaterials1.BindMaterialTextureBlendStates(rc, type);
}
// factor 1 makes overwriting of gbuffer color & subtracting from ao
MyFileTextureManager texManager = MyManagers.FileTextures;
rc.PixelShader.SetSrv(3, texManager.GetTexture(matDesc.AlphamaskTexture, MyFileTextureEnum.ALPHAMASK));
rc.PixelShader.SetSrv(4, texManager.GetTexture(matDesc.ColorMetalTexture, MyFileTextureEnum.COLOR_METAL));
rc.PixelShader.SetSrv(5, texManager.GetTexture(matDesc.NormalmapTexture, MyFileTextureEnum.NORMALMAP_GLOSS));
rc.PixelShader.SetSrv(6, texManager.GetTexture(matDesc.ExtensionsTexture, MyFileTextureEnum.EXTENSIONS));
var decalCb = MyCommon.GetObjectCB(sizeof(MyDecalConstants) * DECAL_BATCH_SIZE);
int batchCount = m_jobs.Count / DECAL_BATCH_SIZE + 1;
int offset = 0;
for (int i1 = 0; i1 < batchCount; i1++)
{
var mapping = MyMapping.MapDiscard(decalCb);
int leftDecals = m_jobs.Count - offset;
int decalCount = leftDecals > DECAL_BATCH_SIZE ? DECAL_BATCH_SIZE : leftDecals;
for (int i2 = 0; i2 < decalCount; ++i2)
{
MyDecalConstants constants = new MyDecalConstants();
EncodeJobConstants(i2 + offset, ref constants);
mapping.WriteAndPosition(ref constants);
}
mapping.Unmap();
// Draw a box without buffer: 36 vertices -> 12 triangles. 2 triangles per face -> 6 faces
MyImmediateRC.RC.DrawIndexed(36 * decalCount, 0, 0);
offset += DECAL_BATCH_SIZE;
}
}
public void Init(string name, string localPath, MyFileTextureEnum type, bool waitTillLoaded, bool skipQualityReduction)
{
Debug.Assert(System.IO.Path.IsPathRooted(localPath), "Path must be rooted");
m_name = name;
m_path = System.IO.Path.GetFullPath(localPath);
m_type = type;
TextureState = waitTillLoaded ? FileTextureState.Unloaded : FileTextureState.Requested;
m_skipQualityReduction = skipQualityReduction;
}
public void Init(string name, MyFileTextureEnum type, byte[] errorBytePattern, Format formatBytePattern)
{
m_name = name;
m_type = type;
m_arrayTexture = null;
m_dirtyFlag = false;
m_numRefs = 1;
m_errorBytePattern = errorBytePattern;
m_formatBytePattern = formatBytePattern;
}
// if texture cannot be loaded, it will be used byte pattern to generate substition texture
public IFileArrayTexture CreateFromFiles(string resourceName, string[] inputFiles, MyFileTextureEnum type, byte[] bytePatternFor4x4, Format formatBytePattern, bool autoDisposeOnUnload)
{
MyFileArrayTexture array;
m_fileTextureArrays.AllocateOrCreate(out array);
array.Load(resourceName, inputFiles, type, bytePatternFor4x4, formatBytePattern);
if (m_isDeviceInit)
{
array.OnDeviceInit();
}
if (autoDisposeOnUnload)
{
m_texturesOnAutoDisposal.Add(array);
}
return(array);
}
public IFileArrayTexture CreateFromFiles(string resourceName, string[] inputFiles, MyFileTextureEnum type, string errorTextureFilepath, bool autoDisposeOnUnload)
{
MyFileArrayTexture array;
m_fileTextureArrays.AllocateOrCreate(out array);
array.Load(resourceName, inputFiles, type, errorTextureFilepath);
if (m_isDeviceInit)
{
array.OnDeviceInit();
}
if (autoDisposeOnUnload)
{
m_texturesOnAutoDisposal.Add(array);
}
return(array);
}
public IFileArrayTexture CreateFromFiles(string resourceName, string[] inputFiles,
MyFileTextureEnum type)
{
MyFileArrayTexture array;
m_fileTextureArrays.AllocateOrCreate(out array);
array.Load(resourceName, inputFiles, type);
if (m_isDeviceInit)
array.OnDeviceInit();
return array;
}
/// <summary>Get macro bundles for texture types</summary>
public static ShaderMacro[] GetMaterialTextureMacros(MyFileTextureEnum textures)
{
const string USE_COLORMETAL_TEXTURE = "USE_COLORMETAL_TEXTURE";
const string USE_NORMALGLOSS_TEXTURE = "USE_NORMALGLOSS_TEXTURE";
const string USE_EXTENSIONS_TEXTURE = "USE_EXTENSIONS_TEXTURE";
List<ShaderMacro> macros = new List<ShaderMacro>();
if (textures.HasFlag(MyFileTextureEnum.COLOR_METAL))
macros.Add(new ShaderMacro(USE_COLORMETAL_TEXTURE, null));
if (textures.HasFlag(MyFileTextureEnum.NORMALMAP_GLOSS))
macros.Add(new ShaderMacro(USE_NORMALGLOSS_TEXTURE, null));
if (textures.HasFlag(MyFileTextureEnum.EXTENSIONS))
macros.Add(new ShaderMacro(USE_EXTENSIONS_TEXTURE, null));
return macros.ToArray();
}
public IFileArrayTexture CreateFromFiles(string resourceName, string[] inputFiles, MyFileTextureEnum type, string errorTextureFilepath, bool autoDisposeOnUnload)
{
MyFileArrayTexture array;
m_fileTextureArrays.AllocateOrCreate(out array);
array.Load(resourceName, inputFiles, type, errorTextureFilepath);
if (m_isDeviceInit)
array.OnDeviceInit();
if (autoDisposeOnUnload)
m_texturesOnAutoDisposal.Add(array);
return array;
}
internal static void AddMaterialShaderFlagMacrosTo(List<ShaderMacro> list, MyShaderUnifiedFlags flags, MyFileTextureEnum textureTypes = MyFileTextureEnum.UNSPECIFIED)
{
if ((flags & MyShaderUnifiedFlags.DEPTH_ONLY) > 0)
list.Add(new ShaderMacro("DEPTH_ONLY", null));
if ((flags & MyShaderUnifiedFlags.ALPHA_MASKED) > 0)
list.Add(new ShaderMacro("ALPHA_MASKED", null));
if ((flags & MyShaderUnifiedFlags.ALPHA_MASK_ARRAY) > 0)
list.Add(new ShaderMacro("ALPHA_MASK_ARRAY", null));
if ((flags & MyShaderUnifiedFlags.TRANSPARENT) > 0)
list.Add(new ShaderMacro("TRANSPARENT", null));
if ((flags & MyShaderUnifiedFlags.DITHERED) > 0)
list.Add(new ShaderMacro("DITHERED", null));
if ((flags & MyShaderUnifiedFlags.DITHERED_LOD) > 0)
list.Add(new ShaderMacro("DITHERED_LOD", null));
if ((flags & MyShaderUnifiedFlags.USE_SKINNING) > 0)
list.Add(new ShaderMacro("USE_SKINNING", null));
if ((flags & MyShaderUnifiedFlags.STATIC_DECAL) > 0)
{
Debug.Assert(textureTypes != MyFileTextureEnum.UNSPECIFIED);
list.Add(new ShaderMacro("STATIC_DECAL", null));
list.AddRange(MyMeshMaterials1.GetMaterialTextureMacros(textureTypes));
}
if ((flags & MyShaderUnifiedFlags.STATIC_DECAL_CUTOUT) > 0)
list.Add(new ShaderMacro("STATIC_DECAL_CUTOUT", null));
if ((flags & MyShaderUnifiedFlags.USE_CUBE_INSTANCING) > 0)
list.Add(new ShaderMacro("USE_CUBE_INSTANCING", null));
if ((flags & MyShaderUnifiedFlags.USE_DEFORMED_CUBE_INSTANCING) > 0)
list.Add(new ShaderMacro("USE_DEFORMED_CUBE_INSTANCING", null));
if ((flags & MyShaderUnifiedFlags.USE_GENERIC_INSTANCING) > 0)
list.Add(new ShaderMacro("USE_GENERIC_INSTANCING", null));
if ((flags & MyShaderUnifiedFlags.USE_MERGE_INSTANCING) > 0)
list.Add(new ShaderMacro("USE_MERGE_INSTANCING", null));
if ((flags & MyShaderUnifiedFlags.USE_SINGLE_INSTANCE) > 0)
{
Debug.Assert((flags & MyShaderUnifiedFlags.USE_MERGE_INSTANCING) > 0);
list.Add(new ShaderMacro("USE_SINGLE_INSTANCE", null));
}
if ((flags & MyShaderUnifiedFlags.USE_VOXEL_MORPHING) > 0)
list.Add(new ShaderMacro("USE_VOXEL_MORPHING", null));
if ((flags & MyShaderUnifiedFlags.USE_VOXEL_DATA) > 0)
list.Add(new ShaderMacro("USE_VOXEL_DATA", null));
if ((flags & MyShaderUnifiedFlags.USE_TEXTURE_INDICES) > 0)
list.Add(new ShaderMacro("USE_TEXTURE_INDICES", null));
}
/// <remarks>On big loops, or whenever recommendable, cache the returned reference</remarks>
public ITexture GetTexture(string name, MyFileTextureEnum type, bool waitTillLoaded = false, bool skipQualityReduction = false)
{
if (name == null || name.Length <= 0)
return ReturnDefaultTexture(type);
Uri uri;
if (!MyResourceUtils.NormalizeFileTextureName(ref name, out uri))
{
IGeneratedTexture texture;
if (m_generatedTextures.TryGetValue(name, out texture))
return texture;
else
{
MyRenderProxy.Assert(false, "Can't find generated texture with name \"" + name + "\"");
return ReturnDefaultTexture(type);
}
}
MyFileTexture texOut;
if (!m_textures.TryGetValue(name, out texOut))
{
if (uri.Scheme != FILE_SCHEME)
{
Debug.Assert(false, "Cannot initialize a non file texture");
return ReturnDefaultTexture(type);
}
m_texturesPool.AllocateOrCreate(out texOut);
texOut.Init(name, uri.LocalPath, type, waitTillLoaded, skipQualityReduction);
m_textures.Add(name, texOut);
}
switch (texOut.TextureState)
{
case FileTextureState.Unloaded:
case FileTextureState.Requested:
if (waitTillLoaded)
LoadInternal(name);
else
{
texOut.TextureState = FileTextureState.Requested;
m_requestedTextures.Add(name);
}
break;
case FileTextureState.Loaded:
break;
}
return texOut;
}
private ITexture ReturnDefaultTexture(MyFileTextureEnum type)
{
switch (type)
{
case MyFileTextureEnum.NORMALMAP_GLOSS:
return MyGeneratedTextureManager.MissingNormalGlossTex;
case MyFileTextureEnum.EXTENSIONS:
return MyGeneratedTextureManager.MissingExtensionTex;
case MyFileTextureEnum.ALPHAMASK:
return MyGeneratedTextureManager.MissingAlphamaskTex;
case MyFileTextureEnum.CUBEMAP:
return MyGeneratedTextureManager.MissingCubeTex;
}
return MyRender11.DebugMode ? MyGeneratedTextureManager.PinkTex : MyGeneratedTextureManager.ZeroTex;
}
public ISrvBindable GetTexture(string name, MyFileTextureEnum type, bool waitTillLoaded = false, bool skipQualityReduction = false)
{
if (name == null || name.Length <= 0)
{
switch (type)
{
case MyFileTextureEnum.NORMALMAP_GLOSS:
return MyGeneratedTextureManager.MissingNormalGlossTex;
case MyFileTextureEnum.EXTENSIONS:
return MyGeneratedTextureManager.MissingExtensionTex;
case MyFileTextureEnum.ALPHAMASK:
return MyGeneratedTextureManager.MissingAlphamaskTex;
case MyFileTextureEnum.CUBEMAP:
return MyGeneratedTextureManager.MissingCubeTex;
}
return MyRender11.DebugMode ? MyGeneratedTextureManager.PinkTex : MyGeneratedTextureManager.ZeroTex;
}
// Check whether name is absolute path to file
if (System.IO.Path.IsPathRooted(name))
MakeRelativePath(ref name);
if (m_unmannagedTextures.ContainsKey(name))
return m_unmannagedTextures[name];
MyFileTexture texOut;
if (!m_textures.TryGetValue(name, out texOut))
{
m_texturesPool.AllocateOrCreate(out texOut);
texOut.Init(name, type, waitTillLoaded, skipQualityReduction);
m_textures.Add(name, texOut);
}
switch (texOut.TextureState)
{
case FileTextureState.Unloaded:
case FileTextureState.Requested:
if (waitTillLoaded)
LoadInternal(name);
else
{
texOut.TextureState = FileTextureState.Requested;
m_requestedTextures.Add(name);
}
break;
case FileTextureState.Loaded:
break;
}
return texOut;
}
internal static MyMaterialShadersBundleId Get(MyStringId material, MyStringId materialPass,
VertexLayoutId vertexLayout, MyShaderUnifiedFlags flags, MyFileTextureEnum textureTypes)
{
int hash = 0;
MyHashHelper.Combine(ref hash, material.GetHashCode());
MyHashHelper.Combine(ref hash, materialPass.GetHashCode());
MyHashHelper.Combine(ref hash, vertexLayout.GetHashCode());
MyHashHelper.Combine(ref hash, unchecked((int)flags));
if (HashIndex.ContainsKey(hash))
{
return HashIndex[hash];
}
var id = new MyMaterialShadersBundleId { Index = BundleInfo.Allocate() };
MyArrayHelpers.Reserve(ref Bundles, id.Index + 1);
HashIndex[hash] = id;
BundleInfo.Data[id.Index] = new MyMaterialShadersInfo
{
Material = material,
Pass = materialPass,
Layout = vertexLayout,
Flags = flags,
TextureTypes = textureTypes,
};
Bundles[id.Index] = new MyMaterialShadersBundle { };
InitBundle(id);
return id;
}
// if texture cannot be loaded, it will be used byte pattern to generate substition texture
public IFileArrayTexture CreateFromFiles(string resourceName, string[] inputFiles, MyFileTextureEnum type, byte[] bytePatternFor4x4, Format formatBytePattern, bool autoDisposeOnUnload)
{
MyFileArrayTexture array;
m_fileTextureArrays.AllocateOrCreate(out array);
array.Load(resourceName, inputFiles, type, bytePatternFor4x4, formatBytePattern);
if (m_isDeviceInit)
array.OnDeviceInit();
if (autoDisposeOnUnload)
m_texturesOnAutoDisposal.Add(array);
return array;
}
/// <summary>Bind blend states for alpha blending</summary>
public static void BindMaterialTextureBlendStates(MyRenderContext rc, MyFileTextureEnum textures)
{
textures &= ~MyFileTextureEnum.ALPHAMASK;
switch (textures)
{
case MyFileTextureEnum.COLOR_METAL:
rc.SetBlendState(MyBlendStateManager.BlendDecalNormal);
break;
case MyFileTextureEnum.NORMALMAP_GLOSS:
rc.SetBlendState(MyBlendStateManager.BlendDecalColor);
break;
case MyFileTextureEnum.COLOR_METAL | MyFileTextureEnum.NORMALMAP_GLOSS:
rc.SetBlendState(MyBlendStateManager.BlendDecalNormalColor);
break;
case MyFileTextureEnum.COLOR_METAL | MyFileTextureEnum.NORMALMAP_GLOSS | MyFileTextureEnum.EXTENSIONS:
rc.SetBlendState(MyBlendStateManager.BlendDecalNormalColorExt);
break;
default:
throw new Exception("Unknown texture bundle type");
}
}
public IDynamicFileArrayTexture CreateTexture(string name, MyFileTextureEnum type, byte[] bytePattern, Format bytePatternFormat)
{
MyDynamicFileArrayTexture tex;
m_objectsPool.AllocateOrCreate(out tex);
tex.Init(name, type, bytePattern, bytePatternFormat);
//if (destroyOnUnloadSession)
// m_texarraysAutodestroyed.Add(tex);
return tex;
}
internal static MyMaterialShadersBundleId Get(MyStringId material, MyStringId materialPass,
VertexLayoutId vertexLayout, MyShaderUnifiedFlags flags, MyFileTextureEnum textureTypes)
{
int hash = 0;
MyHashHelper.Combine(ref hash, material.GetHashCode());
MyHashHelper.Combine(ref hash, materialPass.GetHashCode());
MyHashHelper.Combine(ref hash, vertexLayout.GetHashCode());
MyHashHelper.Combine(ref hash, unchecked ((int)flags));
if (HashIndex.ContainsKey(hash))
{
return(HashIndex[hash]);
}
var id = new MyMaterialShadersBundleId {
Index = BundleInfo.Allocate()
};
MyArrayHelpers.Reserve(ref Bundles, id.Index + 1);
HashIndex[hash] = id;
BundleInfo.Data[id.Index] = new MyMaterialShadersInfo
{
Material = material,
Pass = materialPass,
Layout = vertexLayout,
Flags = flags,
TextureTypes = textureTypes,
};
Bundles[id.Index] = new MyMaterialShadersBundle {
};
InitBundle(id);
return(id);
}
internal static void AddMaterialShaderFlagMacrosTo(List <ShaderMacro> list, MyShaderUnifiedFlags flags, MyFileTextureEnum textureTypes = MyFileTextureEnum.UNSPECIFIED)
{
if ((flags & MyShaderUnifiedFlags.DEPTH_ONLY) > 0)
{
list.Add(new ShaderMacro("DEPTH_ONLY", null));
}
if ((flags & MyShaderUnifiedFlags.ALPHA_MASKED) > 0)
{
list.Add(new ShaderMacro("ALPHA_MASKED", null));
}
if ((flags & MyShaderUnifiedFlags.ALPHA_MASK_ARRAY) > 0)
{
list.Add(new ShaderMacro("ALPHA_MASK_ARRAY", null));
}
if ((flags & MyShaderUnifiedFlags.TRANSPARENT) > 0)
{
list.Add(new ShaderMacro("TRANSPARENT", null));
}
if ((flags & MyShaderUnifiedFlags.DITHERED) > 0)
{
list.Add(new ShaderMacro("DITHERED", null));
}
if ((flags & MyShaderUnifiedFlags.DITHERED_LOD) > 0)
{
list.Add(new ShaderMacro("DITHERED_LOD", null));
}
if ((flags & MyShaderUnifiedFlags.USE_SKINNING) > 0)
{
list.Add(new ShaderMacro("USE_SKINNING", null));
}
if ((flags & MyShaderUnifiedFlags.STATIC_DECAL) > 0)
{
Debug.Assert(textureTypes != MyFileTextureEnum.UNSPECIFIED);
list.Add(new ShaderMacro("STATIC_DECAL", null));
list.AddRange(MyMeshMaterials1.GetMaterialTextureMacros(textureTypes));
}
if ((flags & MyShaderUnifiedFlags.STATIC_DECAL_CUTOUT) > 0)
{
list.Add(new ShaderMacro("STATIC_DECAL_CUTOUT", null));
}
if ((flags & MyShaderUnifiedFlags.USE_CUBE_INSTANCING) > 0)
{
list.Add(new ShaderMacro("USE_CUBE_INSTANCING", null));
}
if ((flags & MyShaderUnifiedFlags.USE_DEFORMED_CUBE_INSTANCING) > 0)
{
list.Add(new ShaderMacro("USE_DEFORMED_CUBE_INSTANCING", null));
}
if ((flags & MyShaderUnifiedFlags.USE_GENERIC_INSTANCING) > 0)
{
list.Add(new ShaderMacro("USE_GENERIC_INSTANCING", null));
}
if ((flags & MyShaderUnifiedFlags.USE_MERGE_INSTANCING) > 0)
{
list.Add(new ShaderMacro("USE_MERGE_INSTANCING", null));
}
if ((flags & MyShaderUnifiedFlags.USE_SINGLE_INSTANCE) > 0)
{
Debug.Assert((flags & MyShaderUnifiedFlags.USE_MERGE_INSTANCING) > 0);
list.Add(new ShaderMacro("USE_SINGLE_INSTANCE", null));
}
if ((flags & MyShaderUnifiedFlags.USE_VOXEL_MORPHING) == MyShaderUnifiedFlags.USE_VOXEL_MORPHING)
{
list.Add(new ShaderMacro("USE_VOXEL_MORPHING", null));
}
if ((flags & MyShaderUnifiedFlags.USE_VOXEL_DATA) == MyShaderUnifiedFlags.USE_VOXEL_DATA)
{
list.Add(new ShaderMacro("USE_VOXEL_DATA", null));
}
}
public ISrvBindable GetTexture(string name, MyFileTextureEnum type, bool waitTillLoaded = false, bool skipQualityReduction = false)
{
if (name == null || name.Length <= 0)
{
switch (type)
{
case MyFileTextureEnum.NORMALMAP_GLOSS:
return(MyGeneratedTextureManager.MissingNormalGlossTex);
case MyFileTextureEnum.EXTENSIONS:
return(MyGeneratedTextureManager.MissingExtensionTex);
case MyFileTextureEnum.ALPHAMASK:
return(MyGeneratedTextureManager.MissingAlphamaskTex);
case MyFileTextureEnum.CUBEMAP:
return(MyGeneratedTextureManager.MissingCubeTex);
}
return(MyRender11.DebugMode ? MyGeneratedTextureManager.PinkTex : MyGeneratedTextureManager.ZeroTex);
}
// Check whether name is absolute path to file
if (System.IO.Path.IsPathRooted(name))
{
MakeRelativePath(ref name);
}
if (m_unmannagedTextures.ContainsKey(name))
{
return(m_unmannagedTextures[name]);
}
MyFileTexture texOut;
if (!m_textures.TryGetValue(name, out texOut))
{
m_texturesPool.AllocateOrCreate(out texOut);
texOut.Init(name, type, waitTillLoaded, skipQualityReduction);
m_textures.Add(name, texOut);
}
switch (texOut.TextureState)
{
case FileTextureState.Unloaded:
case FileTextureState.Requested:
if (waitTillLoaded)
{
LoadInternal(name);
}
else
{
texOut.TextureState = FileTextureState.Requested;
m_requestedTextures.Add(name);
}
break;
case FileTextureState.Loaded:
break;
}
return(texOut);
}
public void Init(string name, MyFileTextureEnum type, bool waitTillLoaded, bool skipQualityReduction)
{
m_name = name;
m_type = type;
TextureState = waitTillLoaded ? FileTextureState.Unloaded : FileTextureState.Requested;
m_skipQualityReduction = skipQualityReduction;
}
