in atari_py/ale_interface/src/emucore/TIA.cxx [3059:3652]
inline void TIA::updateFrameScanlineFast(uInt32 clocksToUpdate, uInt32 hpos)
{
// Calculate the ending frame pointer value
uInt8* ending = myFramePointer + clocksToUpdate;
// See if we're in the vertical blank region
if(myVBLANK & 0x02)
{
// @strip memset(myFramePointer, 0, clocksToUpdate);
}
// Handle all other possible combinations
else
{
switch(myEnabledObjects | myPlayfieldPriorityAndScore)
{
// Background
case 0x00:
case 0x00 | ScoreBit:
case 0x00 | PriorityBit:
case 0x00 | PriorityBit | ScoreBit:
/* @strip {
memset(myFramePointer, myCOLUBK, clocksToUpdate);
break;
} */
break;
// Playfield is enabled and the score bit is not set
case myPFBit:
case myPFBit | PriorityBit:
/* @strip
{
uInt32* mask = &myCurrentPFMask[hpos];
// Update a uInt8 at a time until reaching a uInt32 boundary
for(; ((uintptr_t)myFramePointer & 0x03) && (myFramePointer < ending);
++myFramePointer, ++mask)
{
*myFramePointer = (myPF & *mask) ? myCOLUPF : myCOLUBK;
}
// Now, update a uInt32 at a time
for(; myFramePointer < ending; myFramePointer += 4, mask += 4)
{
*((uInt32*)myFramePointer) = (myPF & *mask) ? myCOLUPF : myCOLUBK;
}
break;
} */ break;
// Playfield is enabled and the score bit is set
case myPFBit | ScoreBit:
case myPFBit | ScoreBit | PriorityBit:
/* @strip {
uInt32* mask = &myCurrentPFMask[hpos];
// Update a uInt8 at a time until reaching a uInt32 boundary
for(; ((uintptr_t)myFramePointer & 0x03) && (myFramePointer < ending);
++myFramePointer, ++mask, ++hpos)
{
*myFramePointer = (myPF & *mask) ?
(hpos < 80 ? myCOLUP0 : myCOLUP1) : myCOLUBK;
}
// Now, update a uInt32 at a time
for(; myFramePointer < ending;
myFramePointer += 4, mask += 4, hpos += 4)
{
*((uInt32*)myFramePointer) = (myPF & *mask) ?
(hpos < 80 ? myCOLUP0 : myCOLUP1) : myCOLUBK;
}
break;
} */
break;
// Player 0 is enabled
case myP0Bit:
case myP0Bit | ScoreBit:
case myP0Bit | PriorityBit:
case myP0Bit | ScoreBit | PriorityBit:
/* @strip {
uInt8* mP0 = &myCurrentP0Mask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mP0)
{
*(uInt32*)myFramePointer = myCOLUBK;
mP0 += 4; myFramePointer += 4;
}
else
{
*myFramePointer = (myCurrentGRP0 & *mP0) ? myCOLUP0 : myCOLUBK;
++mP0; ++myFramePointer;
}
}
break;
} */
// Player 1 is enabled
case myP1Bit:
case myP1Bit | ScoreBit:
case myP1Bit | PriorityBit:
case myP1Bit | ScoreBit | PriorityBit:
/* @strip {
uInt8* mP1 = &myCurrentP1Mask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mP1)
{
*(uInt32*)myFramePointer = myCOLUBK;
mP1 += 4; myFramePointer += 4;
}
else
{
*myFramePointer = (myCurrentGRP1 & *mP1) ? myCOLUP1 : myCOLUBK;
++mP1; ++myFramePointer;
}
}
break;
} */
// Player 0 and 1 are enabled
case myP0Bit | myP1Bit:
case myP0Bit | myP1Bit | ScoreBit:
case myP0Bit | myP1Bit | PriorityBit:
case myP0Bit | myP1Bit | ScoreBit | PriorityBit:
{
uInt8* mP0 = &myCurrentP0Mask[hpos];
uInt8* mP1 = &myCurrentP1Mask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mP0 &&
!*(uInt32*)mP1)
{
// @strip *(uInt32*)myFramePointer = myCOLUBK;
mP0 += 4; mP1 += 4; myFramePointer += 4;
}
else
{
/* @strip *myFramePointer = (myCurrentGRP0 & *mP0) ?
myCOLUP0 : ((myCurrentGRP1 & *mP1) ? myCOLUP1 : myCOLUBK);
*/
if((myCurrentGRP0 & *mP0) && (myCurrentGRP1 & *mP1))
myCollision |= ourCollisionTable[myP0Bit | myP1Bit];
++mP0; ++mP1; ++myFramePointer;
}
}
break;
}
// Missle 0 is enabled
case myM0Bit:
case myM0Bit | ScoreBit:
case myM0Bit | PriorityBit:
case myM0Bit | ScoreBit | PriorityBit:
/* @strip {
uInt8* mM0 = &myCurrentM0Mask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mM0)
{
*(uInt32*)myFramePointer = myCOLUBK;
mM0 += 4; myFramePointer += 4;
}
else
{
*myFramePointer = *mM0 ? myCOLUP0 : myCOLUBK;
++mM0; ++myFramePointer;
}
}
break;
} */
break;
// Missle 1 is enabled
case myM1Bit:
case myM1Bit | ScoreBit:
case myM1Bit | PriorityBit:
case myM1Bit | ScoreBit | PriorityBit:
/* @strip {
uInt8* mM1 = &myCurrentM1Mask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mM1)
{
*(uInt32*)myFramePointer = myCOLUBK;
mM1 += 4; myFramePointer += 4;
}
else
{
*myFramePointer = *mM1 ? myCOLUP1 : myCOLUBK;
++mM1; ++myFramePointer;
}
}
break;
} */
break;
// Ball is enabled
case myBLBit:
case myBLBit | ScoreBit:
case myBLBit | PriorityBit:
case myBLBit | ScoreBit | PriorityBit:
/* @strip {
uInt8* mBL = &myCurrentBLMask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mBL)
{
*(uInt32*)myFramePointer = myCOLUBK;
mBL += 4; myFramePointer += 4;
}
else
{
*myFramePointer = *mBL ? myCOLUPF : myCOLUBK;
++mBL; ++myFramePointer;
}
}
break;
} */
break;
// Missle 0 and 1 are enabled
case myM0Bit | myM1Bit:
case myM0Bit | myM1Bit | ScoreBit:
case myM0Bit | myM1Bit | PriorityBit:
case myM0Bit | myM1Bit | ScoreBit | PriorityBit:
{
uInt8* mM0 = &myCurrentM0Mask[hpos];
uInt8* mM1 = &myCurrentM1Mask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mM0 && !*(uInt32*)mM1)
{
// @strip *(uInt32*)myFramePointer = myCOLUBK;
mM0 += 4; mM1 += 4; myFramePointer += 4;
}
else
{
// @strip *myFramePointer = *mM0 ? myCOLUP0 : (*mM1 ? myCOLUP1 : myCOLUBK);
if(*mM0 && *mM1)
myCollision |= ourCollisionTable[myM0Bit | myM1Bit];
++mM0; ++mM1; ++myFramePointer;
}
}
break;
}
// Ball and Missle 0 are enabled and playfield priority is not set
case myBLBit | myM0Bit:
case myBLBit | myM0Bit | ScoreBit:
{
uInt8* mBL = &myCurrentBLMask[hpos];
uInt8* mM0 = &myCurrentM0Mask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mBL && !*(uInt32*)mM0)
{
// @strip *(uInt32*)myFramePointer = myCOLUBK;
mBL += 4; mM0 += 4; myFramePointer += 4;
}
else
{
// @strip *myFramePointer = (*mM0 ? myCOLUP0 : (*mBL ? myCOLUPF : myCOLUBK));
if(*mBL && *mM0)
myCollision |= ourCollisionTable[myBLBit | myM0Bit];
++mBL; ++mM0; ++myFramePointer;
}
}
break;
}
// Ball and Missle 0 are enabled and playfield priority is set
case myBLBit | myM0Bit | PriorityBit:
case myBLBit | myM0Bit | ScoreBit | PriorityBit:
{
uInt8* mBL = &myCurrentBLMask[hpos];
uInt8* mM0 = &myCurrentM0Mask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mBL && !*(uInt32*)mM0)
{
// @strip *(uInt32*)myFramePointer = myCOLUBK;
mBL += 4; mM0 += 4; myFramePointer += 4;
}
else
{
// @strip *myFramePointer = (*mBL ? myCOLUPF : (*mM0 ? myCOLUP0 : myCOLUBK));
if(*mBL && *mM0)
myCollision |= ourCollisionTable[myBLBit | myM0Bit];
++mBL; ++mM0; ++myFramePointer;
}
}
break;
}
// Ball and Missle 1 are enabled and playfield priority is not set
case myBLBit | myM1Bit:
case myBLBit | myM1Bit | ScoreBit:
{
uInt8* mBL = &myCurrentBLMask[hpos];
uInt8* mM1 = &myCurrentM1Mask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mBL &&
!*(uInt32*)mM1)
{
// @strip *(uInt32*)myFramePointer = myCOLUBK;
mBL += 4; mM1 += 4; myFramePointer += 4;
}
else
{
// @strip *myFramePointer = (*mM1 ? myCOLUP1 : (*mBL ? myCOLUPF : myCOLUBK));
if(*mBL && *mM1)
myCollision |= ourCollisionTable[myBLBit | myM1Bit];
++mBL; ++mM1; ++myFramePointer;
}
}
break;
}
// Ball and Missle 1 are enabled and playfield priority is set
case myBLBit | myM1Bit | PriorityBit:
case myBLBit | myM1Bit | ScoreBit | PriorityBit:
{
uInt8* mBL = &myCurrentBLMask[hpos];
uInt8* mM1 = &myCurrentM1Mask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mBL &&
!*(uInt32*)mM1)
{
// @strip *(uInt32*)myFramePointer = myCOLUBK;
mBL += 4; mM1 += 4; myFramePointer += 4;
}
else
{
// @strip *myFramePointer = (*mBL ? myCOLUPF : (*mM1 ? myCOLUP1 : myCOLUBK));
if(*mBL && *mM1)
myCollision |= ourCollisionTable[myBLBit | myM1Bit];
++mBL; ++mM1; ++myFramePointer;
}
}
break;
}
// Ball and Player 1 are enabled and playfield priority is not set
case myBLBit | myP1Bit:
case myBLBit | myP1Bit | ScoreBit:
{
uInt8* mBL = &myCurrentBLMask[hpos];
uInt8* mP1 = &myCurrentP1Mask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mP1 && !*(uInt32*)mBL)
{
// @strip *(uInt32*)myFramePointer = myCOLUBK;
mBL += 4; mP1 += 4; myFramePointer += 4;
}
else
{
/* @strip *myFramePointer = (myCurrentGRP1 & *mP1) ? myCOLUP1 :
(*mBL ? myCOLUPF : myCOLUBK); */
if(*mBL && (myCurrentGRP1 & *mP1))
myCollision |= ourCollisionTable[myBLBit | myP1Bit];
++mBL; ++mP1; ++myFramePointer;
}
}
break;
}
// Ball and Player 1 are enabled and playfield priority is set
case myBLBit | myP1Bit | PriorityBit:
case myBLBit | myP1Bit | PriorityBit | ScoreBit:
{
uInt8* mBL = &myCurrentBLMask[hpos];
uInt8* mP1 = &myCurrentP1Mask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mP1 && !*(uInt32*)mBL)
{
// @strip *(uInt32*)myFramePointer = myCOLUBK;
mBL += 4; mP1 += 4; myFramePointer += 4;
}
else
{
/* @strip *myFramePointer = *mBL ? myCOLUPF :
((myCurrentGRP1 & *mP1) ? myCOLUP1 : myCOLUBK); */
if(*mBL && (myCurrentGRP1 & *mP1))
myCollision |= ourCollisionTable[myBLBit | myP1Bit];
++mBL; ++mP1; ++myFramePointer;
}
}
break;
}
// Playfield and Player 0 are enabled and playfield priority is not set
case myPFBit | myP0Bit:
{
uInt32* mPF = &myCurrentPFMask[hpos];
uInt8* mP0 = &myCurrentP0Mask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mP0)
{
// @strip *(uInt32*)myFramePointer = (myPF & *mPF) ? myCOLUPF : myCOLUBK;
mPF += 4; mP0 += 4; myFramePointer += 4;
}
else
{
/* @strip *myFramePointer = (myCurrentGRP0 & *mP0) ?
myCOLUP0 : ((myPF & *mPF) ? myCOLUPF : myCOLUBK); */
if((myPF & *mPF) && (myCurrentGRP0 & *mP0))
myCollision |= ourCollisionTable[myPFBit | myP0Bit];
++mPF; ++mP0; ++myFramePointer;
}
}
break;
}
// Playfield and Player 0 are enabled and playfield priority is set
case myPFBit | myP0Bit | PriorityBit:
{
uInt32* mPF = &myCurrentPFMask[hpos];
uInt8* mP0 = &myCurrentP0Mask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mP0)
{
// @strip *(uInt32*)myFramePointer = (myPF & *mPF) ? myCOLUPF : myCOLUBK;
mPF += 4; mP0 += 4; myFramePointer += 4;
}
else
{
/* @strip *myFramePointer = (myPF & *mPF) ? myCOLUPF :
((myCurrentGRP0 & *mP0) ? myCOLUP0 : myCOLUBK); */
if((myPF & *mPF) && (myCurrentGRP0 & *mP0))
myCollision |= ourCollisionTable[myPFBit | myP0Bit];
++mPF; ++mP0; ++myFramePointer;
}
}
break;
}
// Playfield and Player 1 are enabled and playfield priority is not set
case myPFBit | myP1Bit:
{
uInt32* mPF = &myCurrentPFMask[hpos];
uInt8* mP1 = &myCurrentP1Mask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mP1)
{
// @strip *(uInt32*)myFramePointer = (myPF & *mPF) ? myCOLUPF : myCOLUBK;
mPF += 4; mP1 += 4; myFramePointer += 4;
}
else
{
/* @strip *myFramePointer = (myCurrentGRP1 & *mP1) ?
myCOLUP1 : ((myPF & *mPF) ? myCOLUPF : myCOLUBK); */
if((myPF & *mPF) && (myCurrentGRP1 & *mP1))
myCollision |= ourCollisionTable[myPFBit | myP1Bit];
++mPF; ++mP1; ++myFramePointer;
}
}
break;
}
// Playfield and Player 1 are enabled and playfield priority is set
case myPFBit | myP1Bit | PriorityBit:
{
uInt32* mPF = &myCurrentPFMask[hpos];
uInt8* mP1 = &myCurrentP1Mask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mP1)
{
// @strip *(uInt32*)myFramePointer = (myPF & *mPF) ? myCOLUPF : myCOLUBK;
mPF += 4; mP1 += 4; myFramePointer += 4;
}
else
{
/* @strip *myFramePointer = (myPF & *mPF) ? myCOLUPF :
((myCurrentGRP1 & *mP1) ? myCOLUP1 : myCOLUBK); */
if((myPF & *mPF) && (myCurrentGRP1 & *mP1))
myCollision |= ourCollisionTable[myPFBit | myP1Bit];
++mPF; ++mP1; ++myFramePointer;
}
}
break;
}
// Playfield and Ball are enabled
case myPFBit | myBLBit:
case myPFBit | myBLBit | PriorityBit:
{
uInt32* mPF = &myCurrentPFMask[hpos];
uInt8* mBL = &myCurrentBLMask[hpos];
while(myFramePointer < ending)
{
if(!((uintptr_t)myFramePointer & 0x03) && !*(uInt32*)mBL)
{
// @strip *(uInt32*)myFramePointer = (myPF & *mPF) ? myCOLUPF : myCOLUBK;
mPF += 4; mBL += 4; myFramePointer += 4;
}
else
{
// @strip *myFramePointer = ((myPF & *mPF) || *mBL) ? myCOLUPF : myCOLUBK;
if((myPF & *mPF) && *mBL)
myCollision |= ourCollisionTable[myPFBit | myBLBit];
++mPF; ++mBL; ++myFramePointer;
}
}
break;
}
// Handle all of the other cases
default:
{
for(; myFramePointer < ending; ++myFramePointer, ++hpos)
{
uInt8 enabled = (myPF & myCurrentPFMask[hpos]) ? myPFBit : 0;
if((myEnabledObjects & myBLBit) && myCurrentBLMask[hpos])
enabled |= myBLBit;
if(myCurrentGRP1 & myCurrentP1Mask[hpos])
enabled |= myP1Bit;
if((myEnabledObjects & myM1Bit) && myCurrentM1Mask[hpos])
enabled |= myM1Bit;
if(myCurrentGRP0 & myCurrentP0Mask[hpos])
enabled |= myP0Bit;
if((myEnabledObjects & myM0Bit) && myCurrentM0Mask[hpos])
enabled |= myM0Bit;
myCollision |= ourCollisionTable[enabled];
/* @strip *myFramePointer = myColor[myPriorityEncoder[hpos < 80 ? 0 : 1]
[enabled | myPlayfieldPriorityAndScore]]; */
}
break;
}
}
}
myFramePointer = ending;
}