scl::assets_manager::shader_preprocessor Class Reference

#include <shaders_preprocessor.h>

Static Public Member Functions
static void	SeparateShaders (const std::string &ShaderDebugName, const std::string &ShaderText, std::vector< shader_props > &Out)
static void	ProcessIncludes (const std::string &ShaderDebugName, const std::string &ShaderFolderPath, std::string &ShaderText)

Detailed Description

Static shader preprocessor class.

Definition at line 17 of file shaders_preprocessor.h.

Member Function Documentation

ProcessIncludes()

void scl::assets_manager::shader_preprocessor::ProcessIncludes ( const std::string &  ShaderDebugName, const std::string &  ShaderFolderPath, std::string &  ShaderText  )

static

• Process include directives in shader text.

Parameters

ShaderDebugName	- debug name to show if error occures.
ShaderFolderPath	- path to folder where shalder is located.
ShaderText[in,out]	- text of shader to process.

Returns

None.

Definition at line 106 of file shaders_preprocessor.cpp.

{
    size_t offset;
    while ((offset = ShaderText.find(shader_preprocessor::LexemInclude, 0)) != std::string::npos)
    {
        ShaderText.erase(offset, strlen(shader_preprocessor::LexemInclude));
 
        int spaces_count = 0;
        std::string include_path = ReadWord(ShaderText.begin() + offset, ShaderText.end(), &spaces_count);
        ShaderText.erase(offset, spaces_count + include_path.size());
 
        std::string file_name = std::string(include_path.begin() + 1, include_path.end() - 1);
        std::filesystem::path file_path = ShaderFolderPath / std::filesystem::path(file_name);
        ShaderText.insert(offset, LoadFile(file_path));
    }
}

SeparateShaders()

void scl::assets_manager::shader_preprocessor::SeparateShaders ( const std::string &  ShaderDebugName, const std::string &  ShaderText, std::vector< shader_props > &  Out  )

static

• Separate text to diffrent shader blocks function.

Parameters

ShaderDebugName	- debug name to show if error occures.
ShaderText	- inptu text to separate to blocks.
Out	- output array of shaders text.

Definition at line 48 of file shaders_preprocessor.cpp.

{
    size_t offset = ShaderText.find(shader_preprocessor::LexemBlockStart, 0);
    if (offset == std::string::npos)
    {
        SCL_CORE_ERROR("Error while preprocessing shader \"{}\".\nNo shader blcoks was found in text.", ShaderDebugName);
        return;
    }
    std::string global_block(ShaderText.begin(), ShaderText.begin() + offset);
 
    while (offset != std::string::npos)
    {
        size_t block_start_offset = ShaderText.find(' ', offset);
        if (block_start_offset == std::string::npos)
            SCL_CORE_ERROR("Error while preprocessing shader \"{}\".\nNo block text found, block skiped.", ShaderDebugName);
 
        size_t block_end_offset = ShaderText.find(shader_preprocessor::LexemBlockEnd, offset);
        if (block_end_offset == std::string::npos)
            SCL_CORE_ERROR("Error while preprocessing shader \"{}\".\nNo block end lexem found. Block skiped.", ShaderDebugName);
 
        if (block_end_offset != std::string::npos && block_start_offset != std::string::npos)
        {
            int spaces_count;
            std::string block_text(ShaderText.begin() + block_start_offset, ShaderText.begin() + block_end_offset);
            std::string block_shader_type_string = ReadWord(block_text.begin(), block_text.end(), &spaces_count);
 
            shader_type block_shader_type;
            bool block_shader_type_ok = true;
            std::transform(block_shader_type_string.begin(), block_shader_type_string.end(), block_shader_type_string.begin(),
                           [](unsigned char c) { return std::tolower(c); });
 
            switch (StringId(block_shader_type_string.c_str()))
            {
            case "compute"_id:    block_shader_type = shader_type::COMPUTE;  break;
            case "vert"_id:
            case "vertex"_id:     block_shader_type = shader_type::VERTEX;   break;
            case "geom"_id:
            case "geometry"_id:   block_shader_type = shader_type::GEOMETRY; break;
            case "pixel"_id:
            case "frag"_id:
            case "fragment"_id:   block_shader_type = shader_type::PIXEL;    break;
            default:
                SCL_CORE_ERROR("Error while preprocessing shader \"{}\".\nShader type \"{}\" is unknown. Block skipped.", ShaderDebugName, block_shader_type_string);
                block_shader_type_ok = false;
            }
 
            if (block_shader_type_ok)
                Out.push_back({
                    block_shader_type,
                    global_block + std::string(block_text.begin() + spaces_count + block_shader_type_string.size(), block_text.end())
                });
        }
        offset = ShaderText.find(shader_preprocessor::LexemBlockStart, block_end_offset);
    }
}

---

The documentation for this class was generated from the following files:

• utilities/assets_manager/shaders_preprocessor.h
• utilities/assets_manager/shaders_preprocessor.cpp