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;
}
