Classes/Engine3d/Clipping3d.cpp

#include "clipping3d.h"
#include "math.h"

Clipping3d::Clipping3d(int iScreenWidth, int iScreenHeight, float iZNear, float iZFar)
{
        zNear=iZNear;
        zFar=iZFar;
        screenWidth=iScreenWidth;
        screenHeight=iScreenHeight;
        calcPlane(screenWidth,screenHeight);

        numberOfPolygons=16;

        tMapareDataList = new ObjectArray<TMapareData>(numberOfPolygons);

        for ( int i=0; i<numberOfPolygons ; i++)
        {
                tMapareDataList->setObject(new TMapareData(),i);
        }
}

Clipping3d::~Clipping3d()
{
        if (tMapareDataList != null)
        {
                delete tMapareDataList;
        }
}

//*********************************************************************
//return the cliped polygons
//*********************************************************************

bool Clipping3d::getClippedData(TPolytri *tPolytri, int step)
{
                bool event=false;
                
                TMapareData *tMapareData=tMapareDataList->getObject(step);

                if ( tMapareData->getexsists() == 1 )
                {

                        float z1=1/tMapareData->getcz(0);
                        float z2=1/tMapareData->getcz(1);
                        float z3=1/tMapareData->getcz(2);
                        
                        tPolytri->x1=((tMapareData->getcx(0)*screenWidth)*((z1)))+(screenWidth/2);
                        tPolytri->x2=((tMapareData->getcx(1)*screenWidth)*((z2)))+(screenWidth/2);
                        tPolytri->x3=((tMapareData->getcx(2)*screenWidth)*((z3)))+(screenWidth/2);

                        tPolytri->y1=((tMapareData->getcy(0)*screenHeight)*((z1)))+(screenHeight/2);
                        tPolytri->y2=((tMapareData->getcy(1)*screenHeight)*((z2)))+(screenHeight/2);
                        tPolytri->y3=((tMapareData->getcy(2)*screenHeight)*((z3)))+(screenHeight/2);

                        int sant=removePolygon2d(tPolytri);

                        if ( sant == 3 )
                        {

                                tPolytri->z1=tMapareData->getcz(0);
                                tPolytri->z2=tMapareData->getcz(1);
                                tPolytri->z3=tMapareData->getcz(2);                     
        
                                tPolytri->u1=tMapareData->getu(0)*256;
                                tPolytri->u2=tMapareData->getu(1)*256;
                                tPolytri->u3=tMapareData->getu(2)*256;
                
                                tPolytri->v1=tMapareData->getv(0)*256;
                                tPolytri->v2=tMapareData->getv(1)*256;
                                tPolytri->v3=tMapareData->getv(2)*256;
                        
                                event=true;
                        }
                }

                return event;
}

//*********************************************************************
//clip against 6 planes
//*********************************************************************

void Clipping3d::clipPolygonAgainst6Planes(Object3d *object3d, int step)
{
        int pos1=step*3+0;
        int pos2=step*3+1;
        int pos3=step*3+2;

        int position1=object3d->getpoints(pos1);
        int position2=object3d->getpoints(pos2);
        int position3=object3d->getpoints(pos3);

        for ( int ex=0; ex<numberOfPolygons ; ex++ )
        {
                TMapareData *tMapareData=tMapareDataList->getObject(ex);
                tMapareData->setexsists(0);
        }

        TMapareData *tMapareData=tMapareDataList->getObject(0);

        tMapareData->setexsists(1);

        tMapareData->setcx(object3d->getx(position1),0);
        tMapareData->setcy(object3d->gety(position1),0);
        tMapareData->setcz(object3d->getz(position1),0);

        tMapareData->setcx(object3d->getx(position2),1);
        tMapareData->setcy(object3d->gety(position2),1);
        tMapareData->setcz(object3d->getz(position2),1);

        tMapareData->setcx(object3d->getx(position3),2);
        tMapareData->setcy(object3d->gety(position3),2);
        tMapareData->setcz(object3d->getz(position3),2);

        tMapareData->setu(object3d->getvu(pos1),0);
        tMapareData->setv(object3d->getvv(pos1),0);
        tMapareData->setg(object3d->getgouraud(pos1),0);
        
        tMapareData->setu(object3d->getvu(pos2),1);
        tMapareData->setv(object3d->getvv(pos2),1);
        tMapareData->setg(object3d->getgouraud(pos2),1);

        tMapareData->setu(object3d->getvu(pos3),2);
        tMapareData->setv(object3d->getvv(pos3),2);
        tMapareData->setg(object3d->getgouraud(pos3),2);

        // clip against front z

        clipZ(tMapareDataList, zNear, 0, 0);

        tMapareData->setcliped(0);
        tMapareData=tMapareDataList->getObject(1);
        tMapareData->setcliped(0);

        //clip against back z

        for ( int ipc=0 ; ipc<numberOfPolygons ; ipc++ )
        {
                tMapareData=tMapareDataList->getObject(ipc);

                if ( tMapareData->getexsists() == 1 && tMapareData->getcliped() == 0)
                {
                        clipZ(tMapareDataList, zFar, ipc, 1);
                }
        }

        clearSetCliped(tMapareDataList);

        // clip against xleft

   float s=xpangs;
   float c=xpangc;

   planex=s;
   planey=0;
   planez=c;
   planedist=0;


   for ( int pc=0 ; pc<numberOfPolygons ; pc++ )
   {
                tMapareData=tMapareDataList->getObject(pc);

                if ( tMapareData->getexsists() == 1 && tMapareData->getcliped() == 0)
                {
                        clipXY(tMapareDataList, screenWidth, pc);
                }
        }

   // clip against xright

        clearSetCliped(tMapareDataList);

        planex=-s;

        for ( int pc2=0 ; pc2<numberOfPolygons ; pc2++ )
        {
                tMapareData=tMapareDataList->getObject(pc2);

                if ( tMapareData->getexsists() == 1 && tMapareData->getcliped() == 0)
                {
                        clipXY(tMapareDataList, screenWidth, pc2);
                }
        }

        // clip against ytop

        clearSetCliped(tMapareDataList);

        s=ypangs;
        c=ypangc;

        planex=0;
        planey=s;
        planez=c;
        planedist=0;

        for ( int pc3=0 ; pc3<numberOfPolygons ; pc3++ )
        {
                tMapareData=tMapareDataList->getObject(pc3);

                if ( tMapareData->getexsists() == 1 && tMapareData->getcliped() == 0)
                {
                        clipXY(tMapareDataList, screenWidth, pc3);
                }
        }

        // clip against ybottom

        clearSetCliped(tMapareDataList);
        planey=-s;

        for ( int pc4=0 ; pc4<numberOfPolygons ; pc4++ )
        {
                tMapareData=tMapareDataList->getObject(pc4);

                if ( tMapareData->getexsists() == 1 && tMapareData->getcliped() == 0)
                {
                        clipXY(tMapareDataList, screenWidth, pc4);
                }
        }

//      removepolygon(tmapare_);

}

