Code/Sandbox/Plugins/CryDesigner/UVMappingEditor/UVElement.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "UVElement.h"
   5 #include "DesignerEditor.h"
   6 #include "Core/UVIslandManager.h"
   7 #include "UVMappingEditor.h"
   8
   9 namespace Designer {
  10 namespace UVMapping
  11 {
  12
  13 bool UVElement::IsEquivalentEdge(const UVElement& element) const
  14 {
  15         if (!IsEdge() || !element.IsEdge())
  16                 return false;
  17
  18         if (m_pUVIsland != element.m_pUVIsland)
  19                 return false;
  20
  21         if (m_UVVertices[0].pPolygon == element.m_UVVertices[0].pPolygon)
  22         {
  23                 if (m_UVVertices[0].vIndex == element.m_UVVertices[0].vIndex && m_UVVertices[1].vIndex == element.m_UVVertices[1].vIndex)
  24                         return true;
  25
  26                 if (m_UVVertices[0].vIndex == element.m_UVVertices[1].vIndex && m_UVVertices[1].vIndex == element.m_UVVertices[0].vIndex)
  27                         return true;
  28         }
  29         else
  30         {
  31                 const Vec2& uv00 = m_UVVertices[0].GetUV();
  32                 const Vec2& uv01 = m_UVVertices[1].GetUV();
  33
  34                 const Vec2& uv10 = element.m_UVVertices[0].GetUV();
  35                 const Vec2& uv11 = element.m_UVVertices[1].GetUV();
  36
  37                 if (Comparison::IsEquivalent(uv00, uv10) && Comparison::IsEquivalent(uv01, uv11) || Comparison::IsEquivalent(uv00, uv11) && Comparison::IsEquivalent(uv01, uv10))
  38                         return true;
  39         }
  40
  41         return false;
  42 }
  43
  44 bool UVElement::HasEdge(const UVElement& element) const
  45 {
  46         if (!IsPolygon() || !element.IsEdge())
  47                 return false;
  48
  49         for (int i = 0, iCount(m_UVVertices.size()); i < iCount; ++i)
  50         {
  51                 const UVVertex& v0 = m_UVVertices[i];
  52                 const UVVertex& v1 = m_UVVertices[(i + 1) % iCount];
  53
  54                 if (v0.pPolygon == element.m_UVVertices[0].pPolygon)
  55                 {
  56                         if ((v0.vIndex == element.m_UVVertices[0].vIndex && v1.vIndex == element.m_UVVertices[1].vIndex) ||
  57                             (v0.vIndex == element.m_UVVertices[1].vIndex && v1.vIndex == element.m_UVVertices[0].vIndex))
  58                         {
  59                                 return true;
  60                         }
  61                 }
  62                 else
  63                 {
  64                         const Vec2& uv0 = v0.GetUV();
  65                         const Vec2& uv1 = v1.GetUV();
  66
  67                         const Vec2& element_uv0 = element.m_UVVertices[0].GetUV();
  68                         const Vec2& element_uv1 = element.m_UVVertices[1].GetUV();
  69
  70                         if ((Comparison::IsEquivalent(uv0, element_uv0) && Comparison::IsEquivalent(uv1, element_uv1)) || (Comparison::IsEquivalent(uv0, element_uv1) && Comparison::IsEquivalent(uv1, element_uv0)))
  71                                 return true;
  72                 }
  73         }
  74
  75         return false;
  76 }
  77
  78 bool UVElementSet::AddElement(const UVElement& element)
  79 {
  80         const UVElement* pElement = FindElement(element);
  81         if (pElement)
  82                 return false;
  83         m_Elements.push_back(element);
  84         return true;
  85 }
  86
  87 bool UVElementSet::AddSharedOtherElements(const UVElement& element)
  88 {
  89         if (element.m_UVVertices.empty())
  90                 return false;
  91
  92         UVIslandManager* pUVIslandMgr = GetUVEditor()->GetUVIslandMgr();
  93
  94         for (int i = 0, iCount(pUVIslandMgr->GetCount()); i < iCount; ++i)
  95         {
  96                 UVIslandPtr pUVIsland = pUVIslandMgr->GetUVIsland(i);
  97
  98                 for (int k = 0, iPolygonCount(pUVIsland->GetCount()); k < iPolygonCount; ++k)
  99                 {
 100                         PolygonPtr polygon = pUVIsland->GetPolygon(k);
 101                         if (element.m_UVVertices[0].pPolygon == polygon)
 102                                 continue;
 103
 104                         if (element.IsVertex())
 105                         {
 106                                 int vtxIdx = 0;
 107                                 if (polygon->GetVertexIndex(element.m_UVVertices[0].GetPos(), vtxIdx))
 108                                 {
 109                                         if (!Comparison::IsEquivalent(element.m_UVVertices[0].GetUV(), polygon->GetUV(vtxIdx)))
 110                                                 AddElement(UVElement(UVVertex(pUVIsland, polygon, vtxIdx)));
 111                                 }
 112                         }
 113                         else if (element.IsEdge())
 114                         {
 115                                 int vtxIdx0 = 0;
 116                                 int vtxIdx1 = 0;
 117                                 if (polygon->GetVertexIndex(element.m_UVVertices[0].GetPos(), vtxIdx0) && polygon->GetVertexIndex(element.m_UVVertices[1].GetPos(), vtxIdx1))
 118                                 {
 119                                         if (!(Comparison::IsEquivalent(element.m_UVVertices[1].GetUV(), polygon->GetUV(vtxIdx0)) && Comparison::IsEquivalent(element.m_UVVertices[0].GetUV(), polygon->GetUV(vtxIdx1))) &&
 120                                             !(Comparison::IsEquivalent(element.m_UVVertices[0].GetUV(), polygon->GetUV(vtxIdx0)) && Comparison::IsEquivalent(element.m_UVVertices[1].GetUV(), polygon->GetUV(vtxIdx1))))
 121                                         {
 122                                                 AddElement(UVElement(UVEdge(pUVIsland, UVVertex(pUVIsland, polygon, vtxIdx1), UVVertex(pUVIsland, polygon, vtxIdx0))));
 123                                         }
 124                                 }
 125                         }
 126                 }
 127         }
 128
 129         return true;
 130 }
 131
 132 void UVElementSet::EraseAllElementWithIdenticalUVs(const UVElement& element)
 133 {
 134         auto ii = m_Elements.begin();
 135         for (; ii != m_Elements.end(); )
 136         {
 137                 bool bErased = false;
 138                 if (ii->IsVertex() && element.IsVertex())
 139                 {
 140                         if (Comparison::IsEquivalent(ii->m_UVVertices[0].GetUV(), element.m_UVVertices[0].GetUV()))
 141                         {
 142                                 ii = m_Elements.erase(ii);
 143                                 bErased = true;
 144                         }
 145                 }
 146                 else if (ii->IsEdge() && element.IsEdge())
 147                 {
 148                         if (Comparison::IsEquivalent(ii->m_UVVertices[0].GetUV(), element.m_UVVertices[0].GetUV()) && Comparison::IsEquivalent(ii->m_UVVertices[1].GetUV(), element.m_UVVertices[1].GetUV()) ||
 149                             Comparison::IsEquivalent(ii->m_UVVertices[0].GetUV(), element.m_UVVertices[1].GetUV()) && Comparison::IsEquivalent(ii->m_UVVertices[1].GetUV(), element.m_UVVertices[0].GetUV()))
 150                         {
 151                                 ii = m_Elements.erase(ii);
 152                                 bErased = true;
 153                         }
 154                 }
 155                 if (!bErased)
 156                         ++ii;
 157         }
 158 }
 159
 160 void UVElementSet::EraseElement(const UVElement& element)
 161 {
 162         for (auto ii = m_Elements.begin(); ii != m_Elements.end(); )
 163         {
 164                 if (*ii == element)
 165                         ii = m_Elements.erase(ii);
 166                 else
 167                         ++ii;
 168         }
 169 }
 170
 171 bool UVElementSet::HasElement(const UVElement& element)
 172 {
 173         for (auto ii = m_Elements.begin(); ii != m_Elements.end(); ++ii)
 174         {
 175                 if (*ii == element)
 176                         return true;
 177         }
 178         return false;
 179 }
 180
 181 void UVElementSet::Clear()
 182 {
 183         m_Elements.clear();
 184 }
 185
 186 const UVElement* UVElementSet::FindElement(const UVElement& element) const
 187 {
 188         for (auto ii = m_Elements.begin(); ii != m_Elements.end(); ++ii)
 189         {
 190                 if ((*ii) == element || (*ii).HasEdge(element))
 191                         return &(*ii);
 192         }
 193         return NULL;
 194 }
 195
 196 Vec3 UVElementSet::GetCenterPos() const
 197 {
 198         if (m_Elements.empty())
 199                 return Vec3(0, 0, 0);
 200
 201         auto element = m_Elements.begin();
 202         AABB aabb;
 203         aabb.Reset();
 204         for (; element != m_Elements.end(); ++element)
 205         {
 206                 if ((*element).IsUVIsland())
 207                 {
 208                         aabb.Add((*element).m_pUVIsland->GetUVBoundBox().GetCenter());
 209                 }
 210                 else
 211                 {
 212                         for (int i = 0, iVertexCount((*element).m_UVVertices.size()); i < iVertexCount; ++i)
 213                                 aabb.Add((*element).m_UVVertices[i].GetUV());
 214                 }
 215         }
 216
 217         return aabb.GetCenter();
 218 }
 219
 220 bool UVElementSet::AllOnlyVertices() const
 221 {
 222         auto iter = m_Elements.begin();
 223         for (; iter != m_Elements.end(); ++iter)
 224         {
 225                 if (!iter->IsVertex())
 226                         return false;
 227         }
 228         return true;
 229 }
 230
 231 bool UVElementSet::AllOnlyEdges() const
 232 {
 233         auto iter = m_Elements.begin();
 234         for (; iter != m_Elements.end(); ++iter)
 235         {
 236                 if (!iter->IsEdge())
 237                         return false;
 238         }
 239         return true;
 240 }
 241
 242 bool UVElementSet::AllOnlyPolygons() const
 243 {
 244         auto iter = m_Elements.begin();
 245         for (; iter != m_Elements.end(); ++iter)
 246         {
 247                 if (!iter->IsPolygon())
 248                         return false;
 249         }
 250         return true;
 251 }
 252
 253 bool UVElementSet::AllOnlyUVIslands() const
 254 {
 255         auto iter = m_Elements.begin();
 256         for (; iter != m_Elements.end(); ++iter)
 257         {
 258                 if (!iter->IsUVIsland())
 259                         return false;
 260         }
 261         return true;
 262 }
 263
 264 UVElementSet& UVElementSet::operator=(const UVElementSet& uvSet)
 265 {
 266         m_Elements = uvSet.m_Elements;
 267         return *this;
 268 }
 269
 270 UVElementSet* UVElementSet::Clone()
 271 {
 272         UVElementSet* pClone = new UVElementSet;
 273         for (int i = 0, iCount(m_Elements.size()); i < iCount; ++i)
 274                 pClone->AddElement(m_Elements[i]);
 275         return pClone;
 276 }
 277
 278 void UVElementSet::CopyFrom(UVElementSet* pElementSet)
 279 {
 280         *this = *pElementSet;
 281         for (int i = 0, iCount(m_Elements.size()); i < iCount; ++i)
 282                 m_Elements[i].m_pUVIsland->ResetPolygonsInModel(GetUVEditor()->GetModel());
 283 }
 284
 285 void UVElementSet::Join(UVElementSet* pElementSet)
 286 {
 287         for (int i = 0, iCount(pElementSet->GetCount()); i < iCount; ++i)
 288                 m_Elements.push_back(pElementSet->GetElement(i));
 289 }
 290
 291 }
 292 }