static bool simulator_view(WINDOW *out, WINDOW *state, struct program *program,
enum STATE *current_state)
{
int input;
static int timeout = 0;
set_state(current_state);
while (1) {
wtimeout(state, timeout);
input = wgetch(status);
if (program->simulator.memory[program->simulator.PC].isBreakpoint) {
popup_window("Breakpoint hit!", 0, true);
program->simulator.isPaused = true;
program->simulator.memory[program->simulator.PC]
.isBreakpoint = false;
}
if (QUIT == input) {
return false;
} else if (GOBACK == input) {
*current_state = MAIN;
program->simulator.isPaused = true;
return true;
} else if (PAUSE == input) {
program->simulator.isPaused = !program->simulator.isPaused;
} else if (START == input || RUN == input) {
program->simulator.isPaused = program->simulator.isHalted;
} else if (RESTART == input) {
memPopulated = -1;
init_machine(program);
wclear(out);
wrefresh(out);
} else if (STEP_NEXT == input) {
executeNext(&(program->simulator), output);
program->simulator.isPaused = true;
printState(&(program->simulator), state);
} else if (CONTINUE == input) {
memPopulated = -1;
init_machine(program);
} else if (CONTINUE_RUN == input) {
memPopulated = -1;
init_machine(program);
program->simulator.isPaused = false;
}
if (!program->simulator.isPaused && !program->simulator.isHalted) {
executeNext(&(program->simulator), out);
timeout = 0;
} else {
set_state(current_state);
printState(&(program->simulator), state);
timeout = -1;
generateContext(context, program, 0, program->simulator.PC);
}
}
}
static bool main_view(WINDOW *state, enum STATE *current_state,
struct program *program)
{
int input;
while (1) {
set_state(current_state);
input = wgetch(state);
if (QUIT == input) {
return false;
} else if (LOGDUMP == input) {
if (logDump(program)) {
return false;
}
} else if (SIMVIEW == input) {
*current_state = SIM;
return true;
} else if (MEMVIEW == input) {
*current_state = MEM;
return true;
} else if (FILESEL == input) {
prompt((char const *) NULL, "Enter the .obj file: ",
program->objectfile);
if (init_machine(program)) {
return false;
}
}
}
}
int main(int argc, char *argv[]) {
FILE *parFile = fopen(GCODE_PARAMETER_STORE, "r");
FILE *inputFile = (argc > 1 ? fopen(argv[1], "r") : stdin);
char line[0xFF];
init_parameters(parFile);
init_machine(NULL);
init_stacks(NULL);
init_tools(NULL);
init_input(inputFile);
//TODO: align API, add done_gcode_state().
init_gcode_state(NULL);
init_cycles(NULL);
//TODO: align API, make it take a pointer to init data.
init_queue();
init_checker(NULL);
while(machine_running() && gcode_running() && fetch_line_input(line)) {
if(gcode_check(line)) update_gcode_state(line);
move_machine_queue();
}
/* Flush movement queue */
while(move_machine_queue());
done_checker();
done_queue();
done_cycles();
done_input();
done_tools();
done_stacks();
done_machine();
done_parameters();
return 0;
}
/**
* Execute the current ATI shader program, operating on the given span.
*/
void
_swrast_exec_fragment_shader(struct gl_context * ctx, SWspan *span)
{
const struct ati_fragment_shader *shader = ctx->ATIFragmentShader.Current;
struct atifs_machine machine;
GLuint i;
/* incoming colors should be floats */
ASSERT(span->array->ChanType == GL_FLOAT);
for (i = 0; i < span->end; i++) {
if (span->array->mask[i]) {
init_machine(ctx, &machine, shader, span, i);
execute_shader(ctx, shader, &machine, span, i);
/* store result color */
{
const GLfloat *colOut = machine.Registers[0];
/*fprintf(stderr,"outputs %f %f %f %f\n",
colOut[0], colOut[1], colOut[2], colOut[3]); */
COPY_4V(span->array->attribs[FRAG_ATTRIB_COL0][i], colOut);
}
}
}
}
int
main(int argc, char *argv[])
{
char *input; /* input filename (program to run) */
progname=argv[0];
input=parse_command_line(argc, argv); /* parse options, get input filename */
init_machine(); /* initialize machine */
load_imem(input); /* load the instructions */
if( interactive ) {
printf("pendvm %s -- matt debergalis <*****@*****.**>\n",VERSION);
loop(); /* never returns */
} else {
int result=step_processor(-1); /* just go on until halt */
if( !result ) return 0; /* all was good */
/* something went wrong - give 'coredump' and exit */
printf("\n"); /* already printed error message */
com_reg(NULL, 0); /* this is wrong... */
display_state();
printf("\n");
return 1;
}
}
int main(int argc,char **argv)
{
int i,list,log,success;
list = 0;
for (i = 1;i < argc;i++)
{
if (stricmp(argv[i],"-list") == 0)
list = 1;
}
if (list)
{
printf("\nMAME currently supports the following games:\n\n");
i = 0;
while (drivers[i])
{
printf("%10s",drivers[i]->name);
i++;
if (!(i % 7)) printf("\n");
}
if (i % 7) printf("\n");
printf("\nTotal games supported: %4d\n", i);
return 0;
}
success = 1;
log = 0;
for (i = 1;i < argc;i++)
{
if (stricmp(argv[i],"-log") == 0)
log = 1;
}
if (log) errorlog = fopen("error.log","wa");
if (init_machine(argc > 1 && argv[1][0] != '-' ? argv[1] : DEFAULT_NAME,argc,argv) == 0)
{
if (osd_init(argc,argv) == 0)
{
if (run_machine(argc > 1 && argv[1][0] != '-' ? argv[1] : DEFAULT_NAME) == 0)
success = 0;
else printf("Unable to start emulation\n");
osd_exit();
}
else printf("Unable to initialize system\n");
shutdown_machine();
}
else printf("Unable to initialize machine emulation\n");
if (errorlog) fclose(errorlog);
return success;
}
void AgiEngine::initialize() {
memset(&opt, 0, sizeof(struct agi_options));
opt.gamerun = GAMERUN_RUNGAME;
opt.hires = true;
// TODO: Some sound emulation modes do not fit our current music
// drivers, and I'm not sure what they are. For now, they might
// as well be called "PC Speaker" and "Not PC Speaker".
switch (MidiDriver::detectMusicDriver(MDT_PCSPK)) {
case MD_PCSPK:
opt.soundemu = SOUND_EMU_PC;
break;
default:
opt.soundemu = SOUND_EMU_NONE;
break;
}
if (ConfMan.hasKey("render_mode"))
opt.renderMode = Common::parseRenderMode(ConfMan.get("render_mode").c_str());
_console = new Console(this);
init_machine();
game.color_fg = 15;
game.color_bg = 0;
*game.name = 0;
game.sbuf = (uint8 *) calloc(_WIDTH, _HEIGHT);
game.hires = (uint8 *) calloc(_WIDTH * 2, _HEIGHT);
_sprites = new SpritesMan;
_text = new TextMan;
init_video();
tick_timer = 0;
_timer->installTimerProc(agi_timer_function_low, 10 * 1000, NULL);
game.ver = -1; /* Don't display the conf file warning */
debugC(2, kDebugLevelMain, "Detect game");
if (agi_detect_game() == err_OK) {
game.state = STATE_LOADED;
debugC(2, kDebugLevelMain, "game loaded");
} else {
report("Could not open AGI game");
}
debugC(2, kDebugLevelMain, "Init sound");
init_sound();
g_agi_music = new AGIMusic(_mixer);
}
/**
* Run fragment program on the pixels in span from 'start' to 'end' - 1.
*/
static void
run_program(struct gl_context *ctx, SWspan *span, GLuint start, GLuint end)
{
SWcontext *swrast = SWRAST_CONTEXT(ctx);
const struct gl_fragment_program *program = ctx->FragmentProgram._Current;
const GLbitfield64 outputsWritten = program->Base.OutputsWritten;
struct gl_program_machine *machine = &swrast->FragProgMachine;
GLuint i;
for (i = start; i < end; i++) {
if (span->array->mask[i]) {
init_machine(ctx, machine, program, span, i);
if (_mesa_execute_program(ctx, &program->Base, machine)) {
/* Store result color */
if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_COLOR)) {
COPY_4V(span->array->attribs[FRAG_ATTRIB_COL0][i],
machine->Outputs[FRAG_RESULT_COLOR]);
}
else {
/* Multiple drawbuffers / render targets
* Note that colors beyond 0 and 1 will overwrite other
* attributes, such as FOGC, TEX0, TEX1, etc. That's OK.
*/
GLuint buf;
for (buf = 0; buf < ctx->DrawBuffer->_NumColorDrawBuffers; buf++) {
if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DATA0 + buf)) {
COPY_4V(span->array->attribs[FRAG_ATTRIB_COL0 + buf][i],
machine->Outputs[FRAG_RESULT_DATA0 + buf]);
}
}
}
/* Store result depth/z */
if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
const GLfloat depth = machine->Outputs[FRAG_RESULT_DEPTH][2];
if (depth <= 0.0)
span->array->z[i] = 0;
else if (depth >= 1.0)
span->array->z[i] = ctx->DrawBuffer->_DepthMax;
else
span->array->z[i] =
(GLuint) (depth * ctx->DrawBuffer->_DepthMaxF + 0.5F);
}
}
else {
/* killed fragment */
span->array->mask[i] = GL_FALSE;
span->writeAll = GL_FALSE;
}
}
}
}
int main(void)
{
init_environment();
MACHINE *mach = make_machine();
for (int i = 0; i < 23; i++)
printf("ins %d: %08x\n", i, factorial_ins[i]);
printf("\n");
init_machine(mach);
load_memory(factorial_ins, 100, mach, 0);
run_machine(mach);
free_machine(mach);
return 0;
}
int main()
{
char filename[50] = {'\0'};
//fileBrowser(filename, (unsigned char*)"*.lua", (unsigned char*)"*.lc", (unsigned char*)"*.txt", "Title"); //*.lua, *.lc, *.txt: filetypes to filter; "Title": small text to show in blue on the top left corner
Exec_info exec_info = {0,0,0};
int key = 0, debug = 0, handle_program, i=0;
char pc_s[10];
Bdisp_AllClr_VRAM();
srand(time_getTicks());
init_gui();
init_machine();
while(1) {
handle_program = gui(exec_info);
if(handle_program > 0) {
init_machine();
load_game(handle_program);
exec_info = play_game();
} else {
while(i < 10) {
nio_DrawConsole(&c1);
GetKey(&key);
i++;
}
i=0;
}
}
nio_CleanUp(&c1);
while(1) {
GetKey(&key);
}
return 1;
}
extern "C" void
init_ex1(SuifEnv *suif_env)
{
static bool init_done = false;
if (init_done)
return;
init_done = true;
ModuleSubSystem *mSubSystem = suif_env->get_module_subsystem();
mSubSystem->register_module(new Ex1SuifPass(suif_env));
// initialize the libraries required by this OPI pass
init_suifpasses(suif_env);
init_machine(suif_env);
}
extern "C" void
init_m2a(SuifEnv *suif_env)
{
static bool init_done = false;
if (init_done)
return;
init_done = true;
ModuleSubSystem *mSubSystem = suif_env->get_module_subsystem();
mSubSystem->register_module(new M2aSuifPass(suif_env));
init_suifpasses(suif_env);
init_machine(suif_env);
init_suifvm(suif_env);
}
bool Emulator_Init()
{
LOG_DBG("Emulator_Init()\n");
config_default();
init_machine();
int size = cart.romsize;
cart.romsize = 0;
struct stat st;
stat(current_rom, &st);
reloadrom(st.st_size, current_rom);
mode_switch = MODE_EMULATION;
emulator_loaded = true;
need_load_rom = false;
return 1;
}
void startMachine(struct program *program)
{
initscr();
atexit(exit_handle);
raw();
curs_set(0);
noecho();
cbreak();
start_color();
init_pair(1, COLOR_RED, COLOR_BLACK);
MESSAGE_HEIGHT = 5;
MESSAGE_WIDTH = COLS / 2;
status = newwin(6, COLS, 1, 0);
output = newwin((LINES - 6) / 3, COLS, 7, 0);
context = newwin(2 * (LINES - 6) / 3, COLS, (LINES - 6) / 3 + 7, 0);
box(status, 0, 0);
box(context, 0, 0);
keypad(context, 1);
scrollok(output, 1);
if (NULL == program->objectfile) {
program->objectfile = malloc(sizeof(char) * (size_t) MESSAGE_WIDTH);
prompt(NULL, "Enter the .obj file: ", program->objectfile);
}
program->simulator = init_state;
if (!init_machine(program)) {
run_machine(program);
}
delwin(status);
delwin(output);
delwin(context);
endwin();
}
/**
* Execute the current fragment program, operating on the given span.
*/
void
_swrast_exec_fragment_shader(GLcontext * ctx, struct sw_span *span)
{
const struct ati_fragment_shader *shader = ctx->ATIFragmentShader.Current;
GLuint i;
ctx->_CurrentProgram = GL_FRAGMENT_SHADER_ATI;
for (i = 0; i < span->end; i++) {
if (span->array->mask[i]) {
init_machine(ctx, &ctx->ATIFragmentShader.Machine,
ctx->ATIFragmentShader.Current, span, i);
if (execute_shader(ctx, shader, ~0,
&ctx->ATIFragmentShader.Machine, span, i)) {
span->array->mask[i] = GL_FALSE;
}
{
const GLfloat *colOut =
ctx->ATIFragmentShader.Machine.Registers[0];
/*fprintf(stderr,"outputs %f %f %f %f\n", colOut[0], colOut[1], colOut[2], colOut[3]); */
UNCLAMPED_FLOAT_TO_CHAN(span->array->rgba[i][RCOMP], colOut[0]);
UNCLAMPED_FLOAT_TO_CHAN(span->array->rgba[i][GCOMP], colOut[1]);
UNCLAMPED_FLOAT_TO_CHAN(span->array->rgba[i][BCOMP], colOut[2]);
UNCLAMPED_FLOAT_TO_CHAN(span->array->rgba[i][ACOMP], colOut[3]);
}
}
}
ctx->_CurrentProgram = 0;
}
int main (int argc, char *argv[])
{
int ec;
MaxApplZone ();
game.clock_enabled = FALSE;
game.state = STATE_INIT;
init_machine (argc, argv);
game.color_fg = 15;
game.color_bg = 0;
if ((game.sbuf = calloc (_WIDTH, _HEIGHT)) == NULL) {
ec = err_NotEnoughMemory;
goto bail_out;
}
#ifdef USE_HIRES
if ((game.hires = calloc (_WIDTH * 2, _HEIGHT)) == NULL) {
ec = err_NotEnoughMemory;
goto bail_out_2;
};
opt.hires = 1;
#endif
if (init_sprites () != err_OK) {
ec = err_NotEnoughMemory;
goto bail_out_3;
}
if (init_video () != err_OK) {
ec = err_Unk;
goto bail_out_4;
}
console_init ();
report ("--- Starting console ---\n\n");
_D ("Init sound");
init_sound ();
game.ver = -1; /* Disable conf file warning */
report (" \nSarien " VERSION " is ready.\n");
if (game.state < STATE_LOADED) {
console_prompt ();
do { main_cycle (); } while (game.state < STATE_RUNNING);
if (game.ver < 0)
game.ver = 0; /* Enable conf file warning */
}
ec = run_game ();
deinit_sound ();
deinit_video ();
bail_out_4:
deinit_sprites ();
bail_out_3:
#ifdef USE_HIRES
free (game.hires);
#endif
bail_out_2:
free (game.sbuf);
bail_out:
if (ec == err_OK || ec == err_DoNothing) {
deinit_machine ();
exit (ec);
}
deinit_machine ();
return ec;
}
int run_game(int game)
{
callback_item *cb;
int error = 0;
/* start in the "pre-init phase" */
current_phase = MAME_PHASE_PREINIT;
/* AdvanceMAME: Disable validity checks */
#if 0
/* perform validity checks before anything else */
if (mame_validitychecks(game) != 0)
return 1;
#endif
/* loop across multiple hard resets */
exit_pending = FALSE;
while (error == 0 && !exit_pending)
{
/* use setjmp/longjmp for deep error recovery */
fatal_error_jmpbuf_valid = TRUE;
error = setjmp(fatal_error_jmpbuf);
if (error == 0)
{
int settingsloaded;
/* move to the init phase */
current_phase = MAME_PHASE_INIT;
/* start tracking resources for real */
begin_resource_tracking();
/* if we have a logfile, set up the callback */
logerror_callback_list = NULL;
if (options.logfile)
add_logerror_callback(logfile_callback);
/* create the Machine structure and driver */
create_machine(game);
/* then finish setting up our local machine */
init_machine();
/* load the configuration settings and NVRAM */
settingsloaded = config_load_settings();
nvram_load();
/* initialize the UI and display the startup screens */
if (ui_init(!settingsloaded && !options.skip_disclaimer, !options.skip_warnings, !options.skip_gameinfo) != 0)
fatalerror("User cancelled");
/* ensure we don't show the opening screens on a reset */
options.skip_disclaimer = options.skip_warnings = options.skip_gameinfo = TRUE;
/* start resource tracking; note that soft_reset assumes it can */
/* call end_resource_tracking followed by begin_resource_tracking */
/* to clear out resources allocated between resets */
begin_resource_tracking();
/* perform a soft reset -- this takes us to the running phase */
soft_reset(0);
/* run the CPUs until a reset or exit */
hard_reset_pending = FALSE;
while ((!hard_reset_pending && !exit_pending) || saveload_pending_file != NULL)
{
profiler_mark(PROFILER_EXTRA);
/* execute CPUs if not paused */
if (!mame_paused)
cpuexec_timeslice();
/* otherwise, just pump video updates through */
else
{
updatescreen();
reset_partial_updates();
}
/* handle save/load */
if (saveload_schedule_callback)
(*saveload_schedule_callback)();
profiler_mark(PROFILER_END);
}
/* and out via the exit phase */
current_phase = MAME_PHASE_EXIT;
/* stop tracking resources at this level */
end_resource_tracking();
/* save the NVRAM and configuration */
nvram_save();
config_save_settings();
}
fatal_error_jmpbuf_valid = FALSE;
/* call all exit callbacks registered */
for (cb = exit_callback_list; cb; cb = cb->next)
(*cb->func.exit)();
/* close all inner resource tracking */
while (resource_tracking_tag != 0)
end_resource_tracking();
/* free our callback lists */
free_callback_list(&exit_callback_list);
free_callback_list(&reset_callback_list);
free_callback_list(&pause_callback_list);
}
/* return an error */
return error;
}
int main(int argc, char **argv) {
int i;
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-rom")) {
if (++i == argc) usage();
if (++i == argc) usage();
FILE *rom = fopen(argv[i], "r");
if (!rom) {
fprintf(stderr, "Could not open ROM file: '%s'\n", argv[i]);
return 1;
}
add_rom(argv[i-1], rom);
fclose(rom);
} else if (!strcmp(argv[i], "-n")) {
if (++i == argc) usage();
steps = atoi(argv[i]);
} else if (!strcmp(argv[i], "-in")) {
if (++i == argc) usage();
infile = argv[i];
} else if (!strcmp(argv[i], "-out")) {
if (++i == argc) usage();
outfile = argv[i];
} else {
filename = argv[i];
}
}
if (filename == NULL) usage();
// Load program
FILE *p_in;
p_in = fopen(filename, "r");
if (!p_in) {
fprintf(stderr, "Error: could not open file %s for input.\n", filename);
return 1;
}
t_program* program = load_dumb_netlist(p_in);
fclose(p_in);
// Setup input and outputs
FILE *input = stdin, *output = stdout;
if (infile != NULL) {
input = fopen(infile, "r");
if (!infile) {
fprintf(stderr, "Error: could not open file %s for input.\n", infile);
return 1;
}
}
if (outfile != NULL) {
output = fopen(outfile, "w");
if (!output) {
fprintf(stderr, "Error: could not open file %s for output.\n", outfile);
return 1;
}
}
// Run
t_machine *machine = init_machine(program);
machine_banner(machine, output);
i = 0;
while (i < steps || steps == 0) {
read_inputs(machine, input);
machine_step(machine);
write_outputs(machine, output);
i++;
}
// Cleanup
if (input != stdin) fclose(input);
if (output != stdout) fclose(output);
// No need to free memory, the OS deletes everything anyways when the process ends.
return 0;
}
int
states_main( int argc, char ** argv )
{
struct args args;
int fd;
if ( parse_args( argc, argv, &args ) < 0 )
{
fprintf( stderr, "usage:\n"
"stategen file.st -b -h file.H -c file.C [-s file2.C]\n"
" file.st : input file\n"
" -b : emit base class\n"
" file.H : header file\n"
" file.C : implementation\n"
" file2.C : skeleton implementation\n" );
return( 1 );
}
close( 0 );
close( 1 );
if ( open( args.inputfile, O_RDONLY ) < 0 )
{
fprintf( stderr, "unable to open input file: %s\n",
strerror( errno ));
exit( 1 );
}
init_machine( &args );
yyparse();
fprintf( stderr,
"*** used %d bytes of memory in %d parse entries\n",
machine.bytes_allocated, machine.entries );
if ( args.headerfile )
{
fprintf( stderr, "*** producing header file %s\n", args.headerfile );
unlink( args.headerfile );
open( args.headerfile, O_CREAT | O_WRONLY, 0644 );
dump_machine( DUMP_HEADER );
fflush( stdout );
close( 1 );
}
if ( args.implfile )
{
fprintf( stderr, "*** producing implementation file %s\n",
args.implfile );
unlink( args.implfile );
open( args.implfile, O_CREAT | O_WRONLY, 0644 );
dump_machine( DUMP_CODE );
fflush( stdout );
close( 1 );
}
if ( args.skelfile )
{
fprintf( stderr, "*** producing skeleton file %s\n", args.skelfile );
unlink( args.skelfile );
open( args.skelfile, O_CREAT | O_WRONLY, 0644 );
dump_machine( DUMP_SKELETON );
fflush( stdout );
close( 1 );
}
destroy_machine();
if ( args.emit_base_class )
{
fprintf( stderr, "*** producing state machine base header\n" );
unlink( "pk_state_machine_base.H" );
fd = open( "pk_state_machine_base.H", O_CREAT | O_WRONLY, 0644 );
if (write( fd, baseclassH, strlen( baseclassH )) < 0)
fprintf(stderr, "write base class H failed\n");
close( fd );
fprintf( stderr, "*** producing state machine base impl\n" );
unlink( "pk_state_machine_base.C" );
fd = open( "pk_state_machine_base.C", O_CREAT | O_WRONLY, 0644 );
if (write( fd, baseclassC, strlen( baseclassC )) < 0)
fprintf(stderr, "write base class C failed\n");
close( fd );
}
return 0;
}
/**
* This function executes vertex programs
*/
static GLboolean
run_vp( struct gl_context *ctx, struct tnl_pipeline_stage *stage )
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vp_stage_data *store = VP_STAGE_DATA(stage);
struct vertex_buffer *VB = &tnl->vb;
struct gl_vertex_program *program = ctx->VertexProgram._Current;
struct gl_program_machine *machine = &store->machine;
GLuint outputs[VARYING_SLOT_MAX], numOutputs;
GLuint i, j;
if (!program)
return GL_TRUE;
/* ARB program or vertex shader */
_mesa_load_state_parameters(ctx, program->Base.Parameters);
/* make list of outputs to save some time below */
numOutputs = 0;
for (i = 0; i < VARYING_SLOT_MAX; i++) {
if (program->Base.OutputsWritten & BITFIELD64_BIT(i)) {
outputs[numOutputs++] = i;
}
}
/* Allocate result vectors. We delay this until now to avoid allocating
* memory that would never be used if we don't run the software tnl pipeline.
*/
if (!store->results[0].storage) {
for (i = 0; i < VARYING_SLOT_MAX; i++) {
assert(!store->results[i].storage);
_mesa_vector4f_alloc( &store->results[i], 0, VB->Size, 32 );
store->results[i].size = 4;
}
}
map_textures(ctx, program);
for (i = 0; i < VB->Count; i++) {
GLuint attr;
init_machine(ctx, machine, tnl->CurInstance);
#if 0
printf("Input %d: %f, %f, %f, %f\n", i,
VB->AttribPtr[0]->data[i][0],
VB->AttribPtr[0]->data[i][1],
VB->AttribPtr[0]->data[i][2],
VB->AttribPtr[0]->data[i][3]);
printf(" color: %f, %f, %f, %f\n",
VB->AttribPtr[3]->data[i][0],
VB->AttribPtr[3]->data[i][1],
VB->AttribPtr[3]->data[i][2],
VB->AttribPtr[3]->data[i][3]);
printf(" normal: %f, %f, %f, %f\n",
VB->AttribPtr[2]->data[i][0],
VB->AttribPtr[2]->data[i][1],
VB->AttribPtr[2]->data[i][2],
VB->AttribPtr[2]->data[i][3]);
#endif
/* the vertex array case */
for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
if (program->Base.InputsRead & BITFIELD64_BIT(attr)) {
const GLubyte *ptr = (const GLubyte*) VB->AttribPtr[attr]->data;
const GLuint size = VB->AttribPtr[attr]->size;
const GLuint stride = VB->AttribPtr[attr]->stride;
const GLfloat *data = (GLfloat *) (ptr + stride * i);
#ifdef NAN_CHECK
check_float(data[0]);
check_float(data[1]);
check_float(data[2]);
check_float(data[3]);
#endif
COPY_CLEAN_4V(machine->VertAttribs[attr], size, data);
}
}
/* execute the program */
_mesa_execute_program(ctx, &program->Base, machine);
/* copy the output registers into the VB->attribs arrays */
for (j = 0; j < numOutputs; j++) {
const GLuint attr = outputs[j];
#ifdef NAN_CHECK
check_float(machine->Outputs[attr][0]);
check_float(machine->Outputs[attr][1]);
check_float(machine->Outputs[attr][2]);
check_float(machine->Outputs[attr][3]);
#endif
COPY_4V(store->results[attr].data[i], machine->Outputs[attr]);
}
/* FOGC is a special case. Fragment shader expects (f,0,0,1) */
if (program->Base.OutputsWritten & BITFIELD64_BIT(VARYING_SLOT_FOGC)) {
store->results[VARYING_SLOT_FOGC].data[i][1] = 0.0;
store->results[VARYING_SLOT_FOGC].data[i][2] = 0.0;
store->results[VARYING_SLOT_FOGC].data[i][3] = 1.0;
}
#ifdef NAN_CHECK
ASSERT(machine->Outputs[0][3] != 0.0F);
#endif
#if 0
printf("HPOS: %f %f %f %f\n",
machine->Outputs[0][0],
machine->Outputs[0][1],
machine->Outputs[0][2],
machine->Outputs[0][3]);
#endif
}
unmap_textures(ctx, program);
if (program->IsPositionInvariant) {
/* We need the exact same transform as in the fixed function path here
* to guarantee invariance, depending on compiler optimization flags
* results could be different otherwise.
*/
VB->ClipPtr = TransformRaw( &store->results[0],
&ctx->_ModelProjectMatrix,
VB->AttribPtr[0] );
/* Drivers expect this to be clean to element 4...
*/
switch (VB->ClipPtr->size) {
case 1:
/* impossible */
case 2:
_mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 2 );
/* fall-through */
case 3:
_mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 3 );
/* fall-through */
case 4:
break;
}
}
else {
/* Setup the VB pointers so that the next pipeline stages get
* their data from the right place (the program output arrays).
*/
VB->ClipPtr = &store->results[VARYING_SLOT_POS];
VB->ClipPtr->size = 4;
VB->ClipPtr->count = VB->Count;
}
VB->AttribPtr[VERT_ATTRIB_COLOR0] = &store->results[VARYING_SLOT_COL0];
VB->AttribPtr[VERT_ATTRIB_COLOR1] = &store->results[VARYING_SLOT_COL1];
VB->AttribPtr[VERT_ATTRIB_FOG] = &store->results[VARYING_SLOT_FOGC];
VB->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->results[VARYING_SLOT_PSIZ];
VB->BackfaceColorPtr = &store->results[VARYING_SLOT_BFC0];
VB->BackfaceSecondaryColorPtr = &store->results[VARYING_SLOT_BFC1];
for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
VB->AttribPtr[_TNL_ATTRIB_TEX0 + i]
= &store->results[VARYING_SLOT_TEX0 + i];
}
for (i = 0; i < ctx->Const.MaxVarying; i++) {
if (program->Base.OutputsWritten & BITFIELD64_BIT(VARYING_SLOT_VAR0 + i)) {
/* Note: varying results get put into the generic attributes */
VB->AttribPtr[VERT_ATTRIB_GENERIC0+i]
= &store->results[VARYING_SLOT_VAR0 + i];
}
}
/* Perform NDC and cliptest operations:
*/
return do_ndc_cliptest(ctx, store);
}
int main (int argc, char *argv[])
{
#ifdef HW_RVL
/* initialize DVDX */
DI_Init();
#endif
/* initialize hardware */
gx_video_Init();
gx_input_Init();
#ifdef HW_DOL
DVD_Init ();
dvd_drive_detect();
#endif
/* initialize FAT devices */
if (fatInitDefault())
{
/* check for default directories */
DIR_ITER *dir = NULL;
/* base directory */
char pathname[MAXPATHLEN];
sprintf (pathname, DEFAULT_PATH);
dir = diropen(pathname);
if (dir == NULL) mkdir(pathname,S_IRWXU);
else dirclose(dir);
/* SRAM & Savestate files directory */
sprintf (pathname, "%s/saves",DEFAULT_PATH);
dir = diropen(pathname);
if (dir == NULL) mkdir(pathname,S_IRWXU);
else dirclose(dir);
/* Snapshot files directory */
sprintf (pathname, "%s/snaps",DEFAULT_PATH);
dir = diropen(pathname);
if (dir == NULL) mkdir(pathname,S_IRWXU);
else dirclose(dir);
/* Cheat files directory */
sprintf (pathname, "%s/cheats",DEFAULT_PATH);
dir = diropen(pathname);
if (dir == NULL) mkdir(pathname,S_IRWXU);
else dirclose(dir);
}
/* initialize sound engine */
gx_audio_Init();
/* initialize core engine */
legal();
config_default();
history_default();
init_machine();
/* run any injected rom */
if (cart.romsize)
{
ARAMFetch((char *)cart.rom, (void *)0x8000, cart.romsize);
reloadrom (cart.romsize,"INJECT.bin");
gx_video_Start();
gx_audio_Start();
frameticker = 1;
}
else
{
/* Main Menu */
ConfigRequested = 1;
}
/* initialize GUI engine */
GUI_Initialize();
#ifdef HW_RVL
/* Power button callback */
SYS_SetPowerCallback(Power_Off);
#endif
/* main emulation loop */
while (1)
{
/* Main Menu request */
if (ConfigRequested)
{
/* stop video & audio */
gx_audio_Stop();
gx_video_Stop();
/* show menu */
MainMenu ();
ConfigRequested = 0;
/* start video & audio */
gx_audio_Start();
gx_video_Start();
frameticker = 1;
}
if (frameticker > 1)
{
/* skip frame */
system_frame(1);
--frameticker;
}
else
{
while (frameticker < 1)
usleep(10);
/* render frame */
system_frame(0);
--frameticker;
/* update video */
gx_video_Update();
}
/* update audio */
gx_audio_Update();
}
return 0;
}
int
main(int argc, char **argv)
{
extern int game_is_being_shut_down;
char *p;
int i = 0;
struct svalue *ret;
extern struct svalue catch_value;
extern void init_cfuns(void);
struct gdexception exception_frame;
(void)setlinebuf(stdout);
parse_args(argc, argv);
const0.type = T_NUMBER; const0.u.number = 0;
const1.type = T_NUMBER; const1.u.number = 1;
constempty.type = T_FUNCTION; constempty.u.func = &funcempty;
funcempty.funtype = FUN_EMPTY;
catch_value = const0;
/*
* Check that the definition of EXTRACT_UCHAR() is correct.
*/
p = (char *)&i;
*p = -10;
if (EXTRACT_UCHAR(p) != 0x100 - 10)
{
(void)fprintf(stderr, "Bad definition of EXTRACT_UCHAR() in config.h.\n");
exit(1);
}
set_current_time();
#ifdef PROFILE_LPC
set_profile_timebase(60.0); /* One minute */
#endif
#if RESERVED_SIZE > 0
reserved_area = malloc(RESERVED_SIZE);
#endif
init_random();
init_tasks();
query_load_av();
init_num_args();
init_machine();
init_cfuns();
init_hash();
/*
* Set up the signal handling.
*/
init_signals();
if (chdir(mudlib_path) == -1) {
(void)fprintf(stderr, "Bad mudlib directory: %s\n", MUD_LIB);
exit(1);
}
if (setjmp(exception_frame.e_context))
{
clear_state();
add_message("Anomaly in the fabric of world space.\n");
}
else
{
exception_frame.e_exception = NULL;
exception_frame.e_catch = 0;
exception = &exception_frame;
auto_ob = 0;
master_ob = 0;
if ((auto_ob = load_object("secure/auto", 1, 0, 0)) != NULL)
{
add_ref(auto_ob, "main");
auto_ob->prog->flags |= PRAGMA_RESIDENT;
}
get_simul_efun();
master_ob = load_object("secure/master", 1, 0, 0);
if (master_ob)
{
/*
* Make sure master_ob is never made a dangling pointer.
* Look at apply_master_ob() for more details.
*/
add_ref(master_ob, "main");
master_ob->prog->flags |= PRAGMA_RESIDENT;
resolve_master_fkntab();
create_object(master_ob);
load_parse_information();
clear_state();
}
}
exception = NULL;
if (auto_ob == 0)
{
(void)fprintf(stderr, "The file secure/auto must be loadable.\n");
exit(1);
}
if (master_ob == 0)
{
(void)fprintf(stderr, "The file secure/master must be loadable.\n");
exit(1);
}
set_inc_list(apply_master_ob(M_DEFINE_INCLUDE_DIRS, 0));
{
struct svalue* ret1;
ret1 = apply_master_ob(M_PREDEF_DEFINES, 0);
if (ret1 && ret1->type == T_POINTER)
{
int ii;
for (ii = 0; ii < ret1->u.vec->size; ii++)
if (ret1->u.vec->item[ii].type == T_STRING)
{
add_pre_define(ret1->u.vec->item[ii].u.string);
}
}
}
if (flag != NULL)
{
printf("Applying driver flag: %s\n", flag);
push_string(flag, STRING_MSTRING);
(void)apply_master_ob(M_FLAG, 1);
if (game_is_being_shut_down)
{
(void)fprintf(stderr, "Shutdown by master object.\n");
exit(0);
}
}
/*
* See to it that the mud name is always defined in compiled files
*/
ret = apply_master_ob(M_GET_MUD_NAME, 0);
if (ret && ret->type == T_STRING)
{
struct lpc_predef_s *tmp;
tmp = (struct lpc_predef_s *)
xalloc(sizeof(struct lpc_predef_s));
if (!tmp)
fatal("xalloc failed\n");
tmp->flag = string_copy(ret->u.string);
tmp->next = lpc_predefs;
lpc_predefs = tmp;
}
ret = apply_master_ob(M_GET_VBFC_OBJECT, 0);
if (ret && ret->type == T_OBJECT)
{
vbfc_object = ret->u.ob;
INCREF(vbfc_object->ref);
}
else
vbfc_object = 0;
if (game_is_being_shut_down)
exit(1);
init_call_out();
preload_objects(e_flag);
(void)apply_master_ob(M_FINAL_BOOT, 0);
mainloop();
return 0;
}
int run_game(int game)
{
int err;
/* copy some settings into easier-to-handle variables */
record = options.record;
playback = options.playback;
mame_debug = options.mame_debug;
Machine->gamedrv = gamedrv = drivers[game];
Machine->drv = drv = gamedrv->drv;
/* copy configuration */
if (options.color_depth == 16 ||
(options.color_depth != 8 && (Machine->gamedrv->flags & GAME_REQUIRES_16BIT)))
Machine->color_depth = 16;
else
Machine->color_depth = 8;
//if (options.vector_width == 0) options.vector_width = 640;
//if (options.vector_height == 0) options.vector_height = 480;
if (options.vector_width == 0) options.vector_width = 320;
if (options.vector_height == 0) options.vector_height = 240;
Machine->sample_rate = options.samplerate;
/* get orientation right */
Machine->orientation = gamedrv->flags & ORIENTATION_MASK;
Machine->ui_orientation = ROT0;
if (options.norotate)
Machine->orientation = ROT0;
if (options.ror)
{
/* if only one of the components is inverted, switch them */
if ((Machine->orientation & ROT180) == ORIENTATION_FLIP_X ||
(Machine->orientation & ROT180) == ORIENTATION_FLIP_Y)
Machine->orientation ^= ROT180;
Machine->orientation ^= ROT90;
/* if only one of the components is inverted, switch them */
if ((Machine->ui_orientation & ROT180) == ORIENTATION_FLIP_X ||
(Machine->ui_orientation & ROT180) == ORIENTATION_FLIP_Y)
Machine->ui_orientation ^= ROT180;
Machine->ui_orientation ^= ROT90;
}
if (options.rol)
{
/* if only one of the components is inverted, switch them */
if ((Machine->orientation & ROT180) == ORIENTATION_FLIP_X ||
(Machine->orientation & ROT180) == ORIENTATION_FLIP_Y)
Machine->orientation ^= ROT180;
Machine->orientation ^= ROT270;
/* if only one of the components is inverted, switch them */
if ((Machine->ui_orientation & ROT180) == ORIENTATION_FLIP_X ||
(Machine->ui_orientation & ROT180) == ORIENTATION_FLIP_Y)
Machine->ui_orientation ^= ROT180;
Machine->ui_orientation ^= ROT270;
}
if (options.flipx)
{
Machine->orientation ^= ORIENTATION_FLIP_X;
Machine->ui_orientation ^= ORIENTATION_FLIP_X;
}
if (options.flipy)
{
Machine->orientation ^= ORIENTATION_FLIP_Y;
Machine->ui_orientation ^= ORIENTATION_FLIP_Y;
}
set_pixel_functions();
/* Do the work*/
err = 1;
bailing = 0;
#ifdef MESS
if (get_filenames())
return err;
#endif
if (osd_init() == 0)
{
if (init_machine() == 0)
{
if (run_machine() == 0)
err = 0;
else if (!bailing)
{
bailing = 1;
printf("Unable to start machine emulation\n");
}
shutdown_machine();
}
else if (!bailing)
{
bailing = 1;
printf("Unable to initialize machine emulation\n");
}
osd_exit();
}
else if (!bailing)
{
bailing = 1;
printf ("Unable to initialize system\n");
}
return err;
}
int main (int argc, char *argv[])
{
#ifdef HW_RVL
/* initialize DVD device */
DI_Init();
#endif
u16 usBetweenFrames;
long long now, prev;
/* Initialize OGC subsystems */
ogc_video__init();
ogc_input__init();
ogc_audio__init();
#ifdef HW_DOL
/* Initialize GC DVD interface */
DVD_Init ();
dvd_drive_detect();
#endif
#ifdef HW_RVL
/* Power Button callback */
SYS_SetPowerCallback(Power_Off);
#endif
/* Initialize FAT Interface */
if (fatInitDefault() == true)
{
fat_enabled = 1;
}
/* Default Config */
legal();
set_option_defaults ();
config_load();
#ifdef HW_RVL
/* Load SMB Settings */
loadSettings();
#endif
/* Restore Recent Files list */
set_history_defaults();
history_load();
/* Initialize Virtual Machine */
init_machine ();
/* Show Menu */
MainMenu();
ConfigRequested = 0;
/* Initialize Frame timings */
frameticker = 0;
usBetweenFrames = sms.display ? 20000 : 16666;
prev = gettime();
/* Emulation Loop */
while (1)
{
/* update inputs */
ogc_input__update();
/* Frame synchronization */
if (gc_pal != sms.display)
{
/* use timers */
now = gettime();
if (diff_usec(prev, now) > usBetweenFrames)
{
/* Frame skipping */
prev = now;
system_frame(1);
}
else
{
/* Delay */
while (diff_usec(prev, now) < usBetweenFrames) now = gettime();
/* Render Frame */
prev = now;
system_frame(0);
}
}
else
{
/* use VSync */
if (frameticker > 1)
{
/* Frame skipping */
frameticker--;
system_frame (1);
}
else
{
/* Delay */
while (!frameticker) usleep(10);
system_frame (0);
}
frameticker--;
}
/* update video & audio */
ogc_video__update();
ogc_audio__update();
/* Check for Menu request */
if (ConfigRequested)
{
/* reset AUDIO */
ogc_audio__reset();
/* go to menu */
MainMenu ();
ConfigRequested = 0;
ogc_video__reset();
/* reset frame timings */
frameticker = 0;
usBetweenFrames = sms.display ? 20000 : 16666;
prev = gettime();
}
}
return 0;
}
int
main(int argc, char **argv)
{
extern int game_is_being_shut_down;
int i, new_mudlib = 0;
char *p;
struct svalue *ret;
extern struct svalue catch_value;
extern void init_cfuns(void);
struct gdexception exception_frame;
(void)setlinebuf(stdout);
const0.type = T_NUMBER; const0.u.number = 0;
const1.type = T_NUMBER; const1.u.number = 1;
constempty.type = T_FUNCTION; constempty.u.func = &funcempty;
funcempty.funtype = FUN_EMPTY;
catch_value = const0;
/*
* Check that the definition of EXTRACT_UCHAR() is correct.
*/
p = (char *)&i;
*p = -10;
if (EXTRACT_UCHAR(p) != 0x100 - 10)
{
(void)fprintf(stderr, "Bad definition of EXTRACT_UCHAR() in config.h.\n");
exit(1);
}
set_current_time();
#ifdef PROFILE_LPC
set_profile_timebase(60.0); /* One minute */
#endif
#ifdef DRAND48
srand48((long)current_time);
#else
#ifdef RANDOM
srandom(current_time);
#else
#error No random generator specified!\n
#endif /* RANDOM */
#endif /* DRAND48 */
#if RESERVED_SIZE > 0
reserved_area = malloc(RESERVED_SIZE);
#endif
init_tasks();
query_load_av();
init_num_args();
init_machine();
init_cfuns();
/*
* Set up the signal handling.
*/
init_signals();
/*
* The flags are parsed twice !
* The first time, we only search for the -m flag, which specifies
* another mudlib, and the D-flags, so that they will be available
* when compiling master.c.
*/
for (i = 1; i < argc; i++)
{
if (atoi(argv[i]))
port_number = atoi(argv[i]);
else if (argv[i][0] != '-')
continue;
switch(argv[i][1])
{
case 'D':
if (argv[i][2]) { /* Amylaar : allow flags to be passed down to
the LPC preprocessor */
struct lpc_predef_s *tmp;
tmp = (struct lpc_predef_s *)
xalloc(sizeof(struct lpc_predef_s));
if (!tmp)
fatal("xalloc failed\n");
tmp->flag = string_copy(argv[i]+2);
tmp->next = lpc_predefs;
lpc_predefs = tmp;
continue;
}
(void)fprintf(stderr, "Illegal flag syntax: %s\n", argv[i]);
exit(1);
/* NOTREACHED */
case 'N':
no_ip_demon++; continue;
case 'm':
if (chdir(argv[i]+2) == -1)
{
(void)fprintf(stderr, "Bad mudlib directory: %s\n", argv[i]+2);
exit(1);
}
new_mudlib = 1;
break;
}
}
if (!new_mudlib && chdir(MUD_LIB) == -1) {
(void)fprintf(stderr, "Bad mudlib directory: %s\n", MUD_LIB);
exit(1);
}
if (setjmp(exception_frame.e_context))
{
clear_state();
add_message("Anomaly in the fabric of world space.\n");
}
else
{
exception_frame.e_exception = NULL;
exception_frame.e_catch = 0;
exception = &exception_frame;
auto_ob = 0;
master_ob = 0;
if ((auto_ob = load_object("secure/auto", 1, 0, 0)) != NULL)
{
add_ref(auto_ob, "main");
auto_ob->prog->flags |= PRAGMA_RESIDENT;
}
get_simul_efun();
master_ob = load_object("secure/master", 1, 0, 0);
if (master_ob)
{
/*
* Make sure master_ob is never made a dangling pointer.
* Look at apply_master_ob() for more details.
*/
add_ref(master_ob, "main");
master_ob->prog->flags |= PRAGMA_RESIDENT;
resolve_master_fkntab();
create_object(master_ob);
load_parse_information();
clear_state();
}
}
exception = NULL;
if (auto_ob == 0)
{
(void)fprintf(stderr, "The file secure/auto must be loadable.\n");
exit(1);
}
if (master_ob == 0)
{
(void)fprintf(stderr, "The file secure/master must be loadable.\n");
exit(1);
}
set_inc_list(apply_master_ob(M_DEFINE_INCLUDE_DIRS, 0));
{
struct svalue* ret1;
ret1 = apply_master_ob(M_PREDEF_DEFINES, 0);
if (ret1 && ret1->type == T_POINTER)
{
int ii;
struct lpc_predef_s *tmp;
for (ii = 0; ii < ret1->u.vec->size; ii++)
if (ret1->u.vec->item[ii].type == T_STRING)
{
tmp = (struct lpc_predef_s *)
xalloc(sizeof(struct lpc_predef_s));
tmp->flag = string_copy(ret1->u.vec->item[ii].u.string);
tmp->next = lpc_predefs;
lpc_predefs = tmp;
}
}
}
for (i = 1; i < argc; i++)
{
if (atoi(argv[i]))
;
else if (argv[i][0] != '-')
{
(void)fprintf(stderr, "Bad argument %s\n", argv[i]);
exit(1);
}
else
{
/*
* Look at flags. -m has already been tested.
*/
switch(argv[i][1])
{
case 'f':
push_string(argv[i]+2, STRING_MSTRING);
(void)apply_master_ob(M_FLAG, 1);
if (game_is_being_shut_down)
{
(void)fprintf(stderr, "Shutdown by master object.\n");
exit(0);
}
continue;
case 'e':
e_flag++; continue;
case 'O':
warnobsoleteflag++; continue;
case 'D':
continue;
case 'N':
continue;
case 'm':
continue;
case 'd':
d_flag = atoi(argv[i] + 2);
continue;
case 'c':
comp_flag++; continue;
case 'l':
unlimited++;
continue;
case 't':
t_flag++; continue;
case 'S':
s_flag++;
mudstatus_set(1, -1, -1); /* Statistics, default limits */
continue;
case 'u':
#ifdef CATCH_UDP_PORT
udp_port = atoi (&argv[i][2]);
#endif
continue;
case 'p':
#ifdef SERVICE_PORT
service_port = atoi (&argv[i][2]);
#endif
continue;
case 'y':
#ifdef YYDEBUG
yydebug = 1;
#endif
continue;
default:
(void)fprintf(stderr, "Unknown flag: %s\n", argv[i]);
exit(1);
}
}
}
/*
* See to it that the mud name is always defined in compiled files
*/
ret = apply_master_ob(M_GET_MUD_NAME, 0);
if (ret && ret->type == T_STRING)
{
struct lpc_predef_s *tmp;
tmp = (struct lpc_predef_s *)
xalloc(sizeof(struct lpc_predef_s));
if (!tmp)
fatal("xalloc failed\n");
tmp->flag = string_copy(ret->u.string);
tmp->next = lpc_predefs;
lpc_predefs = tmp;
}
ret = apply_master_ob(M_GET_VBFC_OBJECT, 0);
if (ret && ret->type == T_OBJECT)
{
vbfc_object = ret->u.ob;
INCREF(vbfc_object->ref);
}
else
vbfc_object = 0;
if (game_is_being_shut_down)
exit(1);
if (!t_flag)
init_call_out();
preload_objects(e_flag);
(void)apply_master_ob(M_FINAL_BOOT, 0);
mainloop();
/* backend(); */
return 0;
}
int run_game(int game)
{
running_machine *machine;
int error = MAMERR_NONE;
mame_private *mame;
callback_item *cb;
/* create the machine structure and driver */
machine = create_machine(game);
mame = machine->mame_data;
/* looooong term: remove this */
Machine = machine;
/* start in the "pre-init phase" */
mame->current_phase = MAME_PHASE_PREINIT;
/* perform validity checks before anything else */
if (mame_validitychecks(game) != 0)
return MAMERR_FAILED_VALIDITY;
/* loop across multiple hard resets */
mame->exit_pending = FALSE;
while (error == 0 && !mame->exit_pending)
{
init_resource_tracking();
add_free_resources_callback(timer_free);
add_free_resources_callback(state_save_free);
/* use setjmp/longjmp for deep error recovery */
mame->fatal_error_jmpbuf_valid = TRUE;
error = setjmp(mame->fatal_error_jmpbuf);
if (error == 0)
{
int settingsloaded;
/* move to the init phase */
mame->current_phase = MAME_PHASE_INIT;
/* start tracking resources for real */
begin_resource_tracking();
/* if we have a logfile, set up the callback */
mame->logerror_callback_list = NULL;
if (options.logfile)
add_logerror_callback(machine, logfile_callback);
/* then finish setting up our local machine */
init_machine(machine);
/* load the configuration settings and NVRAM */
settingsloaded = config_load_settings();
nvram_load();
/* display the startup screens */
ui_display_startup_screens(!settingsloaded && !options.skip_disclaimer, !options.skip_warnings, !options.skip_gameinfo);
/* ensure we don't show the opening screens on a reset */
options.skip_disclaimer = options.skip_warnings = options.skip_gameinfo = TRUE;
/* start resource tracking; note that soft_reset assumes it can */
/* call end_resource_tracking followed by begin_resource_tracking */
/* to clear out resources allocated between resets */
begin_resource_tracking();
/* perform a soft reset -- this takes us to the running phase */
soft_reset(0);
/* run the CPUs until a reset or exit */
mame->hard_reset_pending = FALSE;
while ((!mame->hard_reset_pending && !mame->exit_pending) || mame->saveload_pending_file != NULL)
{
profiler_mark(PROFILER_EXTRA);
/* execute CPUs if not paused */
if (!mame->paused)
cpuexec_timeslice();
/* otherwise, just pump video updates through */
else
video_frame_update();
/* handle save/load */
if (mame->saveload_schedule_callback)
(*mame->saveload_schedule_callback)(machine);
profiler_mark(PROFILER_END);
}
/* and out via the exit phase */
mame->current_phase = MAME_PHASE_EXIT;
/* stop tracking resources at this level */
end_resource_tracking();
/* save the NVRAM and configuration */
nvram_save();
config_save_settings();
}
mame->fatal_error_jmpbuf_valid = FALSE;
/* call all exit callbacks registered */
for (cb = mame->exit_callback_list; cb; cb = cb->next)
(*cb->func.exit)(machine);
/* close all inner resource tracking */
exit_resource_tracking();
/* free our callback lists */
free_callback_list(&mame->exit_callback_list);
free_callback_list(&mame->reset_callback_list);
free_callback_list(&mame->pause_callback_list);
}
/* destroy the machine */
destroy_machine(machine);
/* return an error */
return error;
}
/**
* This function executes vertex programs
*/
static GLboolean
run_vp( GLcontext *ctx, struct tnl_pipeline_stage *stage )
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vp_stage_data *store = VP_STAGE_DATA(stage);
struct vertex_buffer *VB = &tnl->vb;
struct gl_vertex_program *program = ctx->VertexProgram._Current;
struct gl_program_machine machine;
GLuint outputs[VERT_RESULT_MAX], numOutputs;
GLuint i, j;
if (!program)
return GL_TRUE;
if (program->IsNVProgram) {
_mesa_load_tracked_matrices(ctx);
}
else {
/* ARB program or vertex shader */
_mesa_load_state_parameters(ctx, program->Base.Parameters);
}
numOutputs = 0;
for (i = 0; i < VERT_RESULT_MAX; i++) {
if (program->Base.OutputsWritten & (1 << i)) {
outputs[numOutputs++] = i;
}
}
for (i = 0; i < VB->Count; i++) {
GLuint attr;
init_machine(ctx, &machine);
#if 0
printf("Input %d: %f, %f, %f, %f\n", i,
VB->AttribPtr[0]->data[i][0],
VB->AttribPtr[0]->data[i][1],
VB->AttribPtr[0]->data[i][2],
VB->AttribPtr[0]->data[i][3]);
printf(" color: %f, %f, %f, %f\n",
VB->AttribPtr[3]->data[i][0],
VB->AttribPtr[3]->data[i][1],
VB->AttribPtr[3]->data[i][2],
VB->AttribPtr[3]->data[i][3]);
printf(" normal: %f, %f, %f, %f\n",
VB->AttribPtr[2]->data[i][0],
VB->AttribPtr[2]->data[i][1],
VB->AttribPtr[2]->data[i][2],
VB->AttribPtr[2]->data[i][3]);
#endif
/* the vertex array case */
for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
if (program->Base.InputsRead & (1 << attr)) {
const GLubyte *ptr = (const GLubyte*) VB->AttribPtr[attr]->data;
const GLuint size = VB->AttribPtr[attr]->size;
const GLuint stride = VB->AttribPtr[attr]->stride;
const GLfloat *data = (GLfloat *) (ptr + stride * i);
COPY_CLEAN_4V(machine.VertAttribs[attr], size, data);
}
}
/* execute the program */
_mesa_execute_program(ctx, &program->Base, &machine);
/* copy the output registers into the VB->attribs arrays */
for (j = 0; j < numOutputs; j++) {
const GLuint attr = outputs[j];
COPY_4V(store->results[attr].data[i], machine.Outputs[attr]);
}
#if 0
printf("HPOS: %f %f %f %f\n",
machine.Outputs[0][0],
machine.Outputs[0][1],
machine.Outputs[0][2],
machine.Outputs[0][3]);
#endif
}
/* Fixup fog and point size results if needed */
if (program->IsNVProgram) {
if (ctx->Fog.Enabled &&
(program->Base.OutputsWritten & (1 << VERT_RESULT_FOGC)) == 0) {
for (i = 0; i < VB->Count; i++) {
store->results[VERT_RESULT_FOGC].data[i][0] = 1.0;
}
}
if (ctx->VertexProgram.PointSizeEnabled &&
(program->Base.OutputsWritten & (1 << VERT_RESULT_PSIZ)) == 0) {
for (i = 0; i < VB->Count; i++) {
store->results[VERT_RESULT_PSIZ].data[i][0] = ctx->Point.Size;
}
}
}
/* Setup the VB pointers so that the next pipeline stages get
* their data from the right place (the program output arrays).
*/
VB->ClipPtr = &store->results[VERT_RESULT_HPOS];
VB->ClipPtr->size = 4;
VB->ClipPtr->count = VB->Count;
VB->ColorPtr[0] = &store->results[VERT_RESULT_COL0];
VB->ColorPtr[1] = &store->results[VERT_RESULT_BFC0];
VB->SecondaryColorPtr[0] = &store->results[VERT_RESULT_COL1];
VB->SecondaryColorPtr[1] = &store->results[VERT_RESULT_BFC1];
VB->FogCoordPtr = &store->results[VERT_RESULT_FOGC];
VB->AttribPtr[VERT_ATTRIB_COLOR0] = &store->results[VERT_RESULT_COL0];
VB->AttribPtr[VERT_ATTRIB_COLOR1] = &store->results[VERT_RESULT_COL1];
VB->AttribPtr[VERT_ATTRIB_FOG] = &store->results[VERT_RESULT_FOGC];
VB->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->results[VERT_RESULT_PSIZ];
for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
VB->TexCoordPtr[i] =
VB->AttribPtr[_TNL_ATTRIB_TEX0 + i]
= &store->results[VERT_RESULT_TEX0 + i];
}
for (i = 0; i < ctx->Const.MaxVarying; i++) {
if (program->Base.OutputsWritten & (1 << (VERT_RESULT_VAR0 + i))) {
/* Note: varying results get put into the generic attributes */
VB->AttribPtr[VERT_ATTRIB_GENERIC0+i]
= &store->results[VERT_RESULT_VAR0 + i];
}
}
/* Cliptest and perspective divide. Clip functions must clear
* the clipmask.
*/
store->ormask = 0;
store->andmask = CLIP_FRUSTUM_BITS;
if (tnl->NeedNdcCoords) {
VB->NdcPtr =
_mesa_clip_tab[VB->ClipPtr->size]( VB->ClipPtr,
&store->ndcCoords,
store->clipmask,
&store->ormask,
&store->andmask );
}
else {
VB->NdcPtr = NULL;
_mesa_clip_np_tab[VB->ClipPtr->size]( VB->ClipPtr,
NULL,
store->clipmask,
&store->ormask,
&store->andmask );
}
if (store->andmask) /* All vertices are outside the frustum */
return GL_FALSE;
/* This is where we'd do clip testing against the user-defined
* clipping planes, but they're not supported by vertex programs.
*/
VB->ClipOrMask = store->ormask;
VB->ClipMask = store->clipmask;
return GL_TRUE;
}
/***************************************************************************
* M A I N
*
***************************************************************************/
int main (int argc, char *argv[])
{
#ifdef HW_RVL
/* enable 64-byte fetch mode for L2 cache */
L2Enhance();
/* initialize DI interface */
DI_UseCache(0);
DI_Init();
sprintf(osd_version, "%s (IOS %d)", VERSION, IOS_GetVersion());
#else
sprintf(osd_version, "%s (GCN)", VERSION);
#endif
/* initialize video engine */
gx_video_Init();
#ifndef HW_RVL
/* initialize DVD interface */
DVD_Init();
#endif
/* initialize input engine */
gx_input_Init();
/* initialize FAT devices */
int retry = 0;
int fatMounted = 0;
/* try to mount FAT devices during 3 seconds */
while (!fatMounted && (retry < 12))
{
fatMounted = fatInitDefault();
usleep(250000);
retry++;
}
if (fatMounted)
{
/* base directory */
char pathname[MAXPATHLEN];
sprintf (pathname, DEFAULT_PATH);
DIR *dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
/* default SRAM & Savestate files directories */
sprintf (pathname, "%s/saves",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
sprintf (pathname, "%s/saves/md",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
sprintf (pathname, "%s/saves/ms",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
sprintf (pathname, "%s/saves/gg",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
sprintf (pathname, "%s/saves/sg",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
sprintf (pathname, "%s/saves/cd",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
/* default Snapshot files directories */
sprintf (pathname, "%s/snaps",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
sprintf (pathname, "%s/snaps/md",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
sprintf (pathname, "%s/snaps/ms",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
sprintf (pathname, "%s/snaps/gg",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
sprintf (pathname, "%s/snaps/sg",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
sprintf (pathname, "%s/snaps/cd",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
/* default Cheat files directories */
sprintf (pathname, "%s/cheats",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
sprintf (pathname, "%s/cheats/md",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
sprintf (pathname, "%s/cheats/ms",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
sprintf (pathname, "%s/cheats/gg",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
sprintf (pathname, "%s/cheats/sg",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
sprintf (pathname, "%s/cheats/cd",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
/* default BIOS ROM files directories */
sprintf (pathname, "%s/bios",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
/* default LOCK-ON ROM files directories */
sprintf (pathname, "%s/lock-on",DEFAULT_PATH);
dir = opendir(pathname);
if (dir) closedir(dir);
else mkdir(pathname,S_IRWXU);
}
/* initialize sound engine */
gx_audio_Init();
/* initialize genesis plus core */
history_default();
config_default();
init_machine();
/* auto-load last ROM file */
if (config.autoload)
{
SILENT = 1;
if (OpenDirectory(TYPE_RECENT, -1))
{
if (LoadFile(0))
{
reloadrom();
gx_video_Start();
gx_audio_Start();
ConfigRequested = 0;
}
}
SILENT = 0;
}
/* show disclaimer */
if (ConfigRequested)
{
legal();
}
#ifdef HW_RVL
/* power button callback */
SYS_SetPowerCallback(PowerOff_cb);
#endif
/* reset button callback */
SYS_SetResetCallback(Reset_cb);
/* main emulation loop */
run_emulation();
/* we should never return anyway */
return 0;
}
int main(int argc, char *argv[])
{
#ifdef PSL9
MachineConfig machine;
char *cacheline0, *cacheline1, *name;
uint64_t wed;
unsigned seed;
int i, quadrant, byte, opt, option_index;
int response;
int context, machine_number;
name = strrchr(argv[0], '/');
if (name)
name++;
else
name = argv[0];
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"seed", required_argument, 0, 's'},
{NULL, 0, 0, 0}
};
option_index = 0;
seed = time(NULL);
while ((opt = getopt_long (argc, argv, "hs:",
long_options, &option_index)) >= 0) {
switch (opt)
{
case 0:
break;
case 's':
seed = strtoul(optarg, NULL, 0);
break;
case 'h':
default:
usage(name);
return 0;
}
}
// Seed random number generator
srand(seed);
printf("%s: seed=%d\n", name, seed);
// find first AFU found
struct cxl_afu_h *afu_h, *afu_m, *afu_s;
afu_m = afu_s = NULL;
afu_h = cxl_afu_next(NULL);
if (!afu_h) {
fprintf(stderr, "\nNo AFU found!\n\n");
goto done;
}
// afu master
afu_m = cxl_afu_open_h(afu_h, CXL_VIEW_MASTER);
if (!afu_m) {
perror("cxl_afu_open_h for master");
goto done;
}
// Set WED to random value
wed = rand();
wed <<= 32;
wed |= rand();
// Start AFU for master
printf("Attach AFU master\n");
if (cxl_afu_attach(afu_m, wed) < 0) {
perror("FAILED:cxl_afu_attach for master");
goto done;
}
printf("wed = 0x%"PRIx64"\n", wed);
// Map AFU MMIO registers
printf("Mapping AFU master registers...\n");
if ((cxl_mmio_map(afu_m, CXL_MMIO_BIG_ENDIAN)) < 0) {
perror("cxl_mmio_map for master");
goto done;
}
printf("End AFU master mmio map\n");
context = cxl_afu_get_process_element(afu_m);
printf("Master context = %d\n", context);
// Allocate aligned memory for two cachelines
if (posix_memalign((void **)&cacheline0, CACHELINE_BYTES, CACHELINE_BYTES) != 0) {
perror("FAILED:posix_memalign");
goto done;
}
if (posix_memalign((void **)&cacheline1, CACHELINE_BYTES, CACHELINE_BYTES) != 0) {
perror("FAILED:posix_memalign");
goto done;
}
// Pollute first cacheline with random values
printf("CACHELINE0 = 0x");
for (i = 0; i < CACHELINE_BYTES; i++)
{
cacheline0[i] = rand();
printf("%02x", cacheline0[i]);
}
printf("\n");
// Initialize machine configuration
printf("initialize machine\n");
init_machine(&machine);
printf("End init machine\n");
// Use AFU Machine 0 to read the first cacheline from memory to AFU
printf("Configure, enable and run machine\n");
if ((response = config_enable_and_run_machine(afu_m, &machine, 0, context, PSL_COMMAND_XLAT_RD_P0, CACHELINE_BYTES, 0, 0, (uint64_t)cacheline0, CACHELINE_BYTES, DIRECTED_M)) < 0)
{
printf("FAILED:config_enable_and_run_machine for master XLAT_RD response = %d\n", response);
goto done;
}
printf("End configure enable and run machine for XLAT_RD\n");
// Check for valid response
if (response != PSL_RESPONSE_DONE)
{
printf("FAILED: Unexpected response code 0x%x\n", response);
goto done;
}
printf("Completed cacheline read\n");
// Use AFU Machine 0 to write the data to the second cacheline
if ((response = config_enable_and_run_machine(afu_m, &machine, 0, context, PSL_COMMAND_XLAT_WR_P0, CACHELINE_BYTES, 0, 0, (uint64_t)cacheline1, CACHELINE_BYTES, DIRECTED_M)) < 0)
{
printf("FAILED:config_enable_and_run_machine for master XLAT_WR response = %d\n", response);
goto done;
}
printf("End configure enable and run machine for XLAT WR\n");
// Check for valid response
if (response != PSL_RESPONSE_DONE)
{
printf("FAILED: Unexpected response code 0x%x\n", response);
goto done;
}
// Test if copy from cacheline0 to cacheline1 was successful
if (memcmp(cacheline0,cacheline1, CACHELINE_BYTES) != 0) {
printf("FAILED:memcmp\n");
for (quadrant = 0; quadrant < 4; quadrant++) {
printf("DEBUG: Expected Q%d 0x", quadrant);
for (byte = 0; byte < CACHELINE_BYTES /4; byte++) {
printf("%02x", cacheline0[byte+(quadrant*32)]);
}
printf("\n");
}
for (quadrant = 0; quadrant < 4; quadrant++) {
printf("DEBUG: Actual Q%d 0x", quadrant);
for (byte = 0; byte < CACHELINE_BYTES / 4; byte++) {
printf("%02x", cacheline1[byte+(quadrant*32)]);
}
printf("\n");
}
goto done;
}
printf("Master AFU: PASSED\n");
// afu slave
// find next afu
afu_h = cxl_afu_next(NULL);
if (!afu_h) {
fprintf(stderr, "\nNo AFU found!\n\n");
goto done;
}
afu_s = cxl_afu_open_h(afu_h, CXL_VIEW_SLAVE);
if (!afu_s) {
perror("cxl_afu_open_h for slave");
goto done;
}
// Set WED to random value
wed = rand();
wed <<= 32;
wed |= rand();
// Start AFU for slave
if (cxl_afu_attach(afu_s, wed) < 0) {
perror("FAILED:cxl_afu_attach for slave");
goto done;
}
// Map AFU MMIO registers
printf("Mapping AFU slave registers...\n");
if ((cxl_mmio_map(afu_s, CXL_MMIO_BIG_ENDIAN)) < 0) {
perror("cxl_mmio_map for slave");
goto done;
}
printf("End AFU slave mmio map\n");
context = cxl_afu_get_process_element(afu_s);
printf("Slave context = %d\n", context);
machine_number = 20;
// Allocate aligned memory for two cachelines
if (posix_memalign((void **)&cacheline0, CACHELINE_BYTES, CACHELINE_BYTES) != 0) {
perror("FAILED:posix_memalign");
goto done;
}
if (posix_memalign((void **)&cacheline1, CACHELINE_BYTES, CACHELINE_BYTES) != 0) {
perror("FAILED:posix_memalign");
goto done;
}
// Pollute first cacheline with random values
for (i = 0; i < CACHELINE_BYTES; i++)
cacheline0[i] = rand();
// Initialize machine configuration
//init_machine(&machine);
// Use AFU Machine 1 to read the first cacheline from memory to AFU
printf("Start config enable and run machine for slave\n");
if ((response = config_enable_and_run_machine(afu_s, &machine, machine_number, context, PSL_COMMAND_XLAT_RD_P0, CACHELINE_BYTES, 0, 0, (uint64_t)cacheline0, CACHELINE_BYTES, DIRECTED)) < 0)
{
printf("FAILED:config_enable_and_run_machine for slave");
goto done;
}
printf("End config enable and run machine for slave\n");
// Check for valid response
if (response != PSL_RESPONSE_DONE)
{
printf("FAILED: Unexpected response code 0x%x\n", response);
goto done;
}
printf("Completed cacheline read for slave\n");
// Use AFU Machine 1 to write the data to the second cacheline
if ((response = config_enable_and_run_machine(afu_s, &machine, machine_number, context, PSL_COMMAND_XLAT_WR_P0, CACHELINE_BYTES, 0, 0, (uint64_t)cacheline1, CACHELINE_BYTES, DIRECTED)) < 0)
{
printf("FAILED:config_enable_and_run_machine for slave");
goto done;
}
// Check for valid response
if (response != PSL_RESPONSE_DONE)
{
printf("FAILED: Unexpected response code 0x%x\n", response);
goto done;
}
// Test if copy from cacheline0 to cacheline1 was successful
if (memcmp(cacheline0,cacheline1, CACHELINE_BYTES) != 0) {
printf("FAILED:memcmp\n");
for (quadrant = 0; quadrant < 4; quadrant++) {
printf("DEBUG: Expected Q%d 0x", quadrant);
for (byte = 0; byte < CACHELINE_BYTES /4; byte++) {
printf("%02x", cacheline0[byte+(quadrant*32)]);
}
printf("\n");
}
for (quadrant = 0; quadrant < 4; quadrant++) {
printf("DEBUG: Actual Q%d 0x", quadrant);
for (byte = 0; byte < CACHELINE_BYTES / 4; byte++) {
printf("%02x", cacheline1[byte+(quadrant*32)]);
}
printf("\n");
}
goto done;
}
printf("Slave AFU: PASSED\n");
done:
// unmap and free slave afu
if (afu_s) {
cxl_mmio_unmap(afu_s);
cxl_afu_free(afu_s);
}
// unmap and free master afu
if (afu_m) {
// Unmap AFU MMIO registers
cxl_mmio_unmap(afu_m);
// Free AFU
cxl_afu_free(afu_m);
}
#endif
return 0;
}
/**
* This function executes vertex programs
*/
static GLboolean
run_vp( GLcontext *ctx, struct tnl_pipeline_stage *stage )
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vp_stage_data *store = VP_STAGE_DATA(stage);
struct vertex_buffer *VB = &tnl->vb;
struct gl_vertex_program *program = ctx->VertexProgram._Current;
struct gl_program_machine machine;
GLuint outputs[VERT_RESULT_MAX], numOutputs;
GLuint i, j;
if (!program)
return GL_TRUE;
if (program->IsNVProgram) {
_mesa_load_tracked_matrices(ctx);
}
else {
/* ARB program or vertex shader */
_mesa_load_state_parameters(ctx, program->Base.Parameters);
}
/* make list of outputs to save some time below */
numOutputs = 0;
for (i = 0; i < VERT_RESULT_MAX; i++) {
if (program->Base.OutputsWritten & (1 << i)) {
outputs[numOutputs++] = i;
}
}
map_textures(ctx, program);
for (i = 0; i < VB->Count; i++) {
GLuint attr;
init_machine(ctx, &machine);
#if 0
printf("Input %d: %f, %f, %f, %f\n", i,
VB->AttribPtr[0]->data[i][0],
VB->AttribPtr[0]->data[i][1],
VB->AttribPtr[0]->data[i][2],
VB->AttribPtr[0]->data[i][3]);
printf(" color: %f, %f, %f, %f\n",
VB->AttribPtr[3]->data[i][0],
VB->AttribPtr[3]->data[i][1],
VB->AttribPtr[3]->data[i][2],
VB->AttribPtr[3]->data[i][3]);
printf(" normal: %f, %f, %f, %f\n",
VB->AttribPtr[2]->data[i][0],
VB->AttribPtr[2]->data[i][1],
VB->AttribPtr[2]->data[i][2],
VB->AttribPtr[2]->data[i][3]);
#endif
/* the vertex array case */
for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
if (program->Base.InputsRead & (1 << attr)) {
const GLubyte *ptr = (const GLubyte*) VB->AttribPtr[attr]->data;
const GLuint size = VB->AttribPtr[attr]->size;
const GLuint stride = VB->AttribPtr[attr]->stride;
const GLfloat *data = (GLfloat *) (ptr + stride * i);
COPY_CLEAN_4V(machine.VertAttribs[attr], size, data);
}
}
/* execute the program */
_mesa_execute_program(ctx, &program->Base, &machine);
/* copy the output registers into the VB->attribs arrays */
for (j = 0; j < numOutputs; j++) {
const GLuint attr = outputs[j];
COPY_4V(store->results[attr].data[i], machine.Outputs[attr]);
}
#if 0
printf("HPOS: %f %f %f %f\n",
machine.Outputs[0][0],
machine.Outputs[0][1],
machine.Outputs[0][2],
machine.Outputs[0][3]);
#endif
}
unmap_textures(ctx, program);
/* Fixup fog and point size results if needed */
if (program->IsNVProgram) {
if (ctx->Fog.Enabled &&
(program->Base.OutputsWritten & (1 << VERT_RESULT_FOGC)) == 0) {
for (i = 0; i < VB->Count; i++) {
store->results[VERT_RESULT_FOGC].data[i][0] = 1.0;
}
}
if (ctx->VertexProgram.PointSizeEnabled &&
(program->Base.OutputsWritten & (1 << VERT_RESULT_PSIZ)) == 0) {
for (i = 0; i < VB->Count; i++) {
store->results[VERT_RESULT_PSIZ].data[i][0] = ctx->Point.Size;
}
}
}
if (program->IsPositionInvariant) {
/* We need the exact same transform as in the fixed function path here
* to guarantee invariance, depending on compiler optimization flags
* results could be different otherwise.
*/
VB->ClipPtr = TransformRaw( &store->results[0],
&ctx->_ModelProjectMatrix,
VB->AttribPtr[0] );
/* Drivers expect this to be clean to element 4...
*/
switch (VB->ClipPtr->size) {
case 1:
/* impossible */
case 2:
_mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 2 );
/* fall-through */
case 3:
_mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 3 );
/* fall-through */
case 4:
break;
}
}
else {
/* Setup the VB pointers so that the next pipeline stages get
* their data from the right place (the program output arrays).
*/
VB->ClipPtr = &store->results[VERT_RESULT_HPOS];
VB->ClipPtr->size = 4;
VB->ClipPtr->count = VB->Count;
}
VB->ColorPtr[0] = &store->results[VERT_RESULT_COL0];
VB->ColorPtr[1] = &store->results[VERT_RESULT_BFC0];
VB->SecondaryColorPtr[0] = &store->results[VERT_RESULT_COL1];
VB->SecondaryColorPtr[1] = &store->results[VERT_RESULT_BFC1];
VB->FogCoordPtr = &store->results[VERT_RESULT_FOGC];
VB->AttribPtr[VERT_ATTRIB_COLOR0] = &store->results[VERT_RESULT_COL0];
VB->AttribPtr[VERT_ATTRIB_COLOR1] = &store->results[VERT_RESULT_COL1];
VB->AttribPtr[VERT_ATTRIB_FOG] = &store->results[VERT_RESULT_FOGC];
VB->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->results[VERT_RESULT_PSIZ];
for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
VB->TexCoordPtr[i] =
VB->AttribPtr[_TNL_ATTRIB_TEX0 + i]
= &store->results[VERT_RESULT_TEX0 + i];
}
for (i = 0; i < ctx->Const.MaxVarying; i++) {
if (program->Base.OutputsWritten & (1 << (VERT_RESULT_VAR0 + i))) {
/* Note: varying results get put into the generic attributes */
VB->AttribPtr[VERT_ATTRIB_GENERIC0+i]
= &store->results[VERT_RESULT_VAR0 + i];
}
}
/* Perform NDC and cliptest operations:
*/
return do_ndc_cliptest(ctx, store);
}