#!smake -k
#
# Makefile for RDP verification application test suite.
#
include $(ROOT)/usr/include/make/PRdefs

TEXDIR =	$(ROOT)/PR/apps/rdptex/Texture

APP =		rdpverif
APP_EM =	rdpverif_em

OPTIMIZER =	-g

TARGETS =	rom rom_em

EMULATE	= 	$(ROOT)/usr/sbin/emulate

TEXHFILES =	./RGBA16checker.h \
		./RGBA16mario.h	\
		./RGBA16mario_2.h \
		./RGBA16mario32.h \
		./RGBA16mario_32.h \
		./RGBA16dana.h	\
		./RGBA16grid.h	\
		./RGBA16grid_32.h	\
		./RGBA16grid_32mip.h	\
		./IA16Noise.h	\
		./IA16grid.h	\
		./IA8grid.h	\
		./IA4grid.h	\
		./I8grid.h	\
		./I4grid.h	\
		./RGBA32eye.h 	\
		./RGBA16tree.h

HFILES =	$(TEXHFILES) rdpverif.h controller.h

CODEFILES =	rdpverif.c main.c controller.c
CODEOBJECTS =	$(CODEFILES:.c=.o)
CODEOBJECTS_EM =	rdpverif.o main_em.o

DATAFILES =	zbuffer.c init.c static.c cfb.c
DATAOBJECTS =	$(DATAFILES:.c=.o)

CODESEGMENT =	codesegment.o
CODESEGMENT_EM = codesegment_em.o

OBJECTS =	$(CODESEGMENT) $(DATAOBJECTS)
OBJECTS_EM =	$(CODESEGMENT_EM) $(DATAOBJECTS)

LCINCS =	-I. -I$(ROOT)/usr/include/PR -I $(ROOT)/usr/include
LCOPTS =	-fullwarn -non_shared -G 0

LDIRT  =	$(APP) $(APP_EM) rdpverif rdpverif_em \
		InData/test*Z $(TEXHFILES)

LDFLAGS_EM =	$(MKDEPOPT) -nostdlib -L$(ROOT)/usr/lib -L$(ROOT)/usr/lib/PR \
			-lem -lultra_em

LDFLAGS =	$(MKDEPOPT) -nostdlib -L$(ROOT)/usr/lib -L$(ROOT)/usr/lib/PR \
		-lultra_d

LCDEFS =

default:	$(TARGETS)

include $(COMMONRULES)

install:	default
		$(INSTALL) -m 444 -F /usr/src/PR/rdpverif Makefile spec \
			$(HFILES) $(CODEFILES) $(DATAFILES)

$(CODESEGMENT):	$(CODEOBJECTS)
		$(LD) -o $(CODESEGMENT) -r $(CODEOBJECTS) $(LDFLAGS)

$(CODESEGMENT_EM):	$(CODEOBJECTS_EM)
		$(LD) -o $(CODESEGMENT_EM) -r $(CODEOBJECTS_EM) $(LDFLAGS_EM)

$(OBJECTS): $(HFILES)

#
# This must depend on the generated h-files, which in turn depend
# on the cases utility. If we don't do this, smake fails.
#
main.o: $(HFILES)
static.o: $(HFILES)
rdpverif.o: $(HFILES)

rom $(APP):	spec $(OBJECTS) $(MAKEROM)
		$(MAKEROM) -r rom spec

rom_em $(APP_EM):	spec_em $(OBJECTS_EM) $(MAKEROM)
		$(MAKEROM) -e -r rom_em spec_em

#
# Files specific to Hardware/Emulator
#

main.o: main.c
	$(CC) $(CFLAGS) $(LCDEFS) -c $< 

rdpverif.o: rdpverif.c
	$(CC) $(CFLAGS) $(LCDEFS) -c $< 

static.o: static.c
	$(CC) $(CFLAGS) $(LCDEFS) -c $< 

main_em.o: main.c
	$(CC) $(CFLAGS) $(LCDEFS) -D_EMULATOR -o $*.o -c main.c

#
# ADD TEST CASE:
#
# Note: due to fopen() restrictions in the rsp simulator, the
# directory you send the output to must exist before running...
#
#