//*********************************************************************
//reset all clip polygons
//*********************************************************************

void Clipping3d::clearSetCliped(ObjectArray<TMapareData> *tMapareDataList)
{
        for ( int ex=0; ex<numberOfPolygons ; ex++ )
        {
                TMapareData *tMapareData=tMapareDataList->getObject(ex);
                tMapareData->setcliped(0);
        }
}

//*********************************************************************
//calc x,y clip planes
//*********************************************************************

void Clipping3d::calcPlane(int screenWidth, int screenHeight)
{
   float xsize=(float)screenWidth;

   float ysize=(float)screenHeight;

   float xpang=(float)atan(2.0f/2.0f*((xsize))/(((xsize-2)*0.5f)-1.0f));

   float ypang=(float)atan(2.0f/2.0f*((ysize))/(((ysize-1)*0.5f)-1.0f));

   xpangs=(float)sin(xpang);

   xpangc=(float)cos(xpang);

   ypangs=(float)sin(ypang);

   ypangc=(float)cos(ypang);
}

//*********************************************************************
//remove polygons that is not visibly
//*********************************************************************

int Clipping3d::removePolygon2d(TPolytri *tPolytri)
{
        if (tPolytri->x1 >= (screenWidth-1) )
        {
                tPolytri->x1=(float)(screenWidth-1);
        }

        if (tPolytri->x2 >= (screenWidth-1) )
        {
                tPolytri->x2=(float)(screenWidth-1);
        }

        if (tPolytri->x3 >= (screenWidth-1) )
        {
                tPolytri->x3=(float)(screenWidth-1);
        }

        if (tPolytri->y1 >= (screenHeight-1) )
        {
                tPolytri->y1=(float)(screenHeight-1);
        }

        if (tPolytri->y2 >= (screenHeight-1) )
        {
                tPolytri->y2=(float)(screenHeight-1);
        }

        if (tPolytri->y3 >= (screenHeight-1) )
        {
                tPolytri->y3=(float)(screenHeight-1);
        }

        if (tPolytri->x1 < 1 )
        {
                tPolytri->x1=1;
        }

        if (tPolytri->x2 < 1 )
        {
                tPolytri->x2=1;
        }

        if (tPolytri->x3 < 1 )
        {
                tPolytri->x3=1;
        }

        if (tPolytri->y1 < 1 )
        {
                tPolytri->y1=1;
        }

        if (tPolytri->y2 < 1 )
        {
                tPolytri->y2=1;
        }

        if (tPolytri->y3 < 1 )
        {
                tPolytri->y3=1;
        }

        int sant=0;

        if ( tPolytri->x1 >= 1 && tPolytri->x1 < screenWidth && tPolytri->y1 >= 1 && tPolytri->y1 < screenHeight )
        {
                sant++;
        }

        if ( tPolytri->x2 >= 1 && tPolytri->x2 < screenWidth && tPolytri->y2 >= 1 && tPolytri->y2 < screenHeight )
        {
                sant++;
        }

        if ( tPolytri->x3 >= 1 && tPolytri->x3 < screenWidth && tPolytri->y3 >= 1 && tPolytri->y3 < screenHeight )
        {
                sant++;
        }

        return sant;
}

void Clipping3d::removePolygon(ObjectArray<TMapareData> *tMapareDataList )
{
        for ( int ex=0; ex<numberOfPolygons ; ex++ )
        {
                TMapareData *tMapareData=((TMapareData*)tMapareDataList->getObject(ex));

                if ( tMapareData->getexsists() == 1 )
                {
                        if (removePolygonXY(tMapareData) != 0)
                        {
                                tMapareData->setexsists(0);
                        }
                }
        }
}

int Clipping3d::removePolygon(TMapareData *tMapareData)
{
        int ex=0;

        for ( int cp=0; cp<3; cp++ )
        {
                tMapareData->curdot[cp]=(tMapareData->getcx(cp)*planex)+(tMapareData->getcy(cp)*planey)+(tMapareData->getcz(cp)*planez);
        }

        for ( int cp2=0; cp2<3 ;cp2++ )
        {       
                if ( tMapareData->curdot[cp2]+0.1f < planedist )
                {
                        ex++;                   
                }
        }

        return ex;
}

int Clipping3d::removePolygonXY(TMapareData *tMapareData)
{
        int ex=0;

        float s=xpangs;
        float c=xpangc;

        planex=s;
        planey=0;
        planez=c;
        planedist=0;
                
        ex+=removePolygon(tMapareData); 

        planex=-s;

        ex+=removePolygon(tMapareData);

        s=ypangs;
        c=ypangc;

        planex=0;
        planey=s;
        planez=c;
        planedist=0;

        ex+=removePolygon(tMapareData);
        planey=-s;      

        ex+=removePolygon(tMapareData);

        return ex;              
}

//*********************************************************************
//clip against x,y 
//*********************************************************************

