void TextParticlesApp::mouseDrag( MouseEvent event ) { Rectf r = Rectf( 0, 0, getWindowWidth(), getWindowHeight() ); if ( r.contains( event.getPos() )) { mCamUi.mouseDrag( event ); } }
void Fluid2DTextureApp::draw() { // clear out the window with black gl::clear( Color( 0, 0, 0 ) ); gl::setMatricesWindow( getWindowWidth(), getWindowHeight() ); // Update the positions and tex coords Rectf drawRect = getWindowBounds(); int limX = mFluid2D.resX() - 1; int limY = mFluid2D.resY() - 1; float dx = drawRect.getWidth()/(float)limX; float dy = drawRect.getHeight()/(float)limY; for( int j = 0; j < mFluid2D.resY(); ++j ) { for( int i = 0; i < mFluid2D.resX(); ++i ) { vec2 P = vec2( i*dx, j*dy ); vec2 uv = mFluid2D.texCoordAt( i, j ); int idx = j*mFluid2D.resX() + i; mTriMesh->getPositions<2>()[idx] = P; mTriMesh->getTexCoords0<2>()[idx] = uv; } } mTex->bind(); gl::bindStockShader( gl::ShaderDef().color().texture() ); gl::draw( gl::VboMesh::create(*mTriMesh) ); mTex->unbind(); mParams.draw(); }
//----------------------------------------------------------------------------// void NullGeometryBuffer::setClippingRegion(const Rectf& region) { d_clipRect.top(ceguimax(0.0f, region.top())); d_clipRect.bottom(ceguimax(0.0f, region.bottom())); d_clipRect.left(ceguimax(0.0f, region.left())); d_clipRect.right(ceguimax(0.0f, region.right())); }
/////////////////////////////////////////////////////////// // // TRANSFORMATIONS // // Fit src inside dst Rectf rectToFit( Rectf src, Rectf dst ) { float sw = src.getWidth(); float sh = src.getHeight(); float sa = (sw / sh); // aspect ratio float dw = dst.getWidth(); float dh = dst.getHeight(); float da = (dw / dh); // aspect ratio // different ratio if (da > sa) { float scale = (dh / sh); float gap = (dw - (sw * scale)) / 2.0f; return Rectf( gap, 0, dw-gap, dh); } else if (da < sa) { float scale = (dw / sw); float gap = (dh - (sh * scale)) / 2.0f; return Rectf( 0, gap, dw, dh-gap ); } // Same ratio else return dst; }
//----------------------------------------------------------------------------// float UnifiedDim::getValue(const Window&, const Rectf& container) const { switch (d_what) { case DT_LEFT_EDGE: case DT_RIGHT_EDGE: case DT_X_POSITION: case DT_X_OFFSET: case DT_WIDTH: return CoordConverter::asAbsolute(d_value, container.getWidth()); break; case DT_TOP_EDGE: case DT_BOTTOM_EDGE: case DT_Y_POSITION: case DT_Y_OFFSET: case DT_HEIGHT: return CoordConverter::asAbsolute(d_value, container.getHeight()); break; default: CEGUI_THROW(InvalidRequestException( "unknown or unsupported DimensionType encountered.")); break; } }
void TitleScreen::make_tux_jump() { static bool jumpWasReleased = true; Sector& sector = m_titlesession->get_current_sector(); Player& tux = sector.get_player(); m_controller->update(); m_controller->press(Control::RIGHT); // Check if we should press the jump button Rectf lookahead = tux.get_bbox(); lookahead.set_right(lookahead.get_right() + 96); bool pathBlocked = !sector.is_free_of_statics(lookahead); if ((pathBlocked && jumpWasReleased) || !tux.on_ground()) { m_controller->press(Control::JUMP); jumpWasReleased = false; } else { jumpWasReleased = true; } // Wrap around at the end of the level back to the beginning if (sector.get_width() - 320 < tux.get_pos().x) { sector.activate("main"); sector.get_camera().reset(tux.get_pos()); } }
//---------------------------------------------------------------------------- bool SizeNode::IsIntersectSizeRange(const SizeNode *node) const { Rectf worldRect = GetWorldRect(); Rectf nodeWorldRect = node->GetWorldRect(); return worldRect.IsIntersect(nodeWorldRect); }
void drawGrid(const Rectf &bounds, float sx, float sy, const Vec2f &offset) { float x1 = bounds.x1 - utils::math::boundf(bounds.x1 - offset.x, sx); float y1 = bounds.y1 - utils::math::boundf(bounds.y1 - offset.y, sy); int nx = int(ci::math<float>::ceil(bounds.getWidth() / sx)) + 1; int ny = int(ci::math<float>::ceil(bounds.getHeight() / sy)) + 1; vector<Vec2f> vertices; vertices.reserve((nx + ny) * 4); for (int iy = 0; iy < ny; iy++) { float y = y1 + iy * sy; vertices.emplace_back(bounds.x1, y); vertices.emplace_back(bounds.x2, y); } for (int ix = 0; ix < nx; ix++) { float x = x1 + ix * sx; vertices.emplace_back(x, bounds.y1); vertices.emplace_back(x, bounds.y2); } glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(2, GL_FLOAT, 0, vertices.data()); glDrawArrays(GL_LINES, 0, vertices.size()); glDisableClientState(GL_VERTEX_ARRAY); }
void MultiSlider::setup() { float numSliders = (float)mData.size(); vec2 size = getSize(); size.y = mSliderHeight = std::max( size.y - mPadding.mTop - mPadding.mBottom, ( (float)FontSize::SMALL + mPadding.mBottom + mPadding.mTop ) ); mSliderSpacing = mPadding.mTop; size.y = mSliderHeight * numSliders + mPadding.mTop * 2.0f + mPadding.mBottom * 2.0f; if( mData.size() > 1 ) size.y += mSliderSpacing * ( numSliders - 1.0f ); setSize( size ); vec2 hitRectSize = mHitRect.getSize(); float width = hitRectSize.x - ( mPadding.mLeft + mPadding.mRight ); Rectf rect = mHitRect; int index = 0; for( auto &it : mData ) { rect.y1 = mHitRect.y1 + mPadding.mTop + ( mSliderSpacing + mSliderHeight ) * index; rect.y2 = rect.y1 + mSliderHeight; rect.x1 = mHitRect.x1 + mPadding.mLeft; rect.x2 = rect.x1 + width; string sliderName = it.mKey; LabelRef label = Label::create( sliderName + "_LABEL", sliderName, FontSize::SMALL ); mLabelsMap[sliderName] = label; addSubView( label ); float labelHeight = label->getHeight(); float offset = ( rect.getHeight() - labelHeight ) / 2.0f; label->setOrigin( vec2( rect.x1, rect.y1 + offset ) ); index++; } View::setup(); }
void ClientApp::mouseDown( MouseEvent event ) { // fake "buttons" to trigger events if( infoRect.contains( event.getPos() ) ) { LOG( "testing info logging" ); } if( warnRect.contains( event.getPos() ) ) { LOG_WARN( "testing warn logging" ); } if( errorRect.contains( event.getPos() ) ) { LOG_ERR( "testing error logging" ); } if( eventRect.contains( event.getPos() ) ) { AMPMClient::get()->sendEvent( "category", "action", "label", 10 ); } if( crashRect.contains( event.getPos() ) ) { quit(); } }
void ParticleSystem::update(Timer* timer ) { static float prevTime = (float) timer->getSeconds(); float curTime = (float) timer->getSeconds(); float dt = curTime - prevTime; prevTime = curTime; Rectf bounds = mBounds; float minX = -kBorder; float minY = -kBorder; float maxX = bounds.getWidth(); float maxY = bounds.getHeight(); // Avoid the borders in the remap because the velocity might be zero. // Nothing interesting happens where velocity is zero. float dx = (float)(mFluid->resX() - 4) / (float) bounds.getWidth(); float dy = (float)(mFluid->resY() - 4) / (float) bounds.getHeight(); for( int i = 0; i < numParticles(); ++i ) { Particle& part = mParticles.at( i ); if( part.pos().x < minX || part.pos().y < minY || part.pos().x >= maxX || part.pos().y >= maxY ) { part.reset( newParticleVec(), Rand::randFloat( 0.0f, 1.0f ), mColor ); } float x = part.pos().x * dx + 2.0f; float y = part.pos().y * dy + 2.0f; Vec2f vel = mFluid->velocity().bilinearSampleChecked( x, y, Vec2f( 0.0f, 0.0f ) ); part.addForce( vel ); part.update( mFluid->dt(), dt ); } }
void SmilesApp::setup() { mSmileLimit = 4.0f; mSmileAverageNumOfFrames = 10; mCamIndex = 0; mFps = getAverageFps(); try { mCapture = Capture( CAMWIDTH, CAMHEIGHT ); mCapture.start(); } catch( ... ) { console() << "Failed to initialize capture" << std::endl; } mSmileRect = Rectf(300,100,600,400); setupSmileDetector(mSmileRect.getInteriorArea().getWidth(), mSmileRect.getInteriorArea().getHeight()); console()<< mSmileRect.getInteriorArea().getWidth() << mSmileRect.getInteriorArea().getHeight() << endl; mSmileThreshold = 0; mSmileAverageIndex = 0; mParams = params::InterfaceGl( "Parameters", Vec2i( 220, 170 ) ); mParams.addParam( "FPS", &mFps,"", true ); mParams.addSeparator(); mParams.addParam( "SmileResponse", &mSmileResponse, "", true ); mParams.addParam( "SmileThreshold", &mSmileThreshold, "", true ); mParams.addParam( "mSmileLimit", &mSmileLimit ); mParams.addParam( "mSmileAverageNumOfFrames", &mSmileAverageNumOfFrames ); }
void X11Window::process_window_resize(const Rect &new_rect) { Rect old_client_area = client_area; client_area = new_rect; if (site) { if (old_client_area.left != client_area.left || old_client_area.top != client_area.top) { (site->sig_window_moved)(); } if (old_client_area.get_width() != client_area.get_width() || old_client_area.get_height() != client_area.get_height()) { Rectf rectf = client_area; rectf.left /= pixel_ratio; rectf.top /= pixel_ratio; rectf.right /= pixel_ratio; rectf.bottom /= pixel_ratio; if (callback_on_resized) callback_on_resized(); // OpenGLWindowProvider::on_window_resized (site->sig_resize)(rectf.get_width(), rectf.get_height()); // TopLevelWindow_Impl::on_resize if (site->func_window_resize) (site->func_window_resize)(rectf); } } }
void Camera::buildOrthographicProjectionMatrix(Matrix4x4& mat, const Rectf& viewport, float size, float zNear, float zFar, bool flipY) { const float wideSize = (size * viewport.width() ) / viewport.height(); const float left = -wideSize; const float right = wideSize; const float top = flipY ? - size : size; const float bottom = flipY ? size : -size; const float far = -zFar; const float near = zNear; const float a = 2.0f / (right - left); const float b = 2.0f / (top - bottom); const float c = -2.0f / (far - near); const float tx = -(right + left) / (right - left); const float ty = -(top + bottom) / (top - bottom); const float tz = -(far + near) / (far - near); mat.set( a, 0, 0, 0, 0, b, 0, 0, 0, 0, c, 0, tx, ty, tz, 1, false); }
float CoordConverter::getBaseYValue(const Window& window) { const Window* parent = window.getParent(); const Rectf parent_rect(parent ? parent->getChildContentArea(window.isNonClient()).get() : Rectf(Vector2f(0, 0), window.getRootContainerSize()) ); const float parent_height = parent_rect.getHeight(); float baseY = parent_rect.d_min.d_y; baseY += asAbsolute(window.getArea().d_min.d_y, parent_height); switch(window.getVerticalAlignment()) { case VA_CENTRE: baseY += (parent_height - window.getPixelSize().d_height) * 0.5f; break; case VA_BOTTOM: baseY += parent_height - window.getPixelSize().d_height; break; default: break; } return alignToPixels(baseY); }
void ParticleSoup::update() { static float prevTime = (float)app::getElapsedSeconds(); float curTime = (float)app::getElapsedSeconds(); float dt = curTime - prevTime; prevTime = curTime; Rectf bounds = ci::app::getWindowBounds(); float minX = -kBorder; float minY = -kBorder; float maxX = bounds.getWidth(); float maxY = bounds.getHeight(); // Avoid the borders in the remap because the velocity might be zero. // Nothing interesting happens where velocity is zero. float dx = (float)(mFluid->resX() - 4)/(float)bounds.getWidth(); float dy = (float)(mFluid->resY() - 4)/(float)bounds.getHeight(); for( int i = 0; i < numParticles(); ++i ) { Particle& part = mParticles.at( i ); if( part.pos().x < minX || part.pos().y < minY || part.pos().x >= maxX || part.pos().y >= maxY ) { vec2 P; P.x = Rand::randFloat( bounds.x1 + 5.0f, bounds.x2 - 5.0f ); P.y = Rand::randFloat( bounds.y1 + 5.0f, bounds.y2 - 5.0f ); float life = Rand::randFloat( 2.0f, 3.0f ); part.reset( P, life, mColor ); } float x = part.pos().x*dx + 2.0f; float y = part.pos().y*dy + 2.0f; vec2 vel = mFluid->velocity().bilinearSampleChecked( x, y, vec2( 0.0f, 0.0f ) ); part.addForce( vel ); part.update( mFluid->dt(), dt ); } }
void Layer::updateView( View *view ) { view->mIsIteratingSubviews = true; for( auto &subview : view->getSubviews() ) { if( subview->mMarkedForRemoval ) continue; if( ! subview->mGraph ) subview->mGraph = mGraph; updateView( subview.get() ); } view->updateImpl(); if( view->mLayer && view->mLayer.get() != this && ! view->mMarkedForRemoval ) { view->mLayer->update(); } // make sure we have the right FrameBuffer size if( mRootView->mRendersToFrameBuffer ) { Rectf frameBufferBounds = view->getBoundsForFrameBuffer(); if( mFrameBufferBounds.getWidth() < frameBufferBounds.getWidth() && mFrameBufferBounds.getHeight() < frameBufferBounds.getHeight() ) { mFrameBufferBounds = ceil( frameBufferBounds ); LOG_LAYER( "mFrameBufferBounds: " << mFrameBufferBounds ); } } view->mIsIteratingSubviews = false; view->clearViewsMarkedForRemoval(); }
void drawAudioBuffer( const audio::Buffer &buffer, const Rectf &bounds, bool drawFrame, const ci::ColorA &color ) { gl::ScopedGlslProg glslScope( getStockShader( gl::ShaderDef().color() ) ); gl::color( color ); const float waveHeight = bounds.getHeight() / (float)buffer.getNumChannels(); const float xScale = bounds.getWidth() / (float)buffer.getNumFrames(); float yOffset = bounds.y1; for( size_t ch = 0; ch < buffer.getNumChannels(); ch++ ) { PolyLine2f waveform; const float *channel = buffer.getChannel( ch ); float x = bounds.x1; for( size_t i = 0; i < buffer.getNumFrames(); i++ ) { x += xScale; float y = ( 1 - ( channel[i] * 0.5f + 0.5f ) ) * waveHeight + yOffset; waveform.push_back( vec2( x, y ) ); } if( ! waveform.getPoints().empty() ) gl::draw( waveform ); yOffset += waveHeight; } if( drawFrame ) { gl::color( color.r, color.g, color.b, color.a * 0.6f ); gl::drawStrokedRect( bounds ); } }
TutorialApp::TutorialApp() { // Set square size mSize = 100.0f; const vec2 sz( mSize ); // We are going to create two UiTrees for each type of transform: // one which uses velocity and one that does not. for ( size_t i = Transform_None + 1; i < Transform_Count; ++i ) { for ( size_t j = 0; j < 2; ++j ) { // Define the data structure. UiData data; data.mColor = Colorf( randFloat(), randFloat(), randFloat() ); data.mTransform = (Transform)i; data.mUseVelocity = j == 1; // Create the node and set its data. UiTree& node = mUiTree.createAndReturnChild() .data( data ) .scale( sz ); const Rectf bounds = calcBounds( node ); const vec2 p = bounds.getCenter() - sz * 0.5f; node.translate( p ); } } }
//---------------------------------------------------------------------------- std::pair<float, float> EU_CanvasStage::CalPixelToWorld() { Rectf viewPort = mViewPort; if (viewPort.IsEmpty()) viewPort = Rectf(0.0f, 0.0f, mSize.Width, mSize.Height); std::pair<float, float> pixelToWorld; if (mStageCameraNode) { Camera *camera = mStageCameraNode->GetCamera(); float rMin = camera->GetRMin(); float uMin = camera->GetUMin(); float viewPortWidth = viewPort.Width(); float viewPortHeight = viewPort.Height(); float worldW = 2.0f * -rMin; float worldH = 2.0f * -uMin; worldW *= 1000.0f; worldH *= 1000.0f; pixelToWorld.first = worldW / (float)viewPortWidth; pixelToWorld.second = worldH / (float)viewPortHeight; } mPixelToWorld = pixelToWorld; return mPixelToWorld; }
void EditorInputCenter::update_tile_selection() { Rectf select = tile_drag_rect(); auto tiles = Editor::current()->tileselect.tiles.get(); auto tilemap = dynamic_cast<TileMap*>(Editor::current()->layerselect.selected_tilemap); if ( !tilemap ) { return; } tiles->tiles.clear(); tiles->width = select.get_width() + 1; tiles->height = select.get_height() + 1; int w = tilemap->get_width(); int h = tilemap->get_height(); for (int y = select.p1.y; y <= select.p2.y; y++) { for (int x = select.p1.x; x <= select.p2.x; x++) { if ( x < 0 || y < 0 || x >= w || y >= h) { tiles->tiles.push_back(0); } else { tiles->tiles.push_back(tilemap->get_tile_id(x, y)); } } } }
//---------------------------------------------------------------------------- Vector2f RenderStep::PointWorldToViewPort(const APoint &point, bool *isInBack) { Rectf viewPort = mViewPort; if (viewPort.IsEmpty()) viewPort = Rectf(0.0f, 0.0f, mSize.Width, mSize.Height); HMatrix matProjView = mCamera->GetProjectionMatrix() * mCamera->GetViewMatrix(); HPoint hPoint(point.X(), point.Y(), point.Z(), point.W()); HPoint tempPoint = matProjView * hPoint; if (isInBack) { if (tempPoint.Z() <= 0) *isInBack = true; else *isInBack = false; } float wInv = 1.0f / tempPoint.W(); //投影坐标范围为[-1,1]要变成[0,1] Vector2f screenPoint; screenPoint.X() = (1.0f + tempPoint.X()*wInv) / 2.0f; screenPoint.Y() = (1.0f + tempPoint.Y()*wInv) / 2.0f; //投影坐标范围为[0,1]要变成视口内坐标 screenPoint.X() = viewPort.Left + screenPoint.X()*viewPort.Width(); screenPoint.Y() = viewPort.Bottom + screenPoint.Y()*viewPort.Height(); return screenPoint; }
//----------------------------------------------------------------------------// void NullTextureTarget::declareRenderSize(const Sizef& sz) { Rectf r; r.setSize(sz); r.setPosition(glm::vec2(0, 0)); setArea(r); }
float FalagardSlider::getValueFromThumb(void) const { Slider* w = (Slider*)d_window; // get area the thumb is supposed to use as it's area. const WidgetLookFeel& wlf = getLookNFeel(); const Rectf area(wlf.getNamedArea("ThumbTrackArea").getArea().getPixelRect(*w)); // get accesss to the thumb Thumb* theThumb = w->getThumb(); // slider is vertical if (d_vertical) { // pixel extent of total available area the thumb moves in float slideExtent = area.getHeight() - theThumb->getPixelSize().d_height; // calculate value represented by current thumb position float thumbValue = (CoordConverter::asAbsolute( theThumb->getYPosition(), w->getPixelSize().d_height) - area.top()) / (slideExtent / w->getMaxValue()); // return final thumb value according to slider settings return d_reversed ? thumbValue : w->getMaxValue() - thumbValue; } // slider is horizontal else { // pixel extent of total available area the thumb moves in float slideExtent = area.getWidth() - theThumb->getPixelSize().d_width; // calculate value represented by current thumb position float thumbValue = (CoordConverter::asAbsolute( theThumb->getXPosition(), w->getPixelSize().d_width) - area.left()) / (slideExtent / w->getMaxValue()); // return final thumb value according to slider settings return d_reversed ? w->getMaxValue() - thumbValue : thumbValue; } }
//----------------------------------------------------------------------------// void IrrlichtTexture::blitFromMemory(const void* sourceData, const Rectf& area) { if (!d_texture) return; const size_t pitch = d_texture->getPitch(); const std::uint32_t* src = static_cast<const std::uint32_t*>(sourceData); std::uint32_t* dst = static_cast<std::uint32_t*>(d_texture->lock()); if (!dst) throw RendererException( "[IrrlichtRenderer] ITexture::lock failed."); dst += static_cast<size_t>(area.top()) * (pitch / 4) + static_cast<size_t>(area.left()); const Sizef sz(area.getSize()); for (int j = 0; j < sz.d_height; ++j) { for (int i = 0; i < sz.d_width; ++i) { dst[i] = src[i]; } src += static_cast<int>(sz.d_width); dst += pitch / 4; } d_texture->unlock(); }
//----------------------------------------------------------------------------// float FalagardEditbox::calculateTextOffset(const Rectf& text_area, const float text_extent, const float caret_width, const float extent_to_caret) { // if caret is to the left of the box if ((d_lastTextOffset + extent_to_caret) < 0) return -extent_to_caret; // if caret is off to the right. if ((d_lastTextOffset + extent_to_caret) >= (text_area.getWidth() - caret_width)) return text_area.getWidth() - extent_to_caret - caret_width; // handle formatting of text when it's shorter than the available space if (text_extent < text_area.getWidth()) { if (d_textFormatting == HTF_CENTRE_ALIGNED) return (text_area.getWidth() - text_extent) / 2; if (d_textFormatting == HTF_RIGHT_ALIGNED) return text_area.getWidth() - text_extent; } // no change to text position; re-use last offset value. return d_lastTextOffset; }
void drawBuffer(const std::deque<int8_t>& buffer, const Rectf &bounds, bool drawFrame, const ci::ColorA &color, float scaleFactor ) { gl::ScopedGlslProg glslScope( getStockShader( gl::ShaderDef().color() ) ); gl::color( color ); const float waveHeight = bounds.getHeight(); const float xScale = bounds.getWidth() / (float)buffer.size(); float yOffset = bounds.y1; PolyLine2f waveform; float x = bounds.x1; for( size_t i = 0; i < buffer.size(); i++ ) { x += xScale; float y = ( 1.0f - ( buffer[i] * scaleFactor + 0.5f) ) * waveHeight + yOffset; waveform.push_back( vec2( x, y ) ); } if( ! waveform.getPoints().empty() ) gl::draw( waveform ); if( drawFrame ) { gl::color( color.r, color.g, color.b, color.a * 0.6f ); gl::drawStrokedRect( bounds ); } }
float CoordConverter::getBaseXValue(const Window& window) { const Window* parent = window.getParent(); const Rectf parent_rect(parent ? parent->getChildContentArea(window.isNonClient()).get() : Rectf(Vector2f(0, 0), window.getRootContainerSize()) ); const float parent_width = parent_rect.getWidth(); float baseX = parent_rect.d_min.d_x; baseX += asAbsolute(window.getArea().d_min.d_x, parent_width); switch(window.getHorizontalAlignment()) { case HA_CENTRE: baseX += (parent_width - window.getPixelSize().d_width) * 0.5f; break; case HA_RIGHT: baseX += parent_width - window.getPixelSize().d_width; break; default: break; } return alignToPixels(baseX); }
// gets bounding box of element Rectf DXFBlockRef::GetBoundingBox(void) const { Rectf res; // get dxf object DXF const &dxf = GetDXF(); // get block data by name; if none, returns if(!dxf.HasBlock(name)) return Rectf(1e99, -1e99, -1e99, 1e99); DXFBlock const &blk = dxf.GetBlock(name); // get the bounding box of included entities Rectf bbe = blk.entities.GetBoundingBox(); // now we need to apply transformation to bbox points TransMatrix M; M.Translate(insertPoint).Rotate(angle).Scale(scale); Pointf bl = M(bbe.BottomLeft()); Pointf tl = M(bbe.TopLeft()); Pointf br = M(bbe.BottomRight()); Pointf tr = M(bbe.TopRight()); // and now get the minimum and maximum coordinate values res.left = min(min(bl.x, tl.x), min(br.x, tr.x)); res.right = max(max(bl.x, tl.x), max(br.x, tr.x)); res.bottom = min(min(bl.y, tl.y), min(br.y, tr.y)); res.top = max(max(bl.y, tl.y), max(br.y, tr.y)); return res; }
void Fluid2DTextureApp::draw() { // clear out the window with black gl::clear( Color( 0, 0, 0 ) ); gl::setMatricesWindow( getWindowWidth(), getWindowHeight() ); // Update the positions and tex coords Rectf drawRect = getWindowBounds(); int limX = mFluid2D.resX() - 1; int limY = mFluid2D.resY() - 1; float dx = drawRect.getWidth()/(float)limX; float dy = drawRect.getHeight()/(float)limY; for( int j = 0; j < mFluid2D.resY(); ++j ) { for( int i = 0; i < mFluid2D.resX(); ++i ) { Vec2f P = Vec2f( i*dx, j*dy ); Vec2f uv = mFluid2D.texCoordAt( i, j ); int idx = j*mFluid2D.resX() + i; mTriMesh.getVertices()[idx] = P; mTriMesh.getTexCoords()[idx] = uv; } } mTex.bind(); gl::draw( mTriMesh ); mTex.unbind(); mParams.draw(); }