/** ------------------------------------------------------------------------ ** * \internal * * \brief Get a Scale and Translate Transform * * * * \param pDecISF structure used to decode the ISF file. * * * * \returns the error code given while processing * ** ------------------------------------------------------------------------ **/ int getTransformScaleAndTranslate (decodeISF_t * pDecISF) { int err = OK; transform_t * pTransform; /** * This tag consists of four values describing a scale and translate * transform matrix.\n * Those four values are coded in the stream as floats (IEEE 754)\n * We have in order: * - m11 * - m22 * - m13 * - m23 * * The transform matrix is :\n * \f[ * \mbox{T} = \left( \begin{array}{ccc} \mbox{m}_{11} & 0 & \mbox{m}_{13} \\ 0 & \mbox{m}_{22} & \mbox{m}_{23} \\ 0 & 0 & 1\\ \end{array} \right) * \f] * * \see #transform_t */ /* Check whether we should add a transform or use the default one */ if (pDecISF->lastTransform != &(pDecISF->transforms) ) { err = createTransform(&pTransform); if (err != OK) return err; } else { pTransform = *(pDecISF->lastTransform); } /* Fill the transform matrix */ err = readFloat (pDecISF, &pTransform->m11); if (err != OK) return err; err = readFloat (pDecISF, &pTransform->m22); if (err != OK) return err; err = readFloat (pDecISF, &pTransform->m13); if (err != OK) return err; err = readFloat (pDecISF, &pTransform->m23); if (err != OK) return err; LOG(stdout,"(TRANSFORM_SCALE_AND_TRANSLATE) m11 = %f\n", pTransform->m11); LOG(stdout,"(TRANSFORM_SCALE_AND_TRANSLATE) m22 = %f\n", pTransform->m22); LOG(stdout,"(TRANSFORM_SCALE_AND_TRANSLATE) m13 = %f\n", pTransform->m13); LOG(stdout,"(TRANSFORM_SCALE_AND_TRANSLATE) m23 = %f\n", pTransform->m23); /* Insert the current Transform */ *(pDecISF->lastTransform) = pTransform; pDecISF->lastTransform = &(pTransform->next); return err; }
/** ------------------------------------------------------------------------ ** * \internal * * \brief Get a Rotate Transform * * * * \param pDecISF structure used to decode the ISF file. * * * * \returns the error code given while processing * ** ------------------------------------------------------------------------ **/ int getTransformRotate (decodeISF_t * pDecISF) { int err = OK; INT64 rotate; double angle; transform_t * pTransform; /** * This tag consists of one MBUINT describing a rotate transform matrix.\n * Let's call this value "A". * * If A = 0, then there's no transformation to do; \n * elsewise A is one hundredth of a degree. * * The transform matrix is (with cos and sin working with radians) :\n * \f[ * \mbox{T} = \left( \begin{array}{ccc} \cos{\frac{\mbox{A} * 2 \pi}{36000}} & -\cos{\frac{\mbox{A} * 2 \pi}{36000}} & 0 \\ * \sin{\frac{\mbox{A} * 2 \pi}{36000}} & \cos{\frac{\mbox{A} * 2 \pi}{36000}} & 0 \\ * 0 & 0 & 1 \\ * \end{array} \right) * \f] * * \see #transform_t */ /* Check whether we should add a transform or use the default one */ if (pDecISF->lastTransform != &(pDecISF->transforms) ) { err = createTransform(&pTransform); if (err != OK) return err; } else { pTransform = *(pDecISF->lastTransform); } err = readMBUINT(pDecISF, &rotate); if (err == OK && rotate) { angle = (double) rotate * RADIANPER100THOFDEGREE; LOG(stdout,"(TRANSFORM_ROTATE) Rotate = %lld = %lf\n",rotate,angle); pTransform->m11 = pTransform->m22 = (float) cos(angle); pTransform->m12 = - pTransform->m11; pTransform->m21 = (float) sin(angle); /* Insert the current Transform */ *(pDecISF->lastTransform) = pTransform; pDecISF->lastTransform = &(pTransform->next); } return err; }
/** ------------------------------------------------------------------------ ** * \internal * * \brief Get a Translate Transform * * * * \param pDecISF structure used to decode the ISF file. * * * * \returns the error code given while processing * ** ------------------------------------------------------------------------ **/ int getTransformTranslate (decodeISF_t * pDecISF) { int err = OK; transform_t * pTransform; /** * This tag consists of 2 values describing a translate transform matrix.\n * Those two values are coded in the stream as floats (IEEE 754)\n * We have in order: * - dx * - dy * * The transform matrix is :\n * \f[ * \mbox{T} = \left( \begin{array}{ccc} 0 & 0 & \mbox{dx} \\ 0 & 0 & \mbox{dy} \\ 0 & 0 & 1\\ \end{array} \right) * \f] * * In fact the transform matrix shouldn't be like that cause that * transformation don't translate.\n * Anyway, it seems to work this way with the .Net 3.0 framework ... * The transform matrix should be :\n * \f[ * \mbox{T} = \left( \begin{array}{ccc} \mbox{1} & 0 & \mbox{dx} \\ 0 & \mbox{1} & \mbox{dy} \\ 0 & 0 & 1\\ \end{array} \right) * \f] */ /* Check whether we should add a transform or use the default one */ if (pDecISF->lastTransform != &(pDecISF->transforms) ) { err = createTransform(&pTransform); if (err != OK) return err; } else { pTransform = *(pDecISF->lastTransform); } err = readFloat (pDecISF, &pTransform->m13); if (err != OK) return err; err = readFloat (pDecISF, &pTransform->m23); if (err != OK) return err; LOG(stdout,"(TRANSFORM_TRANSLATE) m13 = %f\n", pTransform->m13); LOG(stdout,"(TRANSFORM_TRANSLATE) m23 = %f\n", pTransform->m23); /* Insert the current Transform */ *(pDecISF->lastTransform) = pTransform; pDecISF->lastTransform = &(pTransform->next); return err; }
void unlinkView(pScene sc1) { pScene sc2; if ( sc1->master == -1 ) return; /* copy master view */ sc2 = cv.scene[sc1->master]; sc1->view = (pTransform)createTransform(); memcpy(sc1->view,sc2->view,sizeof(struct transform)); /* remove link */ sc1->master = -1; sc2->slave = -1; }
void QgsTransformEffect::draw( QgsRenderContext &context ) { if ( !source() || !enabled() || !context.painter() ) return; QPainter* painter = context.painter(); //apply transformations painter->save(); QTransform t = createTransform( context ); painter->setTransform( t, true ); drawSource( *painter ); painter->restore(); }
/** ------------------------------------------------------------------------ ** * \internal * * \brief Get an Anisotropic Scale Transform * * * * \param pDecISF structure used to decode the ISF file. * * * * \returns the error code given while processing * ** ------------------------------------------------------------------------ **/ int getTransformAnisotropicScale (decodeISF_t * pDecISF) { int err = OK; transform_t * pTransform; /** * This tag consists of 2 values describing an anisotropic scale transform * matrix.\n * Those two values are coded in the stream as floats (IEEE 754)\n * We have in order: * - A * - B * * The transform matrix is :\n * \f[ * \mbox{T} = \left( \begin{array}{ccc} \mbox{A} & 0 & 0 \\ 0 & \mbox{B} & 0 \\ 0 & 0 & 1\\ \end{array} \right) * \f] */ /* Check whether we should add a transform or use the default one */ if (pDecISF->lastTransform != &(pDecISF->transforms) ) { err = createTransform(&pTransform); if (err != OK) return err; } else { pTransform = *(pDecISF->lastTransform); } err = readFloat (pDecISF, &pTransform->m11); if (err != OK) return err; err = readFloat (pDecISF, &pTransform->m22); if (err != OK) return err; LOG(stdout,"(TRANSFORM_ANISOTROPIC_SCALE) m11 = %f\n", pTransform->m11); LOG(stdout,"(TRANSFORM_ANISOTROPIC_SCALE) m22 = %f\n", pTransform->m22); /* Insert the current Transform */ *(pDecISF->lastTransform) = pTransform; pDecISF->lastTransform = &(pTransform->next); return err; }
bool ScColorSpaceData::convert(ScColorSpaceData& data, eRenderIntent renderIntent, long transformFlags, void* dataIn, void* dataOut, uint numElems, ScColorTransform* lastTrans) { ScColorTransform transform; if (lastTrans) transform = *lastTrans; if (!transform) transform = createTransform(data, renderIntent, transformFlags); bool success = false; if (transform) { success = transform.apply(dataIn, dataOut, numElems); if (!this->hasAlphaChannel() && data.hasAlphaChannel()) data.flattenAlpha(dataOut, numElems); success = true; } return success; }
/** ------------------------------------------------------------------------ ** * \internal * * \brief Get an Isotropic Scale Transform * * * * \param pDecISF structure used to decode the ISF file. * * * * \returns the error code given while processing * ** ------------------------------------------------------------------------ **/ int getTransformIsotropicScale (decodeISF_t * pDecISF) { int err = OK; float a; transform_t * pTransform; /** * This tag consists of the one value describing an isotropic scale * transform matrix.\n * This value (let's call it "A") is coded in the stream as float IEEE 754\n * The transform matrix is :\n * \f[ * \mbox{T} = \mbox{A} * \left( \begin{array}{ccc} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1\\ \end{array} \right) * = \left( \begin{array}{ccc} \mbox{A} & 0 & 0 \\ 0 & \mbox{A} & 0 \\ 0 & 0 & 1\\ \end{array} \right) * \f] * \see #transform_t */ /* Check whether we should add a transform or use the default one */ if (pDecISF->lastTransform != &(pDecISF->transforms) ) { err = createTransform(&pTransform); if (err != OK) return err; } else { pTransform = *(pDecISF->lastTransform); } /*DEBUG*/ err = readFloat (pDecISF, &a); if (err == OK) { LOG(stdout,"(TRANSFORM_ISOTROPIC_SCALE) a = %f\n", a); /* Apply the transformation to the transformation matrix */ pTransform->m11 = pTransform-> m22 = a; /* Insert the current Transform */ *(pDecISF->lastTransform) = pTransform; pDecISF->lastTransform = &(pTransform->next); } return err; }
// Convert sfRenderStates* to sf::RenderStates inline sf::RenderStates createRenderStates(DInt colorSrcFactor, DInt colorDstFactor, DInt colorEquation, DInt alphaSrcFactor, DInt alphaDstFactor, DInt alphaEquation, const float* transform, const sfTexture* texture, const sfShader* shader) { sf::RenderStates sfmlStates; sf::BlendMode blendMode; blendMode.colorSrcFactor = static_cast<sf::BlendMode::Factor>(colorSrcFactor); blendMode.colorDstFactor = static_cast<sf::BlendMode::Factor>(colorDstFactor); blendMode.colorEquation = static_cast<sf::BlendMode::Equation>(colorEquation); blendMode.alphaSrcFactor = static_cast<sf::BlendMode::Factor>(alphaSrcFactor); blendMode.alphaDstFactor = static_cast<sf::BlendMode::Factor>(alphaDstFactor); blendMode.alphaEquation = static_cast<sf::BlendMode::Equation>(alphaEquation); sfmlStates.blendMode = blendMode; sfmlStates.transform = createTransform(transform); sfmlStates.texture = texture ? texture->This : NULL; sfmlStates.shader = shader ? &shader->This : NULL; return sfmlStates; }
HTMLMarqueeElement::AnimationParameters HTMLMarqueeElement::getAnimationParameters() { AnimationParameters parameters; Metrics metrics = getMetrics(); double totalWidth = metrics.marqueeWidth + metrics.contentWidth; double totalHeight = metrics.marqueeHeight + metrics.contentHeight; double innerWidth = metrics.marqueeWidth - metrics.contentWidth; double innerHeight = metrics.marqueeHeight - metrics.contentHeight; switch (getBehavior()) { case kAlternate: switch (getDirection()) { case kRight: parameters.transformBegin = createTransform(innerWidth >= 0 ? 0 : innerWidth); parameters.transformEnd = createTransform(innerWidth >= 0 ? innerWidth : 0); parameters.distance = std::abs(innerWidth); break; case kUp: parameters.transformBegin = createTransform(innerHeight >= 0 ? innerHeight : 0); parameters.transformEnd = createTransform(innerHeight >= 0 ? 0 : innerHeight); parameters.distance = std::abs(innerHeight); break; case kDown: parameters.transformBegin = createTransform(innerHeight >= 0 ? 0 : innerHeight); parameters.transformEnd = createTransform(innerHeight >= 0 ? innerHeight : 0); parameters.distance = std::abs(innerHeight); break; case kLeft: default: parameters.transformBegin = createTransform(innerWidth >= 0 ? innerWidth : 0); parameters.transformEnd = createTransform(innerWidth >= 0 ? 0 : innerWidth); parameters.distance = std::abs(innerWidth); } if (m_loopCount % 2) std::swap(parameters.transformBegin, parameters.transformEnd); break; case kSlide: switch (getDirection()) { case kRight: parameters.transformBegin = createTransform(-metrics.contentWidth); parameters.transformEnd = createTransform(innerWidth); parameters.distance = metrics.marqueeWidth; break; case kUp: parameters.transformBegin = createTransform(metrics.marqueeHeight); parameters.transformEnd = "translateY(0)"; parameters.distance = metrics.marqueeHeight; break; case kDown: parameters.transformBegin = createTransform(-metrics.contentHeight); parameters.transformEnd = createTransform(innerHeight); parameters.distance = metrics.marqueeHeight; break; case kLeft: default: parameters.transformBegin = createTransform(metrics.marqueeWidth); parameters.transformEnd = "translateX(0)"; parameters.distance = metrics.marqueeWidth; } break; case kScroll: default: switch (getDirection()) { case kRight: parameters.transformBegin = createTransform(-metrics.contentWidth); parameters.transformEnd = createTransform(metrics.marqueeWidth); parameters.distance = totalWidth; break; case kUp: parameters.transformBegin = createTransform(metrics.marqueeHeight); parameters.transformEnd = createTransform(-metrics.contentHeight); parameters.distance = totalHeight; break; case kDown: parameters.transformBegin = createTransform(-metrics.contentHeight); parameters.transformEnd = createTransform(metrics.marqueeHeight); parameters.distance = totalHeight; break; case kLeft: default: parameters.transformBegin = createTransform(metrics.marqueeWidth); parameters.transformEnd = createTransform(-metrics.contentWidth); parameters.distance = totalWidth; } break; } return parameters; }
/** ------------------------------------------------------------------------ ** * \brief Get an ISF structure from a stream * * * * \param pISF where we construct the ISF structure * * \param streamInfo data structure where informations about the stream are * * stored * * \param pGetUChar function used to get an unsigned char from a stream. * * * * \returns the error code given while processing * ** ------------------------------------------------------------------------ **/ int getISF ( ISF_t ** pISF, void * streamInfo, int (*pGetUChar) (void *, INT64 *, unsigned char*)) { int err = OK; /* the error code */ INT64 tag; /* number of the current tag */ decodeISF_t * pDecISF; /* we init the ISF structure */ *pISF = (ISF_t *) malloc (sizeof(ISF_t)); if (!*pISF) return OUT_OF_MEMORY; pDecISF = (decodeISF_t *) malloc(sizeof(decodeISF_t)); if (!pDecISF) { free(*pISF); pISF = NULL; return OUT_OF_MEMORY; } pDecISF->streamInfo = streamInfo; pDecISF->getUChar = pGetUChar; pDecISF->ISF = *pISF; pDecISF->lastStroke = pDecISF->lastHighlighterStroke = &((*pISF)->strokes); (*pISF)->strokes = NULL; pDecISF->gotStylusPressure = 0; /* Add default Transform */ err = createTransform(&pDecISF->transforms); if (err != OK) return err; pDecISF->curTransform = pDecISF->transforms; pDecISF->lastTransform = &pDecISF->transforms; /* Add default drawing attributes */ err = createDrawingAttrs(&(*pISF)->drawAttrs); if (err != OK) return err; pDecISF->curDrawAttrs = (*pISF)->drawAttrs; pDecISF->lastDrawAttrs = &(*pISF)->drawAttrs; (*pISF)->width = (*pISF)->height = 0; (*pISF)->xOrigin = (*pISF)->yOrigin = INT64_MAX; (*pISF)->xEnd = (*pISF)->yEnd = INT64_MIN; (*pISF)->penWidthMax = (*pISF)->penHeightMax = 0; /* Checking the header of that file */ err = checkHeader (pDecISF); while ( err == OK && pDecISF->bytesRead < pDecISF->fileSize ) { err = readMBUINT(pDecISF, &tag); switch (tag) { case INK_SPACE_RECT: LOG(stderr,"\nINK_SPACE_RECT\n"); /* TODO: nothing ?? */ break; case GUID_TABLE: LOG(stdout,"\nGUID_TABLE\n"); err = getGUIDTable (pDecISF); break; case DRAW_ATTRS_TABLE: LOG(stdout,"\nDRAW_ATTRS_TABLE\n"); err = getDrawAttrsTable (pDecISF); break; case DRAW_ATTRS_BLOCK: LOG(stdout,"\nDRAW_ATTRS_BLOCK\n"); err = getDrawAttrsBlock (pDecISF); break; case STROKE_DESC_TABLE: LOG(stderr,"\nSTROKE_DESC_TABLE\n"); /* TODO */ break; case STROKE_DESC_BLOCK: LOG(stdout,"\nSTROKE_DESC_BLOCK\n"); err = getStrokeDescBlock (pDecISF); break; case BUTTONS: LOG(stderr,"\nBUTTONS\n"); /* TODO */ break; case NO_X: LOG(stderr,"\nNO_X\n"); /* TODO */ break; case NO_Y: LOG(stderr,"\nNO_Y\n"); /* TODO */ break; case DIDX: LOG(stdout,"\nDIDX\n"); err = getDIDX (pDecISF); break; case STROKE: LOG(stdout,"\nSTROKE\n"); err = getStroke (pDecISF); break; case STROKE_PROPERTY_LIST: LOG(stderr,"\nSTROKE_PROPERTY_LIST\n"); /* TODO */ break; case POINT_PROPERTY: LOG(stderr,"\nPOINT_PROPERTY\n"); /* TODO */ break; case SIDX: LOG(stderr,"\nSIDX\n"); /* TODO */ break; case COMPRESSION_HEADER: LOG(stderr,"\nCOMPRESSION_HEADER\n"); /* TODO */ break; case TRANSFORM_TABLE: LOG(stdout,"\nTRANSFORM_TABLE\n"); err = getTransformTable (pDecISF); break; case TRANSFORM: LOG(stdout,"\nTRANSFORM\n"); err = getTransform (pDecISF); break; case TRANSFORM_ISOTROPIC_SCALE: LOG(stdout,"\nTRANSFORM_ISOTROPIC_SCALE\n"); err = getTransformIsotropicScale (pDecISF); break; case TRANSFORM_ANISOTROPIC_SCALE: LOG(stdout,"\nTRANSFORM_ANISOTROPIC_SCALE\n"); err = getTransformAnisotropicScale (pDecISF); break; case TRANSFORM_ROTATE: LOG(stdout,"\nTRANSFORM_ROTATE\n"); err = getTransformRotate (pDecISF); break; case TRANSFORM_TRANSLATE: LOG(stdout,"\nTRANSFORM_TRANSLATE\n"); err = getTransformTranslate (pDecISF); break; case TRANSFORM_SCALE_AND_TRANSLATE: LOG(stdout,"\nTRANSFORM_SCALE_AND_TRANSLATE\n"); err = getTransformScaleAndTranslate (pDecISF); break; case TRANSFORM_QUAD: LOG(stderr,"\nTRANSFORM_QUAD\n"); /* TODO */ break; case TIDX: LOG(stdout,"\nTIDX\n"); err = getTIDX (pDecISF); break; case METRIC_TABLE: LOG(stderr,"\nMETRIC_TABLE\n"); /* TODO */ break; case METRIC_BLOCK: LOG(stdout,"\nMETRIC_BLOCK\n"); err = getMetricBlock (pDecISF); break; case MIDX: LOG(stderr,"\nMIDX\n"); /* TODO */ break; case MANTISSA: LOG(stderr,"\nMANTISSA\n"); /* TODO */ break; case PERSISTENT_FORMAT: LOG(stdout,"\nPERSISTENT_FORMAT\n"); err = getPersistentFormat (pDecISF); break; case HIMETRIC_SIZE: LOG(stdout,"\nHIMETRIC_SIZE\n"); err = getHimetricSize (pDecISF); break; case STROKE_IDS: LOG(stdout,"\nSTROKE_IDS\n"); err = getStrokeIds (pDecISF); break; case 31: LOG(stdout,"\nTAG_31\n"); err = getUnknownTag (pDecISF); break; default: if (tag >= 100 && tag <= pDecISF->guidIdMax) { /* There's a GUID for that tag */ LOG(stdout,"\nGUID_%lld\n",tag); err = getProperty (pDecISF, tag); } else { LOG(stderr,"/!\\[MAIN] Oops, wrong flag found: %lld\n", tag); } } } /* pDecISF is no longer needed : decoding is finished */ freeDecodeISF(pDecISF); return err; }
/* new scene */ int createScene (pScene sc, int idmesh) { pMesh mesh; char data[128]; /* default */ mesh = cv.mesh[idmesh]; if (!quiet) fprintf(stdout, " Computing 3D scene\n"); /* set default mode */ sc->idmesh = idmesh; sc->par.xi = sc->par.yi = 10; if (option == SCHNAUZER) { sc->par.xs = schw; sc->par.ys = schh; } else { if (sc->par.xs == 0) sc->par.xs = 600; if (sc->par.ys == 0) sc->par.ys = 600; } if (!sc->mode) sc->mode = HIDDEN; sc->item = 0; sc->shrink = 1.0; sc->slave = sc->master = -1; sc->picked = 0; if (mesh->nvn == 0) sc->type ^= S_FLAT; if (mesh->ne == 0) sc->item |= S_GEOM; /* compute scene depth */ sc->dmax = sc->dmin = mesh->xmax - mesh->xmin; sc->dmax = max(sc->dmax, mesh->ymax - mesh->ymin); sc->dmin = min(sc->dmin, mesh->ymax - mesh->ymin); if (mesh->dim == 3) { sc->dmax = max(sc->dmax, mesh->zmax - mesh->zmin); sc->dmin = min(sc->dmin, mesh->zmax - mesh->zmin); } sc->dmax = fabs(sc->dmax); sc->dmin = fabs(sc->dmin); if (!sc->par.sunp) { sc->par.sunpos[0] *= 2.0 * sc->dmax; sc->par.sunpos[1] *= 2.0 * sc->dmax; sc->par.sunpos[2] *= 2.0 * sc->dmax; } sc->par.sunpos[3] = 1.0; /* create window */ glutInitWindowSize(sc->par.xs, sc->par.ys); sc->idwin = glutCreateWindow(""); assert(sc->idwin != 0); if (fullscreen) { glutFullScreen(); sc->par.xs = glutGet(GLUT_SCREEN_WIDTH); sc->par.ys = glutGet(GLUT_SCREEN_HEIGHT); } /* set window name */ sprintf(data, "Medit - [%s] #%d", mesh->name, sc->idwin); glutSetWindowTitle(data); glutSetIconTitle(data); /* required! to change background color */ glClearColor(sc->par.back[0], sc->par.back[1], sc->par.back[2], sc->par.back[3]); /* init perspective */ sc->persp = initPersp(0, sc->dmax); sc->camera = (pCamera)initCamera(sc, Y_AXIS); if (mesh->typ == 2) { sc->persp->pmode = CAMERA; sc->persp->depth *= 0.5; } /* create default view */ sc->view = (pTransform)createTransform(); if (!sc->view) return (0); sc->type |= S_RESET + S_DECO; sc->clip = (pClip)createClip(sc, mesh); if (!sc->clip) return (0); sc->cube = (pCube)createCube(sc, mesh); if (!sc->cube) return (0); /* create menus */ if (!createMenus(sc, mesh)) return (0); /* assign callbacks */ if (sc->type & S_SCISSOR) { glutDisplayFunc(scissorScene); } else if (option == SCHNAUZER) { glutDisplayFunc(redrawSchnauzer); } else if (sc->persp->pmode == CAMERA) { glutMouseFunc(mouseCamera); glutMotionFunc(motionCamera); glutDisplayFunc(redrawScene); } else { glutMouseFunc(mouse); glutMotionFunc(motion); glutDisplayFunc(redrawScene); } glutReshapeFunc(reshapeScene); glutKeyboardFunc(keyScene); glutSpecialFunc(special); glutAttachMenu(GLUT_RIGHT_BUTTON); /* create display lists by geom type */ glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); doLists(sc, mesh); sc->glist = geomList(sc, mesh); sc->type |= S_FOLLOW; /* local stack */ if (!pilmat) { pilmat = (int *)calloc(sc->par.nbmat + 2, sizeof(int)); if (!pilmat) return (0); } /* color list */ setupPalette(sc, mesh); sc->stream = NULL; initGrafix(sc, mesh); return (1); }
void sfTransform_scale(float* transform, float scaleX, float scaleY) { createTransform(createTransform(transform).scale(scaleX, scaleY),transform); }
QRectF QgsTransformEffect::boundingRect( const QRectF &rect, const QgsRenderContext& context ) const { QTransform t = createTransform( context ); return t.mapRect( rect ); }
void sfShader_setTransformParameter(sfShader* shader, const char* name, size_t length, float* transform) { shader->This.setParameter(std::string(name, length), createTransform(transform)); }
void sfTransform_scaleWithCenter(float* transform, float scaleX, float scaleY, float centerX, float centerY) { createTransform(createTransform(transform).scale(scaleX, scaleY, centerX, centerY),transform); }
void sfTransform_getMatrix(const float* transform, float* matrix) { sf::Transform createed = createTransform(transform); if (matrix) std::memcpy(matrix, createed.getMatrix(), 16 * sizeof(float)); }
void sfTransform_getInverse(const float* transform, float* inverse) { createTransform(createTransform(transform).getInverse(), inverse); }
void sfTransform_rotateWithCenter(float* transform, float angle, float centerX, float centerY) { createTransform(createTransform(transform).rotate(angle, centerX, centerY),transform); }
void sfTransform_rotate(float* transform, float angle) { createTransform(createTransform(transform).rotate(angle),transform); }
void sfTransform_translate(float* transform, float x, float y) { createTransform(createTransform(transform).translate(x, y), transform); }
void sfTransform_combine(float* transform, const float* other) { createTransform(createTransform(transform).combine(createTransform(other)),transform); }