void Clipping3d::clipXY(ObjectArray<TMapareData> *tMapareDataList , int screenwidth, int pc)
{
        TMapareData *tMapareData=tMapareDataList->getObject(pc);

        for ( int cp=0; cp<3; cp++ )
        {
                tMapareData->curdot[cp]=(tMapareData->getcx(cp)*planex)+(tMapareData->getcy(cp)*planey)+(tMapareData->getcz(cp)*planez);
        }

        float x=0;
        int ap=0;
        int position[4]={0,0,0,0};
        int r=1;

        for ( int pp=0; pp<3 ; pp++ )
        {
                if ( tMapareData->curdot[pp] >= planedist )
                {
                        position[0]=pp;
                        ap++;
                }
                else
                {       
                        position[r]=pp;
                        r++;
                }
        }

        if ( ap == 1 )
        {
                int n=0;
                int k=1;

                float f=((tMapareData->curdot[position[k]])/(tMapareData->curdot[position[n]]-tMapareData->curdot[position[k]]));
                interpolateClipXY(tMapareData, f , k, n, position,x);

                n=0;
                k=2;

                f=((tMapareData->curdot[position[k]])/(tMapareData->curdot[position[n]]-tMapareData->curdot[position[k]]));
                interpolateClipXY(tMapareData, f , k, n, position,x);
        }
        
        ap=0;
        r=1;

        for ( int pp2=0; pp2<3 ; pp2++ )
        {
                if ( tMapareData->curdot[pp2] < planedist )
                {
                        position[0]=pp2;
                        ap++;
                }
                else
                {       
                        position[r]=pp2;
                        r++;
                }
        }

        if ( ap == 1 )
        {
                int pc2=newPolygonClipXY(tMapareDataList,pc);
                TMapareData *tMapareData2=((TMapareData*)tMapareDataList->getObject(pc2));

                int n=1;
                int k=0;

                float f=((tMapareData->curdot[position[k]])/(tMapareData->curdot[position[n]]-tMapareData->curdot[position[k]]));
                interpolateClipXY(tMapareData, f , k, n, position,x);

                n=2;
                k=0;

                f=((tMapareData2->curdot[position[k]]-planedist)/(tMapareData2->curdot[position[n]]-tMapareData2->curdot[position[k]]));
                interpolateClipXY(tMapareData2, f , k, n, position,x);

                copyPolygonPointClipXY(tMapareData2, tMapareData, position[1], position[0]);
        }
}

//*********************************************************************
// interpolate x,y,z,u,v,g value against the x,y clip plane
//*********************************************************************

void Clipping3d::interpolateClipXY(TMapareData *tMapareData, float f , int k, int n, int *position, float x)
{
        if ( f < 0 )
        {
                f*=-1;
        }

        float z=tMapareData->getcz(position[n]);
        float z2=tMapareData->getcz(position[k]);
        
        float xs=tMapareData->getcx(position[n])-tMapareData->getcx(position[k]);
        float ys=tMapareData->getcy(position[n])-tMapareData->getcy(position[k]);
        float zs=z-z2;
        float us=tMapareData->getu(position[n])-tMapareData->getu(position[k]);
        float vs=tMapareData->getv(position[n])-tMapareData->getv(position[k]);
        float gs=tMapareData->getg(position[n])-tMapareData->getg(position[k]);

        tMapareData->setcx(tMapareData->getcx(position[k])+(f*(xs)),position[k]);
        tMapareData->setcy(tMapareData->getcy(position[k])+(f*(ys)),position[k]);
        z2+=(f*(zs));
        tMapareData->setcz(z2,position[k]);
        tMapareData->setu(tMapareData->getu(position[k])+((f)*(us)),position[k]);
        tMapareData->setv(tMapareData->getv(position[k])+((f)*(vs)),position[k]);
        tMapareData->setg(tMapareData->getg(position[k])+((f)*(gs)),position[k]);
}

//*********************************************************************
//create a new polygon 
//*********************************************************************

int Clipping3d::newPolygonClipXY(ObjectArray<TMapareData> *tMapareDataList, int e )
{
                int t=0;
                int end=0;
                int tempt;

                while ( t < numberOfPolygons && end == 0)
                {
                        TMapareData *tMapareData=tMapareDataList->getObject(t);

                        if ( tMapareData->getexsists() == 0 )
                        {
                                tMapareData->setexsists(1);
                                tMapareData->setcliped(1);
                                end=1;
                                tempt=t;
                        }

                        t++;
                }
        
                t=tempt;

                TMapareData *tMapareData=tMapareDataList->getObject(t);
                TMapareData *tMapareData2=tMapareDataList->getObject(e);

                for ( int i=0 ; i<3 ; i++ )
                {
                        tMapareData->setcx(tMapareData2->getcx(i),i);
                        tMapareData->setcy(tMapareData2->getcy(i),i);
                        tMapareData->setcz(tMapareData2->getcz(i),i);
                        tMapareData->setu(tMapareData2->getu(i),i);
                        tMapareData->setv(tMapareData2->getv(i),i);
                        tMapareData->setg(tMapareData2->getg(i),i);
                        tMapareData->curdot[i]=tMapareData2->curdot[i];
                }

                return t;
}

//*********************************************************************
//copy clipxy polygon 
//*********************************************************************

void Clipping3d::copyPolygonPointClipXY(TMapareData *tMapareData, TMapareData *tMapareData2, int i, int i2)
{       
                tMapareData->setcx(tMapareData2->getcx(i2),i);
                tMapareData->setcy(tMapareData2->getcy(i2),i);
                tMapareData->setcz(tMapareData2->getcz(i2),i);
                tMapareData->setu(tMapareData2->getu(i2),i);
                tMapareData->setv(tMapareData2->getv(i2),i);
                tMapareData->setg(tMapareData2->getg(i2),i);
                tMapareData->curdot[i]=tMapareData2->curdot[i2];
}

//*********************************************************************
//clip against z 
//*********************************************************************

