/**************************************************************************
 *								          *
 *               Copyright (C) 1994, Silicon Graphics, Inc.       	  *
 *								          *
 *  These coded instructions, statements, and computer programs  contain  *
 *  unpublished  proprietary  information of Silicon Graphics, Inc., and  *
 *  are protected by Federal copyright  law.  They  may not be disclosed  *
 *  to  third  parties  or copied or duplicated in any form, in whole or  *
 *  in part, without the prior written consent of Silicon Graphics, Inc.  *
 *								          *
 *************************************************************************/

/*
 * File:		gimm.s
 * Creator:		hsa@sgi.com
 * Create Date:		Fri Jun 24 13:55:27 PDT 1994
 *
 * This file holds the top-level of the IMM command processing, and
 * related routines.
 *
 */

 ############################################################################	
 #
 # The following code processes the IMM type display list commands.
 # Registers on input:	
 #	gfx0	- first word of display list command
 #	gfx1	- second word of display list command
 #	dinp	- points to *next* DL cmd, so back up for this one.
 #	
		.ent	doIMM
doIMM:
	# $2 is shifted in the delay slot of the branch that 
	# brought us here...
		
	# 'switch' to correct IMM command:
		andi	$2, $2, 0xfe		# shifted up 1 for offset
		lh	$2,(IMM_JMP_ADD)($2)

		jr	$2
	# consolidate some of the similar decoding...
		lbu	$1, (0-1)(dinp)	# pick off first field

		.end	doIMM
 #
 #
 #
 ############################################################################	


#ifdef LINE3D
	
 #############################################################################
 #
 # This code handles G_LINE3D. It's basically modified from Steve's triangle
 # code above. It picks off the two vertex indicies and calls the line code 
 #
 #
.name v0,	$1
.name v1,	$2
.name vn,	$4
.name n,	$5

	
		
		.ent 	case_G_LINE3D
			
  case_G_LINE3D:
	# pick off flag field
		lbu	n, (0-4)(dinp)	# which normal?	
	# dinp points to next dl cmd, so back up to get line indices
 		lbu	v0, (0-3)(dinp)
		lbu	v1, (0-2)(dinp)
	# which normal?
		sll	n, n, 2			# word-size offset

	# translate indices into DMEM offsets. Point buffer entries are
	# 40 bytes (yuk!) each... The interface (mbi.h) pre-multiplies
	# the indices by 10, so we just have to multiply by 4.
		sll	v0, v0, 2
		sll	v1, v1, 2

		
		addi	v0, v0, RSP_POINTS_OFFSET
		addi	v1, v1, RSP_POINTS_OFFSET
	
		sw	v0, (0+RSP_SCRATCH_OFFSET)(zero)
		sw	v1, (4+RSP_SCRATCH_OFFSET)(zero)
		lw	vn, RSP_SCRATCH_OFFSET(n)
	
		jal	doClip
		nop   	# delay slot, might do something useful here later
		j	GfxDone
		nop	# delay slot, might do something useful here later
		
		.end	case_G_LINE3D
	
.unname v0
.unname v1
.unname vn
.unname n
 #
 #
 #
 #############################################################################

#else /* LINE3D */
	
 #############################################################################
 #
 # This code handles G_TRI1. It picks off the three vertex indicies and
 # calls the triangle setup code. 
 #
 #
.name v0,		$1
.name v1,		$2
.name v2,		$3
.name vn,		$4
.name n,		$5
.name tmp,		$6

		.ent	case_G_TRI1
	
  case_G_TRI1:	
	# pick off flag field
		lbu	n, (0-4)(dinp)	# which normal?
	# dinp points to next dl cmd, so back up to get tri indices
		lbu	v0, (0-3)(dinp)
		lbu	v1, (0-2)(dinp)
		lbu	v2, (0-1)(dinp)
	# which normal?
		sll	n, n, 2			# word-size offset

	# translate indices into DMEM offsets. Point buffer entries are
	# 40 bytes (yuk!) each... The interface (mbi.h) pre-multiplies
	# the indices by 10, so we just have to multiply by 4.
		sll	v0, v0, 2
		sll	v1, v1, 2
		sll	v2, v2, 2
	
		addi	v0, v0, RSP_POINTS_OFFSET
		addi	v1, v1, RSP_POINTS_OFFSET
		addi	v2, v2, RSP_POINTS_OFFSET
	
		sw	v0, (0+RSP_SCRATCH_OFFSET)(zero)
		sw	v1, (4+RSP_SCRATCH_OFFSET)(zero)
		sw	v2, (8+RSP_SCRATCH_OFFSET)(zero)
		lw	vn, RSP_SCRATCH_OFFSET(n)
	
		j	clipAndSetup
		lh	return_save,GFXDONE(zero)	# return to GfxDone:
		.end	case_G_TRI1

