static void fprint_dst_reg(FILE * f, const struct prog_dst_register *dstReg, gl_prog_print_mode mode, const struct gl_program *prog) { _mesa_fprintf(f, "%s%s", reg_string((gl_register_file) dstReg->File, dstReg->Index, mode, dstReg->RelAddr, prog), _mesa_writemask_string(dstReg->WriteMask)); if (dstReg->CondMask != COND_TR) { _mesa_fprintf(f, " (%s.%s)", _mesa_condcode_string(dstReg->CondMask), _mesa_swizzle_string(dstReg->CondSwizzle, GL_FALSE, GL_FALSE)); } #if 0 _mesa_fprintf(f, "%s[%d]%s", file_string((gl_register_file) dstReg->File, mode), dstReg->Index, _mesa_writemask_string(dstReg->WriteMask)); #endif }
/** * Print a program parameter list to given file. */ static void _mesa_fprint_parameter_list(FILE *f, const struct gl_program_parameter_list *list) { const gl_prog_print_mode mode = PROG_PRINT_DEBUG; GLuint i; if (!list) return; _mesa_fprintf(f, "param list %p\n", (void *) list); _mesa_fprintf(f, "dirty state flags: 0x%x\n", list->StateFlags); for (i = 0; i < list->NumParameters; i++){ struct gl_program_parameter *param = list->Parameters + i; const GLfloat *v = list->ParameterValues[i]; _mesa_fprintf(f, "param[%d] sz=%d %s %s = {%.3g, %.3g, %.3g, %.3g}", i, param->Size, file_string(list->Parameters[i].Type, mode), param->Name, v[0], v[1], v[2], v[3]); if (param->Flags & PROG_PARAM_BIT_CENTROID) _mesa_fprintf(f, " Centroid"); if (param->Flags & PROG_PARAM_BIT_INVARIANT) _mesa_fprintf(f, " Invariant"); if (param->Flags & PROG_PARAM_BIT_FLAT) _mesa_fprintf(f, " Flat"); if (param->Flags & PROG_PARAM_BIT_LINEAR) _mesa_fprintf(f, " Linear"); _mesa_fprintf(f, "\n"); } }
ImageSequenceAsset::ImageSequenceAsset( const char* dir, const std::vector<std::string>& names, bool load_to_memory ) : VideoAsset( dir ) , m_DirectoryName( dir ) , m_ResourceName( "" ) , m_MaxMemUsed( 0 ) , m_CacheFrames(load_to_memory) , m_IsOpen(false) { m_Format.m_FrameTime = 1000.0/FPS_BASE; bfs::path directory( bfs::system_complete( bfs::path( dir ) ) ); if ( bfs::exists( directory ) && bfs::is_directory( directory ) ) { m_DirectoryName = directory.directory_string(); } std::vector<std::string>::const_iterator it = names.begin(); while (it != names.end()) { std::string file_string( *it++ ); m_FileNames.push_back( file_string ); } if ( m_FileNames.size() > 0 ) { std::sort( m_FileNames.begin(), m_FileNames.end() ); bfs::path path( m_FileNames[0] ); m_ResourceName = path.filename( ); size_t pos = m_ResourceName.rfind( path.extension()); if ( pos != std::string::npos ) { m_ResourceName = m_ResourceName.substr( 0, pos ); } pos = m_ResourceName.rfind( "_" ); if ( pos != std::string::npos ) { m_ResourceName = m_ResourceName.substr( 0, pos ); } } }
void create_new_file_from_template( generator const& gen, std::string const& class_name, std::string const& file_extension) { std::string template_file_name = gen.m_template_file + file_extension + ".template"; std::ifstream template_file(template_file_name); if(!template_file.is_open()) { print_error_and_exit("Error opening template file \"" + template_file_name + "\""); } // Read file into string std::string file_string( (std::istreambuf_iterator<char>(template_file)), std::istreambuf_iterator<char>()); // Search for each token through the entire file, replacing as found. for(auto token_value_pair : gen.m_tokens) { size_t remove_it = file_string.find(token_value_pair.first); while(remove_it != std::string::npos) { // Find end of token (we searched for the whole token including %'s thus it is guaranteed // that it exists) size_t remove_end_it = file_string.find('%', remove_it + 1); size_t token_length = (remove_end_it + 1) - remove_it; // Replace entire token from remove_it to and including remove_end. file_string.replace(remove_it, token_length, token_value_pair.second); remove_it = file_string.find(token_value_pair.first.c_str(), remove_it); } } std::string output_file_name = class_name + file_extension; std::ofstream output_file(output_file_name); if(!output_file.is_open()) { std::cerr << "Error opening ouput file \"" << output_file_name << "\"exiting..." << std::endl; std::exit(-1); } output_file << file_string; std::cout << output_file_name << " written..." << std::endl; }
static void fprint_src_reg(FILE *f, const struct prog_src_register *srcReg, gl_prog_print_mode mode, const struct gl_program *prog) { const char *abs = srcReg->Abs ? "|" : ""; _mesa_fprintf(f, "%s%s%s%s", abs, reg_string((gl_register_file) srcReg->File, srcReg->Index, mode, srcReg->RelAddr, prog), _mesa_swizzle_string(srcReg->Swizzle, srcReg->Negate, GL_FALSE), abs); #if 0 _mesa_fprintf(f, "%s[%d]%s", file_string((gl_register_file) srcReg->File, mode), srcReg->Index, _mesa_swizzle_string(srcReg->Swizzle, srcReg->Negate, GL_FALSE)); #endif }
/** * Print a single vertex/fragment program instruction. */ static GLint _mesa_fprint_instruction_opt(FILE *f, const struct prog_instruction *inst, GLint indent, gl_prog_print_mode mode, const struct gl_program *prog) { GLint i; if (inst->Opcode == OPCODE_ELSE || inst->Opcode == OPCODE_ENDIF || inst->Opcode == OPCODE_ENDLOOP || inst->Opcode == OPCODE_ENDSUB) { indent -= 3; } for (i = 0; i < indent; i++) { _mesa_fprintf(f, " "); } switch (inst->Opcode) { case OPCODE_PRINT: _mesa_fprintf(f, "PRINT '%s'", inst->Data); if (inst->SrcReg[0].File != PROGRAM_UNDEFINED) { _mesa_fprintf(f, ", "); _mesa_fprintf(f, "%s[%d]%s", file_string((gl_register_file) inst->SrcReg[0].File, mode), inst->SrcReg[0].Index, _mesa_swizzle_string(inst->SrcReg[0].Swizzle, inst->SrcReg[0].Negate, GL_FALSE)); } if (inst->Comment) _mesa_fprintf(f, " # %s", inst->Comment); fprint_comment(f, inst); break; case OPCODE_SWZ: _mesa_fprintf(f, "SWZ"); if (inst->SaturateMode == SATURATE_ZERO_ONE) _mesa_fprintf(f, "_SAT"); _mesa_fprintf(f, " "); fprint_dst_reg(f, &inst->DstReg, mode, prog); _mesa_fprintf(f, ", %s[%d], %s", file_string((gl_register_file) inst->SrcReg[0].File, mode), inst->SrcReg[0].Index, _mesa_swizzle_string(inst->SrcReg[0].Swizzle, inst->SrcReg[0].Negate, GL_TRUE)); fprint_comment(f, inst); break; case OPCODE_TEX: case OPCODE_TXP: case OPCODE_TXL: case OPCODE_TXB: _mesa_fprintf(f, "%s", _mesa_opcode_string(inst->Opcode)); if (inst->SaturateMode == SATURATE_ZERO_ONE) _mesa_fprintf(f, "_SAT"); _mesa_fprintf(f, " "); fprint_dst_reg(f, &inst->DstReg, mode, prog); _mesa_fprintf(f, ", "); fprint_src_reg(f, &inst->SrcReg[0], mode, prog); _mesa_fprintf(f, ", texture[%d], ", inst->TexSrcUnit); switch (inst->TexSrcTarget) { case TEXTURE_1D_INDEX: _mesa_fprintf(f, "1D"); break; case TEXTURE_2D_INDEX: _mesa_fprintf(f, "2D"); break; case TEXTURE_3D_INDEX: _mesa_fprintf(f, "3D"); break; case TEXTURE_CUBE_INDEX: _mesa_fprintf(f, "CUBE"); break; case TEXTURE_RECT_INDEX: _mesa_fprintf(f, "RECT"); break; default: ; } if (inst->TexShadow) _mesa_fprintf(f, " SHADOW"); fprint_comment(f, inst); break; case OPCODE_KIL: _mesa_fprintf(f, "%s", _mesa_opcode_string(inst->Opcode)); _mesa_fprintf(f, " "); fprint_src_reg(f, &inst->SrcReg[0], mode, prog); fprint_comment(f, inst); break; case OPCODE_KIL_NV: _mesa_fprintf(f, "%s", _mesa_opcode_string(inst->Opcode)); _mesa_fprintf(f, " "); _mesa_fprintf(f, "%s.%s", _mesa_condcode_string(inst->DstReg.CondMask), _mesa_swizzle_string(inst->DstReg.CondSwizzle, GL_FALSE, GL_FALSE)); fprint_comment(f, inst); break; case OPCODE_ARL: _mesa_fprintf(f, "ARL "); fprint_dst_reg(f, &inst->DstReg, mode, prog); _mesa_fprintf(f, ", "); fprint_src_reg(f, &inst->SrcReg[0], mode, prog); fprint_comment(f, inst); break; case OPCODE_BRA: _mesa_fprintf(f, "BRA %d (%s%s)", inst->BranchTarget, _mesa_condcode_string(inst->DstReg.CondMask), _mesa_swizzle_string(inst->DstReg.CondSwizzle, 0, GL_FALSE)); fprint_comment(f, inst); break; case OPCODE_IF: if (inst->SrcReg[0].File != PROGRAM_UNDEFINED) { /* Use ordinary register */ _mesa_fprintf(f, "IF "); fprint_src_reg(f, &inst->SrcReg[0], mode, prog); _mesa_fprintf(f, "; "); } else { /* Use cond codes */ _mesa_fprintf(f, "IF (%s%s);", _mesa_condcode_string(inst->DstReg.CondMask), _mesa_swizzle_string(inst->DstReg.CondSwizzle, 0, GL_FALSE)); } _mesa_fprintf(f, " # (if false, goto %d)", inst->BranchTarget); fprint_comment(f, inst); return indent + 3; case OPCODE_ELSE: _mesa_fprintf(f, "ELSE; # (goto %d)\n", inst->BranchTarget); return indent + 3; case OPCODE_ENDIF: _mesa_fprintf(f, "ENDIF;\n"); break; case OPCODE_BGNLOOP: _mesa_fprintf(f, "BGNLOOP; # (end at %d)\n", inst->BranchTarget); return indent + 3; case OPCODE_ENDLOOP: _mesa_fprintf(f, "ENDLOOP; # (goto %d)\n", inst->BranchTarget); break; case OPCODE_BRK: case OPCODE_CONT: _mesa_fprintf(f, "%s (%s%s); # (goto %d)", _mesa_opcode_string(inst->Opcode), _mesa_condcode_string(inst->DstReg.CondMask), _mesa_swizzle_string(inst->DstReg.CondSwizzle, 0, GL_FALSE), inst->BranchTarget); fprint_comment(f, inst); break; case OPCODE_BGNSUB: if (mode == PROG_PRINT_NV) { _mesa_fprintf(f, "%s:\n", inst->Comment); /* comment is label */ return indent; } else { _mesa_fprintf(f, "BGNSUB"); fprint_comment(f, inst); return indent + 3; } case OPCODE_ENDSUB: if (mode == PROG_PRINT_DEBUG) { _mesa_fprintf(f, "ENDSUB"); fprint_comment(f, inst); } break; case OPCODE_CAL: if (mode == PROG_PRINT_NV) { _mesa_fprintf(f, "CAL %s; # (goto %d)\n", inst->Comment, inst->BranchTarget); } else { _mesa_fprintf(f, "CAL %u", inst->BranchTarget); fprint_comment(f, inst); } break; case OPCODE_RET: _mesa_fprintf(f, "RET (%s%s)", _mesa_condcode_string(inst->DstReg.CondMask), _mesa_swizzle_string(inst->DstReg.CondSwizzle, 0, GL_FALSE)); fprint_comment(f, inst); break; case OPCODE_END: _mesa_fprintf(f, "END\n"); break; case OPCODE_NOP: if (mode == PROG_PRINT_DEBUG) { _mesa_fprintf(f, "NOP"); fprint_comment(f, inst); } else if (inst->Comment) { /* ARB/NV extensions don't have NOP instruction */ _mesa_fprintf(f, "# %s\n", inst->Comment); } break; /* XXX may need other special-case instructions */ default: if (inst->Opcode < MAX_OPCODE) { /* typical alu instruction */ fprint_alu_instruction(f, inst, _mesa_opcode_string(inst->Opcode), _mesa_num_inst_src_regs(inst->Opcode), mode, prog); } else { _mesa_fprintf(f, "Other opcode %d\n", inst->Opcode); } break; } return indent; }
/** * Return string representation of the given register. * Note that some types of registers (like PROGRAM_UNIFORM) aren't defined * by the ARB/NV program languages so we've taken some liberties here. * \param f the register file (PROGRAM_INPUT, PROGRAM_TEMPORARY, etc) * \param index number of the register in the register file * \param mode the output format/mode/style * \param prog pointer to containing program */ static const char * reg_string(gl_register_file f, GLint index, gl_prog_print_mode mode, GLboolean relAddr, const struct gl_program *prog) { static char str[100]; const char *addr = relAddr ? "ADDR+" : ""; str[0] = 0; switch (mode) { case PROG_PRINT_DEBUG: _mesa_sprintf(str, "%s[%s%d]", file_string(f, mode), addr, index); break; case PROG_PRINT_ARB: switch (f) { case PROGRAM_INPUT: _mesa_sprintf(str, "%s", arb_input_attrib_string(index, prog->Target)); break; case PROGRAM_OUTPUT: _mesa_sprintf(str, "%s", arb_output_attrib_string(index, prog->Target)); break; case PROGRAM_TEMPORARY: _mesa_sprintf(str, "temp%d", index); break; case PROGRAM_ENV_PARAM: _mesa_sprintf(str, "program.env[%s%d]", addr, index); break; case PROGRAM_LOCAL_PARAM: _mesa_sprintf(str, "program.local[%s%d]", addr, index); break; case PROGRAM_VARYING: /* extension */ _mesa_sprintf(str, "varying[%s%d]", addr, index); break; case PROGRAM_CONSTANT: /* extension */ _mesa_sprintf(str, "constant[%s%d]", addr, index); break; case PROGRAM_UNIFORM: /* extension */ _mesa_sprintf(str, "uniform[%s%d]", addr, index); break; case PROGRAM_STATE_VAR: { struct gl_program_parameter *param = prog->Parameters->Parameters + index; char *state = _mesa_program_state_string(param->StateIndexes); _mesa_sprintf(str, state); _mesa_free(state); } break; case PROGRAM_ADDRESS: _mesa_sprintf(str, "A%d", index); break; default: _mesa_problem(NULL, "bad file in reg_string()"); } break; case PROG_PRINT_NV: switch (f) { case PROGRAM_INPUT: if (prog->Target == GL_VERTEX_PROGRAM_ARB) _mesa_sprintf(str, "v[%d]", index); else _mesa_sprintf(str, "f[%d]", index); break; case PROGRAM_OUTPUT: _mesa_sprintf(str, "o[%d]", index); break; case PROGRAM_TEMPORARY: _mesa_sprintf(str, "R%d", index); break; case PROGRAM_ENV_PARAM: _mesa_sprintf(str, "c[%d]", index); break; case PROGRAM_VARYING: /* extension */ _mesa_sprintf(str, "varying[%s%d]", addr, index); break; case PROGRAM_UNIFORM: /* extension */ _mesa_sprintf(str, "uniform[%s%d]", addr, index); break; case PROGRAM_CONSTANT: /* extension */ _mesa_sprintf(str, "constant[%s%d]", addr, index); break; case PROGRAM_STATE_VAR: /* extension */ _mesa_sprintf(str, "state[%s%d]", addr, index); break; default: _mesa_problem(NULL, "bad file in reg_string()"); } break; default: _mesa_problem(NULL, "bad mode in reg_string()"); } return str; }