void Clipping3d::clipZ(ObjectArray<TMapareData> *tMapareDataList, float zNearOrFar,  int pc , int choise)
{
                int ap=0;
                int position[4]={0,0,0,0};
                int r=1;
                TMapareData *tMapareData=tMapareDataList->getObject(pc);

                if ( choise == 0 )
                {       
                        for ( int pp=0; pp<3 ; pp++ )
                        {
                                if (tMapareData->getcz(pp) >= zNearOrFar)
                                {
                                        position[0]=pp;
                                        ap++;
                                }
                                else
                                {       
                                        position[r]=pp;
                                        r++;
                                }
                        }
                }
                else
                {
                        for ( int pp=0; pp<3 ; pp++ )
                        {

                                if ( zNearOrFar >= tMapareData->getcz(pp)  )
                                {
                                        position[0]=pp;
                                        ap++;
                                }
                                else
                                {       
                                        position[r]=pp;
                                        r++;
                                }
                        }
                }

                        if ( ap == 1 )
                        {
                                int n;
                                int k;

                                n=0;
                                k=1;

                                float z=tMapareData->getcz(position[k]);
                                float z2=tMapareData->getcz(position[n]);

                            z2=z2-z;            
                            float tempzc=zNearOrFar;
                            tempzc-=z;
                            tempzc/=z2;    
                                
                                calcClipZ(tMapareDataList, zNearOrFar, pc , k, n, position, tempzc);

                                n=0;
                                k=2;

                                z=tMapareData->getcz(position[k]);
                                z2=tMapareData->getcz(position[n]);

                            z2=z2-z;          
                            tempzc=zNearOrFar;
                            tempzc-=z;
                            tempzc/=z2;    
                                
                                calcClipZ(tMapareDataList, zNearOrFar, pc , k, n, position, tempzc);
                         }
                
                
                        ap=0;
                        r=1;

                if ( choise == 0 )
                {
                        for ( int pp2=0; pp2<3 ; pp2++ )
                        {
                                if ( tMapareData->getcz(pp2) < zNearOrFar )
                                {
                                        position[0]=pp2;
                                        ap++;
                                }
                                else
                                {       
                                        position[r]=pp2;
                                        r++;
                                }
                        }
                }
                else
                {
                        for ( int pp2=0; pp2<3 ; pp2++ )
                        {
                                if ( zNearOrFar < tMapareData->getcz(pp2) )
                                {
                                        position[0]=pp2;
                                        ap++;
                                }
                                else
                                {       
                                        position[r]=pp2;
                                        r++;
                                }
                        }
                }

                        if ( ap == 1 )
                        {
                                int pc2=newPolygonClipZ(tMapareDataList,pc);
                                TMapareData *tMapareData2=tMapareDataList->getObject(pc2);

                                int n;
                                int k;
                                
                                n=1;
                                k=0;

                                float z=tMapareData->getcz(position[k]);
                                float z2=tMapareData->getcz(position[n]);

                            z2=z2-z;          
                            float tempzc=zNearOrFar;
                            tempzc-=z;
                            tempzc/=z2;    
                                
                                calcClipZ(tMapareDataList, zNearOrFar, pc , k, n, position, tempzc);

                                n=2;
                                k=0;

                                z=tMapareData2->getcz(position[k]);
                                z2=tMapareData2->getcz(position[n]);

                            z2=z2-z;          
                            tempzc=zNearOrFar;
                            tempzc-=z;
                            tempzc/=z2;    
                                
                                calcClipZ(tMapareDataList, zNearOrFar, pc2 , k, n, position, tempzc);
                         
                                copyPolygonPointClipZ(tMapareData2, tMapareData, position[1], position[0]);
                        }
}

//*********************************************************************
//calc interpolation z 
//*********************************************************************

void Clipping3d::calcClipZ(ObjectArray<TMapareData> *tMapareDataList, float zNearOrFar, int pc , int k, int n, int *position, float tempzc)
{
        TMapareData *tMapareData=tMapareDataList->getObject(pc);

        tMapareData->setcx(interpolateClipZ(tMapareData->getcx(position[k]),tMapareData->getcx(position[n]),tempzc),position[k]);
        tMapareData->setcy(interpolateClipZ(tMapareData->getcy(position[k]),tMapareData->getcy(position[n]),tempzc),position[k]);
        tMapareData->setcz(zNearOrFar,position[k]);
        tMapareData->setu(interpolateClipZ(tMapareData->getu(position[k]),tMapareData->getu(position[n]),tempzc),position[k]);
        tMapareData->setv(interpolateClipZ(tMapareData->getv(position[k]),tMapareData->getv(position[n]),tempzc),position[k]);
        tMapareData->setg(interpolateClipZ(tMapareData->getg(position[k]),tMapareData->getg(position[n]),tempzc),position[k]);
}

//*********************************************************************
//clip against z 
//*********************************************************************

int Clipping3d::newPolygonClipZ(ObjectArray<TMapareData> *tMapareDataList, int e )
{
                int t=0;
                int end=0;
                int tempt;

                while ( t < numberOfPolygons && end == 0)
                {
                        TMapareData *tMapareData=tMapareDataList->getObject(t);
                        
                        if ( tMapareData->getexsists() == 0 )
                        {
                                tMapareData->setexsists(1);
                                tMapareData->setcliped(1);
                                end=1;
                                tempt=t;
                        }

                        t++;
                }
        
                t=tempt;

                TMapareData *tMapareData=tMapareDataList->getObject(t);
                TMapareData *tMapareData2=tMapareDataList->getObject(e);

                for ( int i=0 ; i<3 ; i++ )
                {
                        tMapareData->setcx(tMapareData2->getcx(i),i);
                        tMapareData->setcy(tMapareData2->getcy(i),i);
                        tMapareData->setcz(tMapareData2->getcz(i),i);
                        tMapareData->setu(tMapareData2->getu(i),i);
                        tMapareData->setv(tMapareData2->getv(i),i);
                        tMapareData->setg(tMapareData2->getg(i),i);
                        tMapareData->curdot[i]=tMapareData2->curdot[i];
                }

                return t;
}

//*********************************************************************
//interpolate z 
//*********************************************************************

float Clipping3d::interpolateClipZ(float temp, float temp2, float d7f)
{
        temp2=(temp2-temp)*d7f;
        temp2+=temp;
        return temp2;                                           
}

//*********************************************************************
//copy z polygonpoint 
//*********************************************************************

