void Draw(const GameObject& Object, const float Angle, const Texture& Texture) { using namespace ci; gl::pushModelView(); gl::translate(Object.GetCenterPos()); gl::rotate(Angle); gl::translate(-Texture.getSize() / 2.f); Texture.enableAndBind(); glEnableClientState(GL_VERTEX_ARRAY); GLfloat verts[8]; glVertexPointer(2, GL_FLOAT, 0, verts); glEnableClientState(GL_TEXTURE_COORD_ARRAY); GLfloat texCoords[8]; glTexCoordPointer(2, GL_FLOAT, 0, texCoords); const Rectf destRect = Texture.getCleanBounds(); verts[0 * 2 + 0] = destRect.getX2(); verts[0 * 2 + 1] = destRect.getY1(); verts[1 * 2 + 0] = destRect.getX1(); verts[1 * 2 + 1] = destRect.getY1(); verts[2 * 2 + 0] = destRect.getX2(); verts[2 * 2 + 1] = destRect.getY2(); verts[3 * 2 + 0] = destRect.getX1(); verts[3 * 2 + 1] = destRect.getY2(); const Rectf srcCoords = Texture.getAreaTexCoords(Texture.getCleanBounds()); texCoords[0 * 2 + 0] = srcCoords.getX2(); texCoords[0 * 2 + 1] = srcCoords.getY1(); texCoords[1 * 2 + 0] = srcCoords.getX1(); texCoords[1 * 2 + 1] = srcCoords.getY1(); texCoords[2 * 2 + 0] = srcCoords.getX2(); texCoords[2 * 2 + 1] = srcCoords.getY2(); texCoords[3 * 2 + 0] = srcCoords.getX1(); texCoords[3 * 2 + 1] = srcCoords.getY2(); for (int i = 0; i != 2400; ++i) { gl::translate(Vec2f(10.f, 0.f)); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); // gl::draw(Texture); } // for (int i = 0; i != 700; ++i) // 13 //{ // gl::translate(Vec2f(10.f, 0.f)); // gl::draw(Texture); // gl::draw(Object.m_Texture2); //} gl::popModelView(); }
void Context::copySurface( const SurfaceBase &surface, const Area &srcArea, const Rectf &dstRect ) { if( ( dstRect.getWidth() == 0 ) || ( dstRect.getHeight() == 0 ) ) return; save(); cairo_set_source_surface( mCairo, const_cast<SurfaceBase&>( surface ).getCairoSurface(), 0, 0 ); cairo_pattern_t *sourcePattern = cairo_get_source( mCairo ); cairo_matrix_t m; cairo_matrix_init_identity( &m ); cairo_matrix_scale( &m, srcArea.getWidth() / (float)dstRect.getWidth(), srcArea.getHeight() / (float)dstRect.getHeight() ); cairo_matrix_translate( &m, srcArea.getX1() - dstRect.getX1(), srcArea.getY1() - dstRect.getY1() ); cairo_pattern_set_matrix( sourcePattern, &m ); cairo_rectangle( mCairo, dstRect.getX1(), dstRect.getY1(), dstRect.getWidth(), dstRect.getHeight() ); cairo_fill( mCairo ); restore(); }
void mouseDrag( MouseEvent event ) { if (mEditMode == EditMode_RECORD) return; // 制御点の選択を行う if (event.isLeftDown()) { if (mSelectionMode == 0) return; float x1 = mSelectRegion.getX1(); float y1 = mSelectRegion.getY1(); mSelectRegion.set(x1, y1, event.getX()+5, event.getY()+5); for (int k = 0; k < mCtrlPointsNum; ++k) { if (mSelectRegion.contains(mCtrlPoints[k].pos)) { mCtrlPoints[k].isSelected = true; } else { mCtrlPoints[k].isSelected = false; } } } Vec2f d = event.getPos() - mMPPrev; if (event.isRightDown()) { for (int k = 0; k < mCtrlPointsNum; ++k) { if (mCtrlPoints[k].isSelected) { mCtrlPoints[k].mag += d; } } } if (event.isMiddleDown()) { int ci = -1; int cj = -1; float nearest = 1.e+10; for (int j = 0; j < 2; ++j) { for (int i = 0; i < 2; ++i) { Vec2f cp(distpoints[j][i][0], distpoints[j][i][1]); float dist = event.getPos().distance(cp); if (dist < nearest) { ci = i; cj = j; nearest = dist; } } } if (ci > -1 && cj > -1) { distpoints[cj][ci][0] += d.x; distpoints[cj][ci][1] += d.y; } } mMPPrev = event.getPos(); }
void MapperOp::drawTexturedRect( const Rectf &srcRect, const Rectf &destRec){ glEnableClientState( GL_VERTEX_ARRAY ); GLfloat verts[8]; glVertexPointer( 2, GL_FLOAT, 0, verts ); glEnableClientState( GL_TEXTURE_COORD_ARRAY ); GLfloat texCoords[8]; glTexCoordPointer( 2, GL_FLOAT, 0, texCoords ); verts[0*2+0] = srcRect.getX2(); texCoords[0*2+0] = destRec.getX2(); verts[0*2+1] = srcRect.getY1(); texCoords[0*2+1] = destRec.getY1(); verts[1*2+0] = srcRect.getX1(); texCoords[1*2+0] = destRec.getX1(); verts[1*2+1] = srcRect.getY1(); texCoords[1*2+1] = destRec.getY1(); verts[2*2+0] = srcRect.getX2(); texCoords[2*2+0] = destRec.getX2(); verts[2*2+1] = srcRect.getY2(); texCoords[2*2+1] = destRec.getY2(); verts[3*2+0] = srcRect.getX1(); texCoords[3*2+0] = destRec.getX1(); verts[3*2+1] = srcRect.getY2(); texCoords[3*2+1] = destRec.getY2(); glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 ); glDisableClientState( GL_VERTEX_ARRAY ); glDisableClientState( GL_TEXTURE_COORD_ARRAY ); }
void TutorialApp::update() { // Animation speed, velocity decay, and epsilon (margin) for all tranform types. static const float decay = 0.96f; static const float epsilon = 0.1f; static const float speed = 0.1f; for ( auto& iter : mUiTree.getChildren() ) { UiTree& node = iter.second; // Get the animation bounds for this node Rectf bounds = calcBounds( node ); // Get the node's transform values const float r = node.getRotation().z; const vec2& s = vec2( node.getScale() ); const vec2& t = vec2( node.getTranslate() ); /* * Switch on this node's animation type, then animate using * either velocity or sequencing. */ switch ( node.getData().mTransform ) { case Transform_Rotate: if ( node.getData().mUseVelocity ) { // Get the velocity values. const float v = node.getRotationVelocity().z; /* * Accelerate the node's rotation CW or CCW randomly when its velocity * gets too low. */ if ( math<float>::abs( v ) < 0.001f ) { node.rotationVelocity( randFloat( -0.1f, 0.1f ), decay ); } } else { // If we're not using velocity, rotate the node CW and CCW. if ( math<float>::abs( node.getRotationTarget().z ) - math<float>::abs( r ) < epsilon ) { const float z = r > 0.0f ? -1.0f : 1.0f; node.setRotation( z, speed ); } } break; case Transform_Scale: if ( node.getData().mUseVelocity ) { /* * Accelerate the node's scale in a random direction when its velocity * gets too low. */ if ( glm::length( node.getScaleVelocity() ) <= epsilon ) { node.scaleVelocity( randVec2() * randFloat( 5.0f, 20.0f ), decay ); } // Get the new scale value. const vec2& scale = vec2( node.getScale() ); // Keep the node centered node.setTranslate( bounds.getCenter() - scale * 0.5f ); // Clamp the node's scale. if ( node.getScale().x > mSize * 2.0f ) { node.setScale( vec2( mSize * 2.0f, scale.y ) ); } else if ( node.getScale().x < mSize * 0.5f ) { node.setScale( vec2( mSize * 0.5f, scale.y ) ); } if ( node.getScale().y > mSize * 2.0f ) { node.setScale( vec2( scale.x, mSize * 2.0f ) ); } else if ( node.getScale().y < mSize * 0.5f ) { node.setScale( vec2( scale.x, mSize * 0.5f ) ); } } else { /* * If we're not using velocity, scale the node up and down. * Keep the node centered in its bounds. */ if ( glm::length( s - vec2( node.getScaleTarget() ) ) < epsilon ) { vec2 scale( s.x > mSize ? mSize * 0.5f : mSize * 2.0f ); node .scale( scale, speed ) .translate( bounds.getCenter() - scale * 0.5f, speed ); } } break; case Transform_Translate: if ( node.getData().mUseVelocity ) { // Get the velocity values. const vec2& v = vec2( node.getTranslateVelocity() ); const float d = node.getTranslateVelocityDecay(); /* * Accelerate the node in a random direction when its velocity * gets too low. */ if ( glm::length( node.getTranslateVelocity() ) <= epsilon ) { node.translateVelocity( randVec2() * randFloat( 5.0f, 20.0f ), decay ); } // Bounce off of bounding box edges. if ( t.x <= bounds.getX1() ) { node .translate( vec2( bounds.getX1() + epsilon, t.y ) ) .translateVelocity( v * vec2( -1.0f, 1.0f ), d ); } else if ( t.x + s.x >= bounds.getX2() ) { node .translate( vec2( ( bounds.getX2() - s.x ) - epsilon, t.y ) ) .translateVelocity( v * vec2( -1.0f, 1.0f ), d ); } if ( t.y <= bounds.getY1() ) { node .translate( vec2( t.x, bounds.getY1() + epsilon ) ) .translateVelocity( v * vec2( 1.0f, -1.0f ), d ); } else if ( t.y + s.y >= bounds.getY2() ) { node .translate( vec2( t.x, ( bounds.getY2() - s.y ) - epsilon ) ) .translateVelocity( v * vec2( 1.0f, -1.0f ), d ); } } else { /* * If we're not using velocity, animate left to right as the * target position is reached. */ if ( glm::length( t - vec2( node.getTranslateTarget() ) ) < epsilon ) { float x = t.x > bounds.getX1() + epsilon ? bounds.getX1() : bounds.getX2() - s.x; node.setTranslate( vec2( x, t.y ), speed ); } } break; default: break; } } mUiTree.update(); }