axmol/cocos/2d/CCAutoPolygon.cpp

735 lines
24 KiB
C++
Raw Normal View History

/****************************************************************************
Copyright (c) 2008-2010 Ricardo Quesada
Copyright (c) 2010-2012 cocos2d-x.org
Copyright (c) 2011 Zynga Inc.
2016-08-05 09:42:15 +08:00
Copyright (c) 2013-2016 Chukong Technologies Inc.
http://www.cocos2d-x.org
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.
****************************************************************************/
#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"
#include "renderer/CCTextureCache.h"
2015-06-11 10:45:37 +08:00
#include "clipper/clipper.hpp"
#include <algorithm>
#include <math.h>
USING_NS_CC;
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,
};
const static float PRECISION = 10.0f;
2015-06-09 18:45:55 +08:00
PolygonInfo::PolygonInfo()
: _rect(Rect::ZERO)
, _filename("")
, _isVertsOwner(true)
{
triangles.verts = nullptr;
triangles.indices = nullptr;
triangles.vertCount = 0;
triangles.indexCount = 0;
};
PolygonInfo::PolygonInfo(const PolygonInfo& other)
: triangles()
, _rect()
, _isVertsOwner(true)
{
_filename = other._filename;
_isVertsOwner = true;
_rect = other._rect;
triangles.verts = new (std::nothrow) V3F_C4B_T2F[other.triangles.vertCount];
triangles.indices = new (std::nothrow) unsigned short[other.triangles.indexCount];
CCASSERT(triangles.verts && triangles.indices, "not enough memory");
triangles.vertCount = other.triangles.vertCount;
triangles.indexCount = other.triangles.indexCount;
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-04 15:43:31 +08:00
PolygonInfo& PolygonInfo::operator= (const PolygonInfo& other)
{
if(this != &other)
{
2015-06-09 18:45:55 +08:00
releaseVertsAndIndices();
_filename = other._filename;
_isVertsOwner = true;
_rect = other._rect;
triangles.verts = new (std::nothrow) V3F_C4B_T2F[other.triangles.vertCount];
triangles.indices = new (std::nothrow) unsigned short[other.triangles.indexCount];
CCASSERT(triangles.verts && triangles.indices, "not enough memory");
2015-06-04 15:43:31 +08:00
triangles.vertCount = other.triangles.vertCount;
triangles.indexCount = other.triangles.indexCount;
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-04 15:43:31 +08:00
}
return *this;
}
2015-06-09 18:45:55 +08:00
PolygonInfo::~PolygonInfo()
{
2015-06-09 18:45:55 +08:00
releaseVertsAndIndices();
}
void PolygonInfo::setQuad(V3F_C4B_T2F_Quad *quad)
{
releaseVertsAndIndices();
_isVertsOwner = false;
triangles.indices = quadIndices9;
2015-06-09 18:45:55 +08:00
triangles.vertCount = 4;
triangles.indexCount = 6;
triangles.verts = (V3F_C4B_T2F*)quad;
}
void PolygonInfo::setQuads(V3F_C4B_T2F_Quad *quad, int numberOfQuads)
{
CCASSERT(numberOfQuads >= 1 && numberOfQuads <= 9, "Invalid number of Quads");
releaseVertsAndIndices();
_isVertsOwner = false;
triangles.indices = quadIndices9;
triangles.vertCount = 4 * numberOfQuads;
triangles.indexCount = 6 * numberOfQuads;
triangles.verts = (V3F_C4B_T2F*)quad;
}
void PolygonInfo::setTriangles(const TrianglesCommand::Triangles& other)
2015-10-29 10:41:58 +08:00
{
this->releaseVertsAndIndices();
_isVertsOwner = false;
2015-10-29 10:41:58 +08:00
this->triangles.vertCount = other.vertCount;
this->triangles.indexCount = other.indexCount;
this->triangles.verts = other.verts;
this->triangles.indices = other.indices;
}
2015-06-09 18:45:55 +08:00
void PolygonInfo::releaseVertsAndIndices()
{
if(_isVertsOwner)
{
2015-06-09 18:45:55 +08:00
if(nullptr != triangles.verts)
{
CC_SAFE_DELETE_ARRAY(triangles.verts);
}
if(nullptr != triangles.indices)
{
CC_SAFE_DELETE_ARRAY(triangles.indices);
}
}
}
2015-06-09 18:45:55 +08:00
unsigned int PolygonInfo::getVertCount() const
2015-06-04 15:43:31 +08:00
{
return (unsigned int)triangles.vertCount;
}
unsigned int PolygonInfo::getTrianglesCount() const
{
return (unsigned int)triangles.indexCount/3;
}
unsigned int PolygonInfo::getTriaglesCount() const
{
return getTrianglesCount();
}
float PolygonInfo::getArea() const
2015-06-04 15:43:31 +08:00
{
float area = 0;
V3F_C4B_T2F *verts = triangles.verts;
unsigned short *indices = triangles.indices;
for(int i = 0; i < triangles.indexCount; i+=3)
{
auto A = verts[indices[i]].vertices;
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;
}
return area;
}
2015-05-20 06:07:50 +08:00
AutoPolygon::AutoPolygon(const std::string &filename)
:_image(nullptr)
,_data(nullptr)
,_filename("")
,_width(0)
,_height(0)
,_scaleFactor(0)
{
_filename = filename;
_image = new (std::nothrow) Image();
_image->initWithImageFile(filename);
CCASSERT(_image->getRenderFormat()==Texture2D::PixelFormat::RGBA8888, "unsupported format, currently only supports rgba8888");
_data = _image->getData();
_width = _image->getWidth();
_height = _image->getHeight();
_scaleFactor = Director::getInstance()->getContentScaleFactor();
}
2015-05-20 06:07:50 +08:00
AutoPolygon::~AutoPolygon()
{
CC_SAFE_DELETE(_image);
}
std::vector<Vec2> AutoPolygon::trace(const Rect& rect, const float& threshold)
{
2015-06-04 15:43:31 +08:00
Vec2 first = findFirstNoneTransparentPixel(rect, threshold);
return marchSquare(rect, first, threshold);
}
2015-06-04 15:43:31 +08:00
Vec2 AutoPolygon::findFirstNoneTransparentPixel(const Rect& rect, const float& threshold)
{
2015-06-09 11:23:37 +08:00
bool found = false;
Vec2 i;
for(i.y = rect.origin.y; i.y < rect.origin.y+rect.size.height; i.y++)
{
2015-06-04 15:43:31 +08:00
if(found)break;
for(i.x = rect.origin.x; i.x < rect.origin.x+rect.size.width; i.x++)
{
2015-06-04 15:43:31 +08:00
auto alpha = getAlphaByPos(i);
if(alpha>threshold)
{
found = true;
break;
}
}
}
CCASSERT(found, "image is all transparent!");
return i;
}
2015-05-20 06:07:50 +08:00
unsigned char AutoPolygon::getAlphaByIndex(const unsigned int& i)
{
return *(_data+i*4+3);
}
2015-06-09 18:45:55 +08:00
unsigned char AutoPolygon::getAlphaByPos(const Vec2& pos)
{
2015-06-09 18:45:55 +08:00
return *(_data+((int)pos.y*_width+(int)pos.x)*4+3);
}
unsigned int AutoPolygon::getSquareValue(const unsigned int& x, const unsigned int& y, const Rect& rect, const float& threshold)
{
/*
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;
2015-06-04 15:43:31 +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-Size(2,2));
Vec2 tl = Vec2(x-1, y-1);
sv += (fixedRect.containsPoint(tl) && getAlphaByPos(tl) > threshold)? 1 : 0;
Vec2 tr = Vec2(x, y-1);
sv += (fixedRect.containsPoint(tr) && getAlphaByPos(tr) > threshold)? 2 : 0;
Vec2 bl = Vec2(x-1, y);
sv += (fixedRect.containsPoint(bl) && getAlphaByPos(bl) > threshold)? 4 : 0;
Vec2 br = Vec2(x, y);
sv += (fixedRect.containsPoint(br) && getAlphaByPos(br) > threshold)? 8 : 0;
CCASSERT(sv != 0 && sv != 15, "square value should not be 0, or 15");
return sv;
}
std::vector<cocos2d::Vec2> AutoPolygon::marchSquare(const Rect& rect, const Vec2& start, const float& threshold)
{
int stepx = 0;
int stepy = 0;
int prevx = 0;
int prevy = 0;
int startx = start.x;
int starty = start.y;
int curx = startx;
int cury = starty;
unsigned int count = 0;
bool problem = false;
std::vector<int> case9s;
std::vector<int> case6s;
int i;
std::vector<int>::iterator it;
std::vector<cocos2d::Vec2> _points;
do{
int sv = getSquareValue(curx, cury, rect, threshold);
switch(sv){
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;
stepx = 0;
stepy = 1;
case9s.erase(it);
problem = true;
}
else
{
//not found, we go up, and add to case9s;
stepx = 0;
stepy = -1;
case9s.push_back(i);
}
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;
stepx = -1;
stepy = 0;
case6s.erase(it);
problem = true;
}
else{
//not found, we go up, and add to case9s;
stepx = 1;
stepy = 0;
case6s.push_back(i);
}
break;
default:
CCLOG("this shouldn't happen.");
}
//little optimization
// if previous direction is same as current direction,
// then we should modify the last vec to current
curx += stepx;
cury += stepy;
if(stepx == prevx && stepy == prevy)
{
2015-06-04 15:43:31 +08:00
_points.back().x = (float)(curx-rect.origin.x) / _scaleFactor;
_points.back().y = (float)(rect.size.height - cury + rect.origin.y) / _scaleFactor;
}
else if(problem)
{
//TODO: we triangulation cannot work collinear points, so we need to modify same point a little
//TODO: maybe we can detect if we go into a hole and coming back the hole, we should extract those points and remove them
2015-06-04 15:43:31 +08:00
_points.push_back(Vec2((float)(curx- rect.origin.x) / _scaleFactor, (float)(rect.size.height - cury + rect.origin.y) / _scaleFactor));
}
else{
2015-06-04 15:43:31 +08:00
_points.push_back(Vec2((float)(curx-rect.origin.x) / _scaleFactor, (float)(rect.size.height - cury + rect.origin.y) / _scaleFactor));
}
count++;
prevx = stepx;
prevy = stepy;
problem = false;
#if defined(COCOS2D_DEBUG) && (COCOS2D_DEBUG > 0)
const auto totalPixel = _width * _height;
CCASSERT(count <= totalPixel, "oh no, marching square cannot find starting position");
#endif
} while(curx != startx || cury != starty);
return _points;
}
2015-05-20 06:07:50 +08:00
float AutoPolygon::perpendicularDistance(const cocos2d::Vec2& i, const cocos2d::Vec2& start, const cocos2d::Vec2& end)
{
float res;
float slope;
float intercept;
if(start.x == end.x)
{
res = fabsf(i.x- end.x);
}
else if (start.y == end.y)
{
res = fabsf(i.y - end.y);
}
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);
}
return res;
}
2016-05-17 12:17:56 +08:00
std::vector<cocos2d::Vec2> AutoPolygon::rdp(const std::vector<cocos2d::Vec2>& v, float optimization)
{
if(v.size() < 3)
return v;
int index = -1;
float dist = 0;
//not looping first and last point
2015-06-09 11:23:37 +08:00
for(size_t i = 1; i < v.size()-1; i++)
{
float cdist = perpendicularDistance(v[i], v.front(), v.back());
if(cdist > dist)
{
dist = cdist;
2016-04-18 16:01:19 +08:00
index = static_cast<int>(i);
}
}
2015-05-20 06:07:50 +08:00
if (dist>optimization)
{
std::vector<Vec2>::const_iterator begin = v.begin();
std::vector<Vec2>::const_iterator end = v.end();
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);
r1.insert(r1.end(), r2.begin()+1, r2.end());
return r1;
}
else {
std::vector<Vec2> ret;
ret.push_back(v.front());
ret.push_back(v.back());
return ret;
}
}
2015-06-04 15:43:31 +08:00
std::vector<Vec2> AutoPolygon::reduce(const std::vector<Vec2>& points, const Rect& rect , const float& epsilon)
{
2015-06-04 15:43:31 +08:00
auto size = points.size();
// if there are less than 3 points, then we have nothing
if(size<3)
{
log("AUTOPOLYGON: cannot reduce points for %s that has less than 3 points in input, e: %f", _filename.c_str(), epsilon);
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)
{
log("AUTOPOLYGON: cannot reduce points for %s e: %f",_filename.c_str(), epsilon);
return points;
2015-06-04 15:43:31 +08:00
}
float maxEp = MIN(rect.size.width, rect.size.height);
float ep = clampf(epsilon, 0.0, maxEp/_scaleFactor/2);
std::vector<Vec2> result = rdp(points, ep);
2015-04-27 16:33:54 +08:00
2015-06-04 15:43:31 +08:00
auto last = result.back();
if (last.y > result.front().y && last.getDistance(result.front()) < ep * 0.5f)
2015-06-04 15:43:31 +08:00
{
result.front().y = last.y;
2015-06-04 15:43:31 +08:00
result.pop_back();
}
return result;
}
std::vector<Vec2> AutoPolygon::expand(const std::vector<Vec2>& points, const cocos2d::Rect &rect, const float& epsilon)
{
2015-06-04 15:43:31 +08:00
auto size = points.size();
// if there are less than 3 points, then we have nothing
2015-06-04 15:43:31 +08:00
if(size<3)
{
log("AUTOPOLYGON: cannot expand points for %s with less than 3 points, e: %f", _filename.c_str(), epsilon);
return std::vector<Vec2>();
}
ClipperLib::Path subj;
ClipperLib::PolyTree solution;
2015-06-04 15:43:31 +08:00
ClipperLib::PolyTree out;
for(const auto& pt : points)
{
subj << ClipperLib::IntPoint(pt.x* PRECISION, pt.y * PRECISION);
}
ClipperLib::ClipperOffset co;
co.AddPath(subj, ClipperLib::jtMiter, ClipperLib::etClosedPolygon);
co.Execute(solution, epsilon * PRECISION);
2015-06-04 15:43:31 +08:00
ClipperLib::PolyNode* p = solution.GetFirst();
2015-06-08 15:08:16 +08:00
if(!p)
{
log("AUTOPOLYGON: Clipper failed to expand the points");
return points;
}
2015-06-04 15:43:31 +08:00
while(p->IsHole()){
p = p->GetNext();
}
2015-06-06 13:31:25 +08:00
//turn the result into simply polygon (AKA, fix overlap)
2015-06-04 15:43:31 +08:00
//clamp into the specified rect
2015-06-09 18:45:55 +08:00
ClipperLib::Clipper cl;
2015-06-04 15:43:31 +08:00
cl.StrictlySimple(true);
cl.AddPath(p->Contour, ClipperLib::ptSubject, true);
2015-06-06 13:31:25 +08:00
//create the clipping rect
2015-06-04 15:43:31 +08:00
ClipperLib::Path clamp;
clamp.push_back(ClipperLib::IntPoint(0, 0));
clamp.push_back(ClipperLib::IntPoint(rect.size.width/_scaleFactor * PRECISION, 0));
clamp.push_back(ClipperLib::IntPoint(rect.size.width/_scaleFactor * PRECISION, rect.size.height/_scaleFactor * PRECISION));
clamp.push_back(ClipperLib::IntPoint(0, rect.size.height/_scaleFactor * PRECISION));
2015-06-04 15:43:31 +08:00
cl.AddPath(clamp, ClipperLib::ptClip, true);
cl.Execute(ClipperLib::ctIntersection, out);
std::vector<Vec2> outPoints;
2015-06-04 15:43:31 +08:00
ClipperLib::PolyNode* p2 = out.GetFirst();
while(p2->IsHole()){
p2 = p2->GetNext();
}
for(const auto& pt : p2->Contour)
{
outPoints.push_back(Vec2(pt.X/PRECISION, pt.Y/PRECISION));
}
return outPoints;
}
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
if(points.size()<3)
{
log("AUTOPOLYGON: cannot triangulate %s with less than 3 points", _filename.c_str());
return TrianglesCommand::Triangles();
}
std::vector<p2t::Point*> p2points;
for(const auto& pt : points)
2015-05-20 06:07:50 +08:00
{
p2t::Point * p = new (std::nothrow) p2t::Point(pt.x, pt.y);
p2points.push_back(p);
2015-05-20 06:07:50 +08:00
}
p2t::CDT cdt(p2points);
2015-05-20 06:07:50 +08:00
cdt.Triangulate();
std::vector<p2t::Triangle*> tris = cdt.GetTriangles();
2016-05-26 01:14:09 +08:00
// we won't know the size of verts and indices until we process all of the triangles!
std::vector<V3F_C4B_T2F> verts;
std::vector<unsigned short> indices;
2015-05-20 06:07:50 +08:00
unsigned short idx = 0;
unsigned short vdx = 0;
for(const auto& ite : tris)
2015-05-20 06:07:50 +08:00
{
for(int i = 0; i < 3; i++)
{
auto p = ite->GetPoint(i);
2015-05-20 06:07:50 +08:00
auto v3 = Vec3(p->x, p->y, 0);
bool found = false;
2015-06-09 11:23:37 +08:00
size_t j;
2015-05-20 06:07:50 +08:00
size_t length = vdx;
for(j = 0; j < length; j++)
{
if(verts[j].vertices == v3)
{
found = true;
break;
}
}
if(found)
{
//if we found the same vertex, don't add to verts, but use the same vertex with indices
2016-05-26 01:14:09 +08:00
indices.push_back(j);
2015-05-20 06:07:50 +08:00
idx++;
}
else
{
//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
V3F_C4B_T2F vert = {v3,c4b,t2f};
2016-05-26 01:14:09 +08:00
verts.push_back(vert);
indices.push_back(vdx);
2015-05-20 06:07:50 +08:00
idx++;
vdx++;
}
}
}
for(auto j : p2points)
2015-05-20 06:07:50 +08:00
{
delete j;
};
2016-05-26 01:14:09 +08:00
// now that we know the size of verts and indices we can create the buffers
V3F_C4B_T2F* vertsBuf = new (std::nothrow) V3F_C4B_T2F[verts.size()];
memcpy(vertsBuf, verts.data(), verts.size() * sizeof(V3F_C4B_T2F));
unsigned short* indicesBuf = new (std::nothrow) unsigned short[indices.size()];
memcpy(indicesBuf, indices.data(), indices.size() * sizeof(short));
// Triangles should really use std::vector and not arrays for verts and indices.
// Then the above memcpy would not be necessary
2016-05-26 07:00:48 +08:00
TrianglesCommand::Triangles triangles = { vertsBuf, indicesBuf, static_cast<int>(verts.size()), static_cast<int>(indices.size()) };
return triangles;
2015-05-20 06:07:50 +08:00
}
2015-06-04 15:43:31 +08:00
void AutoPolygon::calculateUV(const Rect& rect, V3F_C4B_T2F* verts, const 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
*/
CCASSERT(_width && _height, "please specify width and height for this AutoPolygon instance");
2015-06-04 15:43:31 +08:00
float texWidth = _width;
float texHeight = _height;
auto end = &verts[count];
for(auto i = verts; i != end; i++)
2015-05-20 06:07:50 +08:00
{
// for every point, offset with the center point
2015-06-04 15:43:31 +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;
//check rect to see if its zero
if(realRect.equals(Rect::ZERO))
{
//if the instance doesn't have width and height, then the whole operation is kaput
CCASSERT(_height && _width, "Please specify a width and height for this instance before using its functions");
realRect = Rect(0,0, _width, _height);
}
else{
//rect is specified, so convert to real rect
2015-07-31 15:49:44 +08:00
realRect = CC_RECT_POINTS_TO_PIXELS(rect);
2015-06-04 15:43:31 +08:00
}
return realRect;
}
PolygonInfo AutoPolygon::generateTriangles(const Rect& rect, const float& epsilon, const float& threshold)
{
2015-06-04 15:43:31 +08:00
Rect realRect = getRealRect(rect);
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;
ret.triangles = tri;
ret.setFilename(_filename);
ret.setRect(realRect);
return ret;
2015-06-04 15:43:31 +08:00
}
2015-06-04 15:43:31 +08:00
PolygonInfo AutoPolygon::generatePolygon(const std::string& filename, const Rect& rect, const float epsilon, const float threshold)
{
2015-06-09 11:23:37 +08:00
AutoPolygon ap(filename);
return ap.generateTriangles(rect, epsilon, threshold);
2015-06-04 15:43:31 +08:00
}