ResolveContentPath() public method

public ResolveContentPath ( string path ) : string
path string
return string
Beispiel #1
0
        /// <summary>
        /// Return list of key path to changed content file.
        /// </summary>
        /// <returns></returns>
        public IEnumerable <string> GetChangedDependencies()
        {
            var changedDeps = new List <string>();

            if (!TargetFileExists)
            {
                throw new InvalidOperationException("Target file does not exist");
            }

            var targetTime = File.GetLastWriteTime(FullTargetPath);

            using (var assetStream = AssetStream.OpenRead(FullTargetPath)) {
                foreach (var dependency in assetStream.Dependencies)
                {
                    if (context.ContentFileExists(dependency))
                    {
                        var fullDependencyPath = context.ResolveContentPath(dependency);

                        var sourceTime = File.GetLastWriteTime(fullDependencyPath);

                        if (targetTime < sourceTime)
                        {
                            changedDeps.Add(dependency);
                        }
                    }
                }
            }

            return(changedDeps);
        }
Beispiel #2
0
        /// <summary>
        /// Analyzes entire engine searching for RequireShaderAttribute.
        /// Returns collection of required shaders.
        /// </summary>
        /// <returns></returns>
        public IEnumerable <AssetSource> GatherRequiredShaders(BuildContext context, BuildResult result)
        {
            var options = context.Options;
            var srcList = new List <AssetSource>();


            var shaderList = Misc.GetAllClassesWithAttribute <RequireShaderAttribute>()
                             .Select(type1 => new { Type = type1, Name = type1.GetCustomAttribute <RequireShaderAttribute>().RequiredShader })
                             .DistinctBy(shader => shader.Name)
                             .ToArray();


            foreach (var shader in shaderList)
            {
                var nameExt = Path.ChangeExtension(shader.Name, ".hlsl");

                try {
                    var baseDir  = "";
                    var fullPath = context.ResolveContentPath(nameExt, out baseDir);
                    var assetSrc = new AssetSource(nameExt, baseDir, typeof(UbershaderProcessor), new string[0], context);
                    assetSrc.ReflectingType = shader.Type;

                    if (shader.Type.GetCustomAttribute <RequireShaderAttribute>().AutoGenerateHeader)
                    {
                        var headerName = assetSrc.FullSourcePath.Replace(".hlsl", ".auto.hlsl");

                        var headerText = UbershaderGenerator.GenerateVirtualHeader(shader.Type);

                        if (!File.Exists(headerName))
                        {
                            File.WriteAllText(headerName, headerText);
                        }
                        else
                        {
                            var oldText = File.ReadAllText(headerName);
                            if (oldText != headerText)
                            {
                                File.WriteAllText(headerName, headerText);
                            }
                        }
                    }



                    srcList.Add(assetSrc);
                } catch (BuildException bex) {
                    Log.Error(bex.Message);
                }
            }

            return(srcList);
        }