（原创）bls文件格式的解析

wow的shader都是放在bls文件中的，前几天对这些文件分析了一下，发现wowdev.org里对bls的解析不大对，这里对bls的文件格式做一下说明。

文件前四个字节肯定是"SVXG"或"SPXG"，分别表示这个bls里保存的是vs或ps。 
接下来一个uint表示版本号，没什么用。
接下来一个uint是用来表示每个profile里的shader数目，以下检测pc。
接下来是data block的偏移量，如果是vs，会有6个偏移量，如果是ps，会有12个偏移量，其中有些可能会是0。
然后就可以根据这些偏移量，移动到文件中的指定位置，开始读取shader的数据和代码了。

以下是我写的一个解析bls文件的代码，可以把指定的bls里的shader输出到一个文本文件中。

/********************************************************************
filename:   Blsparser.cpp
created:    2006/07/29
author:     Weiliang Xie (feiyurainy at 163.com)

purpose:    To parse the wow shader file(.bls),and log the shader data
            a file.
*********************************************************************/

#include <iostream>
#include <fstream>
#include <string>

#include <assert.h>

#include <d3dx9.h>
#include <dxerr9.h>

typedef unsigned int uint32;

struct BlsHeader
{
    char    shaderType[4];  /// shader type,must be "SPXG" or "SVXG"
    uint32  version;        /// shader version,useless
    uint32  shaderCount;    /// shader count in each shader block
};

/// global shader header for the input bls file
BlsHeader gBlsHeader;

/// input bls file stream
std::ifstream gBlsFStream;

/// output log file stream
std::ofstream gOutputFile;

/** read the data from the gBlsFStream
@param count num of byte to read
@return num of byte read
*/
size_t _readData(void* buf, size_t count)
{
    gBlsFStream.read( static_cast<char*>(buf), static_cast<std::streamsize>(count) );

    return gBlsFStream.gcount();
}

/** parse the bls file,and log the shader data to file
@param offsetCount the num of block offset, in vertex shader file, it must
       be 6, and in pixel shader file, it must be 12
*/
void _parseShaderData(const size_t offsetCount)
{
    uint32* blockOffset = new uint32[offsetCount];

    // read the offsets of blocks
    _readData(blockOffset, sizeof(uint32) * offsetCount);

    // for each block
    for (size_t offsetIndex = 0; offsetIndex < offsetCount; ++offsetIndex)
    {
        uint32 offset = blockOffset[offsetIndex];

        // some block offset is zero, i don't know why
        if (offset > 0)
        {
            // go to the address of the block
            gBlsFStream.seekg(offset, std::ios::beg);

            // for each shader in this block
            for (uint32 shaderIndex = 0; shaderIndex < gBlsHeader.shaderCount; ++shaderIndex)
            {
                gOutputFile << "===== Shader start : " << std::endl;

                /** block header is four uint
                0x0 number of shader parameters
                if this number is not zero, there will be some string follow it,
                each string contain a parameter name and value, and the size is 0x90
                0x4 number of shader texture names
                if this number is not zero, there will be some string follow it,
                each string contain a texture name, and the size is 0x90
                0x8 always 0 or 2
                useless
                0xc number byte of shader code text
                the size of code text
                */
                uint32 blockHeader[4] = {0};

                _readData(&blockHeader[0], sizeof(uint32));

                if (blockHeader[0] > 0)
                {
                    gOutputFile << "Parameter section start :" << std::endl;

                    // log each parameter name
                    for (uint32 i = 0; i < blockHeader[0]; ++i)
                    {
                        char paraName[0x90];
                        _readData(paraName, 0x90);

                        gOutputFile << paraName << std::endl;
                    }

                    gOutputFile << "Parameter section end/n" << std::endl;
                }

                _readData(&blockHeader[1], sizeof(uint32));

                if (blockHeader[1] > 0)
                {
                    gOutputFile << "Texture names section start :/n" << std::endl;

                    // log each texture name
                    for (uint32 i = 0; i < blockHeader[1]; ++i)
                    {
                        char texName[0x90];
                        _readData(texName, 0x90);

                        gOutputFile << texName << std::endl;
                    }

                    gOutputFile << "Texture names section end/n" << std::endl;
                }

                _readData(&blockHeader[2], sizeof(uint32));

                // get the size of shader code text
                _readData(&blockHeader[3], sizeof(uint32));

                uint32 codeSize = blockHeader[3];
                if (codeSize > 0)
                {
                    gOutputFile << "Code section start :" << std::endl;

                    char* codeText = new char[codeSize];

                    // read code text
                    size_t read = _readData(codeText, codeSize);

                    assert (read == codeSize);

                    size_t pos = gBlsFStream.tellg();
                    // if the first char is '!', this shader is written by
                    // arbfp or arbvp, and there will be some unused datas
                    // between two shaders
                    if (codeText[0] == '!')
                    {
                        gOutputFile << codeText << std::endl;

                        // find out the length of the unused datas
                        size_t nowPos = gBlsFStream.tellg();

                        size_t skipCount = 0;

                        if (nowPos % 4 == 0)
                            skipCount = 0;
                        else
                            skipCount = 4 - nowPos % 4;

                        // and skip to the next shader
                        gBlsFStream.seekg(skipCount, std::ios::cur);
                    }
                    else // it is the dx shader
                    {
                        // use d3dx to get the shader code from the binary shader code
                        LPD3DXBUFFER codeBuffer;
                        HRESULT hr = D3DXDisassembleShader(
                            static_cast<DWORD*>( static_cast<void*>(codeText) ),
                            0, NULL, &codeBuffer );

                        if (FAILED(hr))
                        {
                            std::cout << DXGetErrorDescription9(hr) << std::endl;
                        }

                        gOutputFile << static_cast<char*>( codeBuffer->GetBufferPointer() ) << std::endl;
                    }

                    gOutputFile << "Code section end/n" << std::endl;

                    delete [] codeText;
                }

                gOutputFile << "===== Shader end/n" << std::endl;
            } // end of each shader
        }
    } // end of each block

    delete [] blockOffset;
}

int main(int argc, char **argv)
{
    gBlsFStream.open(argv[1], std::ios::binary | std::ios::in);

    if (!gBlsFStream)
    {
        std::cout << "can't find the file : " << argv[1] << std::endl;
        return 1;
    }

    std::string outputName(argv[1]);
    outputName += ".log";

    gOutputFile.open(outputName.c_str(), std::ios::out | std::ios::binary);

    if (!gOutputFile)
    {
        std::cout << "can't create the output file : " << outputName << std::endl;
        return 1;
    }

    // read the header
    _readData(&gBlsHeader, sizeof(BlsHeader));

    gOutputFile << "shader type : " << gBlsHeader.shaderType << std::endl;

    size_t offsetCount;

    // find out this bls file is vs or ps
    if (gBlsHeader.shaderType[1] == 'V')
    {
        offsetCount = 6;       
    }
    else if (gBlsHeader.shaderType[1] == 'P')
    {
        offsetCount = 12;
    }
    else
    {
        std::cout << "the content of the file is wrong : " << argv[1] << std::endl;
        return 1;
    }

    _parseShaderData(offsetCount);

    gBlsFStream.close();
    gOutputFile.close();

    return 0;
}