.unname v0
.unname v1
.unname v2
.unname vn
.unname n
.unname tmp
 #
 #
 #
 #############################################################################

#endif /* LINE3D */

	
 #############################################################################
 #
 # This code handles G_POPMTX. It checks the stack depth, backs up the
 # stack pointer, then DMA's the matrix into DMEM, updates the state,
 # and loads the registers.
 # 
 #
.name param,		$1
.name mstack_p,		$19
.name mstack_max,	$3
.name mat_sz,		$18
.name mat_p,		$20
	
		.ent	case_G_POPMTX
	
  case_G_POPMTX:	
	# 'param' already filled in but not used

	# we can only pop the MODELVIEW stack

	# get pointer and stack size
		lw	mstack_p,  RSP_STATE_MMTX_STACK_P(rsp_state)	# stack ptr
		lw	mstack_max, RSP_STATE_MMTX_STACK_MAX(rsp_state)	# end of stack
		addi	mat_p, zero, RSP_CURR_MMTX_OFFSET		# where to DMA matrix
		addi	mat_sz, zero, 63	# DMA expects sz-1	# DMA length -1
		sub	mstack_max, mstack_max, mstack_p		# size of stack
		addi	mstack_max, mstack_max, (-10*64)		#  ... - max size of stck
	
	# check matrix stack depth, bail if == 0
		bgez	mstack_max, GfxDone				# anything on stack?
		addi	mstack_p, mstack_p, -64				# stack is 1 mtx smaller
 ### BRANCH OCCURS TO GfxDone: IF NOTHING ON STACK

		jal	DMAproc						# DMA matrix from stack
		addi	$17, zero, 0					# DMA is a READ
	
		jal	DMAwait						# wait for DMA to finish
		addi    $3, zero, RSP_CURR_MPMTX_OFFSET                 # where to put MP matrix
	
	# update state, then jump to pre-multiply MxP
		j	mtx_MxP						# mult model * proj mtx
		sw	mstack_p,  RSP_STATE_MMTX_STACK_P(rsp_state)	# store new stack size

	
		.end	case_G_POPMTX
.unname param
.unname mstack_p
.unname mstack_max
.unname mat_sz
.unname mat_p
 #
 #
 #
 #############################################################################
	
	
#if 0
 #############################################################################
 #
 # this handles the G_SEGMENT command, parsing off a segment ID and
 # segment base address, which it stores in the RSP segment table.
 #
 #	
.name seg_id, 	$2
.name seg_addr, $3
.name seg_ptr,	$4
.name mask, 	$5
	
		.ent	case_G_SEGMENT
	
  case_G_SEGMENT:	
		lw	mask, SEGADDR_MASK_OFFSET(zero)
		and	seg_addr, gfx1, mask
		srl	seg_id, gfx1, 24	# must clear bits
		sll	seg_ptr, seg_id, 2	# leave mult. by 4 for offset
 		j	GfxDone
		sw	seg_addr, RSP_SEG_OFFSET(seg_ptr)	# delay slot
	
		.end	case_G_SEGMENT
	
.unname seg_id
.unname seg_addr
.unname seg_ptr
.unname mask
 #
 #
 #############################################################################
#endif /* 0 */	
	
 #############################################################################
 #
 # this handles the G_MOVEWORD command, moving 1 word into dmem
 #
 #	
.name target,	$1
.name outptr,	$5
.name offset,	$2
	
		.ent	case_G_MOVEWORD
	
  case_G_MOVEWORD:	
		lbu	target, (0-6)(dinp)		  # index to address
		lbu	offset, (0-5)(dinp)		  # offset from address
		lh	outptr,(MOVEWORD_TBL)(target) # actual address
		add	outptr,outptr,offset		  #   ...plus offset
		j	GfxDone				  #
		sw	gfx1, 0(outptr)			  # store @ addr + off

		.end	case_G_MOVEWORD
	
.unname target
.unname outptr
.unname offset
 #
 #
 #############################################################################
	
	
 #############################################################################
 #
 # This code handles the G_TEXTURE.
 #
 #
