Example #1
0
        public override string ToString()
        {
            var sb = new StringBuilder();

            if (Chunks.OfType <LibfChunk>().Any())
            {
                WriteLibShader(sb);
                return(sb.ToString());
            }
            if (Chunks.OfType <EffectChunk>().Any())
            {
                foreach (var chunk in Chunks.OfType <EffectChunk>())
                {
                    sb.AppendLine(chunk.ToString());
                }
                foreach (var chunk in Chunks.Where(c => !(c is EffectChunk)))
                {
                    sb.AppendLine($"{chunk.ChunkType} {chunk.GetType()}");
                }
                return(sb.ToString());
            }
            sb.AppendLine("//");
            sb.AppendLine("// Generated by " + ResourceDefinition?.Creator ?? "Unknown");
            sb.AppendLine("//");
            sb.AppendLine("//");

            if (Shader != null && Shader.Tokens.Any(x => x.Header.OpcodeType == OpcodeType.Abort))            // TODO
            {
                sb.AppendLine("// Note: SHADER WILL ONLY WORK WITH THE DEBUG SDK LAYER ENABLED.");
                sb.AppendLine("//");
                sb.AppendLine("//");
            }

            if (Sfi0 != null)
            {
                sb.Append(Sfi0);
            }
            else if (Version.MajorVersion >= 5)
            {
                var globalFlagsDcl = Shader.DeclarationTokens
                                     .OfType <GlobalFlagsDeclarationToken>()
                                     .FirstOrDefault();
                if (globalFlagsDcl != null)
                {
                    sb.Append(Sfi0Chunk.GlobalFlagsToString(globalFlagsDcl?.Flags ?? 0));
                }
            }

            if (ResourceDefinition != null)
            {
                sb.Append(ResourceDefinition);
            }

            sb.AppendLine(@"//");

            if (PatchConstantSignature != null)
            {
                sb.Append(PatchConstantSignature);
                sb.AppendLine(@"//");
            }

            sb.Append(InputSignature);
            sb.AppendLine(@"//");

            sb.Append(OutputSignature);

            if (LibrarySignature != null)
            {
                sb.Append(LibrarySignature);
                sb.AppendLine(@"//");
            }

            if (Version.MajorVersion <= 5)
            {
                sb.Append(Statistics);
            }

            if (Interfaces != null)
            {
                sb.Append(Interfaces);
            }

            foreach (var dx9Shader in Chunks
                     .OfType <Chunks.Aon9.Level9ShaderChunk>()
                     .OrderBy(chunk => chunk.ChunkType))
            {
                sb.AppendLine("//");
                sb.Append(dx9Shader);
            }

            if (Shader != null)
            {
                sb.Append(Shader);
            }

            if (Statistics != null)
            {
                sb.AppendFormat("// Approximately {0} instruction slots used", Statistics.InstructionCount);
                sb.AppendLine();
            }

            return(sb.ToString());
        }
Example #2
0
        public static BytecodeChunk ParseChunk(BytecodeReader chunkReader, BytecodeContainer container)
        {
            // Type of chunk this is.
            uint fourCc = chunkReader.ReadUInt32();

            // Total length of the chunk in bytes.
            uint chunkSize = chunkReader.ReadUInt32();

            ChunkType chunkType;

            if (KnownChunkTypes.ContainsKey(fourCc))
            {
                chunkType = KnownChunkTypes[fourCc];
            }
            else
            {
                System.Diagnostics.Debug.Assert(false, "Chunk type '" + fourCc.ToFourCcString() + "' is not yet supported.");
                System.Diagnostics.Debug.WriteLine("Chunk type '" + fourCc.ToFourCcString() + "' is not yet supported.");
                return(null);
            }

            var           chunkContentReader = chunkReader.CopyAtCurrentPosition((int)chunkSize);
            BytecodeChunk chunk;

            switch (chunkType)
            {
            case ChunkType.Ifce:
                chunk = InterfacesChunk.Parse(chunkContentReader, chunkSize);
                break;

            case ChunkType.Isgn:
            case ChunkType.Osgn:
            case ChunkType.Osg5:
            case ChunkType.Pcsg:
            case ChunkType.Isg1:
            case ChunkType.Osg1:
                chunk = InputOutputSignatureChunk.Parse(chunkContentReader, chunkType,
                                                        container.Version.ProgramType);
                break;

            case ChunkType.Rdef:
                chunk = ResourceDefinitionChunk.Parse(chunkContentReader);
                break;

            case ChunkType.Sdbg:
            case ChunkType.Spdb:
                chunk = DebuggingChunk.Parse(chunkContentReader, chunkType, chunkSize);
                break;

            case ChunkType.Sfi0:
                chunk = Sfi0Chunk.Parse(chunkContentReader, container.Version, chunkSize);
                break;

            case ChunkType.Shdr:
            case ChunkType.Shex:
                chunk = ShaderProgramChunk.Parse(chunkContentReader);
                break;

            case ChunkType.Stat:
                chunk = StatisticsChunk.Parse(chunkContentReader, chunkSize);
                break;

            case ChunkType.Xnas:
            case ChunkType.Xnap:
            case ChunkType.Aon9:
                chunk = Level9ShaderChunk.Parse(chunkContentReader, chunkSize);
                break;

            case ChunkType.Priv:
                chunk = PrivateChunk.Parse(chunkContentReader, chunkSize);
                break;

            case ChunkType.Rts0:
                chunk = RootSignatureChunk.Parse(chunkContentReader, chunkSize);
                break;

            case ChunkType.Libf:
                chunk = LibfChunk.Parse(chunkContentReader, chunkSize);
                break;

            case ChunkType.Libh:
                chunk = LibHeaderChunk.Parse(chunkContentReader, chunkSize);
                break;

            case ChunkType.Lfs0:
                chunk = LibraryParameterSignatureChunk.Parse(chunkContentReader, chunkSize);
                break;

            default:
                throw new ParseException("Invalid chunk type: " + chunkType);
            }

            chunk.Container = container;
            chunk.FourCc    = fourCc;
            chunk.ChunkSize = chunkSize;
            chunk.ChunkType = chunkType;

            return(chunk);
        }