NIGHTLY_REGRESSION_TEST_ARCHIVE =	\
	InData/test030.30.rdp.Z.archive \
	InData/test031.31.rdp.Z.archive \
	InData/test032.32.rdp.Z.archive \
	InData/test036.36.rdp.Z.archive \
	InData/test037.37.rdp.Z.archive \
	InData/test038.38.rdp.Z.archive \
	InData/test039.39.rdp.Z.archive \
	InData/test040.40.rdp.Z.archive \
	InData/test042.42.rdp.Z.archive \
	InData/test044.44.rdp.Z.archive \
	InData/test045.45.rdp.Z.archive \
			\
	InData/test131.31.rdp.Z.archive \
	InData/test132.32.rdp.Z.archive \
	InData/test140.40.rdp.Z.archive


OTHER_TESTS_ARCHIVE =	\
	InData/test001.01.rdp.Z.archive \
	InData/test002.02.rdp.Z.archive \
	InData/test003.03.rdp.Z.archive \
	InData/test004.04.rdp.Z.archive \
	InData/test005.05.rdp.Z.archive \
	InData/test006.06.rdp.Z.archive \
	InData/test009.09.rdp.Z.archive \
	InData/test010.10.rdp.Z.archive \
	InData/test015.15.rdp.Z.archive \
	InData/test020.20.rdp.Z.archive \
	InData/test021.21.rdp.Z.archive \
	InData/test022.22.rdp.Z.archive \
	InData/test033.33.rdp.Z.archive \
	InData/test034.34.rdp.Z.archive \
	InData/test035.35.rdp.Z.archive

NIGHTLY_REGRESSION_TESTS 	= ${NIGHTLY_REGRESSION_TEST_ARCHIVE:R:R:R:R:T}
NIGHTLY_REGRESSION_TEST_TARGETS = ${NIGHTLY_REGRESSION_TEST_ARCHIVE:R}
OTHER_TESTS 			= ${OTHER_TESTS_ARCHIVE:R:R:R:R:T}
OTHER_TESTS_TARGETS 		= ${OTHER_TESTS_ARCHIVE:R}
TESTS 				= ${OTHER_TESTS} ${NIGHTLY_REGRESSION_TESTS}

#
# Header file build rules
#

./RGBA32eye.h: $(TEXDIR)/eye.rgb
	$(RGB2C) -f RGBA -s 32 -m RGBA32eye $(TEXDIR)/eye.rgb > RGBA32eye.h

./RGBA16dana.h: $(TEXDIR)/dana_tiny.rgb
	$(RGB2C) -m RGBA16dana $(TEXDIR)/dana_tiny.rgb > RGBA16dana.h

./RGBA16checker.h: $(TEXDIR)/checker.rgba
	$(RGB2C) -f RGBA -s 16 -m RGBA16checker $(TEXDIR)/checker.rgba > RGBA16checker.h


./RGBA16grid.h: $(TEXDIR)/grid.rgba
	$(RGB2C) -f RGBA -s 16 -m RGBA16grid $(TEXDIR)/grid.rgba > RGBA16grid.h

./RGBA16grid_32.h: $(TEXDIR)/grid.rgba
	$(RGB2C) -f RGBA -s 16 -m RGBA16grid_32 $(TEXDIR)/grid.rgba > RGBA16grid_32.h

./RGBA16grid_32mip.h: $(TEXDIR)/grid.rgba
	$(RGB2C) -o MIP -f RGBA -s 16 -m RGBA16grid_32mip $(TEXDIR)/grid.rgba > RGBA16grid_32mip.h

./RGBA16grid.tmem:
	$(RGB2C) -f RGBA -s 16 -o RAW -m RGBA16grid $(TEXDIR)/grid.rgba > RGBA16grid.raw
	$(ROOT)/PR/tools/tmemfmt/tmemfmt -a 0 -i RGBA16grid.raw -o RGBA16grid.tmem
	-rm RGBA16grid.raw

./RGBA16mario.h: $(TEXDIR)/mario_1.rgb
	$(RGB2C) -f RGBA -s 16 -m RGBA16mario $(TEXDIR)/mario_1.rgb > RGBA16mario.h

./RGBA16mario_2.h: $(TEXDIR)/mario_2.rgb
	$(RGB2C) -f RGBA -s 16 -m RGBA16mario_2 $(TEXDIR)/mario_2.rgb > RGBA16mario_2.h

./RGBA16mario32.h: $(TEXDIR)/mario_32.rgb
	$(RGB2C) -f RGBA -s 16 -m RGBA16mario32 $(TEXDIR)/mario_32.rgb > RGBA16mario32.h

