void RasterNode::calcTexCoords() { glm::vec2 textureSize = glm::vec2(m_pSurface->getTextureSize()); glm::vec2 imageSize = glm::vec2(m_pSurface->getSize()); glm::vec2 texCoordExtents = glm::vec2(imageSize.x/textureSize.x, imageSize.y/textureSize.y); glm::vec2 texSizePerTile; if (m_TileSize.x == -1) { texSizePerTile = texCoordExtents; } else { texSizePerTile = glm::vec2(float(m_TileSize.x)/imageSize.x*texCoordExtents.x, float(m_TileSize.y)/imageSize.y*texCoordExtents.y); } IntPoint numTiles = getNumTiles(); vector<glm::vec2> texCoordLine(numTiles.x+1); m_TexCoords = std::vector<std::vector<glm::vec2> > (numTiles.y+1, texCoordLine); for (unsigned y = 0; y < m_TexCoords.size(); y++) { for (unsigned x = 0; x < m_TexCoords[y].size(); x++) { if (y == m_TexCoords.size()-1) { m_TexCoords[y][x].y = texCoordExtents.y; } else { m_TexCoords[y][x].y = texSizePerTile.y*y; } if (x == m_TexCoords[y].size()-1) { m_TexCoords[y][x].x = texCoordExtents.x; } else { m_TexCoords[y][x].x = texSizePerTile.x*x; } } } }
Tile* WorldSegment::getTile(uint32_t index) { if(index < 0 || index>=getNumTiles() ) { return NULL; } return tiles[index].IsValid() ? &(tiles[index]) : NULL; }
LocalFrameBuffer::LocalFrameBuffer(const vec2i &size, ColorBufferFormat colorBufferFormat, const uint32 channels, void *colorBufferToUse) : FrameBuffer(size, colorBufferFormat, channels) , tileErrorRegion(hasVarianceBuffer ? getNumTiles() : vec2i(0)) { Assert(size.x > 0); Assert(size.y > 0); if (colorBufferToUse) colorBuffer = colorBufferToUse; else { switch (colorBufferFormat) { case OSP_FB_NONE: colorBuffer = nullptr; break; case OSP_FB_RGBA8: case OSP_FB_SRGBA: colorBuffer = (uint32*)alignedMalloc(sizeof(uint32)*size.x*size.y); break; case OSP_FB_RGBA32F: colorBuffer = (vec4f*)alignedMalloc(sizeof(vec4f)*size.x*size.y); break; } } depthBuffer = hasDepthBuffer ? alignedMalloc<float>(size.x*size.y) : nullptr; accumBuffer = hasAccumBuffer ? alignedMalloc<vec4f>(size.x*size.y) : nullptr; const size_t bytes = sizeof(int32)*getTotalTiles(); tileAccumID = (int32*)alignedMalloc(bytes); memset(tileAccumID, 0, bytes); varianceBuffer = hasVarianceBuffer ? alignedMalloc<vec4f>(size.x*size.y) : nullptr; normalBuffer = hasNormalBuffer ? alignedMalloc<vec3f>(size.x*size.y) : nullptr; albedoBuffer = hasAlbedoBuffer ? alignedMalloc<vec3f>(size.x*size.y) : nullptr; ispcEquivalent = ispc::LocalFrameBuffer_create(this,size.x,size.y, colorBufferFormat, colorBuffer, depthBuffer, accumBuffer, varianceBuffer, normalBuffer, albedoBuffer, tileAccumID); }
void RasterNode::calcVertexGrid(VertexGrid& grid) { IntPoint numTiles = getNumTiles(); std::vector<glm::vec2> TileVerticesLine(numTiles.x+1); grid = std::vector<std::vector<glm::vec2> > (numTiles.y+1, TileVerticesLine); for (unsigned y = 0; y < grid.size(); y++) { for (unsigned x = 0; x < grid[y].size(); x++) { calcTileVertex(x, y, grid[y][x]); } } }
void RasterNode::calcTileVertex(int x, int y, glm::vec2& Vertex) { IntPoint numTiles = getNumTiles(); if (x < numTiles.x) { Vertex.x = float(m_TileSize.x*x) / m_pSurface->getSize().x; } else { Vertex.x = 1; } if (y < numTiles.y) { Vertex.y = float(m_TileSize.y*y) / m_pSurface->getSize().y; } else { Vertex.y = 1; } }
void CvArea::changeNumTiles(int iChange) { bool bOldLake; if (iChange != 0) { bOldLake = isLake(); m_iNumTiles += iChange; FAssert(getNumTiles() >= 0); if (bOldLake != isLake()) { GC.getMapINLINE().updateYield(); } } }
void RasterNode::setWarpedVertexCoords(const VertexGrid& grid) { checkDisplayAvailable("setWarpedVertexCoords"); bool bGridOK = true; IntPoint numTiles = getNumTiles(); if (grid.size() != (unsigned)(numTiles.y+1)) { bGridOK = false; } for (unsigned i = 0; i < grid.size(); ++i) { if (grid[i].size() != (unsigned)(numTiles.x+1)) { bGridOK = false; } } if (!bGridOK) { throw Exception(AVG_ERR_OUT_OF_RANGE, "setWarpedVertexCoords() called with incorrect grid size."); } if (m_bHasStdVertices) { m_bHasStdVertices = false; m_pSubVA = new SubVertexArray(); } m_TileVertices = grid; }
bool osgParticle::Particle::update(double dt, bool onlyTimeStamp) { // this method should return false when the particle dies; // so, if we were instructed to die, do it now and return. if (_mustdie) { _alive = -1.0; return false; } double x = 0; // if we don't live forever, compute our normalized age. if (_lifeTime > 0) { x = _t0 / _lifeTime; } _t0 += dt; // if our age is over the lifetime limit, then die and return. if (x > 1) { _alive = -1.0; return false; } // compute the current values for size, alpha and color. if (_lifeTime <= 0) { if (dt == _t0) { _current_size = _sr.get_random(); _current_alpha = _ar.get_random(); _current_color = _cr.get_random(); } } else { _current_size = _si.get()->interpolate(x, _sr); _current_alpha = _ai.get()->interpolate(x, _ar); _current_color = _ci.get()->interpolate(x, _cr); } // update position _prev_pos = _position; _position += _velocity * dt; // return now if we indicate that only time stamp should be updated // the shader will handle remain properties in this case if (onlyTimeStamp) return true; //Compute the current texture tile based on our normalized age int currentTile = _start_tile + static_cast<int>(x * getNumTiles()); //If the current texture tile is different from previous, then compute new texture coords if(currentTile != _cur_tile) { _cur_tile = currentTile; _s_coord = _s_tile * fmod(_cur_tile , 1.0 / _s_tile); _t_coord = 1.0 - _t_tile * (static_cast<int>(_cur_tile * _t_tile) + 1); // OSG_NOTICE<<this<<" setting tex coords "<<_s_coord<<" "<<_t_coord<<std::endl; } // update angle _prev_angle = _angle; _angle += _angul_arvel * dt; if (_angle.x() > osg::PI*2) _angle.x() -= osg::PI*2; if (_angle.x() < -osg::PI*2) _angle.x() += osg::PI*2; if (_angle.y() > osg::PI*2) _angle.y() -= osg::PI*2; if (_angle.y() < -osg::PI*2) _angle.y() += osg::PI*2; if (_angle.z() > osg::PI*2) _angle.z() -= osg::PI*2; if (_angle.z() < -osg::PI*2) _angle.z() += osg::PI*2; return true; }
int CvArea::getNumUnrevealedTiles(TeamTypes eIndex) const { return (getNumTiles() - getNumRevealedTiles(eIndex)); }
int CvArea::getNumUnownedTiles() const { return (getNumTiles() - getNumOwnedTiles()); }
bool CvArea::isLake() const { return (isWater() && (getNumTiles() <= GC.getLAKE_MAX_AREA_SIZE())); }