2015-04-23 00:51:47 +08:00
|
|
|
/****************************************************************************
|
|
|
|
Copyright (c) 2008-2010 Ricardo Quesada
|
|
|
|
Copyright (c) 2010-2012 cocos2d-x.org
|
|
|
|
Copyright (c) 2011 Zynga Inc.
|
2018-01-29 16:25:32 +08:00
|
|
|
Copyright (c) 2013-2016 Chukong Technologies Inc.
|
|
|
|
Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
|
2022-08-27 23:00:10 +08:00
|
|
|
Copyright (c) 2022 @aismann; Peter Eismann, Germany; dreifrankensoft
|
2022-10-09 18:06:15 +08:00
|
|
|
Copyright (c) 2022 Bytedance Inc.
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2022-10-01 16:24:52 +08:00
|
|
|
https://axmolengine.github.io/
|
2015-04-23 00:51:47 +08:00
|
|
|
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
|
|
in the Software without restriction, including without limitation the rights
|
|
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
|
|
all copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
THE SOFTWARE.
|
|
|
|
****************************************************************************/
|
|
|
|
|
2016-03-20 21:53:44 +08:00
|
|
|
#include "2d/CCAutoPolygon.h"
|
2015-05-20 06:07:50 +08:00
|
|
|
#include "poly2tri/poly2tri.h"
|
2015-06-09 11:23:37 +08:00
|
|
|
#include "base/CCDirector.h"
|
2022-11-03 18:01:10 +08:00
|
|
|
#include "base/axstd.h"
|
2015-06-09 11:23:37 +08:00
|
|
|
#include "renderer/CCTextureCache.h"
|
2022-08-28 00:30:22 +08:00
|
|
|
#include "clipper2/clipper.h"
|
2015-04-23 00:51:47 +08:00
|
|
|
#include <algorithm>
|
2015-05-15 17:18:19 +08:00
|
|
|
#include <math.h>
|
2015-04-23 00:51:47 +08:00
|
|
|
|
2022-07-11 17:50:21 +08:00
|
|
|
USING_NS_AX;
|
2015-04-23 00:51:47 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
static unsigned short quadIndices9[] = {
|
|
|
|
0 + 4 * 0, 1 + 4 * 0, 2 + 4 * 0, 3 + 4 * 0, 2 + 4 * 0, 1 + 4 * 0, 0 + 4 * 1, 1 + 4 * 1, 2 + 4 * 1,
|
|
|
|
3 + 4 * 1, 2 + 4 * 1, 1 + 4 * 1, 0 + 4 * 2, 1 + 4 * 2, 2 + 4 * 2, 3 + 4 * 2, 2 + 4 * 2, 1 + 4 * 2,
|
|
|
|
0 + 4 * 3, 1 + 4 * 3, 2 + 4 * 3, 3 + 4 * 3, 2 + 4 * 3, 1 + 4 * 3, 0 + 4 * 4, 1 + 4 * 4, 2 + 4 * 4,
|
|
|
|
3 + 4 * 4, 2 + 4 * 4, 1 + 4 * 4, 0 + 4 * 5, 1 + 4 * 5, 2 + 4 * 5, 3 + 4 * 5, 2 + 4 * 5, 1 + 4 * 5,
|
|
|
|
0 + 4 * 6, 1 + 4 * 6, 2 + 4 * 6, 3 + 4 * 6, 2 + 4 * 6, 1 + 4 * 6, 0 + 4 * 7, 1 + 4 * 7, 2 + 4 * 7,
|
|
|
|
3 + 4 * 7, 2 + 4 * 7, 1 + 4 * 7, 0 + 4 * 8, 1 + 4 * 8, 2 + 4 * 8, 3 + 4 * 8, 2 + 4 * 8, 1 + 4 * 8,
|
2016-10-27 09:45:40 +08:00
|
|
|
};
|
|
|
|
|
2015-06-10 18:54:53 +08:00
|
|
|
const static float PRECISION = 10.0f;
|
2015-06-09 18:45:55 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
PolygonInfo::PolygonInfo() : _isVertsOwner(true), _rect(Rect::ZERO), _filename("")
|
2016-05-25 07:57:40 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
triangles.verts = nullptr;
|
|
|
|
triangles.indices = nullptr;
|
|
|
|
triangles.vertCount = 0;
|
2016-05-25 07:57:40 +08:00
|
|
|
triangles.indexCount = 0;
|
|
|
|
};
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
PolygonInfo::PolygonInfo(const PolygonInfo& other) : triangles(), _isVertsOwner(true), _rect()
|
2015-06-02 10:10:09 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_filename = other._filename;
|
|
|
|
_isVertsOwner = true;
|
|
|
|
_rect = other._rect;
|
|
|
|
triangles.verts = new V3F_C4B_T2F[other.triangles.vertCount];
|
2021-12-08 00:11:53 +08:00
|
|
|
triangles.indices = new unsigned short[other.triangles.indexCount];
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(triangles.verts && triangles.indices, "not enough memory");
|
2021-12-25 10:04:45 +08:00
|
|
|
triangles.vertCount = other.triangles.vertCount;
|
2015-06-02 10:10:09 +08:00
|
|
|
triangles.indexCount = other.triangles.indexCount;
|
2016-05-25 07:57:40 +08:00
|
|
|
memcpy(triangles.verts, other.triangles.verts, other.triangles.vertCount * sizeof(other.triangles.verts[0]));
|
|
|
|
memcpy(triangles.indices, other.triangles.indices, other.triangles.indexCount * sizeof(other.triangles.indices[0]));
|
2015-06-02 10:10:09 +08:00
|
|
|
};
|
2015-06-04 18:27:58 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
PolygonInfo& PolygonInfo::operator=(const PolygonInfo& other)
|
2015-06-04 15:43:31 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (this != &other)
|
2015-06-04 15:43:31 +08:00
|
|
|
{
|
2015-06-09 18:45:55 +08:00
|
|
|
releaseVertsAndIndices();
|
2021-12-25 10:04:45 +08:00
|
|
|
_filename = other._filename;
|
|
|
|
_isVertsOwner = true;
|
|
|
|
_rect = other._rect;
|
|
|
|
triangles.verts = new V3F_C4B_T2F[other.triangles.vertCount];
|
2021-12-08 00:11:53 +08:00
|
|
|
triangles.indices = new unsigned short[other.triangles.indexCount];
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(triangles.verts && triangles.indices, "not enough memory");
|
2021-12-25 10:04:45 +08:00
|
|
|
triangles.vertCount = other.triangles.vertCount;
|
2015-06-04 15:43:31 +08:00
|
|
|
triangles.indexCount = other.triangles.indexCount;
|
2016-05-25 07:57:40 +08:00
|
|
|
memcpy(triangles.verts, other.triangles.verts, other.triangles.vertCount * sizeof(other.triangles.verts[0]));
|
2021-12-25 10:04:45 +08:00
|
|
|
memcpy(triangles.indices, other.triangles.indices,
|
|
|
|
other.triangles.indexCount * sizeof(other.triangles.indices[0]));
|
2015-06-04 15:43:31 +08:00
|
|
|
}
|
|
|
|
return *this;
|
|
|
|
}
|
2015-06-09 18:45:55 +08:00
|
|
|
|
2015-06-02 10:10:09 +08:00
|
|
|
PolygonInfo::~PolygonInfo()
|
|
|
|
{
|
2015-06-09 18:45:55 +08:00
|
|
|
releaseVertsAndIndices();
|
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void PolygonInfo::setQuad(V3F_C4B_T2F_Quad* quad)
|
2015-06-09 18:45:55 +08:00
|
|
|
{
|
|
|
|
releaseVertsAndIndices();
|
2021-12-25 10:04:45 +08:00
|
|
|
_isVertsOwner = false;
|
|
|
|
triangles.indices = quadIndices9;
|
|
|
|
triangles.vertCount = 4;
|
2015-06-09 18:45:55 +08:00
|
|
|
triangles.indexCount = 6;
|
2021-12-25 10:04:45 +08:00
|
|
|
triangles.verts = (V3F_C4B_T2F*)quad;
|
2015-06-09 18:45:55 +08:00
|
|
|
}
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
void PolygonInfo::setQuads(V3F_C4B_T2F_Quad* quad, int numberOfQuads)
|
2016-10-27 09:45:40 +08:00
|
|
|
{
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(numberOfQuads >= 1 && numberOfQuads <= 9, "Invalid number of Quads");
|
2016-10-27 09:45:40 +08:00
|
|
|
|
|
|
|
releaseVertsAndIndices();
|
2021-12-25 10:04:45 +08:00
|
|
|
_isVertsOwner = false;
|
|
|
|
triangles.indices = quadIndices9;
|
|
|
|
triangles.vertCount = 4 * numberOfQuads;
|
2016-10-27 09:45:40 +08:00
|
|
|
triangles.indexCount = 6 * numberOfQuads;
|
2021-12-25 10:04:45 +08:00
|
|
|
triangles.verts = (V3F_C4B_T2F*)quad;
|
2016-10-27 09:45:40 +08:00
|
|
|
}
|
|
|
|
|
2016-05-25 07:57:40 +08:00
|
|
|
void PolygonInfo::setTriangles(const TrianglesCommand::Triangles& other)
|
2015-10-29 10:41:58 +08:00
|
|
|
{
|
|
|
|
this->releaseVertsAndIndices();
|
2016-10-27 09:45:40 +08:00
|
|
|
_isVertsOwner = false;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
this->triangles.vertCount = other.vertCount;
|
2015-10-29 10:41:58 +08:00
|
|
|
this->triangles.indexCount = other.indexCount;
|
2021-12-25 10:04:45 +08:00
|
|
|
this->triangles.verts = other.verts;
|
|
|
|
this->triangles.indices = other.indices;
|
2015-10-29 10:41:58 +08:00
|
|
|
}
|
|
|
|
|
2015-06-09 18:45:55 +08:00
|
|
|
void PolygonInfo::releaseVertsAndIndices()
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (_isVertsOwner)
|
2015-06-02 10:10:09 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (nullptr != triangles.verts)
|
2015-06-09 18:45:55 +08:00
|
|
|
{
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_SAFE_DELETE_ARRAY(triangles.verts);
|
2015-06-09 18:45:55 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
if (nullptr != triangles.indices)
|
2015-06-09 18:45:55 +08:00
|
|
|
{
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_SAFE_DELETE_ARRAY(triangles.indices);
|
2015-06-09 18:45:55 +08:00
|
|
|
}
|
2015-06-02 10:10:09 +08:00
|
|
|
}
|
|
|
|
}
|
2015-06-09 18:45:55 +08:00
|
|
|
|
2016-02-29 15:48:07 +08:00
|
|
|
unsigned int PolygonInfo::getVertCount() const
|
2015-06-04 15:43:31 +08:00
|
|
|
{
|
|
|
|
return (unsigned int)triangles.vertCount;
|
|
|
|
}
|
|
|
|
|
2016-02-29 15:48:07 +08:00
|
|
|
unsigned int PolygonInfo::getTrianglesCount() const
|
2015-06-11 14:38:38 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
return (unsigned int)triangles.indexCount / 3;
|
2015-06-11 14:38:38 +08:00
|
|
|
}
|
|
|
|
|
2016-02-29 15:48:07 +08:00
|
|
|
float PolygonInfo::getArea() const
|
2015-06-04 15:43:31 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
float area = 0;
|
|
|
|
V3F_C4B_T2F* verts = triangles.verts;
|
|
|
|
unsigned short* indices = triangles.indices;
|
|
|
|
for (unsigned int i = 0; i < triangles.indexCount; i += 3)
|
2015-06-04 15:43:31 +08:00
|
|
|
{
|
|
|
|
auto A = verts[indices[i]].vertices;
|
2021-12-25 10:04:45 +08:00
|
|
|
auto B = verts[indices[i + 1]].vertices;
|
|
|
|
auto C = verts[indices[i + 2]].vertices;
|
|
|
|
area += (A.x * (B.y - C.y) + B.x * (C.y - A.y) + C.x * (A.y - B.y)) / 2;
|
2015-06-04 15:43:31 +08:00
|
|
|
}
|
|
|
|
return area;
|
|
|
|
}
|
2015-06-02 10:10:09 +08:00
|
|
|
|
2021-12-26 23:26:34 +08:00
|
|
|
AutoPolygon::AutoPolygon(std::string_view filename)
|
2021-12-25 10:04:45 +08:00
|
|
|
: _image(nullptr), _data(nullptr), _filename(""), _width(0), _height(0), _scaleFactor(0)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
|
|
|
_filename = filename;
|
2021-12-25 10:04:45 +08:00
|
|
|
_image = new Image();
|
2015-05-15 17:18:19 +08:00
|
|
|
_image->initWithImageFile(filename);
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(_image->getPixelFormat() == backend::PixelFormat::RGBA8,
|
2021-12-25 10:04:45 +08:00
|
|
|
"unsupported format, currently only supports rgba8888");
|
|
|
|
_data = _image->getData();
|
|
|
|
_width = _image->getWidth();
|
|
|
|
_height = _image->getHeight();
|
2015-05-15 17:18:19 +08:00
|
|
|
_scaleFactor = Director::getInstance()->getContentScaleFactor();
|
|
|
|
}
|
|
|
|
|
2015-05-20 06:07:50 +08:00
|
|
|
AutoPolygon::~AutoPolygon()
|
2015-05-15 17:18:19 +08:00
|
|
|
{
|
2022-07-15 19:17:01 +08:00
|
|
|
AX_SAFE_DELETE(_image);
|
2015-04-23 00:51:47 +08:00
|
|
|
}
|
|
|
|
|
2017-02-10 10:34:47 +08:00
|
|
|
std::vector<Vec2> AutoPolygon::trace(const Rect& rect, float threshold)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
2015-06-04 15:43:31 +08:00
|
|
|
Vec2 first = findFirstNoneTransparentPixel(rect, threshold);
|
2015-06-02 10:10:09 +08:00
|
|
|
return marchSquare(rect, first, threshold);
|
2015-04-23 00:51:47 +08:00
|
|
|
}
|
|
|
|
|
2017-02-10 10:34:47 +08:00
|
|
|
Vec2 AutoPolygon::findFirstNoneTransparentPixel(const Rect& rect, float threshold)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
bool found = false;
|
2015-06-02 10:10:09 +08:00
|
|
|
Vec2 i;
|
2021-12-25 10:04:45 +08:00
|
|
|
for (i.y = rect.origin.y; i.y < rect.origin.y + rect.size.height; i.y++)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (found)
|
|
|
|
break;
|
|
|
|
for (i.x = rect.origin.x; i.x < rect.origin.x + rect.size.width; i.x++)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
2015-06-04 15:43:31 +08:00
|
|
|
auto alpha = getAlphaByPos(i);
|
2021-12-25 10:04:45 +08:00
|
|
|
if (alpha > threshold)
|
2015-06-02 10:10:09 +08:00
|
|
|
{
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
2015-04-23 00:51:47 +08:00
|
|
|
}
|
|
|
|
}
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(found, "image is all transparent!");
|
2015-06-02 10:10:09 +08:00
|
|
|
return i;
|
2015-04-23 00:51:47 +08:00
|
|
|
}
|
|
|
|
|
2017-02-10 10:34:47 +08:00
|
|
|
unsigned char AutoPolygon::getAlphaByIndex(unsigned int i)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
return *(_data + i * 4 + 3);
|
2015-04-23 00:51:47 +08:00
|
|
|
}
|
2015-06-09 18:45:55 +08:00
|
|
|
unsigned char AutoPolygon::getAlphaByPos(const Vec2& pos)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
return *(_data + ((int)pos.y * _width + (int)pos.x) * 4 + 3);
|
2015-04-23 00:51:47 +08:00
|
|
|
}
|
|
|
|
|
2017-02-10 10:34:47 +08:00
|
|
|
unsigned int AutoPolygon::getSquareValue(unsigned int x, unsigned int y, const Rect& rect, float threshold)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
checking the 2x2 pixel grid, assigning these values to each pixel, if not transparent
|
|
|
|
+---+---+
|
|
|
|
| 1 | 2 |
|
|
|
|
+---+---+
|
|
|
|
| 4 | 8 | <- current pixel (curx,cury)
|
|
|
|
+---+---+
|
|
|
|
*/
|
|
|
|
unsigned int sv = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
// NOTE: due to the way we pick points from texture, rect needs to be smaller, otherwise it goes outside 1 pixel
|
|
|
|
auto fixedRect = Rect(rect.origin, rect.size - Vec2(2, 2));
|
|
|
|
|
|
|
|
Vec2 tl = Vec2(x - 1.0f, y - 1.0f);
|
|
|
|
sv += (fixedRect.containsPoint(tl) && getAlphaByPos(tl) > threshold) ? 1 : 0;
|
|
|
|
Vec2 tr = Vec2(x - 0.0f, y - 1.0f);
|
|
|
|
sv += (fixedRect.containsPoint(tr) && getAlphaByPos(tr) > threshold) ? 2 : 0;
|
|
|
|
Vec2 bl = Vec2(x - 1.0f, y - 0.0f);
|
|
|
|
sv += (fixedRect.containsPoint(bl) && getAlphaByPos(bl) > threshold) ? 4 : 0;
|
|
|
|
Vec2 br = Vec2(x - 0.0f, y - 0.0f);
|
|
|
|
sv += (fixedRect.containsPoint(br) && getAlphaByPos(br) > threshold) ? 8 : 0;
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(sv != 0 && sv != 15, "square value should not be 0, or 15");
|
2015-04-23 00:51:47 +08:00
|
|
|
return sv;
|
|
|
|
}
|
|
|
|
|
2022-08-08 18:02:17 +08:00
|
|
|
std::vector<ax::Vec2> AutoPolygon::marchSquare(const Rect& rect, const Vec2& start, float threshold)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
int stepx = 0;
|
|
|
|
int stepy = 0;
|
|
|
|
int prevx = 0;
|
|
|
|
int prevy = 0;
|
|
|
|
int startx = (int)start.x;
|
|
|
|
int starty = (int)start.y;
|
|
|
|
int curx = startx;
|
|
|
|
int cury = starty;
|
2015-04-23 00:51:47 +08:00
|
|
|
unsigned int count = 0;
|
|
|
|
std::vector<int> case9s;
|
|
|
|
std::vector<int> case6s;
|
|
|
|
int i;
|
|
|
|
std::vector<int>::iterator it;
|
2022-08-08 18:02:17 +08:00
|
|
|
std::vector<ax::Vec2> _points;
|
2021-12-25 10:04:45 +08:00
|
|
|
do
|
|
|
|
{
|
2015-06-02 10:10:09 +08:00
|
|
|
int sv = getSquareValue(curx, cury, rect, threshold);
|
2021-12-25 10:04:45 +08:00
|
|
|
switch (sv)
|
|
|
|
{
|
2015-04-23 00:51:47 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
case 1:
|
|
|
|
case 5:
|
|
|
|
case 13:
|
|
|
|
/* going UP with these cases:
|
|
|
|
1 5 13
|
|
|
|
+---+---+ +---+---+ +---+---+
|
|
|
|
| 1 | | | 1 | | | 1 | |
|
|
|
|
+---+---+ +---+---+ +---+---+
|
|
|
|
| | | | 4 | | | 4 | 8 |
|
|
|
|
+---+---+ +---+---+ +---+---+
|
|
|
|
*/
|
|
|
|
stepx = 0;
|
|
|
|
stepy = -1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 8:
|
|
|
|
case 10:
|
|
|
|
case 11:
|
|
|
|
/* going DOWN with these cases:
|
|
|
|
8 10 11
|
|
|
|
+---+---+ +---+---+ +---+---+
|
|
|
|
| | | | | 2 | | 1 | 2 |
|
|
|
|
+---+---+ +---+---+ +---+---+
|
|
|
|
| | 8 | | | 8 | | | 8 |
|
|
|
|
+---+---+ +---+---+ +---+---+
|
|
|
|
*/
|
|
|
|
stepx = 0;
|
|
|
|
stepy = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 4:
|
|
|
|
case 12:
|
|
|
|
case 14:
|
|
|
|
/* going LEFT with these cases:
|
|
|
|
4 12 14
|
|
|
|
+---+---+ +---+---+ +---+---+
|
|
|
|
| | | | | | | | 2 |
|
|
|
|
+---+---+ +---+---+ +---+---+
|
|
|
|
| 4 | | | 4 | 8 | | 4 | 8 |
|
|
|
|
+---+---+ +---+---+ +---+---+
|
|
|
|
*/
|
|
|
|
stepx = -1;
|
|
|
|
stepy = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
case 3:
|
|
|
|
case 7:
|
|
|
|
/* going RIGHT with these cases:
|
|
|
|
2 3 7
|
|
|
|
+---+---+ +---+---+ +---+---+
|
|
|
|
| | 2 | | 1 | 2 | | 1 | 2 |
|
|
|
|
+---+---+ +---+---+ +---+---+
|
|
|
|
| | | | | | | 4 | |
|
|
|
|
+---+---+ +---+---+ +---+---+
|
|
|
|
*/
|
|
|
|
stepx = 1;
|
|
|
|
stepy = 0;
|
|
|
|
break;
|
|
|
|
case 9:
|
|
|
|
/*
|
|
|
|
+---+---+
|
|
|
|
| 1 | |
|
|
|
|
+---+---+
|
|
|
|
| | 8 |
|
|
|
|
+---+---+
|
|
|
|
this should normally go UP, but if we already been here, we go down
|
|
|
|
*/
|
|
|
|
// find index from xy;
|
|
|
|
i = getIndexFromPos(curx, cury);
|
|
|
|
it = find(case9s.begin(), case9s.end(), i);
|
|
|
|
if (it != case9s.end())
|
|
|
|
{
|
|
|
|
// found, so we go down, and delete from case9s;
|
2015-04-23 00:51:47 +08:00
|
|
|
stepx = 0;
|
|
|
|
stepy = 1;
|
2021-12-25 10:04:45 +08:00
|
|
|
case9s.erase(it);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// not found, we go up, and add to case9s;
|
|
|
|
stepx = 0;
|
|
|
|
stepy = -1;
|
2022-08-08 13:18:33 +08:00
|
|
|
case9s.emplace_back(i);
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 6:
|
|
|
|
/*
|
|
|
|
6
|
|
|
|
+---+---+
|
|
|
|
| | 2 |
|
|
|
|
+---+---+
|
|
|
|
| 4 | |
|
|
|
|
+---+---+
|
|
|
|
this normally go RIGHT, but if its coming from UP, it should go LEFT
|
|
|
|
*/
|
|
|
|
i = getIndexFromPos(curx, cury);
|
|
|
|
it = find(case6s.begin(), case6s.end(), i);
|
|
|
|
if (it != case6s.end())
|
|
|
|
{
|
|
|
|
// found, so we go down, and delete from case9s;
|
2015-04-23 00:51:47 +08:00
|
|
|
stepx = -1;
|
|
|
|
stepy = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
case6s.erase(it);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// not found, we go up, and add to case9s;
|
|
|
|
stepx = 1;
|
|
|
|
stepy = 0;
|
2022-08-08 13:18:33 +08:00
|
|
|
case6s.emplace_back(i);
|
2021-12-25 10:04:45 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2022-07-16 10:43:05 +08:00
|
|
|
AXLOG("this shouldn't happen.");
|
2015-04-23 00:51:47 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
// little optimization
|
|
|
|
// if previous direction is same as current direction,
|
|
|
|
// then we should modify the last vec to current
|
2015-04-23 00:51:47 +08:00
|
|
|
curx += stepx;
|
|
|
|
cury += stepy;
|
2021-12-25 10:04:45 +08:00
|
|
|
if (stepx == prevx && stepy == prevy)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
_points.back().x = (float)(curx - rect.origin.x) / _scaleFactor;
|
2015-06-04 15:43:31 +08:00
|
|
|
_points.back().y = (float)(rect.size.height - cury + rect.origin.y) / _scaleFactor;
|
2015-04-23 00:51:47 +08:00
|
|
|
}
|
2016-11-18 09:27:37 +08:00
|
|
|
else
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
2022-08-27 23:40:03 +08:00
|
|
|
_points.emplace_back(Vec2((float)(curx - rect.origin.x) / _scaleFactor, (float)(rect.size.height - cury + rect.origin.y) / _scaleFactor));
|
2015-04-23 00:51:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
count++;
|
|
|
|
prevx = stepx;
|
|
|
|
prevy = stepy;
|
2016-06-17 13:13:35 +08:00
|
|
|
|
2022-08-08 18:02:17 +08:00
|
|
|
#if defined(_AX_DEBUG) && (_AX_DEBUG > 0)
|
2016-06-17 13:13:35 +08:00
|
|
|
const auto totalPixel = _width * _height;
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(count <= totalPixel, "oh no, marching square cannot find starting position");
|
2016-06-17 13:13:35 +08:00
|
|
|
#endif
|
2021-12-25 10:04:45 +08:00
|
|
|
} while (curx != startx || cury != starty);
|
2015-06-02 10:10:09 +08:00
|
|
|
return _points;
|
2015-04-23 00:51:47 +08:00
|
|
|
}
|
|
|
|
|
2022-08-08 18:02:17 +08:00
|
|
|
float AutoPolygon::perpendicularDistance(const ax::Vec2& i, const ax::Vec2& start, const ax::Vec2& end)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
|
|
|
float res;
|
|
|
|
float slope;
|
|
|
|
float intercept;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
if (start.x == end.x)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
res = fabsf(i.x - end.x);
|
2015-04-23 00:51:47 +08:00
|
|
|
}
|
2015-05-18 15:10:41 +08:00
|
|
|
else if (start.y == end.y)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
2015-05-18 15:10:41 +08:00
|
|
|
res = fabsf(i.y - end.y);
|
2015-04-23 00:51:47 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
slope = (end.y - start.y) / (end.x - start.x);
|
|
|
|
intercept = start.y - (slope * start.x);
|
|
|
|
res = fabsf(slope * i.x - i.y + intercept) / sqrtf(powf(slope, 2) + 1);
|
2015-04-23 00:51:47 +08:00
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
2022-08-08 18:02:17 +08:00
|
|
|
std::vector<ax::Vec2> AutoPolygon::rdp(const std::vector<ax::Vec2>& v, float optimization)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (v.size() < 3)
|
2015-04-23 00:51:47 +08:00
|
|
|
return v;
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
int index = -1;
|
2015-04-23 00:51:47 +08:00
|
|
|
float dist = 0;
|
2021-12-25 10:04:45 +08:00
|
|
|
// not looping first and last point
|
|
|
|
for (size_t i = 1, size = v.size(); i < size - 1; ++i)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
|
|
|
float cdist = perpendicularDistance(v[i], v.front(), v.back());
|
2021-12-25 10:04:45 +08:00
|
|
|
if (cdist > dist)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
dist = cdist;
|
2016-04-18 16:01:19 +08:00
|
|
|
index = static_cast<int>(i);
|
2015-04-23 00:51:47 +08:00
|
|
|
}
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
if (dist > optimization)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
|
|
|
std::vector<Vec2>::const_iterator begin = v.begin();
|
|
|
|
std::vector<Vec2>::const_iterator end = v.end();
|
2021-12-25 10:04:45 +08:00
|
|
|
std::vector<Vec2> l1(begin, begin + index + 1);
|
|
|
|
std::vector<Vec2> l2(begin + index, end);
|
|
|
|
|
2015-05-20 06:07:50 +08:00
|
|
|
std::vector<Vec2> r1 = rdp(l1, optimization);
|
|
|
|
std::vector<Vec2> r2 = rdp(l2, optimization);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
|
|
|
r1.insert(r1.end(), r2.begin() + 1, r2.end());
|
2015-04-23 00:51:47 +08:00
|
|
|
return r1;
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else
|
|
|
|
{
|
2015-04-23 00:51:47 +08:00
|
|
|
std::vector<Vec2> ret;
|
2022-08-08 13:18:33 +08:00
|
|
|
ret.emplace_back(v.front());
|
|
|
|
ret.emplace_back(v.back());
|
2015-04-23 00:51:47 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
2017-02-10 10:34:47 +08:00
|
|
|
std::vector<Vec2> AutoPolygon::reduce(const std::vector<Vec2>& points, const Rect& rect, float epsilon)
|
2015-04-23 00:51:47 +08:00
|
|
|
{
|
2015-06-04 15:43:31 +08:00
|
|
|
auto size = points.size();
|
|
|
|
// if there are less than 3 points, then we have nothing
|
2021-12-25 10:04:45 +08:00
|
|
|
if (size < 3)
|
2015-06-04 15:43:31 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
log("AUTOPOLYGON: cannot reduce points for %s that has less than 3 points in input, e: %f", _filename.c_str(),
|
|
|
|
epsilon);
|
2015-06-04 15:43:31 +08:00
|
|
|
return std::vector<Vec2>();
|
|
|
|
}
|
|
|
|
// if there are less than 9 points (but more than 3), then we don't need to reduce it
|
|
|
|
else if (size < 9)
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
log("AUTOPOLYGON: cannot reduce points for %s e: %f", _filename.c_str(), epsilon);
|
2015-06-02 10:10:09 +08:00
|
|
|
return points;
|
2015-06-04 15:43:31 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
float maxEp = MIN(rect.size.width, rect.size.height);
|
|
|
|
float ep = clampf(epsilon, 0.0, maxEp / _scaleFactor / 2);
|
2015-06-04 15:43:31 +08:00
|
|
|
std::vector<Vec2> result = rdp(points, ep);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2015-06-04 15:43:31 +08:00
|
|
|
auto last = result.back();
|
2016-07-04 22:12:45 +08:00
|
|
|
if (last.y > result.front().y && last.getDistance(result.front()) < ep * 0.5f)
|
2015-06-04 15:43:31 +08:00
|
|
|
{
|
2015-06-02 10:10:09 +08:00
|
|
|
result.front().y = last.y;
|
2015-06-04 15:43:31 +08:00
|
|
|
result.pop_back();
|
|
|
|
}
|
2015-06-02 10:10:09 +08:00
|
|
|
return result;
|
2015-05-15 17:18:19 +08:00
|
|
|
}
|
|
|
|
|
2022-08-08 18:02:17 +08:00
|
|
|
std::vector<Vec2> AutoPolygon::expand(const std::vector<Vec2>& points, const ax::Rect& rect, float epsilon)
|
2015-05-15 17:18:19 +08:00
|
|
|
{
|
2015-09-22 16:08:23 +08:00
|
|
|
// if there are less than 3 points, then we have nothing
|
2022-08-27 23:00:10 +08:00
|
|
|
if (points.size() < 3)
|
2015-06-04 15:43:31 +08:00
|
|
|
{
|
|
|
|
log("AUTOPOLYGON: cannot expand points for %s with less than 3 points, e: %f", _filename.c_str(), epsilon);
|
|
|
|
return std::vector<Vec2>();
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2022-08-27 23:00:10 +08:00
|
|
|
Clipper2Lib::Path64 result;
|
|
|
|
Clipper2Lib::Paths64 solution;
|
|
|
|
|
|
|
|
for (auto&& pt:points)
|
2015-06-08 15:08:16 +08:00
|
|
|
{
|
2022-09-19 14:17:13 +08:00
|
|
|
result.emplace_back(Clipper2Lib::Point64(pt.x * PRECISION, pt.y * PRECISION));
|
2015-06-08 15:08:16 +08:00
|
|
|
}
|
2022-08-27 23:00:10 +08:00
|
|
|
|
|
|
|
if (!Clipper2Lib::IsPositive(result))
|
2021-12-25 10:04:45 +08:00
|
|
|
{
|
2022-08-27 23:00:10 +08:00
|
|
|
log("AUTOPOLYGON: cannot expand points for %s detect a hole!, e: %f", _filename.c_str(), epsilon);
|
|
|
|
return std::vector<Vec2>();
|
2015-06-04 15:43:31 +08:00
|
|
|
}
|
2015-06-02 10:10:09 +08:00
|
|
|
|
2022-08-27 23:00:10 +08:00
|
|
|
Clipper2Lib::ClipperOffset co;
|
|
|
|
co.AddPath(result, Clipper2Lib::JoinType::Miter, Clipper2Lib::EndType::Polygon);
|
|
|
|
solution = co.Execute(epsilon * PRECISION);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2022-08-27 23:00:10 +08:00
|
|
|
|
|
|
|
// turn the result into simply polygon (AKA, fix overlap)
|
2021-12-25 10:04:45 +08:00
|
|
|
// clamp into the specified rect
|
2022-08-27 23:00:10 +08:00
|
|
|
Clipper2Lib::Clipper64 cl;
|
|
|
|
Clipper2Lib::Path64 clamp;
|
|
|
|
Clipper2Lib::Paths64 clamps;
|
|
|
|
Clipper2Lib::PolyTree64 out;
|
|
|
|
|
|
|
|
cl.AddSubject(solution);
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
// create the clipping rect
|
2022-08-27 23:00:10 +08:00
|
|
|
clamp.emplace_back(Clipper2Lib::Point64(0, 0));
|
|
|
|
clamp.emplace_back(Clipper2Lib::Point64(int(rect.size.width / _scaleFactor * PRECISION), 0));
|
|
|
|
clamp.emplace_back(Clipper2Lib::Point64(int(rect.size.width / _scaleFactor * PRECISION),
|
|
|
|
int(rect.size.height / _scaleFactor * PRECISION)));
|
|
|
|
clamp.emplace_back(Clipper2Lib::Point64(0, int(rect.size.height / _scaleFactor * PRECISION)));
|
2022-09-19 18:22:34 +08:00
|
|
|
clamps.emplace_back(std::move(clamp));
|
2022-08-27 23:00:10 +08:00
|
|
|
cl.AddClip(clamps);
|
|
|
|
cl.Execute(Clipper2Lib::ClipType::Intersection, Clipper2Lib::FillRule::NonZero, out);
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2023-02-25 06:21:23 +08:00
|
|
|
/*
|
|
|
|
* Notes: the clipper2 no longer remove duplicates, so we ensure it with std::set to avoid crash some times
|
|
|
|
* Fix issue: https://github.com/axmolengine/axmol/issues/1075
|
|
|
|
* @remark: Still faster than clipper1
|
|
|
|
*/
|
|
|
|
using Point64Ptr = const Clipper2Lib::Point64*;
|
|
|
|
struct point64_less
|
|
|
|
{
|
|
|
|
bool operator()(const Point64Ptr& lhs, const Point64Ptr& rhs) const
|
|
|
|
{
|
|
|
|
return lhs->x < rhs->x || (lhs->x == rhs->x && lhs->y < rhs->y);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
std::set<Point64Ptr, point64_less> pointSets;
|
|
|
|
|
2015-06-02 10:10:09 +08:00
|
|
|
std::vector<Vec2> outPoints;
|
2023-02-25 06:21:23 +08:00
|
|
|
for (auto&& p2 : out)
|
|
|
|
{
|
2022-08-27 23:00:10 +08:00
|
|
|
if (!p2->IsHole())
|
|
|
|
{
|
2023-02-25 06:21:23 +08:00
|
|
|
outPoints.reserve(outPoints.size() + p2->Polygon().size());
|
2022-08-27 23:00:10 +08:00
|
|
|
for (auto&& so : p2->Polygon())
|
|
|
|
{
|
2023-02-25 06:21:23 +08:00
|
|
|
if (pointSets.emplace(&so).second)
|
|
|
|
outPoints.emplace_back(so.x / PRECISION, so.y / PRECISION);
|
2022-08-27 23:00:10 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
AXLOG("Clipper2 detect a hole!");
|
|
|
|
}
|
2015-06-02 10:10:09 +08:00
|
|
|
}
|
2022-08-27 23:00:10 +08:00
|
|
|
|
2015-06-02 10:10:09 +08:00
|
|
|
return outPoints;
|
2015-05-15 17:18:19 +08:00
|
|
|
}
|
|
|
|
|
2015-06-02 10:10:09 +08:00
|
|
|
TrianglesCommand::Triangles AutoPolygon::triangulate(const std::vector<Vec2>& points)
|
2015-05-20 06:07:50 +08:00
|
|
|
{
|
2015-06-04 15:43:31 +08:00
|
|
|
// if there are less than 3 points, then we can't triangulate
|
2021-12-25 10:04:45 +08:00
|
|
|
if (points.size() < 3)
|
2015-06-04 15:43:31 +08:00
|
|
|
{
|
|
|
|
log("AUTOPOLYGON: cannot triangulate %s with less than 3 points", _filename.c_str());
|
|
|
|
return TrianglesCommand::Triangles();
|
|
|
|
}
|
2022-10-09 18:06:15 +08:00
|
|
|
|
|
|
|
|
|
|
|
std::vector<p2t::Point> p2pointsStorage;
|
|
|
|
p2pointsStorage.reserve(points.size());
|
2015-06-02 10:10:09 +08:00
|
|
|
std::vector<p2t::Point*> p2points;
|
2022-10-09 18:06:15 +08:00
|
|
|
p2points.reserve(points.size());
|
|
|
|
for (size_t i = 0; i < points.size(); ++i)
|
2015-05-20 06:07:50 +08:00
|
|
|
{
|
2022-10-09 18:06:15 +08:00
|
|
|
auto& pt = points[i];
|
|
|
|
p2points.emplace_back(&p2pointsStorage.emplace_back((double)pt.x, (double)pt.y));
|
2015-05-20 06:07:50 +08:00
|
|
|
}
|
2022-10-09 18:06:15 +08:00
|
|
|
|
2015-06-02 10:10:09 +08:00
|
|
|
p2t::CDT cdt(p2points);
|
2015-05-20 06:07:50 +08:00
|
|
|
cdt.Triangulate();
|
|
|
|
std::vector<p2t::Triangle*> tris = cdt.GetTriangles();
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2022-11-03 18:01:10 +08:00
|
|
|
axstd::pod_vector<unsigned short> indices(tris.size() * 3);
|
|
|
|
axstd::pod_vector<V3F_C4B_T2F> verts;
|
|
|
|
verts.reserve(indices.size() / 2); // we won't know the size of verts until we process all of the triangles!
|
2016-05-26 01:14:09 +08:00
|
|
|
|
2015-05-20 06:07:50 +08:00
|
|
|
unsigned short idx = 0;
|
|
|
|
unsigned short vdx = 0;
|
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
for (const auto& ite : tris)
|
2015-05-20 06:07:50 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
for (int i = 0; i < 3; ++i)
|
2015-05-20 06:07:50 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
auto p = ite->GetPoint(i);
|
|
|
|
auto v3 = Vec3((float)p->x, (float)p->y, 0);
|
2015-05-20 06:07:50 +08:00
|
|
|
bool found = false;
|
2019-10-09 17:50:32 +08:00
|
|
|
unsigned short j;
|
|
|
|
auto length = vdx;
|
2021-12-25 10:04:45 +08:00
|
|
|
for (j = 0; j < length; j++)
|
2015-05-20 06:07:50 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
if (verts[j].vertices == v3)
|
2015-05-20 06:07:50 +08:00
|
|
|
{
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
if (found)
|
2015-05-20 06:07:50 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
// if we found the same vertex, don't add to verts, but use the same vertex with indices
|
2022-11-03 18:01:10 +08:00
|
|
|
indices[idx++] = j;
|
2015-05-20 06:07:50 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
// vert does not exist yet, so we need to create a new one,
|
|
|
|
auto c4b = Color4B::WHITE;
|
|
|
|
auto t2f = Tex2F(0, 0); // don't worry about tex coords now, we calculate that later
|
2022-11-03 18:01:10 +08:00
|
|
|
verts.emplace_back(V3F_C4B_T2F{v3, c4b, t2f});
|
|
|
|
indices[idx++] = vdx++;;
|
2015-05-20 06:07:50 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-05-26 01:14:09 +08:00
|
|
|
|
2021-12-25 10:04:45 +08:00
|
|
|
// Triangles should really use std::vector and not arrays for verts and indices.
|
2016-05-26 01:14:09 +08:00
|
|
|
// Then the above memcpy would not be necessary
|
2022-11-03 18:01:10 +08:00
|
|
|
TrianglesCommand::Triangles triangles = {verts.release_pointer(), indices.release_pointer(), (unsigned int)vdx,
|
|
|
|
(unsigned int)idx};
|
2015-06-02 10:10:09 +08:00
|
|
|
return triangles;
|
2015-05-20 06:07:50 +08:00
|
|
|
}
|
|
|
|
|
2017-02-10 10:34:47 +08:00
|
|
|
void AutoPolygon::calculateUV(const Rect& rect, V3F_C4B_T2F* verts, ssize_t count)
|
2015-05-20 06:07:50 +08:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
whole texture UV coordination
|
|
|
|
0,0 1,0
|
|
|
|
+---------------------+
|
|
|
|
| |0.1
|
|
|
|
| |0.2
|
|
|
|
| +--------+ |0.3
|
|
|
|
| |texRect | |0.4
|
|
|
|
| | | |0.5
|
|
|
|
| | | |0.6
|
|
|
|
| +--------+ |0.7
|
|
|
|
| |0.8
|
|
|
|
| |0.9
|
|
|
|
+---------------------+
|
|
|
|
0,1 1,1
|
|
|
|
*/
|
2021-12-25 10:04:45 +08:00
|
|
|
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(_width && _height, "please specify width and height for this AutoPolygon instance");
|
2019-10-09 17:50:32 +08:00
|
|
|
auto texWidth = _width;
|
|
|
|
auto texHeight = _height;
|
2015-06-02 10:10:09 +08:00
|
|
|
|
|
|
|
auto end = &verts[count];
|
2021-12-25 10:04:45 +08:00
|
|
|
for (auto i = verts; i != end; ++i)
|
2015-05-20 06:07:50 +08:00
|
|
|
{
|
2015-09-22 16:08:23 +08:00
|
|
|
// for every point, offset with the center point
|
2021-12-25 10:04:45 +08:00
|
|
|
float u = (i->vertices.x * _scaleFactor + rect.origin.x) / texWidth;
|
|
|
|
float v = (rect.origin.y + rect.size.height - i->vertices.y * _scaleFactor) / texHeight;
|
2015-05-20 06:07:50 +08:00
|
|
|
i->texCoords.u = u;
|
|
|
|
i->texCoords.v = v;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-04 15:43:31 +08:00
|
|
|
Rect AutoPolygon::getRealRect(const Rect& rect)
|
|
|
|
{
|
|
|
|
Rect realRect = rect;
|
2021-12-25 10:04:45 +08:00
|
|
|
// check rect to see if its zero
|
|
|
|
if (realRect.equals(Rect::ZERO))
|
2015-06-04 15:43:31 +08:00
|
|
|
{
|
2021-12-25 10:04:45 +08:00
|
|
|
// if the instance doesn't have width and height, then the whole operation is kaput
|
2022-07-16 10:43:05 +08:00
|
|
|
AXASSERT(_height && _width, "Please specify a width and height for this instance before using its functions");
|
2021-12-25 10:04:45 +08:00
|
|
|
realRect = Rect(0, 0, (float)_width, (float)_height);
|
2015-06-04 15:43:31 +08:00
|
|
|
}
|
2021-12-25 10:04:45 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
// rect is specified, so convert to real rect
|
2022-07-15 19:17:01 +08:00
|
|
|
realRect = AX_RECT_POINTS_TO_PIXELS(rect);
|
2015-06-04 15:43:31 +08:00
|
|
|
}
|
|
|
|
return realRect;
|
|
|
|
}
|
|
|
|
|
2017-02-10 10:34:47 +08:00
|
|
|
PolygonInfo AutoPolygon::generateTriangles(const Rect& rect, float epsilon, float threshold)
|
2015-05-15 17:18:19 +08:00
|
|
|
{
|
2015-06-04 15:43:31 +08:00
|
|
|
Rect realRect = getRealRect(rect);
|
2021-12-25 10:04:45 +08:00
|
|
|
auto p = trace(realRect, threshold);
|
|
|
|
p = reduce(p, realRect, epsilon);
|
|
|
|
p = expand(p, realRect, epsilon);
|
|
|
|
auto tri = triangulate(p);
|
2015-06-04 15:43:31 +08:00
|
|
|
calculateUV(realRect, tri.verts, tri.vertCount);
|
2015-06-09 11:23:37 +08:00
|
|
|
PolygonInfo ret;
|
2015-06-02 10:10:09 +08:00
|
|
|
ret.triangles = tri;
|
2016-10-27 09:45:40 +08:00
|
|
|
ret.setFilename(_filename);
|
|
|
|
ret.setRect(realRect);
|
2015-06-02 10:10:09 +08:00
|
|
|
return ret;
|
2015-06-04 15:43:31 +08:00
|
|
|
}
|
2016-10-12 01:59:44 +08:00
|
|
|
|
2021-12-26 23:26:34 +08:00
|
|
|
PolygonInfo AutoPolygon::generatePolygon(std::string_view filename, const Rect& rect, float epsilon, float threshold)
|
2015-06-04 15:43:31 +08:00
|
|
|
{
|
2015-06-09 11:23:37 +08:00
|
|
|
AutoPolygon ap(filename);
|
2016-05-25 07:57:40 +08:00
|
|
|
return ap.generateTriangles(rect, epsilon, threshold);
|
2015-06-04 15:43:31 +08:00
|
|
|
}
|