./RGBA16mario_32.h: $(TEXDIR)/mario_32.rgb
	$(RGB2C) -f RGBA -s 16 -m RGBA16mario_32 $(TEXDIR)/mario_32.rgb > RGBA16mario_32.h

./RGBA16tree.h: $(TEXDIR)/tree_32.rgba
	$(RGB2C) -f RGBA -s 16 -m RGBA16tree $(TEXDIR)/tree_32.rgba > RGBA16tree.h

./IA16Noise.h: $(TEXDIR)/Noise.rgb
	$(RGB2C) -f I -s 16 -m IA16Noise $(TEXDIR)/Noise.rgb > IA16Noise.h

./IA16grid.h: $(TEXDIR)/grid.rgba
	$(RGB2C) -f IA -s 16 -m IA16grid $(TEXDIR)/grid.rgba > IA16grid.h

./IA8grid.h: $(TEXDIR)/grid.rgba
	$(RGB2C) -f IA -s 8 -m IA8grid $(TEXDIR)/grid.rgba > IA8grid.h

./IA4grid.h: $(TEXDIR)/grid.rgba
	$(RGB2C) -f IA -s 4 -m IA4grid $(TEXDIR)/grid.rgba > IA4grid.h

./IA4grid.tmem: $(TEXDIR)/grid.rgba
	$(RGB2C) -f IA -s 4 -o RAW -m IA4grid $(TEXDIR)/grid.rgba > IA4grid.raw
	$(ROOT)/PR/tools/tmemfmt/tmemfmt -a 0 -i IA4grid.raw -o IA4grid
	-rm IA4grid.raw 

./I8grid.h: $(TEXDIR)/grid.rgba
	$(RGB2C) -f I -s 8 -m I8grid $(TEXDIR)/grid.rgba > I8grid.h

./I4grid.h: $(TEXDIR)/grid.rgba
	$(RGB2C) -f I -s 4 -m I4grid $(TEXDIR)/grid.rgba > I4grid.h

./CIgrid.h: $(TEXDIR)/grid.rgba
	$(RGB2C) -f CI -s 8 -m CIgrid $(TEXDIR)/grid.rgba > CIgrid.h

#
#
#  Build RDP Display Lists
#
#

test000:		InData/test000.0.rdp.Z

InData/test000.0.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-a -o 0 -n InData/test000" $(APP_EM) rom_em
	compress -f InData/test000*.rdp

test001:		InData/test001.1.rdp.Z

InData/test001.1.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -o 1 -n InData/test001" $(APP_EM) rom_em
	compress -f InData/test001*.rdp

test002:		InData/test002.2.rdp.Z

InData/test002.2.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -o 2 -n InData/test002" $(APP_EM) rom_em
	compress -f InData/test002*.rdp

test003:		InData/test003.3.rdp.Z

InData/test003.3.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -o 3 -n InData/test003" $(APP_EM) rom_em
	compress -f InData/test003*.rdp

test004:		InData/test004.4.rdp.Z

InData/test004.4.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -f 4 -o 4 -n InData/test004" $(APP_EM) rom_em
	compress -f InData/test004*.rdp

test005:		InData/test005.5.rdp.Z

InData/test005.5.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -f 5 -o 5 -n InData/test005" $(APP_EM) rom_em
	compress -f InData/test005*.rdp

test006:		InData/test006.6.rdp.Z

InData/test006.6.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -o 6 -n InData/test006" $(APP_EM) rom_em
	compress -f InData/test006*.rdp

test009:		InData/test009.9.rdp.Z

InData/test009.9.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -o 9 -n InData/test009" $(APP_EM) rom_em
	compress -f InData/test009*.rdp

test010:		InData/test010.10.rdp.Z

InData/test010.10.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -o 10 -n InData/test010" $(APP_EM) rom_em
	compress -f InData/test010*.rdp

test015:		InData/test015.15.rdp.Z

InData/test015.15.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -o 15 -n InData/test015" $(APP_EM) rom_em
	compress -f InData/test015*.rdp

test020:		InData/test020.14.rdp.Z

InData/test020.14.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -s 20 14 -f 20 -n InData/test020" $(APP_EM) rom_em
	compress -f InData/test020.*.rdp

#
# Anti-aliased
#
test021:		InData/test021.19.rdp.Z

