Ignore:
Timestamp:
06/16/06 16:56:05 (19 years ago)
Author:
gumbau
Message:

Improved Foliage class

Location:
GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/leaves
Files:
2 deleted
3 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/leaves/Hoja.cpp

    r985 r1019  
    11#include <math.h> 
    2 #include "Hoja.h" 
     2#include "Leaf.h" 
    33 
    44//-------------------------------------------------------------------------------------------------------------------------------- 
    … …  
    66// Parameters --> None 
    77//-------------------------------------------------------------------------------------------------------------------------------- 
    8 Hoja::Hoja(void)  
     8Leaf::Leaf(void)  
    99{        
    10         Vert_Hoja[0] = Vert_Hoja[1] = Vert_Hoja[2] = Vert_Hoja[3] =0;  
    11         Centro[0] = Centro[1] = Centro[2] = 0; 
    12         Normal[0] = Normal[1] = Normal[2] = 0; 
    13         hoja_cerca=-1; 
    14         Cuantas_hojas = 1; 
     10        vertsLeaf[0] = vertsLeaf[1] = vertsLeaf[2] = vertsLeaf[3] =0;  
     11        center[0] = center[1] = center[2] = 0; 
     12        normal[0] = normal[1] = normal[2] = 0; 
     13        leafNear=-1; 
     14        parentLeafCount = 1; 
    1515        dist = -1; 
    1616        coplanar = -1; 
    17         criterio = -1; 
    18         hoja_cop = -1; 
    19         hoja_crit =-1; 
    20         existe = false; 
    21         padre=-1; 
    22         hijoi = hijod = -1; 
    23         raiz= visible= -1; 
     17        criteria = -1; 
     18        leafCop = -1; 
     19        leafCrit =-1; 
     20        exists = false; 
     21        parent=-1; 
     22        childLeft = childRight = -1; 
     23        root = visible= -1; 
    2424} 
    2525 
    … …  
    2727//-------------------------------------------------------------------------------------------------------------------------------- 
    2828// Copy constructor 
    29 // Parameters --> const Hoja& aHoja : The Hoja to copy 
    3029//-------------------------------------------------------------------------------------------------------------------------------- 
    31 Hoja::Hoja (const Hoja& aHoja) 
     30Leaf::Leaf (const Leaf& aLeaf) 
    3231{ 
    33         Cuantas_hojas = aHoja.Cuantas_hojas;; 
    34         hoja_cerca = aHoja.hoja_cerca; 
    35         hoja_crit = aHoja.hoja_crit; 
    36         dist = aHoja.dist; 
    37         existe = aHoja.existe; 
    38         coplanar = aHoja.coplanar; 
    39         hoja_cop = aHoja.hoja_cop; 
    40         criterio = aHoja.criterio; 
     32        parentLeafCount = aLeaf.parentLeafCount;; 
     33        leafNear = aLeaf.leafNear; 
     34        leafCrit = aLeaf.leafCrit; 
     35        dist = aLeaf.dist; 
     36        exists = aLeaf.exists; 
     37        coplanar = aLeaf.coplanar; 
     38        leafCop = aLeaf.leafCop; 
     39        criteria = aLeaf.criteria; 
    4140        for ( int i=0;i<3;i++){ 
    42                 Centro[i] = aHoja.Centro[i]; 
    43                 Normal[i] = aHoja.Normal[i]; 
     41                center[i] = aLeaf.center[i]; 
     42                normal[i] = aLeaf.normal[i]; 
    4443        } 
    4544        for (i = 0L; i < 4; i++) 
    46                 Vert_Hoja[i] = aHoja.Vert_Hoja[i];  
     45                vertsLeaf[i] = aLeaf.vertsLeaf[i];  
    4746         
    48         padre = aHoja.padre; 
    49         hijoi = aHoja.hijoi; 
    50         hijod = aHoja.hijod; 
    51         visible = aHoja.visible; 
    52         raiz = aHoja.raiz; 
     47        parent = aLeaf.parent; 
     48        childLeft = aLeaf.childLeft; 
     49        childRight = aLeaf.childRight; 
     50        visible = aLeaf.visible; 
     51        root = aLeaf.root; 
    5352} 
    5453 
    … …  
    5857// Destructor. We must deallocate the memory allocated for pointers to vertices and edges 
    5958//-------------------------------------------------------------------------------------------------------------------------------- 
    60 Hoja::~Hoja (void) 
     59Leaf::~Leaf (void) 
    6160{ 
    6261} 
    … …  
    6766//-------------------------------------------------------------------------------------------------------------------------------- 
    6867 
    69 float Hoja::Distancia (Hoja& Hoja1) 
     68float Leaf::Distance (Leaf& leaf) 
    7069{ 
    7170        float dist =0; 
    7271        float x1,y1,z1; 
    7372 
    74         x1 = Hoja1.Centro[0]; y1 = Hoja1.Centro[1] ; z1 = Hoja1.Centro[2]; 
     73        x1 = leaf.center[0]; y1 = leaf.center[1] ; z1 = leaf.center[2]; 
    7574 
    7675 
    77         //DISTANCIA ENTRE CENTROS 
     76        //DISTANCIA BETWEEN CENTERS 
    7877 
    79         dist = ((Centro[0]-x1)*(Centro[0]-x1)) + ((Centro[1]-y1)*(Centro[1]-y1)) + ((Centro[2]-z1)*(Centro[2]-z1)); 
     78        dist = ((center[0]-x1)*(center[0]-x1)) + ((center[1]-y1)*(center[1]-y1)) + ((center[2]-z1)*(center[2]-z1)); 
    8079 
    81         return (dist); 
     80        return dist; 
    8281} 
    8382 
    … …  
    8786//-------------------------------------------------------------------------------------------------------------------------------- 
    8887 
    89 float Hoja::Coplanaridad (Hoja& Hoja1) 
     88float Leaf::Coplanarity (Leaf& leaf) 
    9089{ 
    9190        float cop =0; 
    … …  
    9594 
    9695        //hoja pasada como parametro, normalizo las componentes 
    97         x1 = Hoja1.Normal[0]; y1 = Hoja1.Normal[1] ; z1 = Hoja1.Normal[2]; 
     96        x1 = leaf.normal[0]; y1 = leaf.normal[1] ; z1 = leaf.normal[2]; 
    9897        modulo1 = sqrt ( (x1*x1) + (y1*y1) + (z1*z1)); 
    9998        nx1 = x1 / modulo1; 
    … …  
    103102        // hoja desde la que llamo 
    104103 
    105         modulo2 = sqrt ( (Normal[0]*Normal[0]) + (Normal[1]*Normal[1]) + (Normal[2]*Normal[2])); 
    106         nx = Normal[0] / modulo2; 
    107         ny = Normal[1] / modulo2; 
    108         nz = Normal[2] / modulo2; 
     104        modulo2 = sqrt ( (normal[0]*normal[0]) + (normal[1]*normal[1]) + (normal[2]*normal[2])); 
     105        nx = normal[0] / modulo2; 
     106        ny = normal[1] / modulo2; 
     107        nz = normal[2] / modulo2; 
    109108 
    110109        // producto escalar : si es proximo a 0, perpendiculares, a 1, coplanares 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/leaves/foliage.cpp

    r985 r1019  
    1 //#include <GL\glut.h> 
    21#include <stdio.h> 
    32#include <string.h> 
    43#include <math.h> 
    5 //#include <vl\VLf.h> 
    64 
    75#include "Foliage.h" 
    … …  
    1311// Parameters --> None 
    1412//-------------------------------------------------------------------------------------------------------------------------------- 
    15 Foliage::Foliage(void):  MiArbol(NULL), Acth(NULL) 
    16 { 
    17          ppio= final = -1; 
    18 } 
    19  
    20  
    21 //-------------------------------------------------------------------------------------------------------------------------------- 
    22 // Constructor with the name of a file cotaining the data 
    23 //-------------------------------------------------------------------------------------------------------------------------------- 
    24 Foliage::Foliage ( Arbol *Arbol1) 
    25 { 
     13Foliage::Foliage(const Geometry::SubMesh *leavesSubMesh, const char *simpSeq, Geometry::CREATEVERTEXDATAFUNC vdfun, Geometry::CREATEINDEXDATAFUNC idfun):  
     14Acth(NULL), 
     15create_vertex_data_func(vdfun==NULL?Geometry::DefaultVertexDataCreator:vdfun), 
     16create_index_data_func(idfun==NULL?Geometry::DefaultIndexDataCreator:idfun), 
     17vertexdata(NULL), Leaves(NULL), MinDet(NULL) 
     18{ 
     19        cx = cy= cz= 0; 
     20        ppio= final = -1; 
     21 
     22        ReadVertices(leavesSubMesh); 
     23        ReadLeafs(leavesSubMesh); 
     24        if (!ReadSimpSeq(simpSeq)) exit(1); 
     25        RellenoRaiz(); 
     26        CalculaTexCoordsYNorms(); 
     27 
     28 
     29        // esto no sé si devería haber akí 
     30        indexdata->SetNumValidIndices(0); 
     31 
    2632        int h=0; 
    2733 
    2834 
    29         MiArbol = Arbol1; 
    30  
    31         Acth  = new Activas[(MiArbol->nHojas)*8]; 
    32  
    33         for ( h=0; h < MiArbol->nHojas; h++) { 
     35        Acth  = new Activas[nHojas*8]; 
     36 
     37        for ( h=0; h < nHojas; h++) { 
    3438 
    3539                Acth[h].indice = h; 
    … …  
    4347                                 
    4448        ppio = 0; 
     49        final = nHojas-1; 
     50        nhactivas = nHojas; 
     51 
     52} 
     53 
     54/* 
     55//-------------------------------------------------------------------------------------------------------------------------------- 
     56// Constructor with the name of a file cotaining the data 
     57//-------------------------------------------------------------------------------------------------------------------------------- 
     58Foliage::Foliage ( Arbol *Arbol1) 
     59{ 
     60        int h=0; 
     61 
     62 
     63        MiArbol = Arbol1; 
     64 
     65        Acth  = new Activas[(MiArbol->nHojas)*8]; 
     66 
     67        for ( h=0; h < MiArbol->nHojas; h++) { 
     68 
     69                Acth[h].indice = h; 
     70                if ( h != 0) 
     71                { 
     72                        Acth[h].prev = (h-1); 
     73                        Acth[h-1].next = h; 
     74                } 
     75 
     76        } 
     77                                 
     78        ppio = 0; 
    4579        final = (MiArbol->nHojas)-1; 
    4680        nhactivas = MiArbol->nHojas; 
    … …  
    4882 
    4983 
    50 } 
     84}*/ 
    5185 
    5286//-------------------------------------------------------------------------------------------------------------------------------- 
    … …  
    5589Foliage::~Foliage (void) 
    5690{ 
    57         delete MiArbol; 
     91        if (vertexdata) delete vertexdata; 
     92        if (indexdata) delete indexdata; 
     93        delete[] Leaves; 
     94        delete MinDet; 
    5895        delete Acth; 
    5996} 
    … …  
    71108        glBegin (GL_TRIANGLE_STRIP); 
    72109                glNormal3fv (aHoja.Normal); 
    73                 MiArbol->Vertices[aHoja.Vert_Hoja[0]].GetCoordinates (a,b,c); 
     110                MiArbol->Vertices[aHoja.vertsLeaf[0]].GetCoordinates (a,b,c); 
    74111                glTexCoord2f ( 0.0, 0.0); 
    75112 
    76113                glVertex3f (a,b,c); 
    77114 
    78                 MiArbol->Vertices[aHoja.Vert_Hoja[1]].GetCoordinates (a,b,c); 
     115                MiArbol->Vertices[aHoja.vertsLeaf[1]].GetCoordinates (a,b,c); 
    79116                glTexCoord2f ( 0.0, 1.0); 
    80117                glVertex3f (a,b,c); 
    81118         
    82                 MiArbol->Vertices[aHoja.Vert_Hoja[2]].GetCoordinates (a,b,c); 
     119                MiArbol->Vertices[aHoja.vertsLeaf[2]].GetCoordinates (a,b,c); 
    83120                glTexCoord2f ( 1.0, 0.0); 
    84121                glVertex3f (a,b,c); 
    85122 
    86                 MiArbol->Vertices[aHoja.Vert_Hoja[3]].GetCoordinates (a,b,c); 
     123                MiArbol->Vertices[aHoja.vertsLeaf[3]].GetCoordinates (a,b,c); 
    87124                glTexCoord2f ( 1.0, 1.0); 
    88125                glVertex3f (a,b,c); 
    … …  
    236273 
    237274        i = 0; 
    238         while ( MiArbol->MinDet[i].indice != -1) 
    239         { 
    240                 j = MiArbol->MinDet[i].indice; 
     275        while ( MinDet[i].indice != -1) 
     276        { 
     277                j = MinDet[i].indice; 
    241278                if (LeafinFrustum ( j, frustum) == true) { 
    242                 //      printf("dentro %i y el padre es %i\n", j, MiArbol->Hojas[MiArbol->MinDet[i].indice].padre); 
    243                         MiArbol->Hojas[j].visible = 1; 
     279                //      printf("dentro %i y el padre es %i\n", j, MiArbol->Hojas[MiArbol->MinDet[i].indice].parent); 
     280                        Leaves[j].visible = 1; 
    244281                } 
    245282                else   
    246283                { 
    247284                //      printf("fuera %i\n", j); 
    248                         MiArbol->Hojas[j].visible = 0; 
     285                        Leaves[j].visible = 0; 
    249286                } 
    250287 
    … …  
    269306        for (j =0; j<4; j++) 
    270307        { 
    271 //              MiArbol->Vertices[MiArbol->Hojas[i].Vert_Hoja[j]].GetCoordinates (a,b,c); 
    272                 MiArbol->vertexdata->GetVertexCoord(MiArbol->Hojas[i].Vert_Hoja[j],a,b,c); 
     308//              MiArbol->Vertices[MiArbol->Hojas[i].vertsLeaf[j]].GetCoordinates (a,b,c); 
     309                vertexdata->GetVertexCoord(Leaves[i].vertsLeaf[j],a,b,c); 
    273310                v[0]=a; v[1]=b; v[2]=c; v[3]=1; 
    274311 
    … …  
    336373 
    337374 
    338 bool Foliage::Criterio ( Hoja &aHoja,  char ch, float rva, float rvb,float rvc, float rvd, float radio) 
     375bool Foliage::Criterio ( Leaf &aLeaf,  char ch, float rva, float rvb,float rvc, float rvd, float radio) 
    339376{ 
    340377        float a,b,c; // coordenadas del primero de los vertices en la hoja 
    … …  
    346383        float ccx, ccy, ccz; 
    347384 
    348          
    349  
    350 //      MiArbol->Vertices[aHoja.Vert_Hoja[0]].GetCoordinates (a,b,c); 
    351         MiArbol->vertexdata->GetVertexCoord(aHoja.Vert_Hoja[0],a,b,c); 
    352  
    353         ccx = MiArbol->cx; 
    354         ccy = MiArbol->cy; 
    355         ccz = MiArbol->cz; 
    356  
     385        vertexdata->GetVertexCoord(aLeaf.vertsLeaf[0],a,b,c); 
     386 
     387        ccx = cx; 
     388        ccy = cy; 
     389        ccz = cz; 
    357390 
    358391        if ( (ch == 'p') || (ch == 'd')) 
    … …  
    361394        if (DondeEsta (a,b,c, rva,rvb,rvc,rvd) == 1) 
    362395        { 
    363 //              MiArbol->Vertices[aHoja.Vert_Hoja[1]].GetCoordinates (d,e,f); 
    364                 MiArbol->vertexdata->GetVertexCoord(aHoja.Vert_Hoja[1],d,e,f); 
     396//              MiArbol->Vertices[aHoja.vertsLeaf[1]].GetCoordinates (d,e,f); 
     397                vertexdata->GetVertexCoord(aLeaf.vertsLeaf[1],d,e,f); 
    365398                if (DondeEsta (d,e,f, rva,rvb,rvc,rvd) == 1) 
    366399                { 
    367 //                      MiArbol->Vertices[aHoja.Vert_Hoja[2]].GetCoordinates (g,h,i); 
    368                         MiArbol->vertexdata->GetVertexCoord(aHoja.Vert_Hoja[2],g,h,i); 
     400//                      MiArbol->Vertices[aHoja.vertsLeaf[2]].GetCoordinates (g,h,i); 
     401                        vertexdata->GetVertexCoord(aLeaf.vertsLeaf[2],g,h,i); 
    369402                        if (DondeEsta (g,h,i, rva,rvb,rvc,rvd) == 1) 
    370403                        { 
    371 //                              MiArbol->Vertices[aHoja.Vert_Hoja[3]].GetCoordinates (j,k,l); 
    372                                 MiArbol->vertexdata->GetVertexCoord(aHoja.Vert_Hoja[3],j,k,l); 
     404//                              Vertices[aHoja.vertsLeaf[3]].GetCoordinates (j,k,l); 
     405                                vertexdata->GetVertexCoord(aLeaf.vertsLeaf[3],j,k,l); 
    373406                                if (DondeEsta (j,k,l, rva,rvb,rvc,rvd) == 1) inter = true; 
    374407                        } 
    … …  
    388421 
    389422        { 
    390 //              MiArbol->Vertices[aHoja.Vert_Hoja[1]].GetCoordinates (a,b,c); 
    391                 MiArbol->vertexdata->GetVertexCoord(aHoja.Vert_Hoja[1],a,b,c); 
     423//              MiArbol->Vertices[aHoja.vertsLeaf[1]].GetCoordinates (a,b,c); 
     424                vertexdata->GetVertexCoord(aLeaf.vertsLeaf[1],a,b,c); 
    392425                dist =(float)sqrt ((a-ccx)*(a-ccx)+ (b-ccy)*(b-ccy)+ (c-ccz)*(c-ccz)); 
    393426 
    394427                if (dist >  radio) 
    395428                { 
    396 //                      MiArbol->Vertices[aHoja.Vert_Hoja[2]].GetCoordinates (a,b,c); 
    397                         MiArbol->vertexdata->GetVertexCoord(aHoja.Vert_Hoja[2],a,b,c); 
     429//                      MiArbol->Vertices[aHoja.vertsLeaf[2]].GetCoordinates (a,b,c); 
     430                        vertexdata->GetVertexCoord(aLeaf.vertsLeaf[2],a,b,c); 
    398431                        dist =(float)sqrt ((a-ccx)*(a-ccx)+ (b-ccy)*(b-ccy)+ (c-ccz)*(c-ccz)); 
    399432 
    400433                        if (dist >  radio) 
    401434                        { 
    402 //                              MiArbol->Vertices[aHoja.Vert_Hoja[3]].GetCoordinates (a,b,c); 
    403                                 MiArbol->vertexdata->GetVertexCoord(aHoja.Vert_Hoja[3],a,b,c); 
     435//                              MiArbol->Vertices[aHoja.vertsLeaf[3]].GetCoordinates (a,b,c); 
     436                                vertexdata->GetVertexCoord(aLeaf.vertsLeaf[3],a,b,c); 
    404437                                dist =(float)sqrt ((a-ccx)*(a-ccx)+ (b-ccy)*(b-ccy)+ (c-ccz)*(c-ccz)); 
    405438 
    … …  
    442475        spli = -1; 
    443476 
    444         renvol = MiArbol->rad; 
    445         centroz = MiArbol->cz; 
     477        renvol = rad; 
     478        centroz = cz; 
    446479//      printf (" el centro en %f y el radio es de %f\n", centroz, renvol); 
    447480 
    … …  
    473506                //COLAPSAR 
    474507 
    475                 if (( Criterio ( MiArbol->Hojas[i], ch, rva,rvb,rvc,rvd, radio )== false) && (MiArbol->Hojas[i].padre != -1))  
     508                if (( Criterio ( Leaves[i], ch, rva,rvb,rvc,rvd, radio )== false) && (Leaves[i].parent != -1))  
    476509                { 
    477510                        // SI ESTA FUESE LA HOJA IZQUIERDA Y LA DERECHA NO CUMPLE TAMPOCO EL CRITERIO 
    478                         if ((MiArbol->Hojas[MiArbol->Hojas[i].padre].hijoi == i) && 
    479                                 ( Criterio (MiArbol->Hojas[MiArbol->Hojas[MiArbol->Hojas[i].padre].hijod] , ch, rva,rvb,rvc,rvd, radio )== false)) 
     511                        if ((Leaves[Leaves[i].parent].childLeft == i) && 
     512                                ( Criterio (Leaves[Leaves[Leaves[i].parent].childRight] , ch, rva,rvb,rvc,rvd, radio )== false)) 
    480513                        {       //hay que colapsar 
    481                                 if (EsActivo(MiArbol->Hojas[MiArbol->Hojas[i].padre].hijod) == false) 
    482                                         lista = Forzar_Colapse (MiArbol->Hojas[MiArbol->Hojas[i].padre].hijod, hpost, ch, rva,rvb,rvc,rvd, radio); // para activarla 
     514                                if (EsActivo(Leaves[Leaves[i].parent].childRight) == false) 
     515                                        lista = Forzar_Colapse (Leaves[Leaves[i].parent].childRight, hpost, ch, rva,rvb,rvc,rvd, radio); // para activarla 
    483516                                else lista = true; 
    484517                                                                         
    … …  
    486519                        else 
    487520                        // SI ESTA FUESE LA HOJA DERECHA Y LA IZQUIERDA NO CUMPLE TAMPOCO EL CRITERIO 
    488                         if ((MiArbol->Hojas[MiArbol->Hojas[i].padre].hijod == i) && 
    489                                 ( Criterio (MiArbol->Hojas[MiArbol->Hojas[MiArbol->Hojas[i].padre].hijoi] , ch, rva,rvb,rvc,rvd, radio )== false)) 
     521                        if ((Leaves[Leaves[i].parent].childRight == i) && 
     522                                ( Criterio (Leaves[Leaves[Leaves[i].parent].childLeft] , ch, rva,rvb,rvc,rvd, radio )== false)) 
    490523                        {//hay que colapsar 
    491                                 if (EsActivo(MiArbol->Hojas[MiArbol->Hojas[i].padre].hijoi) == false) 
    492                                          lista = Forzar_Colapse (MiArbol->Hojas[MiArbol->Hojas[i].padre].hijoi, hpost,  ch, rva,rvb,rvc,rvd, radio); // para activarla 
     524                                if (EsActivo(Leaves[Leaves[i].parent].childLeft) == false) 
     525                                         lista = Forzar_Colapse (Leaves[Leaves[i].parent].childLeft, hpost,  ch, rva,rvb,rvc,rvd, radio); // para activarla 
    493526                                else  lista = true; 
    494527                                         
    … …  
    501534                                lista = false; 
    502535                                 
    503                                         ColapsaHoja ( MiArbol->Hojas[i].padre, hpost); 
     536                                        ColapsaHoja ( Leaves[i].parent, hpost); 
    504537                        } 
    505538                                         
    … …  
    535568 
    536569        //actualizo los punteros del ppio y del final, y post 
    537         while (( ppio == MiArbol->Hojas[h].hijoi) || ( ppio == MiArbol->Hojas[h].hijod)) 
     570        while (( ppio == Leaves[h].childLeft) || ( ppio == Leaves[h].childRight)) 
    538571                ppio = Acth[ppio].next; 
    539         while (( final == MiArbol->Hojas[h].hijoi) || ( final == MiArbol->Hojas[h].hijod)) 
     572        while (( final == Leaves[h].childLeft) || ( final == Leaves[h].childRight)) 
    540573                 final = Acth[final].prev;  
    541574 
    542         while (( post == MiArbol->Hojas[h].hijoi) || ( post == MiArbol->Hojas[h].hijod)) 
     575        while (( post == Leaves[h].childLeft) || ( post == Leaves[h].childRight)) 
    543576                 post = Acth[post].next;  
    544577 
    … …  
    547580        //COLAPSAR = QUITO DOS DE ACTIVOS PONGO UNO A ACTIVO 
    548581 
    549         if (Acth[MiArbol->Hojas[h].hijoi].next != -1) 
    550                 Acth[Acth[MiArbol->Hojas[h].hijoi].next].prev = Acth[MiArbol->Hojas[h].hijoi].prev; 
    551         if (Acth[MiArbol->Hojas[h].hijoi].prev != -1) 
    552                 Acth[Acth[MiArbol->Hojas[h].hijoi].prev].next = Acth[MiArbol->Hojas[h].hijoi].next; 
    553  
    554         if (Acth[MiArbol->Hojas[h].hijod].next != -1) 
    555                 Acth[Acth[MiArbol->Hojas[h].hijod].next].prev = Acth[MiArbol->Hojas[h].hijod].prev; 
    556         if (Acth[MiArbol->Hojas[h].hijod].prev != -1) 
    557                 Acth[Acth[MiArbol->Hojas[h].hijod].prev].next = Acth[MiArbol->Hojas[h].hijod].next; 
     582        if (Acth[Leaves[h].childLeft].next != -1) 
     583                Acth[Acth[Leaves[h].childLeft].next].prev = Acth[Leaves[h].childLeft].prev; 
     584        if (Acth[Leaves[h].childLeft].prev != -1) 
     585                Acth[Acth[Leaves[h].childLeft].prev].next = Acth[Leaves[h].childLeft].next; 
     586 
     587        if (Acth[Leaves[h].childRight].next != -1) 
     588                Acth[Acth[Leaves[h].childRight].next].prev = Acth[Leaves[h].childRight].prev; 
     589        if (Acth[Leaves[h].childRight].prev != -1) 
     590                Acth[Acth[Leaves[h].childRight].prev].next = Acth[Leaves[h].childRight].next; 
    558591 
    559592         
    560593        //  desconecto a los hijos 
    561         Acth[MiArbol->Hojas[h].hijoi].prev = -1; 
    562         Acth[MiArbol->Hojas[h].hijoi].next = -1; 
    563         Acth[MiArbol->Hojas[h].hijod].prev = -1; 
    564         Acth[MiArbol->Hojas[h].hijod].next = -1; 
     594        Acth[Leaves[h].childLeft].prev = -1; 
     595        Acth[Leaves[h].childLeft].next = -1; 
     596        Acth[Leaves[h].childRight].prev = -1; 
     597        Acth[Leaves[h].childRight].next = -1; 
    565598 
    566599        //añado al final 
    … …  
    596629                 
    597630                h = listah.GetCola ();//coger la cola 
    598                 if (MiArbol->Hojas[h].hijoi != -1)  
    599  
    600                 { if (!EsActivo (MiArbol->Hojas[h].hijoi )) 
    601                         listah.Inserta (MiArbol->Hojas[h].hijoi); 
     631                if (Leaves[h].childLeft != -1)  
     632 
     633                { if (!EsActivo (Leaves[h].childLeft )) 
     634                        listah.Inserta (Leaves[h].childLeft); 
    602635                         
    603                   if ( (!EsActivo (MiArbol->Hojas[h].hijod)) )   
    604                         listah.Inserta (MiArbol->Hojas[h].hijod); 
    605                  
    606                   if (EsActivo (MiArbol->Hojas[h].hijoi) && EsActivo (MiArbol->Hojas[h].hijod ))  
    607                           if((Criterio ( MiArbol->Hojas[MiArbol->Hojas[h].hijoi] ,ch, rva,rvb,rvc,rvd, radio )== false) && 
    608                                   (Criterio ( MiArbol->Hojas[MiArbol->Hojas[h].hijod], ch, rva,rvb,rvc,rvd, radio ) == false)) 
     636                  if ( (!EsActivo (Leaves[h].childRight)) )      
     637                        listah.Inserta (Leaves[h].childRight); 
     638                 
     639                  if (EsActivo (Leaves[h].childLeft) && EsActivo (Leaves[h].childRight ))  
     640                          if((Criterio ( Leaves[Leaves[h].childLeft] ,ch, rva,rvb,rvc,rvd, radio )== false) && 
     641                                  (Criterio ( Leaves[Leaves[h].childRight], ch, rva,rvb,rvc,rvd, radio ) == false)) 
    609642                        { 
    610643                        ColapsaHoja ( h, hpost); 
    … …  
    642675 
    643676        // 1 enlazo los hijos  
    644         Acth[MiArbol->Hojas[h].hijoi].next = MiArbol->Hojas[h].hijod; 
    645         Acth[MiArbol->Hojas[h].hijod].prev = MiArbol->Hojas[h].hijoi; 
    646         Acth[MiArbol->Hojas[h].hijod].next = -1; 
     677        Acth[Leaves[h].childLeft].next = Leaves[h].childRight; 
     678        Acth[Leaves[h].childRight].prev = Leaves[h].childLeft; 
     679        Acth[Leaves[h].childRight].next = -1; 
    647680 
    648681        //y desconecto al padre 
    … …  
    655688         
    656689        //añado al final los hijos  
    657         Acth[MiArbol->Hojas[h].hijoi].prev = final; 
    658         Acth[final].next = MiArbol->Hojas[h].hijoi; 
    659         final = MiArbol->Hojas[h].hijod; 
     690        Acth[Leaves[h].childLeft].prev = final; 
     691        Acth[final].next = Leaves[h].childLeft; 
     692        final = Leaves[h].childRight; 
    660693 
    661694} 
    … …  
    676709        nodo = -1; 
    677710 
    678         if (MiArbol->Hojas[h].hijoi != -1)  
     711        if (Leaves[h].childLeft != -1)  
    679712 
    680713        {  // si el hijo derecho o el izquierdo están en la zona de máximo detalle, haré que estos se activen    
    681                   if ( (Criterio (MiArbol->Hojas[MiArbol->Hojas[h].hijoi],  ch, rva,rvb,rvc,rvd, radio ) == true) || 
    682                           (Criterio (MiArbol->Hojas[MiArbol->Hojas[h].hijod], ch, rva,rvb,rvc,rvd, radio ) == true)) 
     714                  if ( (Criterio (Leaves[Leaves[h].childLeft],  ch, rva,rvb,rvc,rvd, radio ) == true) || 
     715                          (Criterio (Leaves[Leaves[h].childRight], ch, rva,rvb,rvc,rvd, radio ) == true)) 
    683716                         
    684                                 nodo = MiArbol->Hojas[h].hijoi;  
     717                                nodo = Leaves[h].childLeft;  
    685718                         
    686719                        else // si no, bajo un nivel más hasta encontrar algún descendiente que se encuentre en la zona de + detalle 
    687720                        { 
    688                                 nodo = Chequea_Split (MiArbol->Hojas[h].hijoi,  ch, rva,rvb,rvc,rvd, radio); 
    689                                 if ( nodo == -1 ) nodo = Chequea_Split (MiArbol->Hojas[h].hijod, ch, rva,rvb,rvc,rvd, radio); 
     721                                nodo = Chequea_Split (Leaves[h].childLeft,  ch, rva,rvb,rvc,rvd, radio); 
     722                                if ( nodo == -1 ) nodo = Chequea_Split (Leaves[h].childRight, ch, rva,rvb,rvc,rvd, radio); 
    690723                        } 
    691724                                   
    … …  
    711744 
    712745        bien = false; 
    713         h = MiArbol->Hojas[hoja].padre; 
     746        h = Leaves[hoja].parent; 
    714747        listah.Inserta (h); // Inserta un dato en la lista 
    715748 
    716749        while ( h != padre) 
    717750        { 
    718                 h = MiArbol->Hojas[h].padre; 
     751                h = Leaves[h].parent; 
    719752                listah.Inserta (h); // Inserta un dato en la lista 
    720753        } 
    … …  
    750783        { 
    751784                difdist = dmax - dmin; 
    752                 difhojas = MiArbol->nHojas - MiArbol->minHojas; 
     785                difhojas = nHojas - minHojas; 
    753786 
    754787                d = dist - dmin; 
    … …  
    758791                nhojas = int(abs(d*difhojas /difdist)); 
    759792 
    760                 AjusteHojas ((MiArbol->nHojas)-nhojas); 
     793                AjusteHojas ((nHojas)-nhojas); 
    761794 
    762795        } 
    763796        else if (dist > dmax) { 
    764                 AjusteHojas (MiArbol->minHojas); 
     797                AjusteHojas (minHojas); 
    765798        } 
    766799        else if (dist < dmin) { 
    767                 AjusteHojas (MiArbol->nHojas); 
     800                AjusteHojas (nHojas); 
    768801        } 
    769802                 
    … …  
    775808void Foliage::AjusteHojas( int nhojas) 
    776809{ 
    777         if ((nhojas <= MiArbol->nHojas) && (nhojas >= MiArbol->minHojas)) 
     810        if ((nhojas <= nHojas) && (nhojas >= minHojas)) 
    778811        { 
    779812                if ( nhojas < nhactivas) { 
    … …  
    810843                hpost = Acth[i].next; 
    811844 
    812                         if ( MiArbol->Hojas[i].padre != -1)  
    813                                 if ( MiArbol->Hojas[MiArbol->Hojas[i].padre].hijoi == i) 
    814                                 {if ( EsActivo (MiArbol->Hojas[MiArbol->Hojas[i].padre].hijod ) ) 
     845                        if ( MiArbol->Hojas[i].parent != -1)  
     846                                if ( MiArbol->Hojas[MiArbol->Hojas[i].parent].childLeft == i) 
     847                                {if ( EsActivo (MiArbol->Hojas[MiArbol->Hojas[i].parent].childRight ) ) 
    815848                                {  
    816                                         ColapsaHoja ( MiArbol->Hojas[i].padre, hpost); 
     849                                        ColapsaHoja ( MiArbol->Hojas[i].parent, hpost); 
    817850                                        nhojas --; } 
    818851                                } 
    819852                                else  
    820                                 {if ( EsActivo (MiArbol->Hojas[MiArbol->Hojas[i].padre].hijoi ) ) 
     853                                {if ( EsActivo (MiArbol->Hojas[MiArbol->Hojas[i].parent].childLeft ) ) 
    821854                                { 
    822                                         ColapsaHoja ( MiArbol->Hojas[i].padre, hpost);  
     855                                        ColapsaHoja ( MiArbol->Hojas[i].parent, hpost);  
    823856                                        nhojas --; } 
    824857                                } 
    … …  
    838871        j = num; 
    839872        h = final+1; 
    840                 while ((h<=MiArbol->TotHojas) && (j>0)) 
     873                while ((h<=TotHojas) && (j>0)) 
    841874                { 
    842                         while (( ppio == MiArbol->Hojas[h].hijoi) || ( ppio == MiArbol->Hojas[h].hijod)) 
     875                        while (( ppio == Leaves[h].childLeft) || ( ppio == Leaves[h].childRight)) 
    843876                                ppio = Acth[ppio].next; 
    844877 
    845                         while (( final == MiArbol->Hojas[h].hijoi) || ( final == MiArbol->Hojas[h].hijod)) 
     878                        while (( final == Leaves[h].childLeft) || ( final == Leaves[h].childRight)) 
    846879                                final = Acth[final].prev;  
    847880 
    … …  
    849882                        //COLAPSAR = QUITO DOS DE ACTIVOS PONGO UNO A ACTIVO 
    850883 
    851                         if (Acth[MiArbol->Hojas[h].hijoi].next != -1) 
    852                                 Acth[Acth[MiArbol->Hojas[h].hijoi].next].prev = Acth[MiArbol->Hojas[h].hijoi].prev; 
    853                         if (Acth[MiArbol->Hojas[h].hijoi].prev != -1) 
    854                                 Acth[Acth[MiArbol->Hojas[h].hijoi].prev].next = Acth[MiArbol->Hojas[h].hijoi].next; 
    855  
    856                         if (Acth[MiArbol->Hojas[h].hijod].next != -1) 
    857                                 Acth[Acth[MiArbol->Hojas[h].hijod].next].prev = Acth[MiArbol->Hojas[h].hijod].prev; 
    858                         if (Acth[MiArbol->Hojas[h].hijod].prev != -1) 
    859                                 Acth[Acth[MiArbol->Hojas[h].hijod].prev].next = Acth[MiArbol->Hojas[h].hijod].next; 
     884                        if (Acth[Leaves[h].childLeft].next != -1) 
     885                                Acth[Acth[Leaves[h].childLeft].next].prev = Acth[Leaves[h].childLeft].prev; 
     886                        if (Acth[Leaves[h].childLeft].prev != -1) 
     887                                Acth[Acth[Leaves[h].childLeft].prev].next = Acth[Leaves[h].childLeft].next; 
     888 
     889                        if (Acth[Leaves[h].childRight].next != -1) 
     890                                Acth[Acth[Leaves[h].childRight].next].prev = Acth[Leaves[h].childRight].prev; 
     891                        if (Acth[Leaves[h].childRight].prev != -1) 
     892                                Acth[Acth[Leaves[h].childRight].prev].next = Acth[Leaves[h].childRight].next; 
    860893 
    861894         
    862895                        //  desconecto a los hijos 
    863                         Acth[MiArbol->Hojas[h].hijoi].prev = -1; 
    864                         Acth[MiArbol->Hojas[h].hijoi].next = -1; 
    865                         Acth[MiArbol->Hojas[h].hijod].prev = -1; 
    866                         Acth[MiArbol->Hojas[h].hijod].next = -1; 
     896                        Acth[Leaves[h].childLeft].prev = -1; 
     897                        Acth[Leaves[h].childLeft].next = -1; 
     898                        Acth[Leaves[h].childRight].prev = -1; 
     899                        Acth[Leaves[h].childRight].next = -1; 
    867900 
    868901                        //añado al final 
    … …  
    893926                hpost = Acth[i].next; 
    894927 
    895                 if (MiArbol->Hojas[i].hijoi != -1){ 
     928                if (MiArbol->Leaves[i].childLeft != -1){ 
    896929                                        SplitHoja(i, hpost); 
    897930                                        nhojas --; 
    … …  
    927960        i = h++; 
    928961         
    929         while ((EsActivo (i) == false) || (i> MiArbol->TotHojas)) 
     962        while ((EsActivo (i) == false) || (i> TotHojas)) 
    930963                i++; 
    931964 
    932         if (i > MiArbol->TotHojas) i=-1; 
     965        if (i > TotHojas) i=-1; 
    933966 
    934967 
    … …  
    943976        j = num; 
    944977        h = final; 
    945         while ((h > MiArbol->nHojas) &&  (j>0)) 
     978        while ((h > nHojas) &&  (j>0)) 
    946979        { 
    947980 
    948981                ///////////// insertar a los hijos en orden segun su indice 
    949982                //hijo izquierdo 
    950                 ant = AnteriorActivo (MiArbol->Hojas[h].hijoi); 
    951                 post = PosteriorActivo (MiArbol->Hojas[h].hijoi); 
    952  
    953  
    954                 Acth[MiArbol->Hojas[h].hijoi].next = post; 
    955                 Acth[MiArbol->Hojas[h].hijoi].prev = ant; 
    956                 if (ant != -1) Acth[ant].next = MiArbol->Hojas[h].hijoi; 
    957                         else ppio = MiArbol->Hojas[h].hijoi; 
    958                 if (post != -1) Acth[post].prev = MiArbol->Hojas[h].hijoi; 
     983                ant = AnteriorActivo (Leaves[h].childLeft); 
     984                post = PosteriorActivo (Leaves[h].childLeft); 
     985 
     986 
     987                Acth[Leaves[h].childLeft].next = post; 
     988                Acth[Leaves[h].childLeft].prev = ant; 
     989                if (ant != -1) Acth[ant].next = Leaves[h].childLeft; 
     990                        else ppio = Leaves[h].childLeft; 
     991                if (post != -1) Acth[post].prev = Leaves[h].childLeft; 
    959992 
    960993                 
    961994                //hijo derecho 
    962                 ant = AnteriorActivo (MiArbol->Hojas[h].hijod); 
    963                 post = PosteriorActivo (MiArbol->Hojas[h].hijod); 
    964  
    965  
    966                 Acth[MiArbol->Hojas[h].hijod].next = post; 
    967                 Acth[MiArbol->Hojas[h].hijod].prev = ant; 
    968                 if (ant != -1)  Acth[ant].next = MiArbol->Hojas[h].hijod; 
    969                                 else ppio = MiArbol->Hojas[h].hijod; 
    970                 if (post != -1) Acth[post].prev = MiArbol->Hojas[h].hijod; 
     995                ant = AnteriorActivo (Leaves[h].childRight); 
     996                post = PosteriorActivo (Leaves[h].childRight); 
     997 
     998 
     999                Acth[Leaves[h].childRight].next = post; 
     1000                Acth[Leaves[h].childRight].prev = ant; 
     1001                if (ant != -1)  Acth[ant].next = Leaves[h].childRight; 
     1002                                else ppio = Leaves[h].childRight; 
     1003                if (post != -1) Acth[post].prev = Leaves[h].childRight; 
    9711004 
    9721005 
    … …  
    9921025 
    9931026 } 
     1027 
     1028void Foliage::ReadVertices(const Geometry::SubMesh *submesh) 
     1029{ 
     1030        int countv= int(submesh->mVertexBuffer->mVertexCount); 
     1031        vertexdata = create_vertex_data_func(2*countv); 
     1032        Leaves = new Leaf[countv*2]; 
     1033        indexdata = create_index_data_func(countv*2*3); // 3 indices x 2 triangulos x hoja 
     1034         
     1035        vertexdata->Begin(); 
     1036        for (int i=0; i<countv; i++) 
     1037        { 
     1038                vertexdata->SetVertexCoord( i,  submesh->mVertexBuffer->mPosition[i].x,  
     1039                                                                                submesh->mVertexBuffer->mPosition[i].y,  
     1040                                                                                submesh->mVertexBuffer->mPosition[i].z ); 
     1041        } 
     1042        vertexdata->End(); 
     1043 
     1044        TotVerts = countv; 
     1045} 
     1046 
     1047 
     1048void Foliage::GetNormalH (Leaf &aleaf) 
     1049{ 
     1050 
     1051        float onex, oney, onez; 
     1052        float twox, twoy, twoz; 
     1053        float threex, threey, threez; 
     1054 
     1055/*      Vertices[aHoja.vertsLeaf[0]].GetCoordinates (onex, oney, onez); 
     1056        Vertices[aHoja.vertsLeaf[1]].GetCoordinates(twox, twoy, twoz); 
     1057        Vertices[aHoja.vertsLeaf[2]].GetCoordinates (threex, threey, threez);*/ 
     1058 
     1059        vertexdata->GetVertexCoord(aleaf.vertsLeaf[0],onex,oney,onez); 
     1060        vertexdata->GetVertexCoord(aleaf.vertsLeaf[1],twox,twoy,twoz); 
     1061        vertexdata->GetVertexCoord(aleaf.vertsLeaf[2],threex,threey,threez); 
     1062 
     1063        float v1[3]={twox-onex,twoy-oney,twoz-onez}; 
     1064        float v2[3]={threex-onex,threey-oney,threez-onez}; 
     1065 
     1066        Normalize(v1,v1); 
     1067        Normalize(v2,v2); 
     1068         
     1069//      aleaf.Normal[0] = (twoz-onez)*(threey-oney) - (twoy-oney)*(threez-onez); 
     1070//      aleaf.Normal[1] = (twox-onex)*(threez-onez) - (threex-onex)*(twoz-onez); 
     1071//      aleaf.Normal[2] = (threex-onex)*(twoy-oney) - (twox-onex)*(threey-oney); 
     1072 
     1073        CrossProduct(v1,v2,aleaf.normal); 
     1074         
     1075} 
     1076 
     1077void Foliage::CrossProduct(const float *v1, const float *v2, float *res) 
     1078{ 
     1079        res[0] = v1[1]*v2[2] - v1[2]*v2[1]; 
     1080        res[1] = v1[2]*v2[0] - v1[0]*v2[2]; 
     1081        res[2] = v1[0]*v2[1] - v1[1]*v2[0]; 
     1082} 
     1083 
     1084void Foliage::Normalize(const float *v, float *res) 
     1085{ 
     1086        float module=sqrtf(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]); 
     1087        res[0]=v[0]/module; 
     1088        res[1]=v[1]/module; 
     1089        res[2]=v[2]/module; 
     1090} 
     1091 
     1092void Foliage::ReadLeafs(const Geometry::SubMesh *submesh) 
     1093{ 
     1094        int numtris = int(submesh->mIndexCount / 3); 
     1095        nHojas =  numtris / 2; 
     1096        for (int h=0; h<nHojas; h++) 
     1097        { 
     1098                Leaves[h].vertsLeaf[0] = submesh->mIndex[h*6+0]; 
     1099                Leaves[h].vertsLeaf[1] = submesh->mIndex[h*6+1]; 
     1100                Leaves[h].vertsLeaf[2] = submesh->mIndex[h*6+2]; 
     1101                Leaves[h].vertsLeaf[3] = submesh->mIndex[h*6+5]; 
     1102                Leaves[h].visible = 0; 
     1103 
     1104                GetNormalH ( Leaves[h]); 
     1105        } 
     1106} 
     1107 
     1108/// returns the number of total leafs 
     1109bool Foliage::ReadSimpSeq(const char *simpSeqFile) 
     1110{ 
     1111        FILE* fp_simpli; 
     1112        char linea[256]; 
     1113        int v0, v1, v2, v3, tn, tv1,tv2, e=0; 
     1114 
     1115        if ((fp_simpli = fopen (simpSeqFile, "r")) == NULL) 
     1116        { 
     1117                printf ("No he podido abrir el fichero %s\n", simpSeqFile); 
     1118                return false; 
     1119        } 
     1120        else 
     1121        { 
     1122                tn = nHojas; 
     1123                while (fgets (linea, 255, fp_simpli) != NULL) 
     1124                { 
     1125                        if (linea[0]<'0' || linea[0]>'9') 
     1126                                continue; 
     1127                 
     1128                        //N 446 Ver 10176 10178 10169 10171  Tv 156 154 E 2 
     1129 
     1130//                      sscanf(linea, "%s %lu %s %lu %lu  %lu %lu %s %lu %lu %s %i",  
     1131//                              &str, &tn, &str, &v0, &v1, &v2, &v3, &str, &tv1, &tv2, &str, &e ); 
     1132                        long int triviej00=-1, triviej01=-1; 
     1133                        long int triviej10=-1, triviej11=-1; 
     1134                        sscanf(linea, "%lu %lu %lu %lu & %lu %lu %lu %lu", &triviej00,&triviej01,&triviej10,&triviej11, &v0,&v1,&v2,&v3); 
     1135 
     1136                        Leaves[tn].vertsLeaf[0] = v0; 
     1137                        Leaves[tn].vertsLeaf[1] = v1; 
     1138                        Leaves[tn].vertsLeaf[2] = v2; 
     1139                        Leaves[tn].vertsLeaf[3] = v3; 
     1140 
     1141                        Leaves[tn].visible = 0; 
     1142 
     1143                        GetNormalH  (Leaves[tn]); 
     1144 
     1145                        tv1 = triviej00/2; 
     1146                        tv2 = triviej10/2; 
     1147 
     1148                        Leaves[tn].childLeft= tv1; 
     1149                        Leaves[tn].childRight= tv2; 
     1150 
     1151                        Leaves[tv1].parent = tn; 
     1152                        Leaves[tv2].parent = tn;                 
     1153 
     1154                        tn++; 
     1155                } 
     1156 
     1157        } 
     1158 
     1159        fclose(fp_simpli); 
     1160 
     1161        TotHojas=tn; 
     1162                 
     1163        return true; 
     1164} 
     1165 
     1166void Foliage::RellenoRaiz (void) 
     1167{ 
     1168        int i,j, k, t, cont; 
     1169        bool esta, fin; 
     1170 
     1171        i=0; 
     1172        k=-1; 
     1173        cont =-1; 
     1174 
     1175        MinDet  = new Activas[nHojas*2]; 
     1176         
     1177        while (i<TotHojas) 
     1178        { 
     1179                j=i; 
     1180                while (Leaves[j].parent > -1) j= Leaves[j].parent; 
     1181                Leaves[i].root = j; 
     1182 
     1183 
     1184                // para la estructura MinDet 
     1185                if ( k == -1){ 
     1186                        k++; 
     1187                        MinDet[k].indice = j; 
     1188                        cont =k; 
     1189                } 
     1190                else 
     1191                { 
     1192                        t = 0; 
     1193                        esta = false; 
     1194                        fin = false; 
     1195 
     1196                        while (( fin == false) && (esta == false)) 
     1197                        {       if ( MinDet[t].indice == j) esta = true; 
     1198                                        else t++; 
     1199                                if (MinDet[t].indice == -1) fin = true; 
     1200                        } 
     1201 
     1202                        if ( esta == false) //añado al final 
     1203                        { 
     1204                                cont++; 
     1205                                MinDet[cont].indice = j; 
     1206                        } 
     1207                } 
     1208 
     1209        i++; 
     1210        }        
     1211 
     1212        minHojas = cont; 
     1213 
     1214} 
     1215 
     1216void Foliage::CalculaTexCoordsYNorms(void) 
     1217{        
     1218        vertexdata->Begin(); 
     1219        for (int i=0; i<nHojas; i++) 
     1220        {        
     1221                const float* lanormal = Leaves[i].normal; 
     1222                vertexdata->SetVertexNormal(Leaves[i].vertsLeaf[0], lanormal[0], lanormal[1], lanormal[2]); 
     1223                vertexdata->SetVertexTexCoord(Leaves[i].vertsLeaf[0], 0.0f, 1.0f); 
     1224 
     1225                vertexdata->SetVertexNormal(Leaves[i].vertsLeaf[1], lanormal[0], lanormal[1], lanormal[2]); 
     1226                vertexdata->SetVertexTexCoord(Leaves[i].vertsLeaf[1], 0.0f, 0.0f); 
     1227 
     1228                vertexdata->SetVertexNormal(Leaves[i].vertsLeaf[2], lanormal[0], lanormal[1], lanormal[2]); 
     1229                vertexdata->SetVertexTexCoord(Leaves[i].vertsLeaf[2], 1.0f, 1.0f); 
     1230 
     1231                vertexdata->SetVertexNormal(Leaves[i].vertsLeaf[3], lanormal[0], lanormal[1], lanormal[2]); 
     1232                vertexdata->SetVertexTexCoord(Leaves[i].vertsLeaf[3], 1.0f, 0.0f); 
     1233 
     1234 
     1235/*              MiArbol->Vertices[aHoja.vertsLeaf[1]].GetCoordinates (a,b,c); 
     1236                glTexCoord2f ( 0.0, 1.0); 
     1237                glVertex3f (a,b,c); 
     1238         
     1239                MiArbol->Vertices[aHoja.vertsLeaf[2]].GetCoordinates (a,b,c); 
     1240                glTexCoord2f ( 1.0, 0.0); 
     1241                glVertex3f (a,b,c); 
     1242 
     1243                MiArbol->Vertices[aHoja.vertsLeaf[3]].GetCoordinates (a,b,c); 
     1244                glTexCoord2f ( 1.0, 1.0); 
     1245                glVertex3f (a,b,c);*/ 
     1246        } 
     1247        vertexdata->End(); 
     1248} 
     1249 
     1250Foliage::Foliage(const Foliage *ar) 
     1251{ 
     1252        nHojas=ar->nHojas; 
     1253        MinDet  = new Activas[nHojas*2]; 
     1254//      for (unsigned int i=0; i<nHojas*2; i++) 
     1255//              MinDet[i]=ar->MinDet[i]; 
     1256        memcpy(MinDet,ar->MinDet,sizeof(Activas)*nHojas*2); 
     1257        TotHojas=ar->TotHojas; 
     1258        cx=ar->cx; 
     1259        cy=ar->cy; 
     1260        cz=ar->cz; 
     1261        rad=ar->rad; 
     1262        minHojas=ar->minHojas; 
     1263        TotVerts=ar->TotVerts; 
     1264 
     1265        create_vertex_data_func=ar->create_vertex_data_func; 
     1266        create_index_data_func=ar->create_index_data_func; 
     1267        vertexdata=create_vertex_data_func(ar->vertexdata->GetNumVertices()); 
     1268        vertexdata->Begin();  
     1269        for (unsigned int i=0; i<vertexdata->GetNumVertices(); i++)  
     1270        { 
     1271                float va,vb,vc; 
     1272                ar->vertexdata->GetVertexCoord(i,va,vb,vc); 
     1273                vertexdata->SetVertexCoord(i,va,vb,vc); 
     1274                ar->vertexdata->GetVertexNormal(i,va,vb,vc); 
     1275                vertexdata->SetVertexNormal(i,va,vb,vc); 
     1276        } 
     1277        vertexdata->End(); 
     1278        indexdata=create_index_data_func(ar->indexdata->GetNumMaxIndices()); 
     1279        indexdata->Begin();  
     1280        for (unsigned int i=0; i<indexdata->GetNumMaxIndices(); i++)  
     1281                indexdata->SetIndex(i,ar->indexdata->GetIndex(i)); 
     1282        indexdata->End(); 
     1283 
     1284        Leaves=new Leaf[vertexdata->GetNumVertices()]; 
     1285//      for (unsigned int i=0; i<vertexdata->GetNumVertices(); i++)  
     1286//              Leaves[i]=ar->Leaves[i]; 
     1287        memcpy(Leaves,ar->Leaves,sizeof(Leaf)*vertexdata->GetNumVertices()); 
     1288 
     1289        // esto no sé si devería haber akí 
     1290        indexdata->SetNumValidIndices(0); 
     1291 
     1292        int h=0; 
     1293 
     1294        Acth  = new Activas[nHojas*8]; 
     1295 
     1296        for ( h=0; h < nHojas; h++) { 
     1297 
     1298                Acth[h].indice = h; 
     1299                if ( h != 0) 
     1300                { 
     1301                        Acth[h].prev = (h-1); 
     1302                        Acth[h-1].next = h; 
     1303                } 
     1304 
     1305        } 
     1306                                 
     1307        ppio = 0; 
     1308        final = nHojas-1; 
     1309        nhactivas = nHojas; 
     1310 
     1311} 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/leaves/foliage.h

    r830 r1019  
    33 
    44 
    5 #include "arbol.h" 
    65#include "Activas.h" 
    7 //#include "material.h" 
     6#include "GeoSubMesh.h" 
    87#include "tlista.h" 
    9 //#include <vl\VLf.h> 
    108#include "TMatrix.h" 
    11  
    12  
     9#include "VertexData.h" 
     10#include "Leaf.h" 
    1311 
    1412class Foliage 
    … …  
    1614        public : 
    1715 
    18         Arbol    *MiArbol; 
    19         Activas  *Acth; // primera hoja activa 
    20         int ppio, final; 
    21         int nhactivas; 
    22         TMatrix mat_aux; 
     16                Activas  *Acth; // primera hoja activa 
     17                int ppio, final; 
     18                int nhactivas; 
     19                TMatrix mat_aux; 
    2320 
    24         public : 
    25                 Foliage (void); // Void constructor 
    26                 Foliage ( Arbol* Arbol1 ); // Constructor with the name of a file cotaining the data 
     21                Foliage (const Geometry::SubMesh *, const char *simpSeq, Geometry::CREATEVERTEXDATAFUNC vdfun=NULL, Geometry::CREATEINDEXDATAFUNC idfun=NULL); 
     22                Foliage (const Foliage *); 
    2723                virtual ~Foliage (void); // Destructor 
    2824                 
    29                 // sacar por pantalla 
    30 /*              void Dibuja_Hoja ( Hoja&); 
    31                 int  DibujarHojas (float frustum[6][4], float zoom); 
    32                 void DibujaEsfera (float);*/ 
    33  
    3425                //culling 
    3526                void Culling (float frustum[6][4]); 
    … …  
    3930                bool EsActivo (  int num); 
    4031                int  DondeEsta (  float x, float y, float z, float rva, float rvb,float rvc, float rvd); 
    41                 bool Criterio ( Hoja &aHoja, char ch, float rva, float rvb,float rvc, float rvd, float radio); 
     32                bool Criterio ( Leaf &, char ch, float rva, float rvb,float rvc, float rvd, float radio); 
    4233                int  ResolucionV ( char c, float rva, float rvb,float rvc, float rvd, float radio); 
    4334                void ColapsaHoja (int, int&); 
    … …  
    5647                void RCsplit (  int nhojas); 
    5748 
    58                 //impostores 
    59 //              void DibujaCaja (float alfa, float d); 
    60 //              int  DibujaMediaCopa ( char c, float rva, float rvb,float rvc, float rvd, float radio); 
     49                Geometry::VertexData *vertexdata; 
     50                Geometry::IndexData *indexdata; 
     51 
     52                Leaf   *Leaves; 
     53                Activas  *MinDet; // primera hoja activa 
     54                int nHojas; 
     55                int TotHojas; 
    6156                 
     57                float cx,cy,cz; //centro de la copa// para los impostores y resolucion variable 
     58                float rad; //radio de la esfera envolvente 
     59                int minHojas; 
     60                int TotVerts; 
     61 
     62        private: 
     63                Geometry::CREATEVERTEXDATAFUNC create_vertex_data_func;          
     64                Geometry::CREATEINDEXDATAFUNC create_index_data_func; 
     65 
     66                void ReadLeafs(const Geometry::SubMesh *); 
     67                void ReadVertices(const Geometry::SubMesh *); 
     68                bool ReadSimpSeq(const char*); /// returns true when successful 
     69                void RellenoRaiz (void); 
     70 
     71                void GetNormalH (Leaf&); 
     72//              void GetNormalT(Tronco&); 
     73 
     74                void CrossProduct(const float *v1, const float *v2, float *res); 
     75                void Normalize(const float *v, float *res); 
     76//              void CalculaNormalesVertice(void); 
     77                void CalculaTexCoordsYNorms(void); 
     78 
    6279}; 
    6380 
Note: See TracChangeset for help on using the changeset viewer.