1 /*---------------------------------------------------------------------------*
2 Project: Matrix vector Library
3 File: mtxstack.c
4
5 Copyright 1998-2001 Nintendo. All rights reserved.
6
7 These coded instructions, statements, and computer programs contain
8 proprietary information of Nintendo of America Inc. and/or Nintendo
9 Company Ltd., and are protected by Federal copyright law. They may
10 not be disclosed to third parties or copied or duplicated in any form,
11 in whole or in part, without the prior written consent of Nintendo.
12
13
14 $Log: mtxstack.c,v $
15 Revision 1.3 2007/01/11 00:45:26 aka
16 Removed win32.h.
17
18 Revision 1.2 2006/02/20 04:25:42 mitu
19 Changed include path from dolphin/ to revolution/.
20
21 Revision 1.1.1.1 2005/05/12 02:15:49 yasuh-to
22 Ported from dolphin source tree.
23
24
25 2 2002/04/11 13:11 Hirose
26 const type specifier support. (by Hiratsu@IRD)
27
28 1 2001/02/22 11:54p Hirose
29 This section is moved from mtx.c
30
31 $NoKeywords: $
32 *---------------------------------------------------------------------------*/
33
34 #include <math.h>
35 #include <revolution/mtx.h>
36 #include "mtxAssert.h"
37
38 /*---------------------------------------------------------------------*
39
40
41
42
43
44 STACK SECTION
45
46
47
48
49
50 *---------------------------------------------------------------------*/
51
52
53 /*---------------------------------------------------------------------*
54
55 Name: MTXInitStack
56
57 Description: Initializes a matrix stack size and stack ptr from
58 a previously allocated stack.
59
60
61 Arguments: sPtr ptr to MtxStack structure to be initialized.
62
63 numMtx Number of matrices in the stack.
64
65 Note: The stack (array) memory must have been
66 previously allocated.
67 MtxVec.h provides a macro
68 ( MTXAllocStack( sPtr, numMtx ) )
69 to accomplish this using OSAlloc().
70
71
72
73 Return: None.
74
75 *---------------------------------------------------------------------*/
MTXInitStack(MtxStack * sPtr,u32 numMtx)76 void MTXInitStack( MtxStack *sPtr, u32 numMtx )
77 {
78
79
80 ASSERTMSG( (sPtr != 0), MTX_INITSTACK_1 );
81 ASSERTMSG( (sPtr->stackBase != 0), MTX_INITSTACK_2 );
82 ASSERTMSG( (numMtx != 0), MTX_INITSTACK_3 );
83
84
85 sPtr->numMtx = numMtx;
86 sPtr->stackPtr = NULL;
87
88 }
89
90 /*---------------------------------------------------------------------*
91
92 Name: MTXPush
93
94 Description: Copies a matrix to stack pointer + 1.
95 Increment stack pointer.
96
97
98 Arguments: sPtr ptr to MtxStack structure.
99
100 m Matrix to copy into (stack pointer + 1) location.
101
102
103 Return: Stack pointer.
104
105 *---------------------------------------------------------------------*/
MTXPush(MtxStack * sPtr,const Mtx m)106 MtxPtr MTXPush ( MtxStack *sPtr, const Mtx m )
107 {
108
109
110 ASSERTMSG( (sPtr != 0), MTX_PUSH_1 );
111 ASSERTMSG( (sPtr->stackBase != 0), MTX_PUSH_2 );
112 ASSERTMSG( (m != 0), MTX_PUSH_3 );
113
114
115 if( sPtr->stackPtr == NULL )
116 {
117 sPtr->stackPtr = sPtr->stackBase;
118 MTXCopy( m, sPtr->stackPtr );
119 }
120
121 else
122 {
123 // Check for stack overflow
124 if( (u32)((sPtr->stackPtr - sPtr->stackBase) / MTX_PTR_OFFSET) >=
125 (sPtr->numMtx - 1) )
126 {
127 ASSERTMSG( 0, MTX_PUSH_4 );
128 }
129
130 MTXCopy( m, (sPtr->stackPtr + MTX_PTR_OFFSET) );
131 sPtr->stackPtr += MTX_PTR_OFFSET;
132 }
133
134
135 return sPtr->stackPtr;
136 }
137
138 /*---------------------------------------------------------------------*
139
140 Name: MTXPushFwd
141
142 Description: Concatenates a matrix with the current top of the stack,
143 increment the stack ptr and push the resultant matrix to
144 the new top of stack.
145
146 This is intended for use in building forward transformations,
147 so concatenation is post-order
148 ( top of stack x mtx ) = ( top of stack + 1 ).
149
150
151 Arguments: sPtr ptr to MtxStack structure.
152
153 m Matrix to concatenate with stack ptr and
154 push to stack ptr + 1.
155
156
157 Return: Stack pointer.
158
159 *---------------------------------------------------------------------*/
MTXPushFwd(MtxStack * sPtr,const Mtx m)160 MtxPtr MTXPushFwd ( MtxStack *sPtr, const Mtx m )
161 {
162
163 ASSERTMSG( (sPtr != 0), MTX_PUSHFWD_1 );
164 ASSERTMSG( (sPtr->stackBase != 0), MTX_PUSHFWD_2 );
165 ASSERTMSG( (m != 0), MTX_PUSHFWD_3 );
166
167
168 if( sPtr->stackPtr == NULL )
169 {
170 sPtr->stackPtr = sPtr->stackBase;
171 MTXCopy( m, sPtr->stackPtr );
172 }
173
174 else
175 {
176 // Check for stack overflow
177 if( (u32)((sPtr->stackPtr - sPtr->stackBase) / MTX_PTR_OFFSET) >=
178 (sPtr->numMtx - 1) )
179 {
180 ASSERTMSG( 0, MTX_PUSHFWD_4 );
181 }
182
183 MTXConcat( sPtr->stackPtr, m, ( sPtr->stackPtr + MTX_PTR_OFFSET ) );
184 sPtr->stackPtr += MTX_PTR_OFFSET;
185 }
186
187
188 return sPtr->stackPtr;
189 }
190
191 /*---------------------------------------------------------------------*
192
193 Name: MTXPushInv
194
195 Description: Takes a matrix, computes its inverse and concatenates that
196 inverse with the current top of the stack,
197 Increments the stack ptr and pushes the resultant matrix to
198 the new top of stack.
199
200 This is intended for use in building inverse transformations,
201 so concatenation is pre-order
202 ( mtx x top of stack ) = ( top of stack + 1 ).
203
204
205 Arguments: sPtr ptr to MtxStack structure.
206
207 m Matrix to concatenate with stack ptr and
208 push to stack ptr + 1.
209
210 m is not modified by this function.
211
212
213 Return: Stack pointer.
214
215 *---------------------------------------------------------------------*/
MTXPushInv(MtxStack * sPtr,const Mtx m)216 MtxPtr MTXPushInv ( MtxStack *sPtr, const Mtx m )
217 {
218
219 Mtx mInv;
220
221
222 ASSERTMSG( (sPtr != 0), MTX_PUSHINV_1 );
223 ASSERTMSG( (sPtr->stackBase != 0), MTX_PUSHINV_2 );
224 ASSERTMSG( (m != 0), MTX_PUSHINV_3 );
225
226
227 MTXInverse( m, mInv );
228
229
230 if( sPtr->stackPtr == NULL )
231 {
232 sPtr->stackPtr = sPtr->stackBase;
233 MTXCopy( mInv, sPtr->stackPtr );
234 }
235
236 else
237 {
238 // Check for stack overflow
239 if( (u32)((sPtr->stackPtr - sPtr->stackBase) / MTX_PTR_OFFSET) >=
240 (sPtr->numMtx - 1) )
241 {
242 ASSERTMSG( 0, MTX_PUSHINV_4 );
243 }
244
245 MTXConcat( mInv, sPtr->stackPtr, ( sPtr->stackPtr + MTX_PTR_OFFSET ) );
246 sPtr->stackPtr += MTX_PTR_OFFSET;
247 }
248
249
250 return sPtr->stackPtr;
251 }
252
253 /*---------------------------------------------------------------------*
254
255 Name: MTXPushInvXpose
256
257 Description: Takes a matrix, computes its inverse-transpose and concatenates it
258 with the current top of the stack,
259 increments the stack ptr and pushes the resultant matrix to
260 the new top of stack.
261
262 This is intended for use in building an inverse-transpose
263 matrix for forward transformations of normals, so
264 concatenation is post-order.
265 ( top of stack x mtx ) = ( top of stack + 1 ).
266
267
268 Arguments: sPtr ptr to MtxStack structure.
269
270 m Matrix to concatenate with stack ptr and
271 push to stack ptr + 1.
272
273 m is not modified by this function.
274
275
276 Return: Stack pointer.
277
278 *---------------------------------------------------------------------*/
MTXPushInvXpose(MtxStack * sPtr,const Mtx m)279 MtxPtr MTXPushInvXpose ( MtxStack *sPtr, const Mtx m )
280 {
281
282 Mtx mIT;
283
284
285 ASSERTMSG( (sPtr != 0), MTX_PUSHINVXPOSE_1 );
286 ASSERTMSG( (sPtr->stackBase != 0), MTX_PUSHINVXPOSE_2 );
287 ASSERTMSG( (m != 0), MTX_PUSHINVXPOSE_3 );
288
289
290 MTXInverse( m, mIT );
291 MTXTranspose( mIT, mIT );
292
293
294 if( sPtr->stackPtr == NULL )
295 {
296 sPtr->stackPtr = sPtr->stackBase;
297 MTXCopy( mIT, sPtr->stackPtr );
298 }
299
300 else
301 {
302 // Check for stack overflow
303 if( (u32)((sPtr->stackPtr - sPtr->stackBase) / MTX_PTR_OFFSET) >=
304 (sPtr->numMtx - 1) )
305 {
306 ASSERTMSG( 0, MTX_PUSHINVXPOSE_4 );
307 }
308
309 MTXConcat( sPtr->stackPtr, mIT, ( sPtr->stackPtr + MTX_PTR_OFFSET ) );
310 sPtr->stackPtr += MTX_PTR_OFFSET;
311 }
312
313
314 return sPtr->stackPtr;
315 }
316
317 /*---------------------------------------------------------------------*
318
319 Name: MTXPop
320
321 Description: Decrements the stack pointer
322
323
324 Arguments: sPtr pointer to stack structure
325
326
327 Return: Stack pointer.
328
329 *---------------------------------------------------------------------*/
MTXPop(MtxStack * sPtr)330 MtxPtr MTXPop ( MtxStack *sPtr )
331 {
332
333
334 ASSERTMSG( (sPtr != 0), MTX_POP_1 );
335 ASSERTMSG( (sPtr->stackBase != 0), MTX_POP_2 );
336
337
338 if( sPtr->stackPtr == NULL )
339 {
340 return NULL;
341 }
342
343 else if( sPtr->stackBase == sPtr->stackPtr )
344 {
345 sPtr->stackPtr = NULL;
346 return NULL;
347 }
348 else
349 {
350 sPtr->stackPtr -= MTX_PTR_OFFSET;
351 return sPtr->stackPtr;
352 }
353
354 }
355
356 /*---------------------------------------------------------------------*
357
358 Name: MTXGetStackPtr
359
360 Description: Returns the stack pointer
361
362
363 Arguments: sPtr pointer to stack structure
364
365
366 Return: Stack pointer.
367
368 *---------------------------------------------------------------------*/
MTXGetStackPtr(const MtxStack * sPtr)369 MtxPtr MTXGetStackPtr( const MtxStack *sPtr )
370 {
371
372 ASSERTMSG( (sPtr != 0), MTX_GETSTACKPTR_1 );
373 ASSERTMSG( (sPtr->stackBase != 0), MTX_GETSTACKPTR_2 );
374
375 return sPtr->stackPtr;
376
377 }
378
379
380 /*===========================================================================*/
381