.name	rmode, 		$2
.name	mask, 		$3
.name	sscale,		$4
.name	tscale,		$5
.name	tile,		$6
	
		.ent	case_G_TEXTURE
	
  case_G_TEXTURE:	

	# turn texture on or off:
		sw	gfx0, RSP_STATE_TEX_CMD(rsp_state)
		sw	gfx1, RSP_STATE_TEX_SCALE_S(rsp_state)
		lh	rmode, RSP_STATE_RENDER_L(rsp_state)
		andi	rmode, rmode, 0xfffd	# clear texture state
		andi	mask, gfx0, 0x01	# on bit
		sll	mask, mask, 1
		or	rmode, rmode, mask	# set texture on (maybe)
 		j	GfxDone
		sh	rmode, RSP_STATE_RENDER_L(rsp_state)
#if 0
	# turn texture on or off:
		lh	rmode, RSP_STATE_RENDER_L(rsp_state)
		andi	rmode, rmode, 0xfffd	# clear texture state
		andi	mask, gfx1, 0x01	# on bit
		sll	mask, mask, 1
		or	rmode, rmode, mask	# set texture on (maybe)
		sh	rmode, RSP_STATE_RENDER_L(rsp_state)

	# get s & t scale:
 		andi	sscale, gfx0, 0xffff
		srl	tscale, gfx1, 16	
		sh	sscale, RSP_STATE_TEX_SCALE_S(rsp_state)
		sh	tscale, RSP_STATE_TEX_SCALE_T(rsp_state)
	
	# get tile number:
		lbu	tile, (0-2)(dinp)
		
 		j	GfxDone
		sb	tile, RSP_STATE_TEX_TILE(rsp_state) # delay slot
#endif
	
		.end	case_G_TEXTURE
	
.unname	rmode
.unname	mask
.unname	sscale
.unname	tscale
.unname	tile
	
 #############################################################################
 #
 # This code handles G_SETOTHERMODE_*.
 #
 #
.name modewd,	$3
 #		.name mask,	$4
.name mask,	$2
.name lenth,	$5
.name shft,	$6
.name waddr,	$7
.name minus1,	$8
	
		.ent	case_G_OTHERMODE
	
  case_G_SETOTHERMODE_H:
		j	doOtherMode
		addi	waddr, rsp_state, RSP_STATE_OTHER_H # delay slot
	
  case_G_SETOTHERMODE_L:
		addi	waddr, rsp_state, RSP_STATE_OTHER_L
	
		# this code is the same for both OTHERMODE commands...
 	doOtherMode:
		lw	modewd, 0(waddr)
		addi	minus1, zero, -1
	
		lbu	lenth, (0-5)(dinp)
		lbu	shft,  (0-6)(dinp)
	
		addi	mask, zero, 0x01
		sllv	mask, mask, lenth
		addi	mask, mask, -1
		sllv	mask, mask, shft
		xor	mask, mask, minus1
		and	mask, mask, modewd
		or	modewd, mask, gfx1
		sw	modewd, 0(waddr)
	
	# output to RDP
	# writes 64-bits at once. cmd byte already there.
	# use the regular RDP output routine, sharing code.
		lw	gfx0, RSP_STATE_OTHER_H(rsp_state)
		j	doRDPSend
		lw	gfx1, RSP_STATE_OTHER_L(rsp_state)

		.end	case_G_OTHERMODE
	
.unname modewd
.unname mask
.unname lenth
.unname shft
.unname waddr
.unname minus1
 #
 #
 #
 #############################################################################


 #############################################################################
 #
 # This code handles G_CULLDL.
 #
 # Ends display list if vertices n through m are mutually trivially rejected
 # (ie the volume described by these vertices is completely outside of the
 # trivial reject volume).
 #
.name cc,	$2
.name tmp,	$3
	
		.ent	case_G_CULLDL
case_G_CULLDL:
		andi	gfx0, gfx0, 0x3ff		# vertex to start on
		ori	cc, zero, 0xffff		# initialize cc
VolCulLoop:
		lh	tmp, (RSP_POINTS_OFFSET+RSP_PTS_CC)(gfx0)
		addi	gfx0, gfx0, RSP_PTS_LEN
		bne	gfx0, gfx1, VolCulLoop		# loop through vtx's
		and	cc, cc, tmp			# is this vtx clipped?
 ### LOOP OCCURS if not all points have been checked

		beq	cc, zero, GfxDone		# continue if not culled
 # NOTE Delay Slot!!
							# If culled End DL
	
		.end	case_G_CULLDL
.unname cc
.unname tmp
 #
 #
 #
 #############################################################################

 ### IMPORTANT!!!!  Do not place any code betweeen case_G_CULLDL and G_ENDDL

 #############################################################################
 #
 # This code handles G_ENDDL.
 #
 # Causes a 'pop' of the display list stack. If we pop an empty 
 # display list stack, that's an error and we end.
 #
