quadup[1] += d * planenormaly;
quadup[2] += d * planenormalz;
// VectorNormalize(quadup);
- d = 1.0 / sqrt(quadup[0] * quadup[0] + quadup[1] * quadup[1] + quadup[2] * quadup[2]);
+ d = (float)(1.0 / sqrt(quadup[0] * quadup[0] + quadup[1] * quadup[1] + quadup[2] * quadup[2]));
quadup[0] *= d;
quadup[1] *= d;
quadup[2] *= d;
outpoints[11] = planedist * planenormalz - quadsize * quadright[2] - quadsize * quadup[2];
}
-void PolygonF_Divide(unsigned int innumpoints, const float *inpoints, float planenormalx, float planenormaly, float planenormalz, float planedist, float epsilon, unsigned int outfrontmaxpoints, float *outfrontpoints, unsigned int *neededfrontpoints, unsigned int outbackmaxpoints, float *outbackpoints, unsigned int *neededbackpoints)
+int PolygonF_Clip(int innumpoints, const float *inpoints, float planenormalx, float planenormaly, float planenormalz, float planedist, float epsilon, int outfrontmaxpoints, float *outfrontpoints)
{
- unsigned int i, frontcount, backcount;
+ int i, frontcount = 0;
const float *n, *p;
float frac, pdist, ndist;
- frontcount = 0;
- backcount = 0;
- for (i = 0;i < innumpoints;i++)
+ if (innumpoints < 1)
+ return 0;
+ n = inpoints;
+ ndist = n[0] * planenormalx + n[1] * planenormaly + n[2] * planenormalz - planedist;
+ for(i = 0;i < innumpoints;i++)
{
- p = inpoints + i * 3;
+ p = n;
+ pdist = ndist;
n = inpoints + ((i + 1) < innumpoints ? (i + 1) : 0) * 3;
- pdist = p[0] * planenormalx + p[1] * planenormaly + p[2] * planenormalz - planedist;
ndist = n[0] * planenormalx + n[1] * planenormaly + n[2] * planenormalz - planedist;
if (pdist >= -epsilon)
{
}
frontcount++;
}
- if (pdist <= epsilon)
- {
- if (backcount < outbackmaxpoints)
- {
- *outbackpoints++ = p[0];
- *outbackpoints++ = p[1];
- *outbackpoints++ = p[2];
- }
- backcount++;
- }
if ((pdist > epsilon && ndist < -epsilon) || (pdist < -epsilon && ndist > epsilon))
{
frac = pdist / (pdist - ndist);
*outfrontpoints++ = p[2] + frac * (n[2] - p[2]);
}
frontcount++;
- if (backcount < outbackmaxpoints)
- {
- *outbackpoints++ = p[0] + frac * (n[0] - p[0]);
- *outbackpoints++ = p[1] + frac * (n[1] - p[1]);
- *outbackpoints++ = p[2] + frac * (n[2] - p[2]);
- }
- backcount++;
}
}
- if (neededfrontpoints)
- *neededfrontpoints = frontcount;
- if (neededbackpoints)
- *neededbackpoints = backcount;
+ return frontcount;
}
-void PolygonD_Divide(unsigned int innumpoints, const double *inpoints, double planenormalx, double planenormaly, double planenormalz, double planedist, double epsilon, unsigned int outfrontmaxpoints, double *outfrontpoints, unsigned int *neededfrontpoints, unsigned int outbackmaxpoints, double *outbackpoints, unsigned int *neededbackpoints)
+int PolygonD_Clip(int innumpoints, const double *inpoints, double planenormalx, double planenormaly, double planenormalz, double planedist, double epsilon, int outfrontmaxpoints, double *outfrontpoints)
{
- unsigned int i, frontcount, backcount;
+ int i, frontcount = 0;
const double *n, *p;
double frac, pdist, ndist;
- frontcount = 0;
- backcount = 0;
- for (i = 0;i < innumpoints;i++)
+ if (innumpoints < 1)
+ return 0;
+ n = inpoints;
+ ndist = n[0] * planenormalx + n[1] * planenormaly + n[2] * planenormalz - planedist;
+ for(i = 0;i < innumpoints;i++)
{
- p = inpoints + i * 3;
+ p = n;
+ pdist = ndist;
n = inpoints + ((i + 1) < innumpoints ? (i + 1) : 0) * 3;
- pdist = p[0] * planenormalx + p[1] * planenormaly + p[2] * planenormalz - planedist;
ndist = n[0] * planenormalx + n[1] * planenormaly + n[2] * planenormalz - planedist;
if (pdist >= -epsilon)
{
}
frontcount++;
}
- if (pdist <= epsilon)
- {
- if (backcount < outbackmaxpoints)
- {
- *outbackpoints++ = p[0];
- *outbackpoints++ = p[1];
- *outbackpoints++ = p[2];
- }
- backcount++;
- }
if ((pdist > epsilon && ndist < -epsilon) || (pdist < -epsilon && ndist > epsilon))
{
frac = pdist / (pdist - ndist);
*outfrontpoints++ = p[2] + frac * (n[2] - p[2]);
}
frontcount++;
- if (backcount < outbackmaxpoints)
+ }
+ }
+ return frontcount;
+}
+
+void PolygonF_Divide(int innumpoints, const float *inpoints, float planenormalx, float planenormaly, float planenormalz, float planedist, float epsilon, int outfrontmaxpoints, float *outfrontpoints, int *neededfrontpoints, int outbackmaxpoints, float *outbackpoints, int *neededbackpoints, int *oncountpointer)
+{
+ int i, frontcount = 0, backcount = 0, oncount = 0;
+ const float *n, *p;
+ float frac, pdist, ndist;
+ if (innumpoints)
+ {
+ n = inpoints;
+ ndist = n[0] * planenormalx + n[1] * planenormaly + n[2] * planenormalz - planedist;
+ for(i = 0;i < innumpoints;i++)
+ {
+ p = n;
+ pdist = ndist;
+ n = inpoints + ((i + 1) < innumpoints ? (i + 1) : 0) * 3;
+ ndist = n[0] * planenormalx + n[1] * planenormaly + n[2] * planenormalz - planedist;
+ if (pdist >= -epsilon)
+ {
+ if (pdist <= epsilon)
+ oncount++;
+ if (frontcount < outfrontmaxpoints)
+ {
+ *outfrontpoints++ = p[0];
+ *outfrontpoints++ = p[1];
+ *outfrontpoints++ = p[2];
+ }
+ frontcount++;
+ }
+ if (pdist <= epsilon)
+ {
+ if (backcount < outbackmaxpoints)
+ {
+ *outbackpoints++ = p[0];
+ *outbackpoints++ = p[1];
+ *outbackpoints++ = p[2];
+ }
+ backcount++;
+ }
+ if ((pdist > epsilon && ndist < -epsilon) || (pdist < -epsilon && ndist > epsilon))
+ {
+ oncount++;
+ frac = pdist / (pdist - ndist);
+ if (frontcount < outfrontmaxpoints)
+ {
+ *outfrontpoints++ = p[0] + frac * (n[0] - p[0]);
+ *outfrontpoints++ = p[1] + frac * (n[1] - p[1]);
+ *outfrontpoints++ = p[2] + frac * (n[2] - p[2]);
+ }
+ frontcount++;
+ if (backcount < outbackmaxpoints)
+ {
+ *outbackpoints++ = p[0] + frac * (n[0] - p[0]);
+ *outbackpoints++ = p[1] + frac * (n[1] - p[1]);
+ *outbackpoints++ = p[2] + frac * (n[2] - p[2]);
+ }
+ backcount++;
+ }
+ }
+ }
+ if (neededfrontpoints)
+ *neededfrontpoints = frontcount;
+ if (neededbackpoints)
+ *neededbackpoints = backcount;
+ if (oncountpointer)
+ *oncountpointer = oncount;
+}
+
+void PolygonD_Divide(int innumpoints, const double *inpoints, double planenormalx, double planenormaly, double planenormalz, double planedist, double epsilon, int outfrontmaxpoints, double *outfrontpoints, int *neededfrontpoints, int outbackmaxpoints, double *outbackpoints, int *neededbackpoints, int *oncountpointer)
+{
+ int i = 0, frontcount = 0, backcount = 0, oncount = 0;
+ const double *n, *p;
+ double frac, pdist, ndist;
+ if (innumpoints)
+ {
+ n = inpoints;
+ ndist = n[0] * planenormalx + n[1] * planenormaly + n[2] * planenormalz - planedist;
+ for(i = 0;i < innumpoints;i++)
+ {
+ p = n;
+ pdist = ndist;
+ n = inpoints + ((i + 1) < innumpoints ? (i + 1) : 0) * 3;
+ ndist = n[0] * planenormalx + n[1] * planenormaly + n[2] * planenormalz - planedist;
+ if (pdist >= -epsilon)
+ {
+ if (pdist <= epsilon)
+ oncount++;
+ if (frontcount < outfrontmaxpoints)
+ {
+ *outfrontpoints++ = p[0];
+ *outfrontpoints++ = p[1];
+ *outfrontpoints++ = p[2];
+ }
+ frontcount++;
+ }
+ if (pdist <= epsilon)
+ {
+ if (backcount < outbackmaxpoints)
+ {
+ *outbackpoints++ = p[0];
+ *outbackpoints++ = p[1];
+ *outbackpoints++ = p[2];
+ }
+ backcount++;
+ }
+ if ((pdist > epsilon && ndist < -epsilon) || (pdist < -epsilon && ndist > epsilon))
{
- *outbackpoints++ = p[0] + frac * (n[0] - p[0]);
- *outbackpoints++ = p[1] + frac * (n[1] - p[1]);
- *outbackpoints++ = p[2] + frac * (n[2] - p[2]);
+ oncount++;
+ frac = pdist / (pdist - ndist);
+ if (frontcount < outfrontmaxpoints)
+ {
+ *outfrontpoints++ = p[0] + frac * (n[0] - p[0]);
+ *outfrontpoints++ = p[1] + frac * (n[1] - p[1]);
+ *outfrontpoints++ = p[2] + frac * (n[2] - p[2]);
+ }
+ frontcount++;
+ if (backcount < outbackmaxpoints)
+ {
+ *outbackpoints++ = p[0] + frac * (n[0] - p[0]);
+ *outbackpoints++ = p[1] + frac * (n[1] - p[1]);
+ *outbackpoints++ = p[2] + frac * (n[2] - p[2]);
+ }
+ backcount++;
}
- backcount++;
}
}
if (neededfrontpoints)
*neededfrontpoints = frontcount;
if (neededbackpoints)
*neededbackpoints = backcount;
+ if (oncountpointer)
+ *oncountpointer = oncount;
}