//**************************************************************** // セッター //**************************************************************** void Unitenemy::SetDirection(Direction getdirection){ Vec2i speed = Vec2i(CHIPSIZE_X, CHIPSIZE_Y); direction = getdirection; if (env.isPushKey(GLFW_KEY_SPACE)){ #if(1) switch (direction) { case Direction::NORTH : unitlist->pos.y() += 1; pos.y() += speed.y(); break; case Direction::SOUTH: unitlist->pos.y() -= 1; pos.y() -= speed.y(); break; case Direction::WEST : unitlist->pos.x() += 1; pos.x() -= speed.x(); break; case Direction::EAST : unitlist->pos.x() -= 1; pos.x() += speed.x(); break; } #else if if (env.isPushKey('W')){ pos.y() -= 1; } if (env.isPushKey('S')){ pos.y() += 1; } if (env.isPushKey('A')){ pos.x() -= 1; } if (env.isPushKey('D')){ pos.x() += 1; } #endif } }
Vec2i Vec2i::clamp(const Vec2i &vec, int a, int b) { Vec2i C; C.x() = clampi(vec.x(), a,b); C.y() = clampi(vec.y(), a,b); return C; }
Vec2 TheGame::GetMouseMovementSinceLastChecked() { Vec2i centerCursorPos = Vec2i((int)(SCREEN_WIDTH/2.f), (int)(SCREEN_HEIGHT/2.f)); Vec2i cursorPos; myWinWrapper.MyGetCursorPos( cursorPos ); myWinWrapper.MySetCursorPos(centerCursorPos.x(), centerCursorPos.y()); Vec2i mouseDeltaInts(cursorPos.x() - centerCursorPos.x(), cursorPos.y() - centerCursorPos.y()); Vec2 mouseDeltas((float)mouseDeltaInts.x(), (float)mouseDeltaInts.y()); return mouseDeltas; }
bool TiledImageBlockAccessor::read2HBlocksA16(Int32 iLow, Int32 iHeigh, Vec2i vSampleOrigin, Int32 iTextureSize, Int16 *pTarget, Int32 iTargetSizeBytes) { Vec2i vNewSampleOrigin(vSampleOrigin.x() - _vSampleDescs[iLow].x0, vSampleOrigin.y() - _vSampleDescs[iLow].y0); _vImages[iLow]->readBlockA16(vNewSampleOrigin, iTextureSize, pTarget, iTargetSizeBytes); _vI16Buffer.resize(iTextureSize * iTextureSize); vNewSampleOrigin.setValues(0, vSampleOrigin.y() - _vSampleDescs[iLow ].y0); _vImages[iHeigh]->readBlockA16(vNewSampleOrigin, iTextureSize, &(_vI16Buffer[0]), iTargetSizeBytes); UInt32 destIdx = 0; UInt32 srcIdx = 0; Int32 xMin = vSampleOrigin.x(); Int32 xMax = vSampleOrigin.x() + iTextureSize; Int32 yMin = vSampleOrigin.y(); Int32 yMax = vSampleOrigin.y() + iTextureSize; for(Int32 y = yMin; y < yMax; y++) { srcIdx = (y - yMin) * iTextureSize; for(Int32 x = xMin; x < xMax; x++) { if(x >= _vSampleDescs[iHeigh].x0) { pTarget[destIdx] = _vI16Buffer[srcIdx]; ++srcIdx; } ++destIdx; } } return true; }
bool TiledImageBlockAccessor::readBlockA16(Vec2i vSampleOrigin, Int32 iTextureSize, UInt16 *pTarget, Int32 iTargetSizeBytes) { #if 0 UInt32 destIdx = 0; UInt8 *pDst = (UInt8 *) pTarget; Int32 xMin = vSampleOrigin.x(); Int32 xMax = vSampleOrigin.x() + iTextureSize; Int32 yMin = vSampleOrigin.y(); Int32 yMax = vSampleOrigin.y() + iTextureSize; for(UInt32 y = yMin; y < yMax; y++) { for(UInt32 x = xMin; x < xMax; x++) { for(UInt32 i = 0; i < 2; i++) { pDst[destIdx] = 0; destIdx++; } } destIdx += (iTextureSize - (xMax - xMin)) * 2; } #endif return true; }
bool GeometryUtils::project(const Mat4d& projectionMultViewMatrix, const Vec2i& viewportPosition, const Vec2ui& viewportSize, const Vec3d& point, Vec3d* out) { CVF_ASSERT(out); Vec4d v = projectionMultViewMatrix * Vec4d(point, 1.0); if (v.w() == 0.0f) { return false; } v.x() /= v.w(); v.y() /= v.w(); v.z() /= v.w(); // map to range 0-1 out->x() = v.x()*0.5 + 0.5; out->y() = v.y()*0.5 + 0.5; out->z() = v.z()*0.5 + 0.5; // map to viewport out->x() = out->x() * viewportSize.x() + viewportPosition.x(); out->y() = out->y() * viewportSize.y() + viewportPosition.y(); return true; }
void Win32Wrapper::MyGetCursorPos(Vec2i& lpPoint) { POINT resultPoint; GetCursorPos(&resultPoint); lpPoint.x() = resultPoint.x; lpPoint.y() = resultPoint.y; }
bool CollisionMap::Check(Vec2i boss_pos_) { if (collison_map[boss_pos_.x()][boss_pos_.y()] == 1) { return true; } return false; }
void Map::selected(Vec2i selected_pos){ drawBox(selected_pos.x() * static_cast<float>(BLOCKSIZE::WIDTH), -selected_pos.y() * static_cast<float>(BLOCKSIZE::HEIGHT), static_cast<float>(BLOCKSIZE::WIDTH), static_cast<float>(BLOCKSIZE::HEIGHT), 10, Color::yellow); }
Vec2i ChessUtils::computePieceBoardPosition(Vec3 scenePosition) { Vec2i boardPosition; boardPosition.x() = scenePosition.x() / BOARD_SQUARE_SIZE; boardPosition.y() = scenePosition.y() / BOARD_SQUARE_SIZE; if (scenePosition.x() < 0) { --boardPosition.x(); } else { ++boardPosition.x(); } if (scenePosition.y() < 0) { --boardPosition.y(); } else { ++boardPosition.y(); } return boardPosition; }
//-------------------------------------------------------------------------------------------------- /// Set up camera/viewport and render //-------------------------------------------------------------------------------------------------- void OverlayNavigationCube::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software, const Mat4d& viewMatrix) { if (size.x() <= 0 || size.y() <= 0) { return; } if (m_axis.isNull()) { createAxisGeometry(software); } if (m_cubeGeos.size() == 0) { createCubeGeos(); // Create the shader for the cube geometry ShaderProgramGenerator gen("CubeGeoShader", ShaderSourceProvider::instance()); gen.configureStandardHeadlightColor(); m_cubeGeoShader = gen.generate(); m_cubeGeoShader->linkProgram(oglContext); } // Position the camera far enough away to make the axis and the text fit within the viewport Mat4d axisMatrix = viewMatrix; axisMatrix.setTranslation(Vec3d(0, 0, -2.0)); // Setup camera Camera cam; cam.setProjectionAsPerspective(40.0, 0.05, 100.0); cam.setViewMatrix(axisMatrix); cam.setViewport(position.x(), position.y(), size.x(), size.y()); // Setup viewport cam.viewport()->applyOpenGL(oglContext, Viewport::CLEAR_DEPTH); cam.applyOpenGL(); // Do the actual rendering // ----------------------------------------------- MatrixState matrixState(cam); if (software) { renderAxisImmediateMode(oglContext, matrixState); } else { renderAxis(oglContext, matrixState); } renderCubeGeos(oglContext, software, matrixState); renderAxisLabels(oglContext, software, matrixState); }
bool InterModule::getRange(int& a, int& b) { Vec2i range; RangeDialog rd(NULL, a,b); if (rd.exec() == QDialog::Accepted) { range = rd.getRange(); a = range.x(); b = range.y(); return true; } else return false; }
MapScreen::MapScreen(ThyKniteGame *g) : m_game(g) { //m_mapRenderer = std::make_shared<DebugMapRenderer>(RandomWalkerGenerator().generate(60, 60)); map(RandomWalkerGenerator().generate(60, 60)); m_mapRenderer = std::make_shared<TileMapRenderer>(map(), Assets::instance->tilesetSheet->getFrame(2) ); Vec2i fw = findFirstWalkable(); std::cout << fw << std::endl; Vec2f player_pos( fw.x() * 16, fw.y() * 16 ); m_player.reset(new PlayerPawnMap(player_pos, map())); }
void WallComponent::setTiles(bool enable) { Level& level = _obj->scene()->level(); Vec2 tileSize = level.tileMap().tileSize().template cast<float>(); Vec2i first = ((_obj->geom().pos.array() / tileSize.array()).matrix() + Vec2(.5, .5)) .template cast<int>(); int height = _obj->geom().box.sizes().y() / tileSize.y() + .5; _state->game()->log("setTiles(", enable, "): ", first.transpose(), ", ", height); Tile tile = enable? 774: 655; for(unsigned i = 0; i < height; ++i) { level.setTile(first.x(), first.y() + i, 0, tile); if(tile == 774) tile = 838; } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- bool OverlayScalarMapperLegend::pick(int oglXCoord, int oglYCoord, const Vec2i& position, const Vec2ui& size) { Recti oglRect(position, size.x(), size.y()); OverlayColorLegendLayoutInfo layoutInViewPortCoords(oglRect.min(), Vec2ui(oglRect.width(), oglRect.height())); layoutInfo(&layoutInViewPortCoords); Vec2i legendBarOrigin = oglRect.min(); legendBarOrigin.x() += static_cast<uint>(layoutInViewPortCoords.legendRect.min().x()); legendBarOrigin.y() += static_cast<uint>(layoutInViewPortCoords.legendRect.min().y()); Recti legendBarRect = Recti(legendBarOrigin, static_cast<uint>(layoutInViewPortCoords.legendRect.width()), static_cast<uint>(layoutInViewPortCoords.legendRect.height())); if ((oglXCoord > legendBarRect.min().x()) && (oglXCoord < legendBarRect.max().x()) && (oglYCoord > legendBarRect.min().y()) && (oglYCoord < legendBarRect.max().y())) { return true; } return false; }
//-------------------------------------------------------------------------------------------------- /// Set up camera/viewport and render //-------------------------------------------------------------------------------------------------- void OverlayScalarMapperLegend::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software) { if (size.x() <= 0 || size.y() <= 0) { return; } Camera camera; camera.setViewport(position.x(), position.y(), size.x(), size.y()); camera.setProjectionAsPixelExact2D(); camera.setViewMatrix(Mat4d::IDENTITY); camera.applyOpenGL(); camera.viewport()->applyOpenGL(oglContext, Viewport::CLEAR_DEPTH); // Get layout information // Todo: Cache this between renderings. Update only when needed. OverlayColorLegendLayoutInfo layout(position, size); layoutInfo(&layout); // Set up text drawer TextDrawer textDrawer(m_font.p()); setupTextDrawer(&textDrawer, &layout); // Do the actual rendering if (software) { renderLegendImmediateMode(oglContext, &layout); textDrawer.renderSoftware(oglContext, camera); } else { const MatrixState matrixState(camera); renderLegend(oglContext, &layout, matrixState); textDrawer.render(oglContext, camera); } CVF_CHECK_OGL(oglContext); }
bool GDALBlockAccessor::readBlockA16(Vec2i vSampleOrigin, Int32 iTextureSize, UInt16 *pTarget, Int32 iTargetSizeBytes) { #ifdef OSG_WITH_GDAL OSG_ASSERT(false); UInt32 destIdx = 0; UInt8 *pDst = reinterpret_cast<UInt8 *>(pTarget); Int32 xMin = vSampleOrigin.x(); Int32 xMax = vSampleOrigin.x() + iTextureSize; Int32 yMin = vSampleOrigin.y(); Int32 yMax = vSampleOrigin.y() + iTextureSize; for(Int32 y = yMin; y < yMax; y++) { for(Int32 x = xMin; x < xMax; x++) { for(UInt32 i = 0; i < 2; i++) { pDst[destIdx] = 0; destIdx++; } } destIdx += (iTextureSize - (xMax - xMin)) * 2; } #endif return false; }
void Astar::parentDraw(Vec2i goal_pos){ if (goal_pos == enemy_pos){ drawFillBox(goal_pos.x() * 50, goal_pos.y() * 50, 50, 50, Color::blue); return; } switch (mapchip.map[goal_pos.y()][goal_pos.x()].parent) { case UP: parentDraw(Vec2i(goal_pos.x(), goal_pos.y() + 1)); break; case DOWN: parentDraw(Vec2i(goal_pos.x(), goal_pos.y() - 1)); break; case LEFT: parentDraw(Vec2i(goal_pos.x() - 1, goal_pos.y())); break; case RIGHT: parentDraw(Vec2i(goal_pos.x() + 1, goal_pos.y())); break; } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void Rendering::calculateOverlayItemLayout(OverlayItemRectMap* itemRectMap, OverlayItem::LayoutCorner corner, OverlayItem::LayoutDirection direction) { const int border = 3; const Vec2i vpSize = Vec2i(static_cast<int>(m_camera->viewport()->width()), static_cast<int>(m_camera->viewport()->height())); const Vec2i vpPos = Vec2i(m_camera->viewport()->x(), m_camera->viewport()->y()); Vec2i cursor(0,0); switch (corner) { case OverlayItem::TOP_LEFT: cursor.set(border, vpSize.y() - border); break; case OverlayItem::TOP_RIGHT: cursor.set(vpSize.x() - border, vpSize.y() - border); break; case OverlayItem::BOTTOM_LEFT: cursor.set(border, border); break; case OverlayItem::BOTTOM_RIGHT: cursor.set(vpSize.x() - border, border); break; default: cursor.set(border,border); } cursor += vpPos; // Adjust based on other already placed items OverlayItemRectMap::iterator it; for (it = itemRectMap->begin(); it != itemRectMap->end(); ++it) { Recti rect = it->second; if (rect.contains(cursor) && (direction == OverlayItem::VERTICAL)) { if (corner == OverlayItem::BOTTOM_LEFT || corner == OverlayItem::BOTTOM_RIGHT) { cursor.y() += rect.height() + border; } else { cursor.y() -= rect.height() + border; } } } size_t numOverlayItems = m_overlayItems.size(); size_t i; for (i = 0; i < numOverlayItems; i++) { OverlayItemLayout item = m_overlayItems.at(i); if ((item.corner == corner) && (item.direction == direction)) { CVF_ASSERT(item.overlayItem.notNull()); // Find this position and size Vec2i position = cursor; Vec2ui size = item.overlayItem->sizeHint(); if ((corner == OverlayItem::TOP_RIGHT) || (corner == OverlayItem::BOTTOM_RIGHT)) { position.x() -= size.x(); } if ((corner == OverlayItem::TOP_LEFT) || (corner == OverlayItem::TOP_RIGHT)) { position.y() -= size.y(); } // Store the position in the map Recti rect(position.x(), position.y(), static_cast<int>(size.x()), static_cast<int>(size.y())); (*itemRectMap)[item.overlayItem.p()] = rect; // Find next position, moving the cursor if (direction == OverlayItem::HORIZONTAL) { if ((corner == OverlayItem::TOP_LEFT) || (corner == OverlayItem::BOTTOM_LEFT)) { cursor.x() += (size.x() + border); } else { cursor.x() -= (size.x() + border); } } else if (direction == OverlayItem::VERTICAL) { if ((corner == OverlayItem::BOTTOM_LEFT) || (corner == OverlayItem::BOTTOM_RIGHT)) { cursor.y() += (size.y() + border); } else { cursor.y() -= (size.y() + border); } } else { CVF_FAIL_MSG("Unhandled OverlayItem::LayoutDirection"); } } } }
Vec2i Game::screenSize() const { Vec2i size; SDL_GetWindowSize(_window, &size.x(), &size.y()); return size; }
bool GDALBlockAccessor::readBlockA16(Vec2i vSampleOrigin, Int32 iTextureSize, Int16 *pTarget, Int32 iTargetSizeBytes) { #ifdef OSG_WITH_GDAL Int32 xMin = vSampleOrigin.x(); Int32 xMax = vSampleOrigin.x() + iTextureSize; Int32 yMin = vSampleOrigin.y(); Int32 yMax = vSampleOrigin.y() + iTextureSize; if(xMax > _vSize[0] || yMax > _vSize[1]) { UInt32 destIdx = 0; UInt32 srcIdx = 0; _vI16Buffer.resize(iTextureSize * iTextureSize); Int32 iSampleX = osgMin(_vSize[0] - vSampleOrigin.x(), iTextureSize); Int32 iSampleY = osgMin(_vSize[1] - vSampleOrigin.y(), iTextureSize); _pBand->RasterIO(GF_Read, vSampleOrigin.x(), vSampleOrigin.y(), iSampleX, iSampleY, &(_vI16Buffer[0]), iSampleX, iSampleY, GDT_Int16, 0, 0); for(Int32 y = yMin; y < yMax; y++) { for(Int32 x = xMin; x < xMax; x++) { if(x >= _vSize[0] || y >= _vSize[1]) { pTarget[destIdx] = Int16(_fNoDataValue); } else { pTarget[destIdx] = _vI16Buffer[srcIdx]; srcIdx++; } destIdx++; } } } else { _pBand->RasterIO(GF_Read, vSampleOrigin.x(), vSampleOrigin.y(), iTextureSize, iTextureSize, pTarget, iTextureSize, iTextureSize, GDT_Int16, 0, 0); } #endif return true; }
int Astar::nowCost(Vec2i start_pos, Vec2i goal_pos){ return std::abs(goal_pos.x() - start_pos.x()) + std::abs(goal_pos.y() - start_pos.y()); }
bool PlayerPawnMap::isNearTile(Vec2i the_tile) { Vec2f possible_tile(the_tile.x() * 16, the_tile.y() * 16); float dist = Vec2f::Distance( position(), possible_tile ); return dist < 1.f; }
void DungeonGenerator::connectRegions() { std::map<std::vector<int>, std::unordered_set<int>> connectorRegions; for (int ix = 1; ix < cm_DungeonWidth - 1; ix++) { for (int iy = 1; iy < cm_DungeonHeight - 1; iy++) { Vec2i Pos(ix, iy); if (Get_Tile(Pos) != Wall) continue; std::unordered_set<int> Regions; for (int i = 0; i < m_Cardinal.size(); i++) { Vec2i Indexer = (Pos + m_Cardinal[i]); int Region = m_Regions[Indexer.x()][Indexer.y()]; if (Region != -1) Regions.insert(Region); } if (Regions.size() < 2) { continue; } std::vector<int> Temp; Temp.push_back(Pos.x()); Temp.push_back(Pos.y()); connectorRegions[Temp] = Regions; } } std::vector<std::vector<int>> connectors; for (std::map<std::vector<int>, std::unordered_set<int>>::iterator it = connectorRegions.begin(); it != connectorRegions.end(); ++it) { connectors.push_back(it->first); } std::map<int, int> merged; std::unordered_set<int> openRegions; for (int i = 0; i <= currentRegion; i++) { merged[i] = i; openRegions.insert(i); } while (openRegions.size() > 1) { std::vector<int> Temp; Temp = connectors[Random(0, connectors.size())]; Vec2i connector(Temp[0], Temp[1]); AddJunction(connector); std::vector<int> Regions; for (std::unordered_set<int>::iterator it = connectorRegions[Temp].begin(); it != connectorRegions[Temp].end(); ++it) { Regions.push_back(merged[*it]); } int dest = Regions[0]; std::vector<int> Sources; for (std::vector<int>::iterator it = Regions.begin() + 1; it != Regions.end(); ++it) { Sources.push_back(*it); } for (int i = 0; i <= currentRegion; i++) { for (int x = 0; x < Sources.size(); x++) { if (Sources[x] == merged[i]) { merged[i] = dest; } } } for (std::vector<int>::iterator it = Sources.begin(); it != Sources.end(); ++it) { openRegions.erase(*it); } for (auto it = connectors.begin(); it != connectors.end();) { if (EraserFunc(*it, connectorRegions, merged)) { it = connectors.erase(it); } else { it++; } } } }
void DungeonGenerator::Carve(Vec2i pos, TILE tile) { DungeonGenerator::Set_Tile(pos, tile); m_Regions[pos.x()][pos.y()] = currentRegion; }
bool TiledImageBlockAccessor::readBlockA16(Vec2i vSampleOrigin, Int32 iTextureSize, Int16 *pTarget, Int32 iTargetSizeBytes) { Vec2i vLow (vSampleOrigin.x(), vSampleOrigin.y()); Vec2i vHeigh(vSampleOrigin.x() + iTextureSize, vSampleOrigin.y() + iTextureSize); UInt32 iFound = 0; Int32 iLow = -1; Int32 iHeigh = -1; for(UInt32 i = 0; i < _vSampleDescs.size(); ++i) { if(_vSampleDescs[i].contains(vLow) == true) { iLow = i; ++iFound; } if(_vSampleDescs[i].contains(vHeigh) == true) { iHeigh = i; ++iFound; } if(iFound == 2) break; } if(iLow == -1 && iHeigh == -1) { UInt32 destIdx = 0; for(Int32 y = 0; y < iTextureSize; y++) { for(Int32 x = 0; x < iTextureSize; x++) { pTarget[destIdx] = Int16(_fNoDataValue); destIdx++; } } } else if(iLow == iHeigh) { Vec2i vNewSampleOrigin(vSampleOrigin.x() - _vSampleDescs[iLow].x0, vSampleOrigin.y() - _vSampleDescs[iLow].y0); return _vImages[iLow]->readBlockA16(vNewSampleOrigin, iTextureSize, pTarget, iTargetSizeBytes); } else if( (iHeigh - iLow) == 1) { read2HBlocksA16(iLow, iHeigh, vSampleOrigin, iTextureSize, pTarget, iTargetSizeBytes); } else if( (iHeigh - iLow) == Int32(_uiColumns)) { read2VBlocksA16(iLow, iHeigh, vSampleOrigin, iTextureSize, pTarget, iTargetSizeBytes); } else if( (iHeigh - iLow) == Int32(_uiColumns + 1)) { read4BlocksA16(iLow, iHeigh, vSampleOrigin, iTextureSize, pTarget, iTargetSizeBytes); } else if(iLow != -1 && iHeigh == -1) { Vec2i vNewSampleOrigin(vSampleOrigin.x() - _vSampleDescs[iLow].x0, vSampleOrigin.y() - _vSampleDescs[iLow].y0); return _vImages[iLow]->readBlockA16(vNewSampleOrigin, iTextureSize, pTarget, iTargetSizeBytes); } else { UInt32 destIdx = 0; for(Int32 y = 0; y < iTextureSize; y++) { for(Int32 x = 0; x < iTextureSize; x++) { pTarget[destIdx] = 15000; destIdx++; } } } return true; }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void OverlayImage::render(OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software) { CVF_CALLSITE_OPENGL(oglContext); Camera projCam; projCam.setViewport(position.x(), position.y(), size.x(), size.y()); projCam.setProjectionAsPixelExact2D(); projCam.setViewMatrix(Mat4d::IDENTITY); // Turn off depth test RenderStateDepth depth(false, RenderStateDepth::LESS, false); depth.applyOpenGL(oglContext); float vertexArray[12]; float textureCoords[] = {0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f}; projCam.viewport()->applyOpenGL(oglContext, Viewport::DO_NOT_CLEAR); if (software) { // Create a POW2 texture for software rendering if needed if (m_image.notNull() && m_pow2Image.isNull() && (!Math::isPow2(m_image->width()) || !Math::isPow2(m_image->height()))) { m_pow2Image = new TextureImage; m_pow2Image->allocate(Math::roundUpPow2(m_image->width()), Math::roundUpPow2(m_image->height())); m_pow2Image->fill(Color4ub(Color3::BLACK)); for (uint y = 0; y < m_image->height(); ++y) { for (uint x = 0; x < m_image->width(); ++x) { m_pow2Image->setPixel(x, y, m_image->pixel(x, y)); } } } if (ShaderProgram::supportedOpenGL(oglContext)) { ShaderProgram::useNoProgram(oglContext); } #ifndef CVF_OPENGL_ES RenderStateMaterial_FF mat; mat.enableColorMaterial(true); mat.applyOpenGL(oglContext); RenderStateLighting_FF light(false); light.applyOpenGL(oglContext); if (m_textureBindings.isNull()) { // Use fixed function texture setup ref<Texture2D_FF> texture = new Texture2D_FF(m_pow2Image.notNull() ? m_pow2Image.p() : m_image.p()); texture->setWrapMode(Texture2D_FF::CLAMP); texture->setMinFilter(Texture2D_FF::NEAREST); texture->setMagFilter(Texture2D_FF::NEAREST); texture->setupTexture(oglContext); texture->setupTextureParams(oglContext); ref<RenderStateTextureMapping_FF> textureMapping = new RenderStateTextureMapping_FF(texture.p()); textureMapping->setTextureFunction(m_blendMode == TEXTURE_ALPHA ? RenderStateTextureMapping_FF::MODULATE : RenderStateTextureMapping_FF::DECAL); m_textureBindings = textureMapping; } #endif // Adjust texture coordinates if (m_pow2Image.notNull()) { float xMax = static_cast<float>(m_image->width())/static_cast<float>(m_pow2Image->width()); float yMax = static_cast<float>(m_image->height())/static_cast<float>(m_pow2Image->height()); textureCoords[2] = xMax; textureCoords[4] = xMax; textureCoords[5] = yMax; textureCoords[7] = yMax; } projCam.applyOpenGL(); } else { glBindBuffer(GL_ARRAY_BUFFER, 0); glEnableVertexAttribArray(ShaderProgram::VERTEX); glEnableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0); glVertexAttribPointer(ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray); glVertexAttribPointer(ShaderProgram::TEX_COORD_2F_0, 2, GL_FLOAT, GL_FALSE, 0, textureCoords); if (m_shaderProgram.isNull()) { ShaderProgramGenerator gen("OverlayImage_Shader", ShaderSourceProvider::instance()); gen.addVertexCode(ShaderSourceRepository::vs_MinimalTexture); if (m_blendMode == GLOBAL_ALPHA) { gen.addFragmentCode(ShaderSourceRepository::src_TextureGlobalAlpha); } else { gen.addFragmentCode(ShaderSourceRepository::src_Texture); } gen.addFragmentCode(ShaderSourceRepository::fs_Unlit); m_shaderProgram = gen.generate(); m_shaderProgram->linkProgram(oglContext); } if (m_shaderProgram->useProgram(oglContext)) { MatrixState projMatrixState(projCam); m_shaderProgram->clearUniformApplyTracking(); m_shaderProgram->applyFixedUniforms(oglContext, projMatrixState); } if (m_texture->textureOglId() == 0) { m_texture->setupTexture(oglContext); } if (m_textureBindings.isNull()) { cvf::RenderStateTextureBindings* textureBindings = new cvf::RenderStateTextureBindings; textureBindings->addBinding(m_texture.p(), m_sampler.p(), "u_texture2D"); m_textureBindings = textureBindings; } } float offset = 0.0f; Vec3f min(offset, offset, 0.0f); Vec3f max(static_cast<float>(size.x()) + offset, static_cast<float>(size.y()) + offset, 0.0f); // Setup the vertex array float* v1 = &vertexArray[0]; float* v2 = &vertexArray[3]; float* v3 = &vertexArray[6]; float* v4 = &vertexArray[9]; v1[0] = min.x(); v1[1] = min.y(); v1[2] = 0.0f; v2[0] = max.x(); v2[1] = min.y(); v2[2] = 0.0f; v3[0] = max.x(); v3[1] = max.y(); v3[2] = 0.0f; v4[0] = min.x(); v4[1] = max.y(); v4[2] = 0.0f; if (m_blendMode != NO_BLENDING) { RenderStateBlending blend; blend.configureTransparencyBlending(); blend.applyOpenGL(oglContext); } m_textureBindings->applyOpenGL(oglContext); if (software) { #ifndef CVF_OPENGL_ES glColor4f(1.0f, 1.0f, 1.0f, m_blendMode == GLOBAL_ALPHA ? m_alpha : 1.0f); glBegin(GL_TRIANGLE_FAN); glTexCoord2f(textureCoords[0], textureCoords[1]); glVertex3fv(v1); glTexCoord2f(textureCoords[2], textureCoords[3]); glVertex3fv(v2); glTexCoord2f(textureCoords[4], textureCoords[5]); glVertex3fv(v3); glTexCoord2f(textureCoords[6], textureCoords[7]); glVertex3fv(v4); glEnd(); #endif } else { if (m_blendMode == GLOBAL_ALPHA) { UniformFloat alphaUniform("u_alpha", m_alpha); m_shaderProgram->applyUniform(oglContext, alphaUniform); } glDrawArrays(GL_TRIANGLE_FAN, 0, 4); } if (m_blendMode != NO_BLENDING) { RenderStateBlending blend; blend.applyOpenGL(oglContext); } RenderStateDepth resetDepth; resetDepth.applyOpenGL(oglContext); if (software) { #ifndef CVF_OPENGL_ES RenderStateTextureMapping_FF resetTextureMapping; resetTextureMapping.applyOpenGL(oglContext); #endif } if (!software) { glDisableVertexAttribArray(ShaderProgram::VERTEX); glDisableVertexAttribArray(ShaderProgram::TEX_COORD_2F_0); } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void Rendering::calculateOverlayItemLayoutForSchemeAndCorner(OverlayItemRectMap* itemRectMap, OverlayItem::LayoutScheme layoutScheme, OverlayItem::AnchorCorner anchorCorner) { CVF_ASSERT(layoutScheme == OverlayItem::HORIZONTAL || layoutScheme == OverlayItem::VERTICAL); const int border = 3; const Vec2i vpSize = Vec2i(static_cast<int>(m_camera->viewport()->width()), static_cast<int>(m_camera->viewport()->height())); const Vec2i vpPos = Vec2i(m_camera->viewport()->x(), m_camera->viewport()->y()); Vec2i cursor(0,0); switch (anchorCorner) { case OverlayItem::TOP_LEFT: cursor.set(border, vpSize.y() - border); break; case OverlayItem::TOP_RIGHT: cursor.set(vpSize.x() - border, vpSize.y() - border); break; case OverlayItem::BOTTOM_LEFT: cursor.set(border, border); break; case OverlayItem::BOTTOM_RIGHT: cursor.set(vpSize.x() - border, border); break; default: cursor.set(border,border); } cursor += vpPos; // Adjust starting cursor position based on other already placed items in this anchor corner // The assumption here is that for each corner, the horizontal layout has already been added to the map if (layoutScheme == OverlayItem::VERTICAL) { OverlayItemRectMap::iterator it; for (it = itemRectMap->begin(); it != itemRectMap->end(); ++it) { const OverlayItem* placedItem = it->first; const Recti placedItemRect = it->second; if (placedItem->anchorCorner() == anchorCorner && placedItemRect.contains(cursor)) { if (anchorCorner == OverlayItem::BOTTOM_LEFT || anchorCorner == OverlayItem::BOTTOM_RIGHT) { cursor.y() += placedItemRect.height() + border; } else { cursor.y() -= placedItemRect.height() + border; } } } } const size_t numOverlayItems = m_overlayItems.size(); for (size_t i = 0; i < numOverlayItems; i++) { OverlayItem* item = m_overlayItems.at(i); if ((item->anchorCorner() == anchorCorner) && (item->layoutScheme() == layoutScheme)) { // Find this position and size Vec2i position = cursor; Vec2ui size = item->sizeHint(); if ((anchorCorner == OverlayItem::TOP_RIGHT) || (anchorCorner == OverlayItem::BOTTOM_RIGHT)) { position.x() -= size.x(); } if ((anchorCorner == OverlayItem::TOP_LEFT) || (anchorCorner == OverlayItem::TOP_RIGHT)) { position.y() -= size.y(); } // Store the position in the map Recti rect(position.x(), position.y(), static_cast<int>(size.x()), static_cast<int>(size.y())); (*itemRectMap)[item] = rect; // Find next position, moving the cursor if (layoutScheme == OverlayItem::HORIZONTAL) { if ((anchorCorner == OverlayItem::TOP_LEFT) || (anchorCorner == OverlayItem::BOTTOM_LEFT)) { cursor.x() += (size.x() + border); } else { cursor.x() -= (size.x() + border); } } else if (layoutScheme == OverlayItem::VERTICAL) { if ((anchorCorner == OverlayItem::BOTTOM_LEFT) || (anchorCorner == OverlayItem::BOTTOM_RIGHT)) { cursor.y() += (size.y() + border); } else { cursor.y() -= (size.y() + border); } } else { CVF_FAIL_MSG("Unhandled OverlayItem::LayoutDirection"); } } } }
void Unitenemy::SetDrawPos(Vec2i getpos){ pos.x() = getpos.x() * CHIPSIZE_X; pos.y() = getpos.y() * CHIPSIZE_Y; }
// ウインドウの位置を変更 // pos 新しい位置 void AppEnv::windowPosition(const Vec2i& pos) { glfwSetWindowPos(window_(), pos.x(), pos.y()); }