void Clipping3d::copyPolygonPointClipZ(TMapareData *tMapareData, TMapareData *tMapareData2, int i, int i2)
{       
                tMapareData->setcx(tMapareData2->getcx(i2),i);
                tMapareData->setcy(tMapareData2->getcy(i2),i);
                tMapareData->setcz(tMapareData2->getcz(i2),i);
                tMapareData->setu(tMapareData2->getu(i2),i);
                tMapareData->setv(tMapareData2->getv(i2),i);
                tMapareData->setg(tMapareData2->getg(i2),i);
                tMapareData->curdot[i]=tMapareData2->curdot[i2];
}
1	bearsoft	1.1	#include "clipping3d.h"
2			#include "math.h"
3
4			Clipping3d::Clipping3d(int iScreenWidth, int iScreenHeight, float iZNear, float iZFar)
5			{
6			zNear=iZNear;
7			zFar=iZFar;
8			screenWidth=iScreenWidth;
9			screenHeight=iScreenHeight;
10			calcPlane(screenWidth,screenHeight);
11
12			numberOfPolygons=16;
13
14			tMapareDataList = new ObjectArray<TMapareData>(numberOfPolygons);
15
16			for ( int i=0; i<numberOfPolygons ; i++)
17			{
18			tMapareDataList->setObject(new TMapareData(),i);
19			}
20			}
21
22			Clipping3d::~Clipping3d()
23			{
24			if (tMapareDataList != null)
25			{
26			delete tMapareDataList;
27			}
28			}
29
30			//*********************************************************************
31			//return the cliped polygons
32			//*********************************************************************
33
34			bool Clipping3d::getClippedData(TPolytri *tPolytri, int step)
35			{
36			bool event=false;
37
38			TMapareData *tMapareData=tMapareDataList->getObject(step);
39
40			if ( tMapareData->getexsists() == 1 )
41			{
42
43			float z1=1/tMapareData->getcz(0);
44			float z2=1/tMapareData->getcz(1);
45			float z3=1/tMapareData->getcz(2);
46
47			tPolytri->x1=((tMapareData->getcx(0)screenWidth)((z1)))+(screenWidth/2);
48			tPolytri->x2=((tMapareData->getcx(1)screenWidth)((z2)))+(screenWidth/2);
49			tPolytri->x3=((tMapareData->getcx(2)screenWidth)((z3)))+(screenWidth/2);
50
51			tPolytri->y1=((tMapareData->getcy(0)screenHeight)((z1)))+(screenHeight/2);
52			tPolytri->y2=((tMapareData->getcy(1)screenHeight)((z2)))+(screenHeight/2);
53			tPolytri->y3=((tMapareData->getcy(2)screenHeight)((z3)))+(screenHeight/2);
54
55			int sant=removePolygon2d(tPolytri);
56
57			if ( sant == 3 )
58			{
59
60			tPolytri->z1=tMapareData->getcz(0);
61			tPolytri->z2=tMapareData->getcz(1);
62			tPolytri->z3=tMapareData->getcz(2);
63
64			tPolytri->u1=tMapareData->getu(0)*256;
65			tPolytri->u2=tMapareData->getu(1)*256;
66			tPolytri->u3=tMapareData->getu(2)*256;
67
68			tPolytri->v1=tMapareData->getv(0)*256;
69			tPolytri->v2=tMapareData->getv(1)*256;
70			tPolytri->v3=tMapareData->getv(2)*256;
71
72			event=true;
73			}
74			}
75
76			return event;
77			}
78
79			//*********************************************************************
80			//clip against 6 planes
81			//*********************************************************************
82
83			void Clipping3d::clipPolygonAgainst6Planes(Object3d *object3d, int step)
84			{
85			int pos1=step*3+0;
86			int pos2=step*3+1;
87			int pos3=step*3+2;
88
89			int position1=object3d->getpoints(pos1);
90			int position2=object3d->getpoints(pos2);
91			int position3=object3d->getpoints(pos3);
92
93			for ( int ex=0; ex<numberOfPolygons ; ex++ )
94			{
95			TMapareData *tMapareData=tMapareDataList->getObject(ex);
96			tMapareData->setexsists(0);
97			}
98
99			TMapareData *tMapareData=tMapareDataList->getObject(0);
100
101			tMapareData->setexsists(1);
102
103			tMapareData->setcx(object3d->getx(position1),0);
104			tMapareData->setcy(object3d->gety(position1),0);
105			tMapareData->setcz(object3d->getz(position1),0);
106
107			tMapareData->setcx(object3d->getx(position2),1);
108			tMapareData->setcy(object3d->gety(position2),1);
109			tMapareData->setcz(object3d->getz(position2),1);
110
111			tMapareData->setcx(object3d->getx(position3),2);
112			tMapareData->setcy(object3d->gety(position3),2);
113			tMapareData->setcz(object3d->getz(position3),2);
114
115			tMapareData->setu(object3d->getvu(pos1),0);
116			tMapareData->setv(object3d->getvv(pos1),0);
117			tMapareData->setg(object3d->getgouraud(pos1),0);
118
119			tMapareData->setu(object3d->getvu(pos2),1);
120			tMapareData->setv(object3d->getvv(pos2),1);
121			tMapareData->setg(object3d->getgouraud(pos2),1);
122
123			tMapareData->setu(object3d->getvu(pos3),2);
124			tMapareData->setv(object3d->getvv(pos3),2);
125			tMapareData->setg(object3d->getgouraud(pos3),2);
126
127			// clip against front z
128
129			clipZ(tMapareDataList, zNear, 0, 0);
130
131			tMapareData->setcliped(0);
132			tMapareData=tMapareDataList->getObject(1);
133			tMapareData->setcliped(0);
134
135			//clip against back z
136
137			for ( int ipc=0 ; ipc<numberOfPolygons ; ipc++ )
138			{
139			tMapareData=tMapareDataList->getObject(ipc);
140
141			if ( tMapareData->getexsists() == 1 && tMapareData->getcliped() == 0)
142			{
143			clipZ(tMapareDataList, zFar, ipc, 1);
144			}
145			}
146
147			clearSetCliped(tMapareDataList);
148
149			// clip against xleft
150
151			float s=xpangs;
152			float c=xpangc;
153
154			planex=s;
155			planey=0;
156			planez=c;
157			planedist=0;
158
159
160			for ( int pc=0 ; pc<numberOfPolygons ; pc++ )
161			{
162			tMapareData=tMapareDataList->getObject(pc);
163
164			if ( tMapareData->getexsists() == 1 && tMapareData->getcliped() == 0)
165			{
166			clipXY(tMapareDataList, screenWidth, pc);
167			}
168			}
169
170			// clip against xright
171
172			clearSetCliped(tMapareDataList);
173
174			planex=-s;
175
176			for ( int pc2=0 ; pc2<numberOfPolygons ; pc2++ )
177			{
178			tMapareData=tMapareDataList->getObject(pc2);
179
180			if ( tMapareData->getexsists() == 1 && tMapareData->getcliped() == 0)
181			{
182			clipXY(tMapareDataList, screenWidth, pc2);
183			}
184			}
185
186			// clip against ytop
187
188			clearSetCliped(tMapareDataList);
189
190			s=ypangs;
191			c=ypangc;
192
193			planex=0;
194			planey=s;
195			planez=c;
196			planedist=0;
197
198			for ( int pc3=0 ; pc3<numberOfPolygons ; pc3++ )
199			{
200			tMapareData=tMapareDataList->getObject(pc3);
201
202			if ( tMapareData->getexsists() == 1 && tMapareData->getcliped() == 0)
203			{
204			clipXY(tMapareDataList, screenWidth, pc3);
205			}
206			}
207
208			// clip against ybottom
209
210			clearSetCliped(tMapareDataList);
211			planey=-s;
212
213			for ( int pc4=0 ; pc4<numberOfPolygons ; pc4++ )
214			{
215			tMapareData=tMapareDataList->getObject(pc4);
216
217			if ( tMapareData->getexsists() == 1 && tMapareData->getcliped() == 0)
218			{
219			clipXY(tMapareDataList, screenWidth, pc4);
220			}
221			}
222
223			// removepolygon(tmapare_);
224
225			}
226
227			//*********************************************************************
228			//reset all clip polygons
229			//*********************************************************************
230
231			void Clipping3d::clearSetCliped(ObjectArray<TMapareData> *tMapareDataList)
232			{
233			for ( int ex=0; ex<numberOfPolygons ; ex++ )
234			{
235			TMapareData *tMapareData=tMapareDataList->getObject(ex);
236			tMapareData->setcliped(0);
237			}
238			}
239
240			//*********************************************************************
241			//calc x,y clip planes
242			//*********************************************************************
243
244			void Clipping3d::calcPlane(int screenWidth, int screenHeight)
245			{
246			float xsize=(float)screenWidth;
247
248			float ysize=(float)screenHeight;
249
250			float xpang=(float)atan(2.0f/2.0f((xsize))/(((xsize-2)0.5f)-1.0f));
251
252			float ypang=(float)atan(2.0f/2.0f((ysize))/(((ysize-1)0.5f)-1.0f));
253
254			xpangs=(float)sin(xpang);
255
256			xpangc=(float)cos(xpang);
257
258			ypangs=(float)sin(ypang);
259
260			ypangc=(float)cos(ypang);
261			}
262
263			//*********************************************************************
264			//remove polygons that is not visibly
265			//*********************************************************************
266
267			int Clipping3d::removePolygon2d(TPolytri *tPolytri)
268			{
269			if (tPolytri->x1 >= (screenWidth-1) )
270			{
271			tPolytri->x1=(float)(screenWidth-1);
272			}
273
274			if (tPolytri->x2 >= (screenWidth-1) )
275			{
276			tPolytri->x2=(float)(screenWidth-1);
277			}
278
279			if (tPolytri->x3 >= (screenWidth-1) )
280			{
281			tPolytri->x3=(float)(screenWidth-1);
282			}
283
284			if (tPolytri->y1 >= (screenHeight-1) )
285			{
286			tPolytri->y1=(float)(screenHeight-1);
287			}
288
289			if (tPolytri->y2 >= (screenHeight-1) )
290			{
291			tPolytri->y2=(float)(screenHeight-1);
292			}
293
294			if (tPolytri->y3 >= (screenHeight-1) )
295			{
296			tPolytri->y3=(float)(screenHeight-1);
297			}
298
299			if (tPolytri->x1 < 1 )
300			{
301			tPolytri->x1=1;
302			}
303
304			if (tPolytri->x2 < 1 )
305			{
306			tPolytri->x2=1;
307			}
308
309			if (tPolytri->x3 < 1 )
310			{
311			tPolytri->x3=1;
312			}
313
314			if (tPolytri->y1 < 1 )
315			{
316			tPolytri->y1=1;
317			}
318
319			if (tPolytri->y2 < 1 )
320			{
321			tPolytri->y2=1;
322			}
323
324			if (tPolytri->y3 < 1 )
325			{
326			tPolytri->y3=1;
327			}
328
329			int sant=0;
330
331			if ( tPolytri->x1 >= 1 && tPolytri->x1 < screenWidth && tPolytri->y1 >= 1 && tPolytri->y1 < screenHeight )
332			{
333			sant++;
334			}
335
336			if ( tPolytri->x2 >= 1 && tPolytri->x2 < screenWidth && tPolytri->y2 >= 1 && tPolytri->y2 < screenHeight )
337			{
338			sant++;
339			}
340
341			if ( tPolytri->x3 >= 1 && tPolytri->x3 < screenWidth && tPolytri->y3 >= 1 && tPolytri->y3 < screenHeight )
342			{
343			sant++;
344			}
345
346			return sant;
347			}
348
349			void Clipping3d::removePolygon(ObjectArray<TMapareData> *tMapareDataList )
350			{
351			for ( int ex=0; ex<numberOfPolygons ; ex++ )
352			{
353			TMapareData tMapareData=((TMapareData)tMapareDataList->getObject(ex));
354
355			if ( tMapareData->getexsists() == 1 )
356			{
357			if (removePolygonXY(tMapareData) != 0)
358			{
359			tMapareData->setexsists(0);
360			}
361			}
362			}
363			}
364
365			int Clipping3d::removePolygon(TMapareData *tMapareData)
366			{
367			int ex=0;
368
369			for ( int cp=0; cp<3; cp++ )
370			{
371			tMapareData->curdot[cp]=(tMapareData->getcx(cp)planex)+(tMapareData->getcy(cp)planey)+(tMapareData->getcz(cp)*planez);
372			}
373
374			for ( int cp2=0; cp2<3 ;cp2++ )
375			{
376			if ( tMapareData->curdot[cp2]+0.1f < planedist )
377			{
378			ex++;
379			}
380			}
381
382			return ex;
383			}
384
385			int Clipping3d::removePolygonXY(TMapareData *tMapareData)
386			{
387			int ex=0;
388
389			float s=xpangs;
390			float c=xpangc;
391
392			planex=s;
393			planey=0;
394			planez=c;
395			planedist=0;
396
397			ex+=removePolygon(tMapareData);
398
399			planex=-s;
400
401			ex+=removePolygon(tMapareData);
402
403			s=ypangs;
404			c=ypangc;
405
406			planex=0;
407			planey=s;
408			planez=c;
409			planedist=0;
410
411			ex+=removePolygon(tMapareData);
412			planey=-s;
413
414			ex+=removePolygon(tMapareData);
415
416			return ex;
417			}
418
419			//*********************************************************************
420			//clip against x,y
421			//*********************************************************************
422
423			void Clipping3d::clipXY(ObjectArray<TMapareData> *tMapareDataList , int screenwidth, int pc)
424			{
425			TMapareData *tMapareData=tMapareDataList->getObject(pc);
426
427			for ( int cp=0; cp<3; cp++ )
428			{
429			tMapareData->curdot[cp]=(tMapareData->getcx(cp)planex)+(tMapareData->getcy(cp)planey)+(tMapareData->getcz(cp)*planez);
430			}
431
432			float x=0;
433			int ap=0;
434			int position[4]={0,0,0,0};
435			int r=1;
436
437			for ( int pp=0; pp<3 ; pp++ )
438			{
439			if ( tMapareData->curdot[pp] >= planedist )
440			{
441			position[0]=pp;
442			ap++;
443			}
444			else
445			{
446			position[r]=pp;
447			r++;
448			}
449			}
450
451			if ( ap == 1 )
452			{
453			int n=0;
454			int k=1;
455
456			float f=((tMapareData->curdot[position[k]])/(tMapareData->curdot[position[n]]-tMapareData->curdot[position[k]]));
457			interpolateClipXY(tMapareData, f , k, n, position,x);
458
459			n=0;
460			k=2;
461
462			f=((tMapareData->curdot[position[k]])/(tMapareData->curdot[position[n]]-tMapareData->curdot[position[k]]));
463			interpolateClipXY(tMapareData, f , k, n, position,x);
464			}
465
466			ap=0;
467			r=1;
468
469			for ( int pp2=0; pp2<3 ; pp2++ )
470			{
471			if ( tMapareData->curdot[pp2] < planedist )
472			{
473			position[0]=pp2;
474			ap++;
475			}
476			else
477			{
478			position[r]=pp2;
479			r++;
480			}
481			}
482
483			if ( ap == 1 )
484			{
485			int pc2=newPolygonClipXY(tMapareDataList,pc);
486			TMapareData tMapareData2=((TMapareData)tMapareDataList->getObject(pc2));
487
488			int n=1;
489			int k=0;
490
491			float f=((tMapareData->curdot[position[k]])/(tMapareData->curdot[position[n]]-tMapareData->curdot[position[k]]));
492			interpolateClipXY(tMapareData, f , k, n, position,x);
493
494			n=2;
495			k=0;
496
497			f=((tMapareData2->curdot[position[k]]-planedist)/(tMapareData2->curdot[position[n]]-tMapareData2->curdot[position[k]]));
498			interpolateClipXY(tMapareData2, f , k, n, position,x);
499
500			copyPolygonPointClipXY(tMapareData2, tMapareData, position[1], position[0]);
501			}
502			}
503
504			//*********************************************************************
505			// interpolate x,y,z,u,v,g value against the x,y clip plane
506			//*********************************************************************
507
508			void Clipping3d::interpolateClipXY(TMapareData tMapareData, float f , int k, int n, int position, float x)
509			{
510			if ( f < 0 )
511			{
512			f*=-1;
513			}
514
515			float z=tMapareData->getcz(position[n]);
516			float z2=tMapareData->getcz(position[k]);
517
518			float xs=tMapareData->getcx(position[n])-tMapareData->getcx(position[k]);
519			float ys=tMapareData->getcy(position[n])-tMapareData->getcy(position[k]);
520			float zs=z-z2;
521			float us=tMapareData->getu(position[n])-tMapareData->getu(position[k]);
522			float vs=tMapareData->getv(position[n])-tMapareData->getv(position[k]);
523			float gs=tMapareData->getg(position[n])-tMapareData->getg(position[k]);
524
525			tMapareData->setcx(tMapareData->getcx(position[k])+(f*(xs)),position[k]);
526			tMapareData->setcy(tMapareData->getcy(position[k])+(f*(ys)),position[k]);
527			z2+=(f*(zs));
528			tMapareData->setcz(z2,position[k]);
529			tMapareData->setu(tMapareData->getu(position[k])+((f)*(us)),position[k]);
530			tMapareData->setv(tMapareData->getv(position[k])+((f)*(vs)),position[k]);
531			tMapareData->setg(tMapareData->getg(position[k])+((f)*(gs)),position[k]);
532			}
533
534			//*********************************************************************
535			//create a new polygon
536			//*********************************************************************
537
538			int Clipping3d::newPolygonClipXY(ObjectArray<TMapareData> *tMapareDataList, int e )
539			{
540			int t=0;
541			int end=0;
542			int tempt;
543
544			while ( t < numberOfPolygons && end == 0)
545			{
546			TMapareData *tMapareData=tMapareDataList->getObject(t);
547
548			if ( tMapareData->getexsists() == 0 )
549			{
550			tMapareData->setexsists(1);
551			tMapareData->setcliped(1);
552			end=1;
553			tempt=t;
554			}
555
556			t++;
557			}
558
559			t=tempt;
560
561			TMapareData *tMapareData=tMapareDataList->getObject(t);
562			TMapareData *tMapareData2=tMapareDataList->getObject(e);
563
564			for ( int i=0 ; i<3 ; i++ )
565			{
566			tMapareData->setcx(tMapareData2->getcx(i),i);
567			tMapareData->setcy(tMapareData2->getcy(i),i);
568			tMapareData->setcz(tMapareData2->getcz(i),i);
569			tMapareData->setu(tMapareData2->getu(i),i);
570			tMapareData->setv(tMapareData2->getv(i),i);
571			tMapareData->setg(tMapareData2->getg(i),i);
572			tMapareData->curdot[i]=tMapareData2->curdot[i];
573			}
574
575			return t;
576			}
577
578			//*********************************************************************
579			//copy clipxy polygon
580			//*********************************************************************
581
582			void Clipping3d::copyPolygonPointClipXY(TMapareData tMapareData, TMapareData tMapareData2, int i, int i2)
583			{
584			tMapareData->setcx(tMapareData2->getcx(i2),i);
585			tMapareData->setcy(tMapareData2->getcy(i2),i);
586			tMapareData->setcz(tMapareData2->getcz(i2),i);
587			tMapareData->setu(tMapareData2->getu(i2),i);
588			tMapareData->setv(tMapareData2->getv(i2),i);
589			tMapareData->setg(tMapareData2->getg(i2),i);
590			tMapareData->curdot[i]=tMapareData2->curdot[i2];
591			}
592
593			//*********************************************************************
594			//clip against z
595			//*********************************************************************
596
597			void Clipping3d::clipZ(ObjectArray<TMapareData> *tMapareDataList, float zNearOrFar, int pc , int choise)
598			{
599			int ap=0;
600			int position[4]={0,0,0,0};
601			int r=1;
602			TMapareData *tMapareData=tMapareDataList->getObject(pc);
603
604			if ( choise == 0 )
605			{
606			for ( int pp=0; pp<3 ; pp++ )
607			{
608			if (tMapareData->getcz(pp) >= zNearOrFar)
609			{
610			position[0]=pp;
611			ap++;
612			}
613			else
614			{
615			position[r]=pp;
616			r++;
617			}
618			}
619			}
620			else
621			{
622			for ( int pp=0; pp<3 ; pp++ )
623			{
624
625			if ( zNearOrFar >= tMapareData->getcz(pp) )
626			{
627			position[0]=pp;
628			ap++;
629			}
630			else
631			{
632			position[r]=pp;
633			r++;
634			}
635			}
636			}
637
638			if ( ap == 1 )
639			{
640			int n;
641			int k;
642
643			n=0;
644			k=1;
645
646			float z=tMapareData->getcz(position[k]);
647			float z2=tMapareData->getcz(position[n]);
648
649			z2=z2-z;
650			float tempzc=zNearOrFar;
651			tempzc-=z;
652			tempzc/=z2;
653
654			calcClipZ(tMapareDataList, zNearOrFar, pc , k, n, position, tempzc);
655
656			n=0;
657			k=2;
658
659			z=tMapareData->getcz(position[k]);
660			z2=tMapareData->getcz(position[n]);
661
662			z2=z2-z;
663			tempzc=zNearOrFar;
664			tempzc-=z;
665			tempzc/=z2;
666
667			calcClipZ(tMapareDataList, zNearOrFar, pc , k, n, position, tempzc);
668			}
669
670
671			ap=0;
672			r=1;
673
674			if ( choise == 0 )
675			{
676			for ( int pp2=0; pp2<3 ; pp2++ )
677			{
678			if ( tMapareData->getcz(pp2) < zNearOrFar )
679			{
680			position[0]=pp2;
681			ap++;
682			}
683			else
684			{
685			position[r]=pp2;
686			r++;
687			}
688			}
689			}
690			else
691			{
692			for ( int pp2=0; pp2<3 ; pp2++ )
693			{
694			if ( zNearOrFar < tMapareData->getcz(pp2) )
695			{
696			position[0]=pp2;
697			ap++;
698			}
699			else
700			{
701			position[r]=pp2;
702			r++;
703			}
704			}
705			}
706
707			if ( ap == 1 )
708			{
709			int pc2=newPolygonClipZ(tMapareDataList,pc);
710			TMapareData *tMapareData2=tMapareDataList->getObject(pc2);
711
712			int n;
713			int k;
714
715			n=1;
716			k=0;
717
718			float z=tMapareData->getcz(position[k]);
719			float z2=tMapareData->getcz(position[n]);
720
721			z2=z2-z;
722			float tempzc=zNearOrFar;
723			tempzc-=z;
724			tempzc/=z2;
725
726			calcClipZ(tMapareDataList, zNearOrFar, pc , k, n, position, tempzc);
727
728			n=2;
729			k=0;
730
731			z=tMapareData2->getcz(position[k]);
732			z2=tMapareData2->getcz(position[n]);
733
734			z2=z2-z;
735			tempzc=zNearOrFar;
736			tempzc-=z;
737			tempzc/=z2;
738
739			calcClipZ(tMapareDataList, zNearOrFar, pc2 , k, n, position, tempzc);
740
741			copyPolygonPointClipZ(tMapareData2, tMapareData, position[1], position[0]);
742			}
743			}
744
745			//*********************************************************************
746			//calc interpolation z
747			//*********************************************************************
748
749			void Clipping3d::calcClipZ(ObjectArray<TMapareData> tMapareDataList, float zNearOrFar, int pc , int k, int n, int position, float tempzc)
750			{
751			TMapareData *tMapareData=tMapareDataList->getObject(pc);
752
753			tMapareData->setcx(interpolateClipZ(tMapareData->getcx(position[k]),tMapareData->getcx(position[n]),tempzc),position[k]);
754			tMapareData->setcy(interpolateClipZ(tMapareData->getcy(position[k]),tMapareData->getcy(position[n]),tempzc),position[k]);
755			tMapareData->setcz(zNearOrFar,position[k]);
756			tMapareData->setu(interpolateClipZ(tMapareData->getu(position[k]),tMapareData->getu(position[n]),tempzc),position[k]);
757			tMapareData->setv(interpolateClipZ(tMapareData->getv(position[k]),tMapareData->getv(position[n]),tempzc),position[k]);
758			tMapareData->setg(interpolateClipZ(tMapareData->getg(position[k]),tMapareData->getg(position[n]),tempzc),position[k]);
759			}
760
761			//*********************************************************************
762			//clip against z
763			//*********************************************************************
764
765			int Clipping3d::newPolygonClipZ(ObjectArray<TMapareData> *tMapareDataList, int e )
766			{
767			int t=0;
768			int end=0;
769			int tempt;
770
771			while ( t < numberOfPolygons && end == 0)
772			{
773			TMapareData *tMapareData=tMapareDataList->getObject(t);
774
775			if ( tMapareData->getexsists() == 0 )
776			{
777			tMapareData->setexsists(1);
778			tMapareData->setcliped(1);
779			end=1;
780			tempt=t;
781			}
782
783			t++;
784			}
785
786			t=tempt;
787
788			TMapareData *tMapareData=tMapareDataList->getObject(t);
789			TMapareData *tMapareData2=tMapareDataList->getObject(e);
790
791			for ( int i=0 ; i<3 ; i++ )
792			{
793			tMapareData->setcx(tMapareData2->getcx(i),i);
794			tMapareData->setcy(tMapareData2->getcy(i),i);
795			tMapareData->setcz(tMapareData2->getcz(i),i);
796			tMapareData->setu(tMapareData2->getu(i),i);
797			tMapareData->setv(tMapareData2->getv(i),i);
798			tMapareData->setg(tMapareData2->getg(i),i);
799			tMapareData->curdot[i]=tMapareData2->curdot[i];
800			}
801
802			return t;
803			}
804
805			//*********************************************************************
806			//interpolate z
807			//*********************************************************************
808
809			float Clipping3d::interpolateClipZ(float temp, float temp2, float d7f)
810			{
811			temp2=(temp2-temp)*d7f;
812			temp2+=temp;
813			return temp2;
814			}
815
816			//*********************************************************************
817			//copy z polygonpoint
818			//*********************************************************************
819
820			void Clipping3d::copyPolygonPointClipZ(TMapareData tMapareData, TMapareData tMapareData2, int i, int i2)
821			{
822			tMapareData->setcx(tMapareData2->getcx(i2),i);
823			tMapareData->setcy(tMapareData2->getcy(i2),i);
824			tMapareData->setcz(tMapareData2->getcz(i2),i);
825			tMapareData->setu(tMapareData2->getu(i2),i);
826			tMapareData->setv(tMapareData2->getv(i2),i);
827			tMapareData->setg(tMapareData2->getg(i2),i);
828			tMapareData->curdot[i]=tMapareData2->curdot[i2];
829			}