.name stack_sz,	$2
.name stack_p,	$3
	
		.ent	case_G_ENDDL
	
  case_G_ENDDL:	
	# pop display list
		lb	stack_sz, RSP_STATE_DL_N(rsp_state)
		addi	stack_sz, stack_sz, -4
		bltz	stack_sz, TaskDone		# empty stack
		addi	stack_p, stack_sz, RSP_DLSTACK_OFFSET
		lw	inp,     0(stack_p)	# pointer of DL
		sb	stack_sz, RSP_STATE_DL_N(rsp_state)
 		j	GfxDone
		addi	dlcount, zero, 0
	
		.end	case_G_ENDDL
	
.unname stack_sz
.unname stack_p
 #
 #
 #
 #############################################################################

	
 #############################################################################
 #
 # This code handles G_SETGEOMETRYRMODE
 #
 # Any bit set 'on' in the incoming command is 'set' in the state.
 # Assumes gfx1 is all 0's, except some of the lower 16 bits.
 #
.name	rmode, 		$2
	
		.ent	case_G_SETGEOMETRYMODE
	
  case_G_SETGEOMETRYMODE:	
		lw	rmode, RSP_STATE_RENDER(rsp_state)
		or	rmode, rmode, gfx1
 		j	GfxDone
		sw	rmode, RSP_STATE_RENDER(rsp_state) # delay slot
	
		.end	case_G_SETGEOMETRYMODE
	
.unname	rmode
 #
 #
 #
 #############################################################################
	
	
 #############################################################################
 #
 # This code handles G_CLEARGEOMETRYMODE
 #
 # Any bit set 'on' in the incoming command is 'cleared' in the state.
 # Assumes gfx1 is all 0's, except some of the lower 16 bits.
 #
.name	rmode, 		$2
.name	mask, 		$3
	
		.ent	case_G_CLEARGEOMETRYMODE
	
  case_G_CLEARGEOMETRYMODE:	
		lw	rmode, RSP_STATE_RENDER(rsp_state)
		addi	mask, zero, -1
		xor	mask, mask, gfx1
		and	rmode, rmode, mask
 		j	GfxDone
		sw	rmode, RSP_STATE_RENDER(rsp_state) # delay slot
	
		.end	case_G_CLEARGEOMETRYMODE
	
.unname	rmode
.unname	mask
 #
 #
 #
 #############################################################################

 #############################################################################
 #
 # This code handles G_PERSPNORM
 #
 # This magic number is needed to fix the transformation and clip
 # math, extracting the most precision. Grab the scale from gfx1
 # and save it for later.
 #
 		.ent	case_G_PERSPNORM
	
    case_G_PERSPNORM:
 		j	GfxDone
		sh	gfx1, RSP_STATE_PERSPNORM(rsp_state) # delay slot
	
 		.end	case_G_PERSPNORM
 #
 #
 #
 #############################################################################

 #############################################################################
 #
 # This code handles G_RDPHALF_1
 #
 # This received the 3rd quarter of a texrect or texrectflip command
 #
 		.ent	case_G_RDPHALF_1
	
    case_G_RDPHALF_1:
 		j	noYield			   # don't yield mid cmd
		sw	gfx1, RSP_STATE_RDPHALF(rsp_state) # save for later...
	
 		.end	case_G_RDPHALF_1
 #
 #
 #
 #############################################################################

 #############################################################################
 #
 # This code handles G_RDPHALF_CONT
 #
 # This received the 2nd 32 bits of a 64 bit string to send to the RDP.
 # It sends it (using the G_RDPHALF_2 code below) AND disables yield
 # so the data will not get interrupted by a yield.  This shoulb be used
 # only to send data which will be followed by more data from a G_RDPHALF_1
 # and G_RDPHALF_2 pair (or a G_RDPHALF_1 and G_RDPHALF_CONT pair).
 #
 		.ent	case_G_RDPHALF_CONT
	
    case_G_RDPHALF_CONT:
		ori	$2, zero, 0		# disable yield

 		.end	case_G_RDPHALF_CONT
 #
 #
 #
 #############################################################################

 #############################################################################
 #
 # This code handles G_RDPHALF_2
 #
 # This received the 4rd quarter of a texrect or texrectflip command
 # and sends it and the 3rd quarter (ie the 2nd half) to the rdp.
 #
 		.ent	case_G_RDPHALF_2
	
    case_G_RDPHALF_2:
 		j	doRDPSend		   # jmp to send routine
		lw	gfx0, RSP_STATE_RDPHALF(rsp_state) # retrieve 3rd qtr
	
 		.end	case_G_RDPHALF_2
 #
 #
 #
 #############################################################################