Esempio n. 1
0
void CachegrindLoader::setFunction(const QString& name)
{
    ensureFile();
    ensureObject();

    currentFunction = compressedFunction( name,
                                          currentFile,
                                          currentObject);

    if (!currentFunction) {
        error(QStringLiteral("Invalid function specification, setting to unknown"));

        currentFunction = _data->function(_emptyString,
                                          currentFile,
                                          currentObject);
    }

    currentPartFunction = currentFunction->partFunction(_part,
                                                        currentPartFile,
                                                        currentPartObject);

    currentFunctionSource = 0;
    currentLine = 0;
    currentPartLine = 0;
}
Esempio n. 2
0
// make sure that a valid function is set, at least dummy with empty name
void CachegrindLoader::ensureFunction()
{
    if (currentFunction) return;

    error(QStringLiteral("Function not specified, setting to unknown"));

    ensureFile();
    ensureObject();

    currentFunction = _data->function(_emptyString,
                                      currentFile,
                                      currentObject);
    currentPartFunction = currentFunction->partFunction(_part,
                                                        currentPartFile,
                                                        currentPartObject);
}
bool
parseShaderComments(gfd::GFDVertexShader &shader,
                    std::vector<std::string> &comments)
{
   for (auto &comment : comments) {
      CommentKeyValue kv;

      if (!parseComment(comment, kv)) {
         continue;
      }

      std::transform(kv.obj.begin(), kv.obj.end(), kv.obj.begin(), ::toupper);
      std::transform(kv.member.begin(), kv.member.end(), kv.member.begin(), ::toupper);

      if (kv.obj == "SQ_PGM_RESOURCES_VS") {
         ensureObject(kv);
         parseRegisterValue(shader.regs.sq_pgm_resources_vs, kv.member, kv.value);
      } else if (kv.obj == "VGT_PRIMITIVEID_EN") {
         ensureObject(kv);
         parseRegisterValue(shader.regs.vgt_primitiveid_en, kv.member, kv.value);
      } else if (kv.obj == "SPI_VS_OUT_CONFIG") {
         ensureObject(kv);
         parseRegisterValue(shader.regs.spi_vs_out_config, kv.member, kv.value);
      } else if (kv.obj == "NUM_SPI_VS_OUT_ID") {
         ensureValue(kv);
         shader.regs.num_spi_vs_out_id = parseValueNumber(kv.value);
      } else if (kv.obj == "SPI_VS_OUT_ID") {
         ensureArrayOfObjects(kv);
         parseRegisterValue(shader.regs.spi_vs_out_id, std::stoul(kv.index), kv.member, kv.value);
      } else if (kv.obj == "PA_CL_VS_OUT_CNTL") {
         ensureObject(kv);
         parseRegisterValue(shader.regs.pa_cl_vs_out_cntl, kv.member, kv.value);
      } else if (kv.obj == "SQ_VTX_SEMANTIC_CLEAR") {
         ensureValue(kv);
         shader.regs.sq_vtx_semantic_clear = shader.regs.sq_vtx_semantic_clear
            .CLEAR(parseValueNumber(kv.value));
      } else if (kv.obj == "NUM_SQ_VTX_SEMANTIC") {
         ensureValue(kv);
         shader.regs.num_sq_vtx_semantic = parseValueNumber(kv.value);
      } else if (kv.obj == "SQ_VTX_SEMANTIC") {
         ensureArrayOfObjects(kv);
         parseRegisterValue(shader.regs.sq_vtx_semantic, std::stoul(kv.index), kv.member, kv.value);
      } else if (kv.obj == "VGT_STRMOUT_BUFFER_EN") {
         ensureObject(kv);
         parseRegisterValue(shader.regs.vgt_strmout_buffer_en, kv.member, kv.value);
      } else if (kv.obj == "VGT_VERTEX_REUSE_BLOCK_CNTL") {
         ensureObject(kv);
         parseRegisterValue(shader.regs.vgt_vertex_reuse_block_cntl, kv.member, kv.value);
      } else if (kv.obj == "VGT_HOS_REUSE_DEPTH") {
         ensureObject(kv);
         parseRegisterValue(shader.regs.vgt_hos_reuse_depth, kv.member, kv.value);
      } else if (kv.obj == "ATTRIB_VARS") {
         ensureArrayOfObjects(kv);
         parseAttribVars(shader.attribVars, std::stoul(kv.index), kv.member, kv.value);
      } else if (kv.obj == "MODE") {
         ensureValue(kv);
         shader.mode = parseShaderMode(kv.value);
      } else if (kv.obj == "RING_ITEM_SIZE") {
         ensureValue(kv);
         shader.ringItemSize = parseValueNumber(kv.value);
      } else if (kv.obj == "HAS_STREAM_OUT") {
         ensureValue(kv);
         shader.hasStreamOut = parseValueBool(kv.value);
      } else if (kv.obj == "STREAM_OUT_STRIDE") {
         ensureArrayOfValues(kv);
         auto index = std::stoul(kv.index);

         if (index >= shader.streamOutStride.size()) {
            throw gfd_header_parse_exception { fmt::format("STREAM_OUT_STRIDE[{}] invalid index, max: {}", index, shader.streamOutStride.size()) };
         }

         shader.streamOutStride[index] = parseValueNumber(kv.value);
      } else {
         throw gfd_header_parse_exception { fmt::format("Unknown key {}", kv.obj) };
      }

      /*
      TODO:
      std::vector<GFDUniformBlock> uniformBlocks;
      std::vector<GFDUniformVar> uniformVars;
      std::vector<GFDUniformInitialValue> initialValues;
      std::vector<GFDLoopVar> loopVars;
      std::vector<GFDSamplerVar> samplerVars;
      GFDRBuffer gx2rData;
      */
   }

   return true;
}