int
limnPolyDataCopy(limnPolyData *pldB, const limnPolyData *pldA) {
char me[]="limnPolyDataCopy", err[BIFF_STRLEN];
if (!( pldB && pldA )) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(LIMN, err); return 1;
}
if (limnPolyDataAlloc(pldB, limnPolyDataInfoBitFlag(pldA),
pldA->xyzwNum, pldA->indxNum, pldA->primNum)) {
sprintf(err, "%s: couldn't allocate output", me);
biffAdd(LIMN, err); return 1;
}
memcpy(pldB->xyzw, pldA->xyzw, pldA->xyzwNum*sizeof(float)*4);
if (pldA->rgba) {
memcpy(pldB->rgba, pldA->rgba, pldA->rgbaNum*sizeof(unsigned char)*4);
}
if (pldA->norm) {
memcpy(pldB->norm, pldA->norm, pldA->normNum*sizeof(float)*3);
}
if (pldA->tex2) {
memcpy(pldB->tex2, pldA->tex2, pldA->tex2Num*sizeof(float)*2);
}
memcpy(pldB->indx, pldA->indx, pldA->indxNum*sizeof(unsigned int));
memcpy(pldB->type, pldA->type, pldA->primNum*sizeof(signed char));
memcpy(pldB->icnt, pldA->icnt, pldA->primNum*sizeof(unsigned int));
return 0;
}
int
limnPolyDataCopyN(limnPolyData *pldB, const limnPolyData *pldA,
unsigned int num) {
char me[]="limnPolyDataCopyN", err[BIFF_STRLEN];
unsigned int ii, jj, size;
if (!( pldB && pldA )) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(LIMN, err); return 1;
}
if (limnPolyDataAlloc(pldB, limnPolyDataInfoBitFlag(pldA),
num*pldA->xyzwNum,
num*pldA->indxNum,
num*pldA->primNum)) {
sprintf(err, "%s: couldn't allocate output", me);
biffAdd(LIMN, err); return 1;
}
for (ii=0; ii<num; ii++) {
/* fprintf(stderr, "!%s: ii = %u/%u\n", me, ii, num); */
size = pldA->xyzwNum*4;
/*
char *_beg = (char *)(pldB->xyzw + ii*size);
char *_end = _beg + size - 1;
fprintf(stderr, "!%s: memcpy(%p+%u=%p,%u) --> [%p,%p] inside: %d %d\n", me,
pldB->xyzw, ii*size, pldB->xyzw + ii*size, size,
_beg, _end, AIR_IN_CL(_xyzwBeg, _beg, _xyzwEnd),
AIR_IN_CL(_xyzwBeg, _end, _xyzwEnd));
*/
memcpy(pldB->xyzw + ii*size, pldA->xyzw, size*sizeof(float));
for (jj=0; jj<pldA->indxNum; jj++) {
(pldB->indx + ii*pldA->indxNum)[jj] = pldA->indx[jj] + ii*pldA->xyzwNum;
}
size = pldA->primNum;
memcpy(pldB->type + ii*size, pldA->type, size*sizeof(unsigned char));
memcpy(pldB->icnt + ii*size, pldA->icnt, size*sizeof(unsigned int));
if (pldA->rgba) {
size = pldA->rgbaNum*4;
memcpy(pldB->rgba + ii*size, pldA->rgba, size*sizeof(unsigned char));
}
if (pldA->norm) {
size = pldA->normNum*3;
memcpy(pldB->norm + ii*size, pldA->norm, size*sizeof(float));
}
if (pldA->tex2) {
size = pldA->tex2Num*2;
memcpy(pldB->tex2 + ii*size, pldA->tex2, size*sizeof(float));
}
}
return 0;
}
int
limnPolyDataSpiralTubeWrap(limnPolyData *pldOut, const limnPolyData *pldIn,
unsigned int infoBitFlag, Nrrd *nvertmap,
unsigned int tubeFacet, unsigned int endFacet,
double radius) {
char me[]="limnPolyDataSpiralTubeWrap", err[BIFF_STRLEN];
double *cost, *sint;
unsigned int tubeVertNum = 0, tubeIndxNum = 0, primIdx, pi, *vertmap;
unsigned int inVertTotalIdx = 0, outVertTotalIdx = 0, outIndxIdx = 0;
int color;
airArray *mop;
if (!( pldOut && pldIn )) {
sprintf(err, "%s: got NULL pointer", me);
return 1;
}
if ((1 << limnPrimitiveLineStrip) != limnPolyDataPrimitiveTypes(pldIn)) {
sprintf(err, "%s: sorry, can only handle %s primitives", me,
airEnumStr(limnPrimitive, limnPrimitiveLineStrip));
biffAdd(LIMN, err); return 1;
}
for (primIdx=0; primIdx<pldIn->primNum; primIdx++) {
tubeVertNum += tubeFacet*(2*endFacet
+ pldIn->icnt[primIdx]) + 1;
tubeIndxNum += 2*tubeFacet*(2*endFacet
+ pldIn->icnt[primIdx] + 1)-2;
}
if (limnPolyDataAlloc(pldOut,
/* sorry have to have normals, even if they weren't
asked for, because currently they're used as part
of vertex position calc */
(infoBitFlag | (1 << limnPolyDataInfoNorm)),
tubeVertNum, tubeIndxNum, pldIn->primNum)) {
sprintf(err, "%s: trouble allocating output", me);
biffAdd(LIMN, err); return 1;
}
if (nvertmap) {
if (nrrdMaybeAlloc_va(nvertmap, nrrdTypeUInt, 1,
AIR_CAST(size_t, tubeVertNum))) {
sprintf(err, "%s: trouble allocating vert map", me);
biffMove(LIMN, err, NRRD); return 1;
}
vertmap = AIR_CAST(unsigned int *, nvertmap->data);
} else {
int
limnPolyDataCube(limnPolyData *pld,
unsigned int infoBitFlag,
int sharpEdge) {
char me[]="limnPolyDataCube", err[BIFF_STRLEN];
unsigned int vertNum, vertIdx, primNum, indxNum, cnum, ci;
float cn;
vertNum = sharpEdge ? 6*4 : 8;
primNum = 1;
indxNum = 6*4;
if (limnPolyDataAlloc(pld, infoBitFlag, vertNum, indxNum, primNum)) {
sprintf(err, "%s: couldn't allocate output", me);
biffAdd(LIMN, err); return 1;
}
vertIdx = 0;
cnum = sharpEdge ? 3 : 1;
cn = AIR_CAST(float, sqrt(3.0));
for (ci=0; ci<cnum; ci++) {
ELL_4V_SET(pld->xyzw + 4*vertIdx, -1, -1, -1, 1); vertIdx++;
}
for (ci=0; ci<cnum; ci++) {
ELL_4V_SET(pld->xyzw + 4*vertIdx, -1, 1, -1, 1); vertIdx++;
}
for (ci=0; ci<cnum; ci++) {
ELL_4V_SET(pld->xyzw + 4*vertIdx, 1, 1, -1, 1); vertIdx++;
}
for (ci=0; ci<cnum; ci++) {
ELL_4V_SET(pld->xyzw + 4*vertIdx, 1, -1, -1, 1); vertIdx++;
}
for (ci=0; ci<cnum; ci++) {
ELL_4V_SET(pld->xyzw + 4*vertIdx, -1, -1, 1, 1); vertIdx++;
}
for (ci=0; ci<cnum; ci++) {
ELL_4V_SET(pld->xyzw + 4*vertIdx, -1, 1, 1, 1); vertIdx++;
}
for (ci=0; ci<cnum; ci++) {
ELL_4V_SET(pld->xyzw + 4*vertIdx, 1, 1, 1, 1); vertIdx++;
}
for (ci=0; ci<cnum; ci++) {
ELL_4V_SET(pld->xyzw + 4*vertIdx, 1, -1, 1, 1); vertIdx++;
}
vertIdx = 0;
if (sharpEdge) {
ELL_4V_SET(pld->indx + vertIdx, 0, 3, 6, 9); vertIdx += 4;
ELL_4V_SET(pld->indx + vertIdx, 2, 14, 16, 5); vertIdx += 4;
ELL_4V_SET(pld->indx + vertIdx, 4, 17, 18, 8); vertIdx += 4;
ELL_4V_SET(pld->indx + vertIdx, 7, 19, 21, 10); vertIdx += 4;
ELL_4V_SET(pld->indx + vertIdx, 1, 11, 23, 13); vertIdx += 4;
ELL_4V_SET(pld->indx + vertIdx, 12, 22, 20, 15); vertIdx += 4;
} else {
ELL_4V_SET(pld->indx + vertIdx, 0, 1, 2, 3); vertIdx += 4;
ELL_4V_SET(pld->indx + vertIdx, 0, 4, 5, 1); vertIdx += 4;
ELL_4V_SET(pld->indx + vertIdx, 1, 5, 6, 2); vertIdx += 4;
ELL_4V_SET(pld->indx + vertIdx, 2, 6, 7, 3); vertIdx += 4;
ELL_4V_SET(pld->indx + vertIdx, 0, 3, 7, 4); vertIdx += 4;
ELL_4V_SET(pld->indx + vertIdx, 4, 7, 6, 5); vertIdx += 4;
}
if ((1 << limnPolyDataInfoNorm) & infoBitFlag) {
if (sharpEdge) {
ELL_3V_SET(pld->norm + 3*0, 0, 0, -1);
ELL_3V_SET(pld->norm + 3*3, 0, 0, -1);
ELL_3V_SET(pld->norm + 3*6, 0, 0, -1);
ELL_3V_SET(pld->norm + 3*9, 0, 0, -1);
ELL_3V_SET(pld->norm + 3*2, -1, 0, 0);
ELL_3V_SET(pld->norm + 3*5, -1, 0, 0);
ELL_3V_SET(pld->norm + 3*14, -1, 0, 0);
ELL_3V_SET(pld->norm + 3*16, -1, 0, 0);
ELL_3V_SET(pld->norm + 3*4, 0, 1, 0);
ELL_3V_SET(pld->norm + 3*8, 0, 1, 0);
ELL_3V_SET(pld->norm + 3*17, 0, 1, 0);
ELL_3V_SET(pld->norm + 3*18, 0, 1, 0);
ELL_3V_SET(pld->norm + 3*7, 1, 0, 0);
ELL_3V_SET(pld->norm + 3*10, 1, 0, 0);
ELL_3V_SET(pld->norm + 3*19, 1, 0, 0);
ELL_3V_SET(pld->norm + 3*21, 1, 0, 0);
ELL_3V_SET(pld->norm + 3*1, 0, -1, 0);
ELL_3V_SET(pld->norm + 3*11, 0, -1, 0);
ELL_3V_SET(pld->norm + 3*13, 0, -1, 0);
ELL_3V_SET(pld->norm + 3*23, 0, -1, 0);
ELL_3V_SET(pld->norm + 3*12, 0, 0, 1);
ELL_3V_SET(pld->norm + 3*15, 0, 0, 1);
ELL_3V_SET(pld->norm + 3*20, 0, 0, 1);
ELL_3V_SET(pld->norm + 3*22, 0, 0, 1);
} else {
ELL_3V_SET(pld->norm + 3*0, -cn, -cn, -cn);
ELL_3V_SET(pld->norm + 3*1, -cn, cn, -cn);
ELL_3V_SET(pld->norm + 3*2, cn, cn, -cn);
ELL_3V_SET(pld->norm + 3*3, cn, -cn, -cn);
ELL_3V_SET(pld->norm + 3*4, -cn, -cn, cn);
ELL_3V_SET(pld->norm + 3*5, -cn, cn, cn);
ELL_3V_SET(pld->norm + 3*6, cn, cn, cn);
ELL_3V_SET(pld->norm + 3*7, cn, -cn, cn);
}
}
pld->type[0] = limnPrimitiveQuads;
pld->icnt[0] = indxNum;
if ((1 << limnPolyDataInfoRGBA) & infoBitFlag) {
for (vertIdx=0; vertIdx<pld->rgbaNum; vertIdx++) {
ELL_4V_SET(pld->rgba + 4*vertIdx, 255, 255, 255, 255);
}
}
return 0;
}
int
limnPolyDataCylinder(limnPolyData *pld,
unsigned int infoBitFlag,
unsigned int thetaRes, int sharpEdge) {
char me[]="limnPolyDataCylinder", err[BIFF_STRLEN];
unsigned int vertNum, primNum, primIdx, indxNum, thetaIdx, vertIdx, blah;
double theta, cth, sth, sq2;
/* sanity bounds */
thetaRes = AIR_MAX(3, thetaRes);
vertNum = sharpEdge ? 4*thetaRes : 2*thetaRes;
primNum = 3;
indxNum = 2*thetaRes + 2*(thetaRes+1); /* 2 fans + 1 strip */
if (limnPolyDataAlloc(pld, infoBitFlag, vertNum, indxNum, primNum)) {
sprintf(err, "%s: couldn't allocate output", me);
biffAdd(LIMN, err); return 1;
}
vertIdx = 0;
for (blah=0; blah < (sharpEdge ? 2u : 1u); blah++) {
for (thetaIdx=0; thetaIdx<thetaRes; thetaIdx++) {
theta = AIR_AFFINE(0, thetaIdx, thetaRes, 0, 2*AIR_PI);
ELL_4V_SET_TT(pld->xyzw + 4*vertIdx, float,
cos(theta), sin(theta), 1, 1);
/*
fprintf(stderr, "!%s: vert[%u] = %g %g %g\n", me, vertIdx,
(pld->xyzw + 4*vertIdx)[0],
(pld->xyzw + 4*vertIdx)[1],
(pld->xyzw + 4*vertIdx)[2]);
*/
++vertIdx;
}
}
for (blah=0; blah < (sharpEdge ? 2u : 1u); blah++) {
for (thetaIdx=0; thetaIdx<thetaRes; thetaIdx++) {
theta = AIR_AFFINE(0, thetaIdx, thetaRes, 0, 2*AIR_PI);
ELL_4V_SET_TT(pld->xyzw + 4*vertIdx, float,
cos(theta), sin(theta), -1, 1);
/*
fprintf(stderr, "!%s: vert[%u] = %g %g %g\n", me, vertIdx,
(pld->xyzw + 4*vertIdx)[0],
(pld->xyzw + 4*vertIdx)[1],
(pld->xyzw + 4*vertIdx)[2]);
*/
++vertIdx;
}
}
primIdx = 0;
vertIdx = 0;
/* fan on top */
for (thetaIdx=0; thetaIdx<thetaRes; thetaIdx++) {
pld->indx[vertIdx++] = thetaIdx;
}
pld->type[primIdx] = limnPrimitiveTriangleFan;
pld->icnt[primIdx] = thetaRes;
primIdx++;
/* single strip around */
for (thetaIdx=0; thetaIdx<thetaRes; thetaIdx++) {
pld->indx[vertIdx++] = (sharpEdge ? 1 : 0)*thetaRes + thetaIdx;
pld->indx[vertIdx++] = (sharpEdge ? 2 : 1)*thetaRes + thetaIdx;
}
pld->indx[vertIdx++] = (sharpEdge ? 1 : 0)*thetaRes;
pld->indx[vertIdx++] = (sharpEdge ? 2 : 1)*thetaRes;
pld->type[primIdx] = limnPrimitiveTriangleStrip;
pld->icnt[primIdx] = 2*(thetaRes+1);
primIdx++;
/* fan on bottom */
for (thetaIdx=0; thetaIdx<thetaRes; thetaIdx++) {
pld->indx[vertIdx++] = (sharpEdge ? 3 : 1)*thetaRes + thetaIdx;
}
pld->type[primIdx] = limnPrimitiveTriangleFan;
pld->icnt[primIdx] = thetaRes;
primIdx++;
if ((1 << limnPolyDataInfoNorm) & infoBitFlag) {
sq2 = sqrt(2.0);
if (sharpEdge) {
for (thetaIdx=0; thetaIdx<thetaRes; thetaIdx++) {
theta = AIR_AFFINE(0, thetaIdx, thetaRes, 0, 2*AIR_PI);
cth = cos(theta);
sth = sin(theta);
ELL_3V_SET_TT(pld->norm + 3*(thetaIdx + 0*thetaRes),
float, 0, 0, 1);
ELL_3V_SET_TT(pld->norm + 3*(thetaIdx + 1*thetaRes),
float, cth, sth, 0);
ELL_3V_SET_TT(pld->norm + 3*(thetaIdx + 2*thetaRes),
float, cth, sth, 0);
ELL_3V_SET_TT(pld->norm + 3*(thetaIdx + 3*thetaRes),
float, 0, 0, -1);
}
} else {
for (thetaIdx=0; thetaIdx<thetaRes; thetaIdx++) {
