//---------------------------------------------------------------------------
void CGQuadric::m_addTriangle(float x0, float y0, float z0, float nx0, float ny0, float nz0,
float x1, float y1, float z1, float nx1, float ny1, float nz1,
float x2, float y2, float z2, float nx2, float ny2, float nz2)
{
// Increase array storage by 3 vertices.
m_positions = (float*)realloc(m_positions,sizeof(float)*3*(m_vertexCount+3));
m_normals = (float*)realloc(m_normals,sizeof(float)*3*(m_vertexCount+3));
m_colors = (float*)realloc(m_colors,sizeof(float)*4*(m_vertexCount+3));
m_texcoords = (float*)realloc(m_texcoords,sizeof(float)*2*(m_vertexCount+3));
// Get the next free array position.
float *p=m_positions+3*m_vertexCount,
*n=m_normals +3*m_vertexCount,
*c=m_colors +4*m_vertexCount,
*t=m_texcoords+2*m_vertexCount;
// Set the respective values.
#define SET2(p,x,y) { (p)[0]=x; (p)[1]=y; }
#define SET3(p,x,y,z) { (p)[0]=x; (p)[1]=y; (p)[2]=z; }
SET3(p+0,x0,y0,z0) SET3(n+0,nx0,ny0,nz0) SET2(t+0,0,0) memcpy(c+0,m_standardRGBA,sizeof(float)*4);
SET3(p+3,x1,y1,z1) SET3(n+3,nx1,ny1,nz1) SET2(t+2,0,0) memcpy(c+4,m_standardRGBA,sizeof(float)*4);
SET3(p+6,x2,y2,z2) SET3(n+6,nx2,ny2,nz2) SET2(t+4,0,0) memcpy(c+8,m_standardRGBA,sizeof(float)*4);
#undef SET2
#undef SET3
// Increase internal vertex count.
m_vertexCount+=3;
}
static void step4(int *ix, int *mdist, mat_t mstar, mat_t nmstar,
mat_t mprime, col_t ccol, col_t crow, int nrows, int ncols,
int dmin, int row, int col)
{
int n, rstar, cstar, primeRow, primeCol;
/* generate temporary copy of mstar */
memcpy(nmstar, mstar, sizeof(mat_t));
/* star current zero */
SET2(nmstar, row, col);
/* find starred zero in current column */
cstar = col;
for (rstar = 0; rstar < nrows; rstar++)
if (GET2(mstar, rstar, cstar))
break;
while (rstar < nrows) {
/* unstar the starred zero */
CLEAR2(nmstar, rstar, cstar);
/* find primed zero in current row */
primeRow = rstar;
for (primeCol = 0; primeCol < ncols; primeCol++)
if (GET2(mprime, primeRow, primeCol))
break;
/* star the primed zero */
SET2(nmstar, primeRow, primeCol);
/* find starred zero in current column */
cstar = primeCol;
for (rstar = 0; rstar < nrows; rstar++)
if (GET2(mstar, rstar, cstar))
break;
}
/* use temporary copy as new mstar */
/* delete all primes, uncover all rows */
memcpy(mstar, nmstar, sizeof(mat_t));
memset(mprime, 0, sizeof(mat_t));
memset(crow, 0, sizeof(col_t));
/* move to step 2a */
step2a(ix, mdist, mstar, nmstar,
mprime, ccol, crow, nrows, ncols,
dmin);
}
int local_sieve(int a, int b) {
int sqr = (int) sqrt(b), gap = b - a;
int *mark2 = (int *) calloc(MAXN, sizeof(int));
for (int i = 0; i < Pt && P[i] <= sqr; i++) {
unsigned p = P[i], base = a / p * p;
while (base < a) base += p;
if (base == p) base += p;
for (unsigned j = base; j <= b; j += p)
SET2(j - a);
}
if (a == 1) SET2(0);
int ret = 0;
for (int i = 0; i <= gap; i++) {
if (!GET2(i))
ret++;
}
free(mark2);
return ret;
}
int Encrypt(unsigned char *out, u64 nonce[], u128 rk[], u64 key[], int numbytes)
{
u64 x[2],y[2];
u128 X[4],Y[4],Z[4];
if (numbytes==16){
x[0]=nonce[1]; y[0]=nonce[0]; nonce[0]++;
Enc(x,y,key,1);
((u64 *)out)[1]=x[0]; ((u64 *)out)[0]=y[0];
return 0;
}
SET1(X[0],nonce[1]);
SET2(Y[0],nonce[0]);
if (numbytes==32) Enc(X,Y,rk,2);
else{
X[1]=X[0];
SET2(Y[1],nonce[0]);
if (numbytes==64) Enc(X,Y,rk,4);
else{
X[2]=X[0];
SET2(Y[2],nonce[0]);
if (numbytes==96) Enc(X,Y,rk,6);
else{
X[3]=X[0];
SET2(Y[3],nonce[0]);
Enc(X,Y,rk,8);
}
}
}
STORE(out,X[0],Y[0]);
if (numbytes>=64) STORE(out+32,X[1],Y[1]);
if (numbytes>=96) STORE(out+64,X[2],Y[2]);
if (numbytes>=128) STORE(out+96,X[3],Y[3]);
return 0;
}
VGboolean shIsTessCacheValid (VGContext *c, SHPath *p)
{
SHfloat nX, nY;
SHVector2 X, Y;
SHMatrix3x3 mi, mchange;
VGboolean valid = VG_TRUE;
if (p->cacheDataValid == VG_FALSE) {
valid = VG_FALSE;
}
else if (p->cacheTransformInit == VG_FALSE) {
valid = VG_FALSE;
}
else if (shInvertMatrix( &p->cacheTransform, &mi ) == VG_FALSE) {
valid = VG_FALSE;
}
else
{
/* TODO: Compare change matrix for any scale or shear */
MULMATMAT( c->pathTransform, mi, mchange );
SET2( X, mi.m[0][0], mi.m[1][0] );
SET2( Y, mi.m[0][1], mi.m[1][1] );
nX = NORM2( X ); nY = NORM2( Y );
if (nX > 1.01f || nX < 0.99 ||
nY > 1.01f || nY < 0.99)
valid = VG_FALSE;
}
if (valid == VG_FALSE)
{
/* Update cache */
p->cacheDataValid = VG_TRUE;
p->cacheTransformInit = VG_TRUE;
p->cacheTransform = c->pathTransform;
p->cacheStrokeTessValid = VG_FALSE;
}
return valid;
}
static void step3(int *ix, int *mdist, mat_t mstar, mat_t nmstar,
mat_t mprime, col_t ccol, col_t crow, int nrows, int ncols,
int dmin)
{
int zerosFound;
int row, col, cstar;
zerosFound = 1;
while (zerosFound) {
zerosFound = 0;
for (col = 0; col < ncols; col++) {
if (GET1(ccol, col))
continue;
for (row = 0; row < nrows; row++) {
if (mdist[row + nrows * col] != 0)
continue;
if (GET1(crow, row))
continue;
/* prime zero */
SET2(mprime, row, col);
/* find starred zero in current row */
for (cstar = 0; cstar < ncols; cstar++)
if (GET2(mstar, row, cstar))
break;
if (cstar == ncols) { /* no starred zero */
/* move to step 4 */
step4(ix, mdist, mstar, nmstar,
mprime, ccol, crow, nrows, ncols,
dmin, row, col);
return;
} else {
SET1(crow, row);
CLEAR1(ccol, cstar);
zerosFound = 1;
break;
}
}
}
}
/* move to step 5 */
step5(ix, mdist, mstar, nmstar,
mprime, ccol, crow, nrows, ncols,
dmin);
}
int shDrawPatternMesh(SHPaint *p, SHVector2 *min, SHVector2 *max,
VGPaintMode mode, GLenum texUnit)
{
SHMatrix3x3 *m;
SHMatrix3x3 mi;
SHfloat migl[16];
SHint invertible;
SHVector2 corners[4];
VGfloat sx, sy;
SHImage *img;
int i;
/* Pick paint transform matrix */
SH_GETCONTEXT(0);
if (mode == VG_FILL_PATH)
m = &context->fillTransform;
else if (mode == VG_STROKE_PATH)
m = &context->strokeTransform;
/* Boundbox corners */
SET2(corners[0], min->x, min->y);
SET2(corners[1], max->x, min->y);
SET2(corners[2], max->x, max->y);
SET2(corners[3], min->x, max->y);
/* Find inverse transformation (back to paint space) */
invertible = shInvertMatrix(m, &mi);
if (!invertible) {
/* Fill boundbox with tile fill color */
SHColor *c = &context->tileFillColor;
glColor4fv((GLfloat*)c); glBegin(GL_QUADS);
for (i=0; i<4; ++i) glVertex2fv((GLfloat*)&corners[i]);
glEnd();
return 1;
}
/* Setup texture coordinate transform */
img = (SHImage*)p->pattern;
sx = 1.0f/(VGfloat)img->texwidth;
sy = 1.0f/(VGfloat)img->texheight;
glActiveTexture(texUnit);
shMatrixToGL(&mi, migl);
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glScalef(sx, sy, 1.0f);
glMultMatrixf(migl);
/* Draw boundbox with same texture coordinates
that will get transformed back to paint space */
shSetPatternTexGLState(p, context);
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
for (i=0; i<4; ++i) {
glMultiTexCoord2f(texUnit, corners[i].x, corners[i].y);
glVertex2fv((GLfloat*)&corners[i]);
}
glEnd();
glDisable(GL_TEXTURE_2D);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
return 1;
}
int shDrawRadialGradientMesh(SHPaint *p, SHVector2 *min, SHVector2 *max,
VGPaintMode mode, GLenum texUnit)
{
SHint i, j;
float a, n;
SHfloat cx = p->radialGradient[0];
SHfloat cy = p->radialGradient[1];
SHfloat fx = p->radialGradient[2];
SHfloat fy = p->radialGradient[3];
float r = p->radialGradient[4];
float fcx, fcy, rr, C;
SHVector2 ux;
SHVector2 uy;
SHVector2 c, f;
SHVector2 cf;
SHMatrix3x3 *m;
SHMatrix3x3 mi;
SHint invertible;
SHVector2 corners[4];
SHVector2 fcorners[4];
SHfloat minOffset=0.0f;
SHfloat maxOffset=0.0f;
SHint maxI=0, maxJ=0;
SHfloat maxA=0.0f;
SHfloat startA=0.0f;
int numsteps = 100;
float step = 2*PI/numsteps;
SHVector2 tmin, tmax;
SHVector2 min1, max1, min2, max2;
/* Pick paint transform matrix */
SH_GETCONTEXT(0);
if (mode == VG_FILL_PATH)
m = &context->fillTransform;
else if (mode == VG_STROKE_PATH)
m = &context->strokeTransform;
/* Move focus into circle if outside */
SET2(cf, fx,fy);
SUB2(cf, cx,cy);
n = NORM2(cf);
if (n > r) {
DIV2(cf, n);
fx = cx + 0.995f * r * cf.x;
fy = cy + 0.995f * r * cf.y;
}
/* Precalculations */
rr = r*r;
fcx = fx - cx;
fcy = fy - cy;
C = fcx*fcx + fcy*fcy - rr;
/* Apply paint-to-user transformation
to focus and unit vectors */
SET2(f, fx, fy);
SET2(c, cx, cy);
SET2(ux, 1, 0);
SET2(uy, 0, 1);
ADD2(ux, cx, cy);
ADD2(uy, cx, cy);
TRANSFORM2(f, (*m));
TRANSFORM2(c, (*m));
TRANSFORM2(ux, (*m));
TRANSFORM2(uy, (*m));
SUB2V(ux, c); SUB2V(uy, c);
/* Boundbox corners */
SET2(corners[0], min->x, min->y);
SET2(corners[1], max->x, min->y);
SET2(corners[2], max->x, max->y);
SET2(corners[3], min->x, max->y);
/* Find inverse transformation (back to paint space) */
invertible = shInvertMatrix(m, &mi);
if (!invertible || r <= 0.0f) {
/* Fill boundbox with color at offset 1 */
SHColor *c = &p->stops.items[p->stops.size-1].color;
glColor4fv((GLfloat*)c); glBegin(GL_QUADS);
for (i=0; i<4; ++i) glVertex2fv((GLfloat*)&corners[i]);
glEnd();
return 1;
}
/*--------------------------------------------------------*/
/* Find min/max offset */
for (i=0; i<4; ++i) {
/* Transform to paint space */
SHfloat ax,ay, A,B,D,t, off;
TRANSFORM2TO(corners[i], mi, fcorners[i]);
SUB2(fcorners[i], fx, fy);
n = NORM2(fcorners[i]);
if (n == 0.0f) {
/* Avoid zero-length vectors */
off = 0.0f;
}else{
/* Distance from focus to circle at corner angle */
DIV2(fcorners[i], n);
ax = fcorners[i].x;
ay = fcorners[i].y;
A = ax*ax + ay*ay;
B = 2 * (fcx*ax + fcy*ay);
D = B*B - 4*A*C;
t = (-B + SH_SQRT(D)) / (2*A);
/* Relative offset of boundbox corner */
if (D <= 0.0f) off = 1.0f;
else off = n / t;
}
/* Find smallest and largest offset */
if (off < minOffset || i==0) minOffset = off;
if (off > maxOffset || i==0) maxOffset = off;
}
/* Is transformed focus inside original boundbox? */
if (f.x >= min->x && f.x <= max->x &&
f.y >= min->y && f.y <= max->y) {
/* Draw whole circle */
minOffset = 0.0f;
startA = 0.0f;
maxA = 2*PI;
}else{
/* Find most distant corner pair */
for (i=0; i<3; ++i) {
if (ISZERO2(fcorners[i])) continue;
for (j=i+1; j<4; ++j) {
if (ISZERO2(fcorners[j])) continue;
a = ANGLE2N(fcorners[i], fcorners[j]);
if (a > maxA || maxA == 0.0f)
{maxA=a; maxI=i; maxJ=j;}
}}
/* Pick starting angle */
if (CROSS2(fcorners[maxI],fcorners[maxJ]) > 0.0f)
startA = shVectorOrientation(&fcorners[maxI]);
else startA = shVectorOrientation(&fcorners[maxJ]);
}
/*---------------------------------------------------------*/
/* TODO: for minOffset we'd actually need to find minimum
of the gradient function when X and Y are substitued
with a line equation for each bound-box edge. As a
workaround we use 0.0f for now. */
minOffset = 0.0f;
step = PI/50;
numsteps = (SHint)SH_CEIL(maxA / step) + 1;
glActiveTexture(texUnit);
shSetGradientTexGLState(p);
glEnable(GL_TEXTURE_1D);
glBegin(GL_QUADS);
/* Walk the steps and draw gradient mesh */
for (i=0, a=startA; i<numsteps; ++i, a+=step) {
/* Distance from focus to circle border
at current angle (gradient space) */
float ax = SH_COS(a);
float ay = SH_SIN(a);
float A = ax*ax + ay*ay;
float B = 2 * (fcx*ax + fcy*ay);
float D = B*B - 4*A*C;
float t = (-B + SH_SQRT(D)) / (2*A);
if (D <= 0.0f) t = 0.0f;
/* Vectors pointing towards minimum and maximum
offset at current angle (gradient space) */
tmin.x = ax * t * minOffset;
tmin.y = ay * t * minOffset;
tmax.x = ax * t * maxOffset;
tmax.y = ay * t * maxOffset;
/* Transform back to user space */
min2.x = f.x + tmin.x * ux.x + tmin.y * uy.x;
min2.y = f.y + tmin.x * ux.y + tmin.y * uy.y;
max2.x = f.x + tmax.x * ux.x + tmax.y * uy.x;
max2.y = f.y + tmax.x * ux.y + tmax.y * uy.y;
/* Draw quad */
if (i!=0) {
glMultiTexCoord1f(texUnit, minOffset);
glVertex2fv((GLfloat*)&min1);
glVertex2fv((GLfloat*)&min2);
glMultiTexCoord1f(texUnit, maxOffset);
glVertex2fv((GLfloat*)&max2);
glVertex2fv((GLfloat*)&max1);
}
/* Save prev points */
min1 = min2;
max1 = max2;
}
glEnd();
glDisable(GL_TEXTURE_1D);
return 1;
}
int shDrawLinearGradientMesh(SHPaint *p, SHVector2 *min, SHVector2 *max,
VGPaintMode mode, GLenum texUnit)
{
SHint i;
SHfloat n;
SHfloat x1 = p->linearGradient[0];
SHfloat y1 = p->linearGradient[1];
SHfloat x2 = p->linearGradient[2];
SHfloat y2 = p->linearGradient[3];
SHVector2 c, ux, uy;
SHVector2 cc, uux, uuy;
SHMatrix3x3 *m;
SHMatrix3x3 mi;
SHint invertible;
SHVector2 corners[4];
SHfloat minOffset = 0.0f;
SHfloat maxOffset = 0.0f;
SHfloat left = 0.0f;
SHfloat right = 0.0f;
SHVector2 l1,r1,l2,r2;
/* Pick paint transform matrix */
SH_GETCONTEXT(0);
if (mode == VG_FILL_PATH)
m = &context->fillTransform;
else if (mode == VG_STROKE_PATH)
m = &context->strokeTransform;
/* Gradient center and unit vectors */
SET2(c, x1, y1);
SET2(ux, x2-x1, y2-y1);
SET2(uy, -ux.y, ux.x);
n = NORM2(ux);
DIV2(ux, n);
NORMALIZE2(uy);
/* Apply paint-to-user transformation */
ADD2V(ux, c); ADD2V(uy, c);
TRANSFORM2TO(c, (*m), cc);
TRANSFORM2TO(ux, (*m), uux);
TRANSFORM2TO(uy, (*m), uuy);
SUB2V(ux,c); SUB2V(uy,c);
SUB2V(uux,cc); SUB2V(uuy,cc);
/* Boundbox corners */
SET2(corners[0], min->x, min->y);
SET2(corners[1], max->x, min->y);
SET2(corners[2], max->x, max->y);
SET2(corners[3], min->x, max->y);
/* Find inverse transformation (back to paint space) */
invertible = shInvertMatrix(m, &mi);
if (!invertible || n==0.0f) {
/* Fill boundbox with color at offset 1 */
SHColor *c = &p->stops.items[p->stops.size-1].color;
glColor4fv((GLfloat*)c); glBegin(GL_QUADS);
for (i=0; i<4; ++i) glVertex2fv((GLfloat*)&corners[i]);
glEnd();
return 1;
}
/*--------------------------------------------------------*/
for (i=0; i<4; ++i) {
/* Find min/max offset and perpendicular span */
SHfloat o, s;
TRANSFORM2(corners[i], mi);
SUB2V(corners[i], c);
o = DOT2(corners[i], ux) / n;
s = DOT2(corners[i], uy);
if (o < minOffset || i==0) minOffset = o;
if (o > maxOffset || i==0) maxOffset = o;
if (s < left || i==0) left = s;
if (s > right || i==0) right = s;
}
/*---------------------------------------------------------*/
/* Corners of boundbox in gradient system */
SET2V(l1, cc); SET2V(r1, cc);
SET2V(l2, cc); SET2V(r2, cc);
OFFSET2V(l1, uuy, left); OFFSET2V(l1, uux, minOffset * n);
OFFSET2V(r1, uuy, right); OFFSET2V(r1, uux, minOffset * n);
OFFSET2V(l2, uuy, left); OFFSET2V(l2, uux, maxOffset * n);
OFFSET2V(r2, uuy, right); OFFSET2V(r2, uux, maxOffset * n);
/* Draw quad using color-ramp texture */
glActiveTexture(texUnit);
shSetGradientTexGLState(p);
glEnable(GL_TEXTURE_1D);
glBegin(GL_QUAD_STRIP);
glMultiTexCoord1f(texUnit, minOffset);
glVertex2fv((GLfloat*)&r1);
glVertex2fv((GLfloat*)&l1);
glMultiTexCoord1f(texUnit, maxOffset);
glVertex2fv((GLfloat*)&r2);
glVertex2fv((GLfloat*)&l2);
glEnd();
glDisable(GL_TEXTURE_1D);
return 1;
}
VG_API_CALL void vgDrawImage(VGImage image)
{
SHImage *i;
SHfloat mgl[16];
SHfloat texGenS[4] = {0,0,0,0};
SHfloat texGenT[4] = {0,0,0,0};
SHPaint *fill;
SHVector2 min, max;
SHRectangle *rect;
VG_GETCONTEXT(VG_NO_RETVAL);
VG_RETURN_ERR_IF(!shIsValidImage(context, image),
VG_BAD_HANDLE_ERROR, VG_NO_RETVAL);
/* TODO: check if image is current render target */
/* Check whether scissoring is enabled and scissor
rectangle is valid */
if (context->scissoring == VG_TRUE) {
rect = &context->scissor.items[0];
if (context->scissor.size == 0) VG_RETURN( VG_NO_RETVAL );
if (rect->w <= 0.0f || rect->h <= 0.0f) VG_RETURN( VG_NO_RETVAL );
glScissor( (GLint)rect->x, (GLint)rect->y, (GLint)rect->w, (GLint)rect->h );
glEnable( GL_SCISSOR_TEST );
}
/* Apply image-user-to-surface transformation */
i = (SHImage*)image;
shMatrixToGL(&context->imageTransform, mgl);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glMultMatrixf(mgl);
/* Clamp to edge for proper filtering, modulate for multiply mode */
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, i->texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
/* Adjust antialiasing to settings */
if (context->imageQuality == VG_IMAGE_QUALITY_NONANTIALIASED) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glDisable(GL_MULTISAMPLE);
}else{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glEnable(GL_MULTISAMPLE);
}
/* Generate image texture coords automatically */
texGenS[0] = 1.0f / i->texwidth;
texGenT[1] = 1.0f / i->texheight;
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
glTexGenfv(GL_S, GL_OBJECT_PLANE, texGenS);
glTexGenfv(GL_T, GL_OBJECT_PLANE, texGenT);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
/* Pick fill paint */
fill = (context->fillPaint ? context->fillPaint : &context->defaultPaint);
/* Use paint color when multiplying with a color-paint */
if (context->imageMode == VG_DRAW_IMAGE_MULTIPLY &&
fill->type == VG_PAINT_TYPE_COLOR)
glColor4fv((GLfloat*)&fill->color);
else glColor4f(1,1,1,1);
/* Check image drawing mode */
if (context->imageMode == VG_DRAW_IMAGE_MULTIPLY &&
fill->type != VG_PAINT_TYPE_COLOR) {
/* Draw image quad into stencil */
glDisable(GL_BLEND);
glDisable(GL_TEXTURE_2D);
glEnable(GL_STENCIL_TEST);
glStencilFunc(GL_ALWAYS, 1, 1);
glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE);
glBegin(GL_QUADS);
glVertex2i(0, 0);
glVertex2i(i->width, 0);
glVertex2i(i->width, i->height);
glVertex2i(0, i->height);
glEnd();
/* Setup blending */
updateBlendingStateGL(context, 0);
/* Draw gradient mesh where stencil 1*/
glEnable(GL_TEXTURE_2D);
glStencilFunc(GL_EQUAL, 1, 1);
glStencilOp(GL_ZERO,GL_ZERO,GL_ZERO);
glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
SET2(min,0,0);
SET2(max, (SHfloat)i->width, (SHfloat)i->height);
if (fill->type == VG_PAINT_TYPE_RADIAL_GRADIENT) {
shDrawRadialGradientMesh(fill, &min, &max, VG_FILL_PATH, GL_TEXTURE1);
}else if (fill->type == VG_PAINT_TYPE_LINEAR_GRADIENT) {
shDrawLinearGradientMesh(fill, &min, &max, VG_FILL_PATH, GL_TEXTURE1);
}else if (fill->type == VG_PAINT_TYPE_PATTERN) {
shDrawPatternMesh(fill, &min, &max, VG_FILL_PATH, GL_TEXTURE1); }
glActiveTexture(GL_TEXTURE0);
glDisable(GL_TEXTURE_2D);
glDisable(GL_STENCIL_TEST);
}else if (context->imageMode == VG_DRAW_IMAGE_STENCIL) {
}else{/* Either normal mode or multiplying with a color-paint */
/* Setup blending */
updateBlendingStateGL(context, 0);
/* Draw textured quad */
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glVertex2i(0, 0);
glVertex2i(i->width, 0);
glVertex2i(i->width, i->height);
glVertex2i(0, i->height);
glEnd();
glDisable(GL_TEXTURE_2D);
}
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glPopMatrix();
if (context->scissoring == VG_TRUE)
glDisable( GL_SCISSOR_TEST );
VG_RETURN(VG_NO_RETVAL);
}
void
check_various (void)
{
mpz_t x, y;
mpz_init (x);
mpz_init (y);
mpz_realloc (x, (mp_size_t) 20);
mpz_realloc (y, (mp_size_t) 20);
/* 0 cmp 0, junk in low limbs */
SET1 (x,0, 123);
SET1 (y,0, 456);
check_all (x, y, 0, 0);
/* 123 cmp 0 */
SET1 (x,1, 123);
SET1 (y,0, 456);
check_all (x, y, 1, 1);
/* 123:456 cmp 0 */
SET2 (x,2, 456,123);
SET1 (y,0, 9999);
check_all (x, y, 1, 1);
/* 123 cmp 123 */
SET1(x,1, 123);
SET1(y,1, 123);
check_all (x, y, 0, 0);
/* -123 cmp 123 */
SET1(x,-1, 123);
SET1(y,1, 123);
check_all (x, y, -1, 0);
/* 123 cmp 456 */
SET1(x,1, 123);
SET1(y,1, 456);
check_all (x, y, -1, -1);
/* -123 cmp 456 */
SET1(x,-1, 123);
SET1(y,1, 456);
check_all (x, y, -1, -1);
/* 123 cmp -456 */
SET1(x,1, 123);
SET1(y,-1, 456);
check_all (x, y, 1, -1);
/* 1:0 cmp 1:0 */
SET2 (x,2, 1,0);
SET2 (y,2, 1,0);
check_all (x, y, 0, 0);
/* -1:0 cmp 1:0 */
SET2 (x,-2, 1,0);
SET2 (y,2, 1,0);
check_all (x, y, -1, 0);
/* 2:0 cmp 1:0 */
SET2 (x,2, 2,0);
SET2 (y,2, 1,0);
check_all (x, y, 1, 1);
/* 4:3:2:1 cmp 2:1 */
SET4 (x,4, 4,3,2,1);
SET2 (y,2, 2,1);
check_all (x, y, 1, 1);
/* -4:3:2:1 cmp 2:1 */
SET4 (x,-4, 4,3,2,1);
SET2 (y,2, 2,1);
check_all (x, y, -1, 1);
mpz_clear (x);
mpz_clear (y);
}
//gfd*
static void md5_process(mir_md5_state_t *pms, const mir_md5_byte_t *data /*[64]*/)
{
mir_md5_word_t
a = pms->abcd[0], b = pms->abcd[1],
c = pms->abcd[2], d = pms->abcd[3];
mir_md5_word_t t;
/* Define storage for little-endian or both types of CPUs. */
mir_md5_word_t xbuf[16];
const mir_md5_word_t *X;
{
/*
* Determine dynamically whether this is a big-endian or
* little-endian machine, since we can use a more efficient
* algorithm on the latter.
*/
static const int w = 1;
if (*((const mir_md5_byte_t *)&w)) /* dynamic little-endian */
{
/*
* On little-endian machines, we can process properly aligned
* data without copying it.
*/
if (!((data - (const mir_md5_byte_t *)0) & 3)) {
/* data are properly aligned */
X = (const mir_md5_word_t *)data;
} else {
/* not aligned */
memcpy(xbuf, data, 64);
X = xbuf;
}
}
else /* dynamic big-endian */
{
/*
* On big-endian machines, we must arrange the bytes in the
* right order.
*/
const mir_md5_byte_t *xp = data;
int i;
X = xbuf; /* (dynamic only) */
for (i = 0; i < 16; ++i, xp += 4)
xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
}
}
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
/* Round 1. */
/* Let [abcd k s i] denote the operation
a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
#define SET1(a, b, c, d, k, s, Ti)\
t = a + F(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET1(a, b, c, d, 0, 7, T1);
SET1(d, a, b, c, 1, 12, T2);
SET1(c, d, a, b, 2, 17, T3);
SET1(b, c, d, a, 3, 22, T4);
SET1(a, b, c, d, 4, 7, T5);
SET1(d, a, b, c, 5, 12, T6);
SET1(c, d, a, b, 6, 17, T7);
SET1(b, c, d, a, 7, 22, T8);
SET1(a, b, c, d, 8, 7, T9);
SET1(d, a, b, c, 9, 12, T10);
SET1(c, d, a, b, 10, 17, T11);
SET1(b, c, d, a, 11, 22, T12);
SET1(a, b, c, d, 12, 7, T13);
SET1(d, a, b, c, 13, 12, T14);
SET1(c, d, a, b, 14, 17, T15);
SET1(b, c, d, a, 15, 22, T16);
/* Round 2. */
/* Let [abcd k s i] denote the operation
a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
#define SET2(a, b, c, d, k, s, Ti)\
t = a + G(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET2(a, b, c, d, 1, 5, T17);
SET2(d, a, b, c, 6, 9, T18);
SET2(c, d, a, b, 11, 14, T19);
SET2(b, c, d, a, 0, 20, T20);
SET2(a, b, c, d, 5, 5, T21);
SET2(d, a, b, c, 10, 9, T22);
SET2(c, d, a, b, 15, 14, T23);
SET2(b, c, d, a, 4, 20, T24);
SET2(a, b, c, d, 9, 5, T25);
SET2(d, a, b, c, 14, 9, T26);
SET2(c, d, a, b, 3, 14, T27);
SET2(b, c, d, a, 8, 20, T28);
SET2(a, b, c, d, 13, 5, T29);
SET2(d, a, b, c, 2, 9, T30);
SET2(c, d, a, b, 7, 14, T31);
SET2(b, c, d, a, 12, 20, T32);
/* Round 3. */
/* Let [abcd k s t] denote the operation
a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define SET3(a, b, c, d, k, s, Ti)\
t = a + H(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET3(a, b, c, d, 5, 4, T33);
SET3(d, a, b, c, 8, 11, T34);
SET3(c, d, a, b, 11, 16, T35);
SET3(b, c, d, a, 14, 23, T36);
SET3(a, b, c, d, 1, 4, T37);
SET3(d, a, b, c, 4, 11, T38);
SET3(c, d, a, b, 7, 16, T39);
SET3(b, c, d, a, 10, 23, T40);
SET3(a, b, c, d, 13, 4, T41);
SET3(d, a, b, c, 0, 11, T42);
SET3(c, d, a, b, 3, 16, T43);
SET3(b, c, d, a, 6, 23, T44);
SET3(a, b, c, d, 9, 4, T45);
SET3(d, a, b, c, 12, 11, T46);
SET3(c, d, a, b, 15, 16, T47);
SET3(b, c, d, a, 2, 23, T48);
/* Round 4. */
/* Let [abcd k s t] denote the operation
a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
#define I(x, y, z) ((y) ^ ((x) | ~(z)))
#define SET4(a, b, c, d, k, s, Ti)\
t = a + I(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET4(a, b, c, d, 0, 6, T49);
SET4(d, a, b, c, 7, 10, T50);
SET4(c, d, a, b, 14, 15, T51);
SET4(b, c, d, a, 5, 21, T52);
SET4(a, b, c, d, 12, 6, T53);
SET4(d, a, b, c, 3, 10, T54);
SET4(c, d, a, b, 10, 15, T55);
SET4(b, c, d, a, 1, 21, T56);
SET4(a, b, c, d, 8, 6, T57);
SET4(d, a, b, c, 15, 10, T58);
SET4(c, d, a, b, 6, 15, T59);
SET4(b, c, d, a, 13, 21, T60);
SET4(a, b, c, d, 4, 6, T61);
SET4(d, a, b, c, 11, 10, T62);
SET4(c, d, a, b, 2, 15, T63);
SET4(b, c, d, a, 9, 21, T64);
/* Then perform the following additions. (That is increment each
of the four registers by the value it had before this block
was started.) */
pms->abcd[0] += a;
pms->abcd[1] += b;
pms->abcd[2] += c;
pms->abcd[3] += d;
}
/*
Converted from FORTRAN July 05, 1997 K. Tarbet
C
C---SUBROUTINE TO SET VARIABLE DIRECTIONS.
C DIRECTIONS MEASURED ANTICLOCKWISE FROM EAST IN RADIANS.
C
*/
void setdf2(void )
{
float FANG[9];
float dxx[3];
int i,j;
float dd;
/* INITIALISE ANGLES and slopes */
for (i=0; i<nx; i++)
{
ang[i][0]=-2;
ang[i][ny-1]=-2;
slope[i][0]=-1;
slope[i][ny-1]=-1;
}
for(i=0; i<ny; i++)
{
ang[0][i]=-2;
ang[nx-1][i]=-2;
slope[0][i]=-1;
slope[nx-1][i]=-1;
}
FANG[1]=0.;
FANG[2]=(float)atan2(dy,dx);
FANG[3]=(float) PI2;
FANG[4]=2*FANG[3]-FANG[2];
FANG[5]=2*FANG[3];
FANG[6]=2*FANG[3]+FANG[2];
FANG[7]=3*FANG[3];
FANG[8]=4*FANG[3]-FANG[2];
/* --INITIALISE INTERNAL POINTERS (-VE POINTER INDICATES OUTSIDE DOMAIN) */
for(i=1; i<ny-1; i++)
for(j=1; j<nx-1; j++)
{
if(dir[j][i] < 0)
{
ang[j][i]=-2.;
slope[j][i]=-1.; /* ! -1 slope indicates no data */
}
else if(dir[j][i] == 0)
{
ang[j][i]=-1.; /* DGT 9/2/97 since without */
slope[j][i]=0.; /* pit filling dir = 0 is possible */
/* ang = -1 designates unfilled pit, ang = -2 designates no data. */
}
else
ang[j][i]=0.;
}
/* TEST ALL INTERNAL ELEVATIONS AND SET SLOPE AND ANGLE */
dxx[1]=dx;
dxx[2]=dy;
dd=(float)sqrt(dx*dx+dy*dy);
for(i=1; i<ny-1; i++)
{
SetWorkingStatus();
for(j=1; j<nx-1; j++)
{
if(dir[j][i]>0 )
{
SET2(i,j,dxx,dd);
if(ang[j][i] < -0.5)
ang[j][i]=FANG[dir[j][i]];
}
}
}
}
static void ixoptimal(int *ix, int *mdist, int nrows, int ncols)
{
int *mdistTemp, *mdistEnd, *columnEnd, value, minValue;
int dmin, row, col;
col_t ccol, crow;
mat_t mstar, mprime, nmstar;
memset(ccol, 0, sizeof(col_t));
memset(crow, 0, sizeof(col_t));
memset(mstar, 0, sizeof(mat_t));
memset(mprime, 0, sizeof(mat_t));
memset(nmstar, 0, sizeof(mat_t));
/* initialization */
for (row = 0; row < nrows; row++)
ix[row] = -1;
mdistEnd = mdist + nrows * ncols;
/* preliminary steps */
if (nrows <= ncols) {
dmin = nrows;
for (row = 0; row < nrows; row++) {
/* find the smallest element in the row */
mdistTemp = mdist + row;
minValue = *mdistTemp;
mdistTemp += nrows;
while (mdistTemp < mdistEnd) {
value = *mdistTemp;
if (value < minValue)
minValue = value;
mdistTemp += nrows;
}
/* subtract the smallest element from each element
of the row */
mdistTemp = mdist + row;
while (mdistTemp < mdistEnd) {
*mdistTemp -= minValue;
mdistTemp += nrows;
}
}
/* Steps 1 and 2a */
for (row = 0; row < nrows; row++) {
for (col = 0; col < ncols; col++) {
if (mdist[row + nrows * col] != 0)
continue;
if (GET1(ccol, col))
continue;
SET2(mstar, row, col);
SET1(ccol, col);
break;
}
}
} else {
dmin = ncols;
for (col = 0; col < ncols; col++) {
/* find the smallest element in the column */
mdistTemp = mdist + nrows*col;
columnEnd = mdistTemp + nrows;
minValue = *mdistTemp++;
while (mdistTemp < columnEnd) {
value = *mdistTemp++;
if (value < minValue)
minValue = value;
}
/* subtract the smallest element from each element
of the column */
mdistTemp = mdist + nrows*col;
while (mdistTemp < columnEnd)
*mdistTemp++ -= minValue;
}
/* Steps 1 and 2a */
for (col = 0; col < ncols; col++) {
for (row = 0; row < nrows; row++) {
if (mdist[row + nrows * col] != 0)
continue;
if (GET1(crow, row))
continue;
SET2(mstar, row, col);
SET1(ccol, col);
SET1(crow, row);
break;
}
}
memset(crow, 0, sizeof(col_t));
}
/* move to step 2b */
step2b(ix, mdist, mstar, nmstar,
mprime, ccol, crow, nrows, ncols,
dmin);
}
