#define CONDITION_OP_FLAG_SET 3
#define CONDITION_SECOND_HALF_LINE 4
+#if 0
#define OPFLAG_RELEASE 8 // Bus release bit
#define OPFLAG_TRANS 4 // Transparency bit
#define OPFLAG_RMW 2 // Read-Modify-Write bit
#define OPFLAG_REFLECT 1 // Horizontal mirror bit
+#endif
// Private function prototypes
OPReset();
}
+
//
// Object Processor reset
//
objectp_running = 0;
}
+
static const char * opType[8] =
{ "(BITMAP)", "(SCALED BITMAP)", "(GPU INT)", "(BRANCH)", "(STOP)", "???", "???", "???" };
static const char * ccType[8] =
//static uint32 objectLink[8192];
//static uint32 numberOfLinks;
+
void OPDone(void)
{
//#warning "!!! Fix OL dump so that it follows links !!!"
WriteLog("\n");
#else
-#warning "!!! Fix lockup in OPDiscoverObjects() !!!"
+//#warning "!!! Fix lockup in OPDiscoverObjects() !!!"
//temp, to keep the following function from locking up on bad/weird OLs
-return;
+//return;
numberOfObjects = 0;
+//printf("OPDiscoverObjects...\n");
OPDiscoverObjects(olp);
+//printf("OPDumpObjectList...\n");
OPDumpObjectList();
#endif
}
-void OPDiscoverObjects(uint32 address)
+
+bool OPObjectExists(uint32 address)
{
- // Check to see if we've already seen this object
+ // Yes, we really do a linear search, every time. :-/
for(uint32 i=0; i<numberOfObjects; i++)
{
if (address == object[i])
- return;
+ return true;
}
- // Store the object...
- object[numberOfObjects++] = address;
+ return false;
+}
+
+
+void OPDiscoverObjects(uint32 address)
+{
uint8 objectType = 0;
do
{
+ // If we've seen this object already, bail out!
+ // Otherwise, add it to the list
+ if (OPObjectExists(address))
+ return;
+
+ object[numberOfObjects++] = address;
+
+ // Get the object & decode its type, link address
uint32 hi = JaguarReadLong(address + 0, OP);
uint32 lo = JaguarReadLong(address + 4, OP);
objectType = lo & 0x07;
if (objectType == 3)
{
- uint16 ypos = (lo >> 3) & 0x7FF;
- uint8 cc = (lo >> 14) & 0x07; // Proper # of bits == 3
-
- // Recursion needed to follow all links!
+ // Recursion needed to follow all links! This does depth-first recursion
+ // on the not-taken objects
OPDiscoverObjects(address + 8);
}
- if (address == link) // Ruh roh...
- {
- // Runaway recursive link is bad!
- return;
- }
-
+ // Get the next object...
address = link;
-
- // Check to see if we've already seen this object, and add it if not
- bool seenObject = false;
-
- for(uint32 i=0; i<numberOfObjects; i++)
- {
- if (address == object[i])
- {
- seenObject = true;
- break;
- }
- }
-
- if (!seenObject)
- object[numberOfObjects++] = address;
}
while (objectType != 4);
}
+
void OPDumpObjectList(void)
{
for(uint32 i=0; i<numberOfObjects; i++)
WriteLog("\n");
}
+
//
// Object Processor memory access
// Memory range: F00010 - F00027
}
#endif
+
uint32 OPGetListPointer(void)
{
// Note: This register is LO / HI WORD, hence the funky look of this...
return GET16(tomRam8, 0x20) | (GET16(tomRam8, 0x22) << 16);
}
+
// This is WRONG, since the OBF is only 16 bits wide!!! [FIXED]
uint32 OPGetStatusRegister(void)
return GET16(tomRam8, 0x26);
}
+
// This is WRONG, since the OBF is only 16 bits wide!!! [FIXED]
void OPSetStatusRegister(uint32 data)
tomRam8[0x27] |= (data & 0xFE);
}
+
void OPSetCurrentObject(uint64 object)
{
//Not sure this is right... Wouldn't it just be stored 64 bit BE?
tomRam8[0x10] = object & 0xFF;
}
+
uint64 OPLoadPhrase(uint32 offset)
{
offset &= ~0x07; // 8 byte alignment
return ((uint64)JaguarReadLong(offset, OP) << 32) | (uint64)JaguarReadLong(offset+4, OP);
}
+
void OPStorePhrase(uint32 offset, uint64 p)
{
offset &= ~0x07; // 8 byte alignment
JaguarWriteLong(offset + 4, p & 0xFFFFFFFF, OP);
}
+
//
// Debugging routines
//
WriteLog(" [hsc: %02X, vsc: %02X, rem: %02X]\n", hscale, vscale, remainder);
}
+
void DumpFixedObject(uint64 p0, uint64 p1)
{
WriteLog(" %08X %08X\n", (uint32)(p1>>32), (uint32)(p1&0xFFFFFFFF));
DumpBitmapCore(p0, p1);
}
+
void DumpBitmapCore(uint64 p0, uint64 p1)
{
uint32 bdMultiplier[8] = { 64, 32, 16, 8, 4, 2, 1, 1 };
(flags&OPFLAG_RELEASE ? "RELEASE" : ""), idx, pitch);
}
+
//
// Object Processor main routine
//
}
}
+
//
// Store fixed size bitmap in line buffer
//
}
}
+
//
// Store scaled bitmap in line buffer
//