InData/test021.19.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -s 21 19 -f 21 -n InData/test021" $(APP_EM) rom_em
	compress -f InData/test021.*.rdp

test022:		InData/test022.63.rdp.Z

InData/test022.63.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -s 22 63 -f 22 -n InData/test022" $(APP_EM) rom_em
	compress -f InData/test022.*.rdp

#
# Collection of texture tests to run for nightly toplevel texture regression
# DP in 1 clock mode
#
test030:	InData/test030.30.rdp.Z InData/test030.30.rdram.Z

InData/test030.30.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -r -a -f 30 -o 30 -n InData/test030" $(APP_EM) rom_em
	compress -f InData/test030.*.rdp

InData/test030.30.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-d -m -r -a -f 30 -o 30 -n InData/test030" $(APP_EM) rom_em

#
# Collection of texture tests to run for nightly toplevel texture regression
# DP in 2 clock mode
#
test031:	InData/test031.31.rdp.Z InData/test031.31.rdram.Z

InData/test031.31.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -r -a -f 31 -o 31 -n InData/test031" $(APP_EM) rom_em
	compress -f InData/test031.*.rdp

InData/test031.31.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -m -r -a -f 31 -o 31 -n InData/test031" $(APP_EM) rom_em

#
# (32 bit version)
# Collection of texture tests to run for nightly toplevel texture regression
# DP in 2 clock mode
#
test131:	InData/test131.31.rdp.Z InData/test131.31.rdram.Z

InData/test131.31.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -r -a -f 31 -o 31 -n InData/test131 -t" $(APP_EM) rom_em
	compress -f InData/test131.*.rdp

InData/test131.31.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -m -r -a -f 31 -o 31 -n InData/test131 -t" $(APP_EM) rom_em

#
# Interlaced version of test 30, odd field
#
# Don't use the -r (shrink viewport) flag, as this test
# turns on scissoring, which only allows rendering in the middle of a
# 320x240 frame buffer region.
#
test032:	InData/test032.32.rdp.Z InData/test032.32.rdram.Z

InData/test032.32.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -f 32 -o 32 -n InData/test032" $(APP_EM) rom_em
	compress -f InData/test032.*.rdp

InData/test032.32.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-m -d -a -f 32 -o 32 -n InData/test032" $(APP_EM) rom_em

#
# (32 bit version)
# Interlaced version of test 30, odd field
#
# Don't use the -r (shrink viewport) flag, as this test
# turns on scissoring, which only allows rendering in the middle of a
# 320x240 frame buffer region.
#
test132:	InData/test132.32.rdp.Z InData/test132.32.rdram.Z

InData/test132.32.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -f 32 -o 32 -n InData/test132 -t" $(APP_EM) rom_em
	compress -f InData/test132.*.rdp

InData/test132.32.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-m -d -a -f 32 -o 32 -n InData/test132 -t" $(APP_EM) rom_em

#
# Interlaced version of test 30, even field
#
# Don't use the -r (shrink viewport) flag, as this test
# turns on scissoring, which only allows rendering in the middle of a
# 320x240 frame buffer region.
#
test033:	InData/test033.33.rdp.Z InData/test033.33.rdram.Z

InData/test033.33.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -f 33 -o 33 -n InData/test033" $(APP_EM) rom_em
	compress -f InData/test033.*.rdp

InData/test033.33.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-m -d -a -f 33 -o 33 -n InData/test033" $(APP_EM) rom_em

test034:		InData/test034.34.rdp.Z

InData/test034.34.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -f 34 -o 34 -n InData/test034" $(APP_EM) rom_em
	compress -f InData/test034.*.rdp

test035:		InData/test035.35.rdp.Z

InData/test035.35.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -f 35 -o 35 -n InData/test035" $(APP_EM) rom_em
	compress -f InData/test035.*.rdp

#
# 16-bit copies
#
test036:	InData/test036.36.rdp.Z InData/test036.36.rdram.Z

InData/test036.36.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -f 36 -o 36 -n InData/test036" $(APP_EM) rom_em
	compress -f InData/test036.*.rdp

InData/test036.36.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -r -m -a -f 36 -o 36 -n InData/test036" $(APP_EM) rom_em

#
# 16-bit texture rectangle in 1 cycle mode
# 123pixels x 125pixels
#
test037:	InData/test037.37.rdp.Z InData/test037.37.rdram.Z

