//****************************************************************
// セッター
//****************************************************************
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());
}
