public bool IsMaterialAcceptableForTheSystem(MyMeshMaterialInfo info)
        {
            if (m_ignoredMaterials.Contains(info.Name.String))
            {
                return(false);
            }

            if (MyFileTextureParamsManager.IsArrayTextureInFile(info.ColorMetal_Texture))
            {
                return(false);
            }

            if (MyFileTextureParamsManager.IsArrayTextureInFile(info.NormalGloss_Texture))
            {
                return(false);
            }

            if (MyFileTextureParamsManager.IsArrayTextureInFile(info.Extensions_Texture))
            {
                return(false);
            }

            if (MyFileTextureParamsManager.IsArrayTextureInFile(info.Alphamask_Texture))
            {
                return(false);
            }

            return(true);
        }
        IDynamicFileArrayTexture GetArrayTextureFromFilepath(string filepath, MyChannel channel, Vector2I defaultResolution)
        {
            MyFileTextureParams textureParams;
            MyArrayTextureKey   key;

            key.Channel = channel;

            bool isLoaded = MyFileTextureParamsManager.LoadFromFile(filepath, out textureParams);

            if (isLoaded)
            {
                Format format;
                format = textureParams.Format;
                if (MyCompilationSymbols.ReinterpretFormatsStoredInFiles)
                {
                    if (channel != MyChannel.NormalGloss)
                    {
                        format = MyResourceUtils.MakeSrgb(format);
                    }
                }
                key.Format           = format;
                key.ResolutionInFile = textureParams.Resolution;
                key.MipmapsCount     = textureParams.Mipmaps;
            }
            else
            {
                Format format;
                switch (channel)
                {
                case MyChannel.ColorMetal:
                    format = Format.BC7_UNorm_SRgb;
                    break;

                case MyChannel.NormalGloss:
                    format = Format.BC7_UNorm;
                    break;

                case MyChannel.Extension:
                    format = Format.BC7_UNorm_SRgb;
                    break;

                case MyChannel.Alphamask:
                    format = Format.BC4_UNorm;
                    break;

                default:
                    MyRenderProxy.Assert(false);
                    format = Format.Unknown;
                    break;
                }
                key.Format           = format;
                key.ResolutionInFile = defaultResolution;
                key.MipmapsCount     = MyResourceUtils.GetMipmapsCount(Math.Max(key.ResolutionInFile.X, key.ResolutionInFile.Y));
            }

            return(GetArrayTextureFromKey(key));
        }
        Vector2I GetDefaultTextureSize(string cmFilepath, string ngFilepath, string extFilepath, string alphamaskFilepath)
        {
            Vector2I cmSize        = MyFileTextureParamsManager.GetResolutionFromFile(cmFilepath);
            Vector2I ngSize        = MyFileTextureParamsManager.GetResolutionFromFile(ngFilepath);
            Vector2I extSize       = MyFileTextureParamsManager.GetResolutionFromFile(extFilepath);
            Vector2I alphamaskSize = MyFileTextureParamsManager.GetResolutionFromFile(alphamaskFilepath);

            Vector2I defaultSize = cmSize;

            if (defaultSize == Vector2I.Zero)
            {
                defaultSize = Vector2I.Max(ngSize, Vector2I.Max(extSize, alphamaskSize));
            }
            if (defaultSize == Vector2I.Zero) // if no texture cannot be found, we use "random size 1k"
            {
                defaultSize = new Vector2I(1024, 1024);
            }
            return(defaultSize);
        }
        void CheckTexture(string filepath, MyChannel channel, Format format, Vector2I texSize)
        {
            MyFileTextureParams parameters;

            if (m_checkedFilepaths.Contains(filepath))
            {
                return;
            }
            m_checkedFilepaths.Add(filepath);
            if (MyFileTextureParamsManager.LoadFromFile(filepath, out parameters))
            {
                if (parameters.Format != format)
                {
                    MyRenderProxy.Log.WriteLineAndConsole(String.Format("{0} texture '{1}' should be {2}", channel, filepath, format));
                }

                if (parameters.Resolution != texSize)
                {
                    MyRenderProxy.Log.WriteLineAndConsole(String.Format("{0} texture '{1}' should be {2}x{3}", channel, filepath, texSize.X, texSize.Y));
                }
            }
        }
Example #5
0
            // if no file texture can be loaded, the function will return false and default value in parameters
            bool GetCorrectedFileTextureParams(out MyFileTextureParams parameters)
            {
                //parameters = new MyFileTextureParams();
                foreach (string filepath in m_listSubresourceFilenames)
                {
                    if (MyFileTextureParamsManager.LoadFromFile(filepath, out parameters))
                    {
                        if (MyCompilationSymbols.ReinterpretFormatsStoredInFiles)
                        {
                            if (m_type != MyFileTextureEnum.NORMALMAP_GLOSS)
                            {
                                parameters.Format = MyResourceUtils.MakeSrgb(parameters.Format);
                            }
                        }

                        int skipMipmaps = 0;
                        if (m_type != MyFileTextureEnum.GUI && m_type != MyFileTextureEnum.GPUPARTICLES)
                        {
                            skipMipmaps = MyRender11.RenderSettings.TextureQuality.MipmapsToSkip(parameters.Resolution.X, parameters.Resolution.Y);
                        }

                        if (parameters.Mipmaps > 1)
                        {
                            parameters.Mipmaps     -= skipMipmaps;
                            parameters.Resolution.X = MyResourceUtils.GetMipmapSize(parameters.Resolution.X, skipMipmaps);
                            parameters.Resolution.Y = MyResourceUtils.GetMipmapSize(parameters.Resolution.Y, skipMipmaps);
                        }
                        return(true);
                    }
                }
                parameters.Format     = m_recoverySystem.FormatBytePattern;
                parameters.Mipmaps    = 3;
                parameters.Resolution = new Vector2I(4, 4);
                parameters.ArraySize  = 1;
                return(false);
            }