/*---------------------------------------------------------------------------* Project: Matrix vector Library File: mtxstack.c Copyright 1998-2001 Nintendo. All rights reserved. These coded instructions, statements, and computer programs contain proprietary information of Nintendo of America Inc. and/or Nintendo Company Ltd., 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 Nintendo. $Log: mtxstack.c,v $ Revision 1.3 2007/01/11 00:45:26 aka Removed win32.h. Revision 1.2 2006/02/20 04:25:42 mitu Changed include path from dolphin/ to revolution/. Revision 1.1.1.1 2005/05/12 02:15:49 yasuh-to Ported from dolphin source tree. 2 2002/04/11 13:11 Hirose const type specifier support. (by Hiratsu@IRD) 1 2001/02/22 11:54p Hirose This section is moved from mtx.c $NoKeywords: $ *---------------------------------------------------------------------------*/ #include #include #include "mtxAssert.h" /*---------------------------------------------------------------------* STACK SECTION *---------------------------------------------------------------------*/ /*---------------------------------------------------------------------* Name: MTXInitStack Description: Initializes a matrix stack size and stack ptr from a previously allocated stack. Arguments: sPtr ptr to MtxStack structure to be initialized. numMtx Number of matrices in the stack. Note: The stack (array) memory must have been previously allocated. MtxVec.h provides a macro ( MTXAllocStack( sPtr, numMtx ) ) to accomplish this using OSAlloc(). Return: None. *---------------------------------------------------------------------*/ void MTXInitStack( MtxStack *sPtr, u32 numMtx ) { ASSERTMSG( (sPtr != 0), MTX_INITSTACK_1 ); ASSERTMSG( (sPtr->stackBase != 0), MTX_INITSTACK_2 ); ASSERTMSG( (numMtx != 0), MTX_INITSTACK_3 ); sPtr->numMtx = numMtx; sPtr->stackPtr = NULL; } /*---------------------------------------------------------------------* Name: MTXPush Description: Copies a matrix to stack pointer + 1. Increment stack pointer. Arguments: sPtr ptr to MtxStack structure. m Matrix to copy into (stack pointer + 1) location. Return: Stack pointer. *---------------------------------------------------------------------*/ MtxPtr MTXPush ( MtxStack *sPtr, const Mtx m ) { ASSERTMSG( (sPtr != 0), MTX_PUSH_1 ); ASSERTMSG( (sPtr->stackBase != 0), MTX_PUSH_2 ); ASSERTMSG( (m != 0), MTX_PUSH_3 ); if( sPtr->stackPtr == NULL ) { sPtr->stackPtr = sPtr->stackBase; MTXCopy( m, sPtr->stackPtr ); } else { // Check for stack overflow if( (u32)((sPtr->stackPtr - sPtr->stackBase) / MTX_PTR_OFFSET) >= (sPtr->numMtx - 1) ) { ASSERTMSG( 0, MTX_PUSH_4 ); } MTXCopy( m, (sPtr->stackPtr + MTX_PTR_OFFSET) ); sPtr->stackPtr += MTX_PTR_OFFSET; } return sPtr->stackPtr; } /*---------------------------------------------------------------------* Name: MTXPushFwd Description: Concatenates a matrix with the current top of the stack, increment the stack ptr and push the resultant matrix to the new top of stack. This is intended for use in building forward transformations, so concatenation is post-order ( top of stack x mtx ) = ( top of stack + 1 ). Arguments: sPtr ptr to MtxStack structure. m Matrix to concatenate with stack ptr and push to stack ptr + 1. Return: Stack pointer. *---------------------------------------------------------------------*/ MtxPtr MTXPushFwd ( MtxStack *sPtr, const Mtx m ) { ASSERTMSG( (sPtr != 0), MTX_PUSHFWD_1 ); ASSERTMSG( (sPtr->stackBase != 0), MTX_PUSHFWD_2 ); ASSERTMSG( (m != 0), MTX_PUSHFWD_3 ); if( sPtr->stackPtr == NULL ) { sPtr->stackPtr = sPtr->stackBase; MTXCopy( m, sPtr->stackPtr ); } else { // Check for stack overflow if( (u32)((sPtr->stackPtr - sPtr->stackBase) / MTX_PTR_OFFSET) >= (sPtr->numMtx - 1) ) { ASSERTMSG( 0, MTX_PUSHFWD_4 ); } MTXConcat( sPtr->stackPtr, m, ( sPtr->stackPtr + MTX_PTR_OFFSET ) ); sPtr->stackPtr += MTX_PTR_OFFSET; } return sPtr->stackPtr; } /*---------------------------------------------------------------------* Name: MTXPushInv Description: Takes a matrix, computes its inverse and concatenates that inverse with the current top of the stack, Increments the stack ptr and pushes the resultant matrix to the new top of stack. This is intended for use in building inverse transformations, so concatenation is pre-order ( mtx x top of stack ) = ( top of stack + 1 ). Arguments: sPtr ptr to MtxStack structure. m Matrix to concatenate with stack ptr and push to stack ptr + 1. m is not modified by this function. Return: Stack pointer. *---------------------------------------------------------------------*/ MtxPtr MTXPushInv ( MtxStack *sPtr, const Mtx m ) { Mtx mInv; ASSERTMSG( (sPtr != 0), MTX_PUSHINV_1 ); ASSERTMSG( (sPtr->stackBase != 0), MTX_PUSHINV_2 ); ASSERTMSG( (m != 0), MTX_PUSHINV_3 ); MTXInverse( m, mInv ); if( sPtr->stackPtr == NULL ) { sPtr->stackPtr = sPtr->stackBase; MTXCopy( mInv, sPtr->stackPtr ); } else { // Check for stack overflow if( (u32)((sPtr->stackPtr - sPtr->stackBase) / MTX_PTR_OFFSET) >= (sPtr->numMtx - 1) ) { ASSERTMSG( 0, MTX_PUSHINV_4 ); } MTXConcat( mInv, sPtr->stackPtr, ( sPtr->stackPtr + MTX_PTR_OFFSET ) ); sPtr->stackPtr += MTX_PTR_OFFSET; } return sPtr->stackPtr; } /*---------------------------------------------------------------------* Name: MTXPushInvXpose Description: Takes a matrix, computes its inverse-transpose and concatenates it with the current top of the stack, increments the stack ptr and pushes the resultant matrix to the new top of stack. This is intended for use in building an inverse-transpose matrix for forward transformations of normals, so concatenation is post-order. ( top of stack x mtx ) = ( top of stack + 1 ). Arguments: sPtr ptr to MtxStack structure. m Matrix to concatenate with stack ptr and push to stack ptr + 1. m is not modified by this function. Return: Stack pointer. *---------------------------------------------------------------------*/ MtxPtr MTXPushInvXpose ( MtxStack *sPtr, const Mtx m ) { Mtx mIT; ASSERTMSG( (sPtr != 0), MTX_PUSHINVXPOSE_1 ); ASSERTMSG( (sPtr->stackBase != 0), MTX_PUSHINVXPOSE_2 ); ASSERTMSG( (m != 0), MTX_PUSHINVXPOSE_3 ); MTXInverse( m, mIT ); MTXTranspose( mIT, mIT ); if( sPtr->stackPtr == NULL ) { sPtr->stackPtr = sPtr->stackBase; MTXCopy( mIT, sPtr->stackPtr ); } else { // Check for stack overflow if( (u32)((sPtr->stackPtr - sPtr->stackBase) / MTX_PTR_OFFSET) >= (sPtr->numMtx - 1) ) { ASSERTMSG( 0, MTX_PUSHINVXPOSE_4 ); } MTXConcat( sPtr->stackPtr, mIT, ( sPtr->stackPtr + MTX_PTR_OFFSET ) ); sPtr->stackPtr += MTX_PTR_OFFSET; } return sPtr->stackPtr; } /*---------------------------------------------------------------------* Name: MTXPop Description: Decrements the stack pointer Arguments: sPtr pointer to stack structure Return: Stack pointer. *---------------------------------------------------------------------*/ MtxPtr MTXPop ( MtxStack *sPtr ) { ASSERTMSG( (sPtr != 0), MTX_POP_1 ); ASSERTMSG( (sPtr->stackBase != 0), MTX_POP_2 ); if( sPtr->stackPtr == NULL ) { return NULL; } else if( sPtr->stackBase == sPtr->stackPtr ) { sPtr->stackPtr = NULL; return NULL; } else { sPtr->stackPtr -= MTX_PTR_OFFSET; return sPtr->stackPtr; } } /*---------------------------------------------------------------------* Name: MTXGetStackPtr Description: Returns the stack pointer Arguments: sPtr pointer to stack structure Return: Stack pointer. *---------------------------------------------------------------------*/ MtxPtr MTXGetStackPtr( const MtxStack *sPtr ) { ASSERTMSG( (sPtr != 0), MTX_GETSTACKPTR_1 ); ASSERTMSG( (sPtr->stackBase != 0), MTX_GETSTACKPTR_2 ); return sPtr->stackPtr; } /*===========================================================================*/