#!smake -k
#
# Makefile for RDP verification application test suite.
#
# Wed Oct  5 21:03:47 PDT 1994
#

PRDEPTH = ../..

include $(PRDEPTH)/PRdefs

OPTIMIZER =	-g -D_HW_VERSION_2

TARGETS =	rom
APP = 		rom

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

#
# 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/test014.14.rdp.Z.archive \
	InData/test015.15.rdp.Z.archive \
	InData/test016.16.rdp.Z.archive \
	InData/test017.17.rdp.Z.archive \
	InData/test031.31.rdp.Z.archive \
	InData/test032.32.rdp.Z.archive \
	InData/test038.38.rdp.Z.archive \
	InData/test132.32.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/test007.07.rdp.Z.archive \
	InData/test008.08.rdp.Z.archive \
	InData/test009.09.rdp.Z.archive \
	InData/test010.10.rdp.Z.archive \
	InData/test011.11.rdp.Z.archive \
	InData/test012.12.rdp.Z.archive \
	InData/test013.13.rdp.Z.archive \
	InData/test020.20.rdp.Z.archive \
	InData/test033.33.rdp.Z.archive \
	InData/test034.34.rdp.Z.archive \
	InData/test035.35.rdp.Z.archive \
	InData/test036.36.rdp.Z.archive \
	InData/test037.37.rdp.Z.archive \
	InData/test039.39.rdp.Z.archive \
	InData/test040.40.rdp.Z.archive

ROBTESTS =	test005 \
		test006 \
		test007 \
		test008 \
		test010 \
		test011 \
		test012 \
		test013 \
		test037 \
		test038 \
		test039 \
		test040 \
		test061 \
		test062 \
		test065 \
		test067

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}

TEXHFILES =	RGBA16dana.h	\
		RGBA16grid.h	\
		IA4checker.h	\
		I4granite3.h	\
		I4luna.h	\
		I4haeberli_fixed.h	\
		IA4haeberli_fixed.h	\
		IA4Tymes-Elfin.h	\
		I4Tymes-Elfin.h

HFILES =	$(TEXHFILES) rdpverif.h

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

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

CODESEGMENT =	codesegment.o

OBJECTS =	$(CODESEGMENT) $(DATAOBJECTS)

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

LDIRT  =	InData/test*Z $(TEXHFILES)

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

default:	$(TARGETS)

include $(COMMONRULES)

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

#
# This must depend on the generated h-files.
# If we don't do this, smake fails.
#
rdpverif.o: $(TEXHFILES)

$(OBJECTS): $(HFILES)

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

#
# Header file build rules
#

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

RGBA16grid.h: Texture/grid.rgb
	$(RGB2C) -m RGBA16grid Texture/grid.rgb > RGBA16grid.h

IA4checker.h: Texture/checker.rgb
	$(RGB2C) -f IA -s 4 -m IA4checker Texture/checker.rgb > IA4checker.h

IA4circle.h: Texture/circle.rgb
	$(RGB2C) -f IA -s 4 -m IA4circle Texture/circle.rgb > IA4circle.h

I4granite3.h: Texture/granite.3.bw
	$(RGB2C) -f I -s 4 -m I4granite3 Texture/granite.3.bw > I4granite3.h

I4luna.h: Texture/luna.rgb
	$(RGB2C) -f I -s 4 -m I4luna Texture/luna.rgb > I4luna.h

I4haeberli_fixed.h: Texture/haeberli_fixed.bw
	$(RGB2C) -f I -s 4 -m I4haeberli_fixed Texture/haeberli_fixed.bw > I4haeberli_fixed.h

IA4haeberli_fixed.h: Texture/haeberli_fixed.bw
	$(RGB2C) -f IA -s 4 -m IA4haeberli_fixed Texture/haeberli_fixed.bw > IA4haeberli_fixed.h

IA4Tymes-Elfin.h: Texture/Tymes-Elfin.bw
	$(RGB2C) -f IA -s 4 -m IA4Tymes_Elfin Texture/Tymes-Elfin.bw > IA4Tymes-Elfin.h

I4Tymes-Elfin.h: Texture/Tymes-Elfin.bw
	$(RGB2C) -f I -s 4 -m I4Tymes_Elfin Texture/Tymes-Elfin.bw > I4Tymes-Elfin.h

#
#  Tests not in regression, but interesting anyway
#
robtests: $(ROBTESTS)

#
# Targets to generate the individual rdram images
#

#
# Anti-aliased square
#
test000:                        InData/test000.0.rdram.Z
InData/test000.0.rdram.Z:        $(APP)
	gen_rdram 0 InData/test000.0.rdram
	compress -f InData/test000.0.rdram

test001:                        InData/test001.1.rdram.Z
InData/test001.1.rdram.Z:        $(APP)
	gen_rdram 1 InData/test001.1.rdram
	compress -f InData/test001.1.rdram

test002:                        InData/test002.2.rdram.Z
InData/test002.2.rdram.Z:        $(APP)
	gen_rdram 2 InData/test002.2.rdram
	compress -f InData/test002.2.rdram

