public override void update(float time)
{
if (this.m_bDirty)
{
for (int i = 0; i < this.m_sGridSize.x + 1; i++)
{
for (int j = 0; j < this.m_sGridSize.y + 1; j++)
{
ccVertex3F _ccVertex3F = base.originalVertex(new ccGridSize(i, j));
CCPoint cCPoint = new CCPoint(this.m_positionInPixels.x - (new CCPoint(_ccVertex3F.x, _ccVertex3F.y)).x, this.m_positionInPixels.y - (new CCPoint(_ccVertex3F.x, _ccVertex3F.y)).y);
float mFRadius = CCPointExtension.ccpLength(cCPoint);
if (mFRadius < this.m_fRadius)
{
mFRadius = this.m_fRadius - mFRadius;
float single = mFRadius / this.m_fRadius;
if (single == 0f)
{
single = 0.001f;
}
float single1 = (float)Math.Log((double)single) * this.m_fLensEffect;
float single2 = (float)Math.Exp((double)single1) * this.m_fRadius;
if (Math.Sqrt((double)(cCPoint.x * cCPoint.x + cCPoint.y * cCPoint.y)) > 0)
{
cCPoint = CCPointExtension.ccpNormalize(cCPoint);
CCPoint cCPoint1 = CCPointExtension.ccpMult(cCPoint, single2);
ccVertex3F _ccVertex3F1 = _ccVertex3F;
_ccVertex3F1.z = _ccVertex3F1.z + CCPointExtension.ccpLength(cCPoint1) * this.m_fLensEffect;
}
}
base.setVertex(new ccGridSize(i, j), _ccVertex3F);
}
}
this.m_bDirty = false;
}
}
public static float ccpAngle(CCPoint a, CCPoint b)
{
float single = (float)Math.Acos((double)CCPointExtension.ccpDot(CCPointExtension.ccpNormalize(a), CCPointExtension.ccpNormalize(b)));
if (Math.Abs(single) < ccMacros.FLT_EPSILON)
{
return(0f);
}
return(single);
}
public static float ccpAngleSigned(CCPoint a, CCPoint b)
{
CCPoint cCPoint = CCPointExtension.ccpNormalize(a);
CCPoint cCPoint1 = CCPointExtension.ccpNormalize(b);
float single = (float)Math.Atan2((double)(cCPoint.x * cCPoint1.y - cCPoint.y * cCPoint1.x), (double)CCPointExtension.ccpDot(cCPoint, cCPoint1));
if (Math.Abs(single) < ccMacros.FLT_EPSILON)
{
return(0f);
}
return(single);
}
public override void Update(float time)
{
if (m_bDirty)
{
int i, j;
for (i = 0; i < m_sGridSize.x + 1; ++i)
{
for (j = 0; j < m_sGridSize.y + 1; ++j)
{
ccVertex3F v = originalVertex(new ccGridSize(i, j));
CCPoint vect = new CCPoint(m_positionInPixels.X - new CCPoint(v.x, v.y).X, m_positionInPixels.Y - new CCPoint(v.x, v.y).Y);
float r = CCPointExtension.ccpLength(vect);
if (r < m_fRadius)
{
r = m_fRadius - r;
float pre_log = r / m_fRadius;
if (pre_log == 0)
{
pre_log = 0.001f;
}
float l = (float)Math.Log(pre_log) * m_fLensEffect;
float new_r = (float)Math.Exp(l) * m_fRadius;
if (Math.Sqrt((vect.X * vect.X + vect.Y * vect.Y)) > 0)
{
vect = CCPointExtension.ccpNormalize(vect);
CCPoint new_vect = CCPointExtension.ccpMult(vect, new_r);;
v.z += CCPointExtension.ccpLength(new_vect) * m_fLensEffect;
}
}
setVertex(new ccGridSize(i, j), v);
}
}
m_bDirty = false;
}
}
public override void update(float dt)
{
if (this.m_bIsActive && (this.m_fEmissionRate != 0f))
{
float num = 1f / this.m_fEmissionRate;
this.m_fEmitCounter += dt;
while ((this.m_uParticleCount < this.m_uTotalParticles) && (this.m_fEmitCounter > num))
{
this.addParticle();
this.m_fEmitCounter -= num;
}
this.m_fElapsed += dt;
if ((this.m_fDuration != -1f) && (this.m_fDuration < this.m_fElapsed))
{
this.stopSystem();
}
}
this.m_uParticleIdx = 0;
CCPoint tPosition = new CCPoint(0f, 0f);
if (this.m_ePositionType == eParticlePositionType.kCCPositionTypeFree)
{
tPosition = base.convertToWorldSpace(new CCPoint(0f, 0f));
tPosition.x *= CCDirector.sharedDirector().ContentScaleFactor;
tPosition.y *= CCDirector.sharedDirector().ContentScaleFactor;
}
else if (this.m_ePositionType == eParticlePositionType.kCCPositionTypeRelative)
{
tPosition = base.m_tPosition;
tPosition.x *= CCDirector.sharedDirector().ContentScaleFactor;
tPosition.y *= CCDirector.sharedDirector().ContentScaleFactor;
}
while (this.m_uParticleIdx < this.m_uParticleCount)
{
CCParticle particle = this.m_pParticles[this.m_uParticleIdx];
particle.timeToLive -= dt;
if (particle.timeToLive > 0f)
{
CCPoint pos;
if (this.m_nEmitterMode == 0)
{
CCPoint v = new CCPoint(0f, 0f);
if ((particle.pos.x != 0f) || (particle.pos.y != 0f))
{
v = CCPointExtension.ccpNormalize(particle.pos);
}
CCPoint point4 = v;
v = CCPointExtension.ccpMult(v, particle.modeA.radialAccel);
float x = point4.x;
point4.x = -point4.y;
point4.y = x;
point4 = CCPointExtension.ccpMult(point4, particle.modeA.tangentialAccel);
CCPoint point2 = CCPointExtension.ccpMult(CCPointExtension.ccpAdd(CCPointExtension.ccpAdd(v, point4), this.modeA.gravity), dt);
particle.modeA.dir = CCPointExtension.ccpAdd(particle.modeA.dir, point2);
point2 = CCPointExtension.ccpMult(particle.modeA.dir, dt);
particle.pos = CCPointExtension.ccpAdd(particle.pos, point2);
}
else
{
particle.modeB.angle += particle.modeB.degreesPerSecond * dt;
particle.modeB.radius += particle.modeB.deltaRadius * dt;
particle.pos.x = -((float)Math.Cos((double)particle.modeB.angle)) * particle.modeB.radius;
particle.pos.y = -((float)Math.Sin((double)particle.modeB.angle)) * particle.modeB.radius;
}
particle.color.r += particle.deltaColor.r * dt;
particle.color.g += particle.deltaColor.g * dt;
particle.color.b += particle.deltaColor.b * dt;
particle.color.a += particle.deltaColor.a * dt;
particle.size += particle.deltaSize * dt;
particle.size = (0f > particle.size) ? 0f : particle.size;
particle.rotation += particle.deltaRotation * dt;
if ((this.m_ePositionType == eParticlePositionType.kCCPositionTypeFree) || (this.m_ePositionType == eParticlePositionType.kCCPositionTypeRelative))
{
CCPoint point6 = CCPointExtension.ccpSub(tPosition, particle.startPos);
pos = CCPointExtension.ccpSub(particle.pos, point6);
}
else
{
pos = particle.pos;
}
this.updateQuadWithParticle(particle, pos);
this.m_uParticleIdx++;
}
else
{
if (this.m_uParticleIdx != (this.m_uParticleCount - 1))
{
this.m_pParticles[this.m_uParticleIdx].copy(this.m_pParticles[(int)((IntPtr)(this.m_uParticleCount - 1))]);
}
this.m_uParticleCount--;
if ((this.m_uParticleCount == 0) && this.m_bIsAutoRemoveOnFinish)
{
base.unscheduleUpdate();
base.m_pParent.removeChild(this, true);
return;
}
}
}
this.postStep();
}
public static void LineToPolygon(CCPoint[] points, float stroke, ccVertex2F[] vertices, int offset, int nuPoints)
{
int num;
CCPoint cCPoint;
nuPoints = nuPoints + offset;
if (nuPoints <= 1)
{
return;
}
stroke = stroke * 0.5f;
int num1 = nuPoints - 1;
for (int i = offset; i < nuPoints; i++)
{
num = i * 2;
CCPoint cCPoint1 = points[i];
if (i == 0)
{
cCPoint = CCPointExtension.ccpPerp(CCPointExtension.ccpNormalize(CCPointExtension.ccpSub(cCPoint1, points[i + 1])));
}
else if (i != num1)
{
CCPoint cCPoint2 = points[i + 1];
CCPoint cCPoint3 = points[i - 1];
CCPoint cCPoint4 = CCPointExtension.ccpNormalize(CCPointExtension.ccpSub(cCPoint2, cCPoint1));
CCPoint cCPoint5 = CCPointExtension.ccpNormalize(CCPointExtension.ccpSub(cCPoint3, cCPoint1));
float single = (float)Math.Acos((double)CCPointExtension.ccpDot(cCPoint4, cCPoint5));
if (single >= ccMacros.CC_DEGREES_TO_RADIANS(70f))
{
cCPoint = (single >= ccMacros.CC_DEGREES_TO_RADIANS(170f) ? CCPointExtension.ccpPerp(CCPointExtension.ccpNormalize(CCPointExtension.ccpSub(cCPoint2, cCPoint3))) : CCPointExtension.ccpNormalize(CCPointExtension.ccpMidpoint(cCPoint4, cCPoint5)));
}
else
{
cCPoint = CCPointExtension.ccpPerp(CCPointExtension.ccpNormalize(CCPointExtension.ccpMidpoint(cCPoint4, cCPoint5)));
}
}
else
{
cCPoint = CCPointExtension.ccpPerp(CCPointExtension.ccpNormalize(CCPointExtension.ccpSub(points[i - 1], cCPoint1)));
}
cCPoint = CCPointExtension.ccpMult(cCPoint, stroke);
vertices[num] = new ccVertex2F(cCPoint1.x + cCPoint.x, cCPoint1.y + cCPoint.y);
vertices[num + 1] = new ccVertex2F(cCPoint1.x - cCPoint.x, cCPoint1.y - cCPoint.y);
}
offset = (offset == 0 ? 0 : offset - 1);
for (int j = offset; j < num1; j++)
{
num = j * 2;
int num2 = num + 2;
ccVertex2F _ccVertex2F = vertices[num];
ccVertex2F _ccVertex2F1 = vertices[num + 1];
ccVertex2F _ccVertex2F2 = vertices[num2];
ccVertex2F _ccVertex2F3 = vertices[num2 + 1];
float single1 = 0f;
bool flag = !CCVertex.LineIntersect(_ccVertex2F.x, _ccVertex2F.y, _ccVertex2F3.x, _ccVertex2F3.y, _ccVertex2F1.x, _ccVertex2F1.y, _ccVertex2F2.x, _ccVertex2F2.y, out single1);
if (!flag && (single1 < 0f || single1 > 1f))
{
flag = true;
}
if (flag)
{
vertices[num2] = _ccVertex2F3;
vertices[num2 + 1] = _ccVertex2F2;
}
}
}
public static void LineToPolygon(CCPoint[] points, float stroke, ccVertex2F[] vertices, int offset, int nuPoints)
{
nuPoints += offset;
if (nuPoints <= 1)
{
return;
}
stroke *= 0.5f;
int idx;
int nuPointsMinus = nuPoints - 1;
for (int i = offset; i < nuPoints; i++)
{
idx = i * 2;
CCPoint p1 = points[i];
CCPoint perpVector;
if (i == 0)
{
perpVector = CCPointExtension.ccpPerp(CCPointExtension.ccpNormalize(CCPointExtension.ccpSub(p1, points[i + 1])));
}
else if (i == nuPointsMinus)
{
perpVector = CCPointExtension.ccpPerp(CCPointExtension.ccpNormalize(CCPointExtension.ccpSub(points[i - 1], p1)));
}
else
{
CCPoint p2 = points[i + 1];
CCPoint p0 = points[i - 1];
CCPoint p2p1 = CCPointExtension.ccpNormalize(CCPointExtension.ccpSub(p2, p1));
CCPoint p0p1 = CCPointExtension.ccpNormalize(CCPointExtension.ccpSub(p0, p1));
// Calculate angle between vectors
float angle = (float)Math.Acos(CCPointExtension.ccpDot(p2p1, p0p1));
if (angle < ccMacros.CC_DEGREES_TO_RADIANS(70))
{
perpVector = CCPointExtension.ccpPerp(CCPointExtension.ccpNormalize(CCPointExtension.ccpMidpoint(p2p1, p0p1)));
}
else if (angle < ccMacros.CC_DEGREES_TO_RADIANS(170))
{
perpVector = CCPointExtension.ccpNormalize(CCPointExtension.ccpMidpoint(p2p1, p0p1));
}
else
{
perpVector = CCPointExtension.ccpPerp(CCPointExtension.ccpNormalize(CCPointExtension.ccpSub(p2, p0)));
}
}
perpVector = CCPointExtension.ccpMult(perpVector, stroke);
vertices[idx] = new ccVertex2F(p1.x + perpVector.x, p1.y + perpVector.y);
vertices[idx + 1] = new ccVertex2F(p1.x - perpVector.x, p1.y - perpVector.y);
}
// Validate vertexes
offset = (offset == 0) ? 0 : (offset - 1);
for (int i = offset; i < nuPointsMinus; i++)
{
idx = i * 2;
int idx1 = idx + 2;
ccVertex2F p1 = vertices[idx];
ccVertex2F p2 = vertices[idx + 1];
ccVertex2F p3 = vertices[idx1];
ccVertex2F p4 = vertices[idx1 + 1];
float s = 0f;
//BOOL fixVertex = !ccpLineIntersect(ccp(p1.x, p1.y), ccp(p4.x, p4.y), ccp(p2.x, p2.y), ccp(p3.x, p3.y), &s, &t);
bool fixVertex = !LineIntersect(p1.x, p1.y, p4.x, p4.y, p2.x, p2.y, p3.x, p3.y, out s);
if (!fixVertex)
{
if (s < 0.0f || s > 1.0f)
{
fixVertex = true;
}
}
if (fixVertex)
{
vertices[idx1] = p4;
vertices[idx1 + 1] = p3;
}
}
}