InData/test037.37.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-r -m -a -f 37 -o 37 -n InData/test037" $(APP_EM) rom_em
	compress -f InData/test037.*.rdp

InData/test037.37.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -r -m -a -f 37 -o 37 -n InData/test037" $(APP_EM) rom_em

#
# 1 cycle Texture LOD test
#
test038:	InData/test038.38.rdp.Z InData/test038.38.rdram.Z

InData/test038.38.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-r -m -a -f 38 -o 38 -n InData/test038" $(APP_EM) rom_em
	compress -f InData/test038.*.rdp

InData/test038.38.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -r -m -a -f 38 -o 38 -n InData/test038" $(APP_EM) rom_em

#
# 2 cycle trilerp texture + detail test (Anti-aliased)
#
test039:	InData/test039.39.rdp.Z InData/test039.39.rdram.Z

InData/test039.39.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-r -m -a -f 39 -o 39 -n InData/test039" $(APP_EM) rom_em
	compress -f InData/test039.*.rdp

InData/test039.39.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -r -m -a -f 39 -o 39 -n InData/test039" $(APP_EM) rom_em

#
# load_tlut_dl
#
test040:	InData/test040.40.rdp.Z InData/test040.40.rdram.Z

InData/test040.40.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-r -m -a -f 40 -o 40 -n InData/test040" $(APP_EM) rom_em
	compress -f InData/test040.*.rdp

InData/test040.40.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -r -m -a -f 40 -o 40 -n InData/test040" $(APP_EM) rom_em

#
# (32 bit version)
# load_tlut_dl
#
test140:	InData/test140.40.rdp.Z InData/test140.40.rdram.Z

InData/test140.40.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-r -m -a -f 40 -o 40 -n InData/test140 -t" $(APP_EM) rom_em
	compress -f InData/test140.*.rdp

InData/test140.40.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -r -m -a -f 40 -o 40 -n InData/test140 -t" $(APP_EM) rom_em

#
# Texture sharpen test
#
test042:	InData/test042.42.rdp.Z InData/test042.42.rdram.Z

InData/test042.42.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-r -m -a -f 42 -o 42 -n InData/test042" $(APP_EM) rom_em
	compress -f InData/test042.*.rdp

InData/test042.42.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -r -m -a -f 42 -o 42 -n InData/test042" $(APP_EM) rom_em

#
# 2 cycle trilerp texture + detail test
# (different mask and shift from_em Test 39) (Anti-aliased)
#
test044:	InData/test044.44.rdp.Z InData/test044.44.rdram.Z

InData/test044.44.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-r -m -a -f 44 -o 44 -n InData/test044" $(APP_EM) rom_em
	compress -f InData/test044.*.rdp

InData/test044.44.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -r -m -a -f 44 -o 44 -n InData/test044" $(APP_EM) rom_em

#
# 2 clock test with exact differences between clock 1 and 2 in CC/BL/MS
# has random noise, therefore, visual checks only
#
test045:	InData/test045.45.rdp.Z InData/test045.45.rdram.Z

InData/test045.45.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -f 45 -o 45 -n InData/test045" $(APP_EM) rom_em
	compress -f InData/test045.*.rdp

InData/test045.45.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -m -a -f 45 -o 45 -n InData/test045" $(APP_EM) rom_em

#
# Clear frame buffer (16-bit)
#
test050:	InData/test050.50.rdp.Z InData/test050.50.rdram.Z

InData/test050.50.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -r -a -f 50 -o 50 -n InData/test050" $(APP_EM) rom_em
	compress -f InData/test050.*.rdp

InData/test050.50.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -m -r -a -f 50 -o 50 -n InData/test050" $(APP_EM) rom_em

#
# Clear frame buffer
#
test051:	InData/test051.51.rdp.Z InData/test051.51.rdram.Z

InData/test051.51.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -r -a -f 51 -o 51 -n InData/test051" $(APP_EM) rom_em
	compress -f InData/test051.*.rdp

InData/test051.51.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -m -r -a -f 51 -o 51 -n InData/test051" $(APP_EM) rom_em

#
# Clear frame buffer - (32-bit)
#
test152:	InData/test152.52.rdp.Z InData/test152.52.rdram.Z

InData/test152.52.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -r -a -f 52 -o 52 -n InData/test152 -t" $(APP_EM) rom_em
	compress -f InData/test152.*.rdp