test003:                        InData/test003.3.rdram.Z
InData/test003.3.rdram.Z:        $(APP)
	gen_rdram 3 InData/test003.3.rdram
	compress -f InData/test003.3.rdram

test004:                        InData/test004.4.rdram.Z
InData/test004.4.rdram.Z:        $(APP)
	gen_rdram 4 InData/test004.4.rdram
	compress -f InData/test004.4.rdram

test005:                        InData/test005.5.rdram.Z
InData/test005.5.rdram.Z:        $(APP)
	gen_rdram 5 InData/test005.5.rdram
	compress -f InData/test005.5.rdram

test006:                        InData/test006.6.rdram.Z
InData/test006.6.rdram.Z:        $(APP)
	gen_rdram 6 InData/test006.6.rdram
	compress -f InData/test006.6.rdram

test007:                        InData/test007.7.rdram.Z 
InData/test007.7.rdram.Z:        $(APP)
	gen_rdram 7 InData/test007.7.rdram
	compress -f InData/test007.7.rdram

test008:                        InData/test008.8.rdram.Z
InData/test008.8.rdram.Z:        $(APP)
	gen_rdram 8 InData/test008.8.rdram
	compress -f InData/test008.8.rdram

test009:                        InData/test009.9.rdram.Z
InData/test009.9.rdram.Z:        $(APP)
	gen_rdram 9 InData/test009.9.rdram
	compress -f InData/test009.9.rdram

test010:                        InData/test010.10.rdram.Z
InData/test010.10.rdram.Z:        $(APP)
	gen_rdram 10 InData/test0010.10.rdram
	compress -f InData/test0010.10.rdram

test011:                        InData/test011.11.rdram.Z
InData/test011.11.rdram.Z:        $(APP)
	gen_rdram 11 InData/test0011.11.rdram
	compress -f InData/test0011.11.rdram

test012:		InData/test012.12.rdram.Z 
InData/test012.12.rdram.Z:        $(APP)
	gen_rdram 12 InData/test0012.12.rdram
	compress -f InData/test0012.12.rdram

test013:                InData/test013.13.rdram.Z
InData/test013.13.rdram.Z:	$(APP)
	gen_rdram 13 InData/test0013.13.rdram
	compress -f InData/test0013.13.rdram
#
# test014: attribute update/sync in one-cycle mode (has anti-aliasing)
#
test014:	InData/test014.14.rdram.Z 
InData/test014.14.rdram.Z:	$(APP)
	gen_rdram 14 InData/test0014.14.rdram
	compress -f InData/test0014.14.rdram

#
# test015: attribute update/sync in two-cycle mode (has anti-aliasing)
#
test015:	InData/test015.15.rdram.Z 
InData/test015.15.rdram.Z:	$(APP)
	gen_rdram 15 InData/test0015.15.rdram
	compress -f InData/test0015.15.rdram

#
# test016: attribute update/sync in fill mode (no anti-aliasing)
#
test016:	InData/test016.16.rdram.Z 

InData/test016.16.rdram.Z:	$(APP)
	gen_rdram 16 InData/test0016.16.rdram
	compress -f InData/test0016.16.rdram

#
# test017: attribute update in copy mode (no anti-aliasing)
#
test017:	InData/test017.17.rdram.Z InData/test017.17.rdram.Z
InData/test017.17.rdram.Z:	$(APP)
	gen_rdram 17 InData/test0017.17.rdram
	compress -f InData/test0017.17.rdram

#
# Has anti-aliasing
#
test020:			InData/test020.20.rdram.Z
InData/test020.20.rdram.Z:	$(APP)
	gen_rdram 20 InData/test0020.20.rdram
	compress -f InData/test0020.20.rdram

#
#  Flight path
#
#  Warning, this target dumps 15 frames with 2M memory file for each frame.
#
#  Each 2M memory file will subsequently be compressed to ~32K each, but
#  this won't get done until all 15 frames of the animation have been run
#  (i.e. make sure you have 30MB available before running this target).
#
# (has anti-aliasing)
#
#
test030:			InData/test030.31.rdram.Z

InData/test030.31.rdram.Z:	$(APP)
	$(EMULATE) -n -s -a "-a -m -s 30 31 -f 30 -n InData/test030" $(APP) rom
	compress -f InData/test030*.rdp

#
# test031: AA modes, texture loads, z-buffer, interpenetration, coverage, etc.
# (LOOK_ALL)
# (has anti-aliasing)
#
test031:	InData/test031.31.rdram.Z 
InData/test031.31.rdram.Z:	$(APP)
	gen_rdram 31 InData/test0031.31.rdram
	compress -f InData/test0031.31.rdram

#
# test032: another view of 31, more edge-on cases
# (LOOK_ALL_FOUR_TREES)
# (has anti-aliasing)
#
test032:	InData/test032.32.rdram.Z 
InData/test032.32.rdram.Z:	$(APP)
	gen_rdram 32 InData/test0032.32.rdram
	compress -f InData/test0032.32.rdram
