C++ FilePath::str方法代码示例

inline void storeFramebuffer(int resultIndex,
                             const FilePath& pngDir,
                             const FilePath& exrDir,
                             const FilePath& baseName,
                             float gamma,
                             const Framebuffer& framebuffer) {
    // Create output directories in case they don't exist
    createDirectory(pngDir.str());
    createDirectory(exrDir.str());

    // Path of primary output image files
    FilePath pngFile = pngDir + baseName.addExt(".png");
    FilePath exrFile = exrDir + baseName.addExt(".exr");

    // Make a copy of the image
    Image copy = framebuffer.getChannel(0);
    // Store the EXR image "as is"
    storeEXRImage(exrFile.str(), copy);

    // Post-process copy of image and store PNG file
    copy.flipY();
    copy.divideByAlpha();
    copy.applyGamma(gamma);
    storeImage(pngFile.str(), copy);

    // Store complete framebuffer as a single EXR multi layer image
    auto exrFramebufferFilePath = exrDir + baseName.addExt(".bnzframebuffer.exr");
    storeEXRFramebuffer(exrFramebufferFilePath.str(), framebuffer);

    // Store complete framebuffer as PNG indivual files in a dediacted subdirectory
    auto pngFramebufferDirPath = pngDir + "framebuffers/";
    createDirectory(pngFramebufferDirPath.str());
    if(resultIndex >= 0) {
        pngFramebufferDirPath = pngFramebufferDirPath + toString3(resultIndex); // Split different results of the same batch in different subdirectories
    }
    createDirectory(pngFramebufferDirPath.str());

    // Store each channel of the framebuffer
    for(auto i = 0u; i < framebuffer.getChannelCount(); ++i) {
        auto name = framebuffer.getChannelName(i);
        // Prefix by the index of the channel
        FilePath pngFile = pngFramebufferDirPath + FilePath(toString3(i)).addExt("_" + name + ".png");

        auto copy = framebuffer.getChannel(i);

        copy.flipY();
        copy.divideByAlpha();

        copy.applyGamma(gamma);
        storeImage(pngFile.str(), copy);
    }
}

void AnimInfo::save(const FilePath& path) {
    FILE* file = fopen(path.str(), "w");
    if (!file) {
        printf("cannot open for write \"%s\"\n", path.str());
        return;
    }
    fprintf(file, "%s", _tex_name.c_str());
    for (int i = 0; i < _frames.size(); i++) {
        Frame& frame = _frames[i];
        fprintf(file, "\n%d %d %d %d %d %d", frame.x(), frame.y(), frame.w(), frame.h(), frame.dx(), frame.dy());
    }
    fclose(file);
}

    PG15RendererManager(const Scene& scene, const Sensor& sensor,
                        Vec2u framebufferSize, const FilePath& referenceImagePath,
                        const FilePath& resultPath,
                        tinyxml2::XMLDocument& configDoc,
                        tinyxml2::XMLDocument& sceneDoc,
                        float gamma,
                        std::size_t renderTimeMsOrIterationCount,
                        std::size_t maxPathDepth,
                        std::size_t resamplingPathCount,
                        const PG15ICBPTSettings& icBPTSettings,
                        const std::vector<PG15SkelBPTSettings>& skelBPTSettings,
                        bool equalTime):
        m_ResultPath(resultPath),
        m_Params(scene, sensor, framebufferSize, maxPathDepth, resamplingPathCount),
        m_SharedData(framebufferSize.x * framebufferSize.y, m_Params.m_nMaxDepth - 1u),
        m_pReferenceImage(loadEXRImage(referenceImagePath.str())),
        m_ICBPTRenderer(m_Params, m_SharedData, icBPTSettings),
        m_RenderStatistics(2 + skelBPTSettings.size()),
        m_fGamma(gamma),
        m_nRenderTimeMsOrIterationCount(renderTimeMsOrIterationCount),
        m_bEqualTime(equalTime) {

        for(const auto& settings: skelBPTSettings) {
            m_SkelBPTRenderers.emplace_back(m_Params, m_SharedData, settings);
        }

        m_Rng.init(getSystemThreadCount(), m_nSeed);

        m_SharedData.m_LightSampler.initFrame(scene);

        initResultDir(configDoc, sceneDoc);
    }

// Load source code from files and build a GLSL program
Program loadProgramShader(const FilePath& vsFile, const FilePath& fsFile) {
	Shader vs = loadShader(GL_VERTEX_SHADER, vsFile);
	Shader fs = loadShader(GL_FRAGMENT_SHADER, fsFile);
	
	if(!vs.compile()) {
		throw std::runtime_error("Compilation error for vertex shader (from file " + std::string(vsFile) + "): " + vs.getInfoLog());
	}

	if(!fs.compile()) {
		throw std::runtime_error("Compilation error for fragment shader (from file " + std::string(fsFile) + "): " + fs.getInfoLog());
	}

	Program program;
	program.attachShader(vs);
	program.attachShader(fs);

	if(!program.link()) {
        throw std::runtime_error("Link error (for files " + vsFile.str() + " and " + fsFile.str() + "): " + program.getInfoLog());
	}

	return program;
}

Shader loadShader(GLenum type, const FilePath& filepath) {
    std::ifstream input(filepath.c_str());
    if(!input) {
        throw std::runtime_error("Unable to load the file " + filepath.str());
    }

    std::stringstream buffer;
    buffer << input.rdbuf();

    Shader shader(type);
    shader.setSource(buffer.str().c_str());

    return shader;
}

void AnimInfo::load(const FilePath& path) {
    TextFile file(path);
    if (!file.open()) {
        printf("cannot open for read \"%s\"\n", path.str());
        return;
    }
    clear();

    _tex_name = strip(file.read_line());
    std::string current_frame = file.read_line();

    while (!current_frame.empty()) {
        std::string result;
        std::vector<int> results;
        for (int i = 0; i < current_frame.size(); i++) {
            char c = current_frame[i];
            if (c == ' ' || c == '\n') {
                results.push_back(atoi(result.c_str()));
                result = "";
                continue;
            }
            result.push_back(c);
        }
        if (!result.empty()) {
            results.push_back(atoi(result.c_str()));
        }
        int xx = results[0];
        int yy = results[1];
        int w = results[2];
        int h = results[3];
        int dx = results[4];
        int dy = results[5];
        _frames.push_back(Frame(xx, yy, w, h, dx, dy));
        current_frame = file.read_line();
    }
}