InData/test152.52.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -m -r -a -f 52 -o 52 -n InData/test152 -t" $(APP_EM) rom_em

#
# Clear frame buffer
#
test053:	InData/test053.53.rdp.Z InData/test053.53.rdram.Z

InData/test053.53.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -r -a -f 53 -o 53 -n InData/test053" $(APP_EM) rom_em
	compress -f InData/test053.*.rdp

InData/test053.53.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -m -r -a -f 53 -o 53 -n InData/test053" $(APP_EM) rom_em

#
# Clear frame buffer
#
test054:	InData/test054.54.rdp.Z InData/test054.54.rdram.Z

InData/test054.54.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -r -a -f 54 -o 54 -n InData/test054" $(APP_EM) rom_em
	compress -f InData/test054.*.rdp

InData/test054.54.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -m -r -a -f 54 -o 54 -n InData/test054" $(APP_EM) rom_em

#
# Clear frame buffer
#
test055:	InData/test055.55.rdp.Z InData/test055.55.rdram.Z

InData/test055.55.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -r -a -f 55 -o 55 -n InData/test055" $(APP_EM) rom_em
	compress -f InData/test055.*.rdp

InData/test055.55.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -m -r -a -f 55 -o 55 -n InData/test055" $(APP_EM) rom_em

#
# Clear frame buffer
#
test056:	InData/test056.56.rdp.Z InData/test056.56.rdram.Z

InData/test056.56.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -r -a -f 56 -o 56 -n InData/test056" $(APP_EM) rom_em
	compress -f InData/test056.*.rdp

InData/test056.56.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -m -r -a -f 56 -o 56 -n InData/test056" $(APP_EM) rom_em

#
# Clear frame buffer
#
test057:	InData/test057.57.rdp.Z InData/test057.57.rdram.Z

InData/test057.57.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -r -a -f 57 -o 57 -n InData/test057" $(APP_EM) rom_em
	compress -f InData/test057.*.rdp

InData/test057.57.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -m -r -a -f 57 -o 57 -n InData/test057" $(APP_EM) rom_em

#
# Clear frame buffer
#
test158:	InData/test158.58.rdp.Z InData/test158.58.rdram.Z

InData/test158.58.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -r -a -f 58 -o 58 -n InData/test158 -t" $(APP_EM) rom_em
	compress -f InData/test158.*.rdp

InData/test158.58.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -m -r -a -f 58 -o 58 -n InData/test158 -t" $(APP_EM) rom_em

#
# Clear frame buffer
#
test059:	InData/test059.59.rdp.Z InData/test059.59.rdram.Z

InData/test059.59.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -r -a -f 59 -o 59 -n InData/test059" $(APP_EM) rom_em
	compress -f InData/test059.*.rdp

InData/test059.59.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -m -r -a -f 59 -o 59 -n InData/test059" $(APP_EM) rom_em

#
# YUV texture load/render
#
test060:	InData/test060.60.rdp.Z InData/test060.60.rdram.Z

InData/test060.60.rdp.Z:	$(APP_EM)
	$(EMULATE) -n -s -a "-m -a -f 60 -o 60 -n InData/test060" $(APP_EM) rom_em
	compress -f InData/test060.*.rdp

InData/test060.60.rdram.Z:	$(APP_EM)
	$(EMULATE) -n -s -a \
	    "-d -F -m -a -f 60 -o 60 -n InData/test060" $(APP_EM) rom_em


tests:	$(TESTS)

#
# Run a smaller subset of the total test coverage on a nightly basis.
#
nightly_regression: $(NIGHTLY_REGRESSION_TESTS)

#
# Run test not run in nightly regression
#
other_tests: $(OTHER_TESTS)

#
# Only checkin archived versions of the .mem, .rdp files on a periodic, 
# on-demand basis (e.g. whenever an RSP simulator/ucode change affects the 
# output files mumble.mem or mumble.rdp).
#
# Otherwise we'll pollute the source tree with unnecessary copies
# of these data files.  The intent is to provide a way to resurrect data
# files for downstream simulation purposes whenever the output files generated
# by the rsp sim environment causes a hiccup downstream.
#
periodic_checkin: $(NIGHTLY_REGRESSION_TESTS)
	$(ROOT)/PR/tools/scripts/copyToArchive $(NIGHTLY_REGRESSION_TEST_TARGETS)