/**

  * $Id$

  *

  * Tile iterator ADT. Defines an iterator that can be used to iterate through

  * a PVR2 tile list a polygon at a time.

  *

  * Note: The iterator functions are defined here to allow the compiler to

  * inline them if it wants to, but it's not always beneficial to do so

  * (hence we don't force them to be inlined)

  *

  * Copyright (c) 2010 Nathan Keynes.

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation; either version 2 of the License, or

  * (at your option) any later version.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  */

 #ifndef lxdream_tileiter_H

 #define lxdream_tileiter_H 1

 #include <assert.h>

 #include "pvr2/pvr2.h"

 #ifdef __cplusplus

 extern "C" {

 #endif

 /**

  * tileiter: iterator over individual polygons in a tile list.

  */

 typedef struct tileiter {

     uint32_t *ptr;

     unsigned strip_count;

     unsigned poly_size;

     uint32_t poly_addr;

 } tileiter;

 #define TILEITER_IS_MODIFIED(it) ((*(it).ptr) & 0x01000000)

 #define TILEITER_IS_TRIANGLE(it) (((*(it).ptr) >> 29) == 4)

 #define TILEITER_IS_QUAD(it) (((*(it).ptr) >> 29) == 5)

 #define TILEITER_IS_POLY(it) (((*(it).ptr) >> 31) == 0)

 #define TILEITER_POLYADDR(it) ((it).poly_addr)

 #define TILEITER_STRIPCOUNT(it) ((it).strip_count)

 #define TILEITER_DONE(it) ((it).ptr == 0)

 #define TILEITER_BEGIN(it, tileent) (tileiter_init(&it, tileent))

 #define TILEITER_NEXT(it) (tileiter_next(&it))

 #define FOREACH_TILE(it, seg) for( TILEITER_BEGIN(it, seg); !TILEITER_DONE(it); TILEITER_NEXT(it) )

 /**

  * tileentryiter: iterator over entries in the tile list, where each entry is

  * a polygon, triangle set, or quad set.

  */

 typedef struct tileentryiter {

     uint32_t *ptr;

     unsigned strip_count;

 } tileentryiter;

 #define TILEENTRYITER_POLYADDR(it) ((*((it).ptr)) & 0x001FFFFF)

 #define TILEENTRYITER_STRIPCOUNT(it) ((it).strip_count)

 #define TILEENTRYITER_DONE(it) ((it).ptr == 0)

 #define TILEENTRYITER_BEGIN(it, tileent) (tileentryiter_init(&(it),tileent))

 #define TILEENTRYITER_NEXT(it) (tileentryiter_next(&(it)))

 #define FOREACH_TILEENTRY(it,seg) for( TILEENTRYITER_BEGIN(it,seg); !TILEENTRYITER_DONE(it); TILEENTRYITER_NEXT(it) )

 /**************************** tileiter functions ****************************/

 /**

  * Read the entry pointed to by it->ptr into the tileiter structure. If the

  * entry if a list pointer or invalid entry, the pointer will first be

  * updated to the next real entry. On end-of-list, sets ptr to NULL

  */

 static void tileiter_read( tileiter *it )

 {

     for(;;){

         uint32_t entry = *it->ptr;

         uint32_t tag = entry >> 29;

         if( tag == 0x07 ) {

             if( tag & 0x10000000 ) {

                 it->ptr = NULL;

                 return;

             } else {

                 it->ptr = (uint32_t *)(pvr2_main_ram + (entry&0x007FFFFF));

                 it->poly_addr = -1;

                 entry = *it->ptr;

             }

         } else if( tag == 6 ) {

             /* Illegal? Skip */

             it->ptr++;

         } else if( tag & 0x04 ) {

             int vertex_count = tag-1; /* 4 == tri, 5 == quad */

             int vertex_length = (entry >> 21) & 0x07;

             if( (entry & 0x01000000) && (pvr2_scene.shadow_mode == SHADOW_FULL) ) {

                 it->poly_size = 5 + (vertex_length<<1) * vertex_count;

             } else {

                 it->poly_size = 3 + vertex_length * vertex_count;

             }

             it->strip_count = ((entry >> 25) & 0x0F);

             it->poly_addr = entry & 0x001FFFFF;

             return;

         } else {

             /* Other polygon */

             it->strip_count = 0;

             it->poly_addr = entry & 0x001FFFFF;

             return;

         }

     }

 }

 static void tileiter_init( tileiter *it, uint32_t segptr )

 {

     if( IS_TILE_PTR(segptr) ) {

         it->ptr = (uint32_t *)(pvr2_main_ram + (segptr & 0x007FFFFF));

         tileiter_read(it);

     } else {

         it->ptr = 0;

     }

 }

 static inline void tileiter_next( tileiter *it )

 {

     assert( it->ptr != NULL );

     if( it->strip_count > 0 ) {

         it->strip_count--;

         it->poly_addr += it->poly_size;

     } else {

         it->ptr++;

         tileiter_read(it);

     }

 }

 /************************* tileentryiter functions **************************/

 /**

  * Read the entry pointed to by it->ptr, updating the pointer to point

  * to the next real element if the current value is not a polygon entry.

  */

 static void tileentryiter_read( tileentryiter *it )

 {

     for(;;){

         uint32_t entry = *it->ptr;

         uint32_t tag = entry >> 28;

         if( tag < 0x0C ) {

             if( tag & 0x08 ) {

                 it->strip_count = ((entry >> 25) & 0x0F);

             } else {

                 it->strip_count = 0;

             }

             return;

         } else {

             if( tag == 0x0F ) {

                 it->ptr = NULL;

                 return;

             } else if( tag == 0x0E ) {

                 it->ptr = (uint32_t *)(pvr2_main_ram + (entry&0x007FFFFF));

                 entry = *it->ptr;

             } else {

                 /* Illegal? Skip */

                 it->ptr++;

             }

         }

     }

 }

 static void tileentryiter_init( tileentryiter *it, uint32_t segptr )

 {

     if( IS_TILE_PTR(segptr) ) {

         it->ptr = (uint32_t *)(pvr2_main_ram + (segptr & 0x007FFFFF));

         tileentryiter_read(it);

     } else {

         it->ptr = 0;

     }

 }

 static void inline tileentryiter_next( tileentryiter *it )

 {

     it->ptr++;

     tileentryiter_read(it);

 }

 #ifdef __cplusplus

 }

 #endif

 #endif /* !lxdream_tileiter_H */