Linux multi-monitor fullscreen support

[ryzomcore.git] / nel / src / 3d / zone_corner_smoother.cpp

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#include "std3d.h"

#include "nel/3d/zone_corner_smoother.h"
#include "nel/3d/patchuv_locator.h"

#ifdef DEBUG_NEW
#define new DEBUG_NEW
#endif

namespace NL3D {


// ***************************************************************************
CZoneCornerSmoother::CZoneCornerSmoother()
{
}


// ***************************************************************************
void    CZoneCornerSmoother::buildPatchBindInfo(CPatch &pa, const CZone::CPatchConnect &pc, bool smoothEdge[4], bool cornerOnBind[4])
{
        uint    edge, corner;

        /*
                Some terminology here: an edge is supposed going from Corner=edge, to corner=(edge+1)&3.
                eg: edge 0 goes from corner0 to corner1.
        */

        for(corner=0; corner<4; corner++)
                cornerOnBind[corner]= false;

        // for 4 edges.
        for(edge=0; edge<4; edge++)
        {
                // Is this edge smoothed??
                smoothEdge[edge]= pa.getSmoothFlag(edge);

                // build bindInfo.
                CPatch::CBindInfo       bindInfo;
                CPatchUVLocator         patchUvLocator;
                pa.getBindNeighbor(edge, bindInfo);
                // if neighbor(s) is present.
                if(bindInfo.Zone)
                {
                        patchUvLocator.build(&pa, edge, bindInfo);
                        // if not sameEdgeOnOrder (NB: all special cases of bind 1/X X/1 managed :) ), not smoothed!
                        if( !patchUvLocator.sameEdgeOrder() )
                                smoothEdge[edge]= false;

                        // Manage bind 1/4 for the 2 patchs on the center of the bind.
                        if(bindInfo.MultipleBindNum==4 && (bindInfo.MultipleBindId==1 || bindInfo.MultipleBindId==2) )
                        {
                                // easy, this edge starts and ends on a bind...
                                cornerOnBind[edge]= true;
                                cornerOnBind[(edge+1)&3]= true;
                        }
                        // else for case bind 1/2, and for case of patch 0 and patch 3 of the bind 1/4.
                        else if(bindInfo.MultipleBindNum>=2)
                        {
                                // Beware of the mirroring!! (make a draw...)
                                /*
                                        ----------|-----------
                                                      |
                                                      | |
                                                    1 | |
                                                  ^   | v
                                                  |   |
                                                  |   *-----------
                                                  |   |
                                                  |   | |
                                                    0 | |
                                                      | v
                                                      |
                                        ----------|-----------
                                */
                                // If we are the patch0 on the neighbor, then we start on a bind, else we ends.
                                if(bindInfo.MultipleBindId==0)
                                        cornerOnBind[edge]= true;
                                else
                                        cornerOnBind[(edge+1)&3]= true;
                        }

                }
        }
}


// ***************************************************************************
void    CZoneCornerSmoother::updateVertex(uint idVert, uint corner, bool smoothEdge[4], bool cornerOnBind[4])
{
        // get or insert into map (with default).
        CVertexSmoothInfo       &vert= VertexMap[idVert];

        // inc the number of patch binded to this point.
        vert.NPatchShared++;

        // get the smooth flag of edge before and after this corner.
        uint    e0= (4+corner-1)&3;
        uint    e1= corner;
        // if any one of those edge is not smoothed, then this vertex is not smoothed.
        if( !smoothEdge[e0] || !smoothEdge[e1] )
                vert.Smoothed= false;


        // Are we a vertex on a bind??
        if(cornerOnBind[corner])
                vert.VertexOnBind= true;
}


// ***************************************************************************
void    CZoneCornerSmoother::computeAllCornerSmoothFlags(CZone *zone, std::vector<CZone*> neighborZones)
{
        nlassert(zone);
        sint    npatchs= zone->getNumPatchs();
        sint    i;

        VertexMap.clear();
        IdVertexMap.clear();

        // for all patchs of the center zone, build the vertexMap.
        //==================
        for(i=0; i<npatchs; i++)
        {
                CPatch                                          &pa= (CPatch&)*(((const CZone*)zone)->getPatch(i));
                const CZone::CPatchConnect      &pc= *(zone->getPatchConnect(i));
                uint    corner;

                // build bind info for 4 edges and 4 vertices.
                bool    smoothEdge[4];
                bool    cornerOnBind[4];
                buildPatchBindInfo(pa, pc, smoothEdge, cornerOnBind);

                // for 4 corners.
                for(corner=0; corner<4; corner++)
                {
                        // get the vertex id for this patch.
                        uint    idVert= pc.BaseVertices[corner];

                        // update this vertex smooth info.
                        updateVertex(idVert, corner, smoothEdge, cornerOnBind);

                        // for Bind with neighbor zones, must insert it in the map CTessVertex* -> VertexId.
                        IdVertexMap[pa.getCornerVertex(corner)]= idVert;
                }
        }


        // for all patchs of all neigbhors zone, update for vertices that are connected to the centerZone.
        //==================
        for(uint nbZone=0; nbZone<neighborZones.size(); nbZone++)
        {
                CZone   *neighborZone= neighborZones[nbZone];
                nlassert(neighborZone);
                for(i=0; i<neighborZone->getNumPatchs(); i++)
                {
                        CPatch                                          &pa= (CPatch&)*(((const CZone*)neighborZone)->getPatch(i));
                        const CZone::CPatchConnect      &pc= *(neighborZone->getPatchConnect(i));
                        uint    corner;

                        // build bind info for 4 edges and 4 vertices.
                        bool    smoothEdge[4];
                        bool    cornerOnBind[4];
                        buildPatchBindInfo(pa, pc, smoothEdge, cornerOnBind);

                        // for 4 corners.
                        for(corner=0; corner<4; corner++)
                        {
                                // try to find the vertex of the centerZone binded to this corner.
                                ItIdVertexMap   it= IdVertexMap.find(pa.getCornerVertex(corner));

                                // If this patch is binded on a vertex of the centerZone, must update this vertex.
                                if(it != IdVertexMap.end())
                                {
                                        // get the vertex id for this patch.
                                        uint    idVert= it->second;

                                        // update this vertex smooth info.
                                        updateVertex(idVert, corner, smoothEdge, cornerOnBind);
                                }

                        }
                }
        }


        // for all patchs of the center zone, build the finalSmooth.
        //==================
        for(i=0; i<npatchs; i++)
        {
                CPatch                                          &pa= (CPatch&)*(((const CZone*)zone)->getPatch(i));
                const CZone::CPatchConnect      &pc= *(zone->getPatchConnect(i));
                uint    corner;

                // for 4 corners.
                for(corner=0; corner<4; corner++)
                {
                        uint    idVert= pc.BaseVertices[corner];
                        // get from map.
                        CVertexSmoothInfo       &vert= VertexMap[idVert];

                        // the vertex is smoothed if all edges around him are smoothed, AND
                        // if it has 4 patchs around him or if it is a bind.
                        bool    finalSmooth;
                        finalSmooth= vert.Smoothed && (vert.VertexOnBind || vert.NPatchShared==4);

                        // update the patch.
                        pa.setCornerSmoothFlag(corner, finalSmooth);
                }

        }


}



} // NL3D