#
# test132: 32 bit version of another view of 31, more edge-on cases
# (LOOK_ALL_FOUR_TREES)
# (has anti-aliasing)
#
test132:	InData/test132.32.rdram.Z 
InData/test132.32.rdram.Z:	$(APP)
	gen_rdram 132 InData/test00132.132.rdram
	compress -f InData/test00132.132.rdram
#
#  LOOK_ICOSA
#
test033:                        InData/test033.33.rdram.Z
InData/test033.33.rdram.Z:	$(APP)
	gen_rdram 133 InData/test00133.133.rdram
	compress -f InData/test00133.133.rdram
#
#  LOOK_BOX
#
test034:                        InData/test034.34.rdram.Z
InData/test034.34.rdram.Z:	$(APP)
	gen_rdram 34 InData/test0034.34.rdram
	compress -f InData/test0034.34.rdram
#
#  LOOK_FIRST_TREE
#
test035:                        InData/test035.35.rdram.Z
InData/test035.35.rdram.Z:	$(APP)
	gen_rdram 35 InData/test0035.35.rdram
	compress -f InData/test0035.35.rdram
#
#  LOOK_SECOND_TREE
#
test036:                        InData/test036.36.rdram.Z
InData/test036.36.rdram.Z:	$(APP)
	gen_rdram 36 InData/test0036.36.rdram
	compress -f InData/test0036.36.rdram

#
#  texture edge mode test
#
test037:                        InData/test037.37.rdram.Z
InData/test037.37.rdram.Z:	$(APP)
	gen_rdram 37 InData/test0037.37.rdram
	compress -f InData/test0037.37.rdram

#
#  zbuffer range/accuracy test (no anti-aliasing)
#
test038:	InData/test038.38.rdram.Z 
InData/test038.38.rdram.Z:	$(APP)
	gen_rdram 38 InData/test0038.38.rdram
	compress -f InData/test0038.38.rdram
#
#  odd interlaced version of test030
#
test039:	InData/test039.39.rdram.Z
InData/test039.39.rdram.Z:	$(APP)
	gen_rdram 39 InData/test0039.39.rdram
	compress -f InData/test0039.39.rdram
#
#  even interlaced version of test030
#
test040:	InData/test040.40.rdram.Z 
InData/test040.40.rdram.Z:	$(APP)
	gen_rdram 40 InData/test0040.40.rdram
	compress -f InData/test0040.40.rdram

#
#  Rolling doughnuts
#
test041:                        InData/test041.41.rdram.Z
InData/test041.41.rdram.Z:	$(APP)
	gen_rdram 41 InData/test0041.41.rdram
	compress -f InData/test0041.41.rdram

#
#  Random forest, vert strip, 16b
#
test061:	InData/test061.61.rdram.Z
InData/test061.61.rdram.Z:	$(APP)
	gen_rdram 61 InData/test0061.61.rdram
	compress -f InData/test0061.61.rdram

#
#  Random forest, horz strip, 16b
#
test062:	InData/test062.62.rdram.Z 
InData/test062.62.rdram.Z:	$(APP)
	gen_rdram 62 InData/test0062.62.rdram
	compress -f InData/test0062.62.rdram

#
#  Random forest, vert strip, 32b
#
test063:	InData/test063.63.rdram.Z 
InData/test063.63.rdram.Z:	$(APP)
	gen_rdram 63 InData/test0063.63.rdram
	compress -f InData/test0063.63.rdram
#
#  Random forest, horz strip, 32b
#
test064:	InData/test064.64.rdram.Z 
InData/test064.64.rdram.Z:	$(APP)
	gen_rdram 64 InData/test0064.64.rdram
	compress -f InData/test0064.64.rdram
#
#  Fractal terrain
#
test065:	InData/test065.65.rdram.Z InData/test065.65.rdram.Z
InData/test065.65.rdram.Z:	$(APP)
	gen_rdram 65 InData/test0065.65.rdram
	compress -f InData/test0065.65.rdram

#
#  Spinning Torus
#

test066:	InData/test066.16.rdram.Z InData/test066.16.rdram.Z

InData/test066.16.rdram.Z:	$(APP)
	$(EMULATE) -n -s -a "-a -m -s 66 16 -f 66 -n InData/test066" $(APP) rom
	compress -f InData/test066*.rdp

#
#  Spinning "U-64"
#
test067:	InData/test067.67.rdram.Z 

InData/test067.67.rdram.Z:	$(APP)
	$(EMULATE) -n -s -a "-a -m -o 67 -f 67 -n InData/test067" $(APP) rom
	compress -f InData/test067*.rdp
#
#  Texture Font Example
#
test068:	InData/test068.68.rdram.Z
InData/test068.68.rdram.Z:	$(APP)
	gen_rdram 68 InData/test0068.68.rdram
	compress -f InData/test0068.68.rdram

tests:	$(TESTS)

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

#
# Run tests 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)