void Player::draw(sf::RenderWindow &render) const
{
View view(sf::FloatRect(0, 0, m_drawDim.x*(m_zooms[m_controller.getZoom()]), m_drawDim.y*m_zooms[m_controller.getZoom()]));
view.setCenter(m_controller.getViewCenter());
view.setViewport(sf::FloatRect(m_drawPos.x/m_resolution.x, m_drawPos.y/m_resolution.y, m_drawDim.x/m_resolution.x, m_drawDim.y/m_resolution.y));
render.setView(view);
std::vector<Entity*> toDraw = m_world.getEntitiesInRect(screenToWorld(Vec(0, 0)), screenToWorld(m_drawDim));
//m_world.draw(render);
for(int i=0; i<toDraw.size(); i++)
{
toDraw[i]->draw(render);
}
for(int i=0; i<m_selection.size(); i++)
{
m_selection[i]->drawSelected(render);
}
draw::drawRect(render, Vec(0, 0), Vec(m_world.getDim()), sf::Color::White);
for(int i=0; i<toDraw.size(); i++)
{
toDraw[i]->drawForeground(render, screenToWorld(mousePos()));
}
view.reset(sf::FloatRect(0, 0, m_drawDim.x, m_drawDim.y));
render.setView(view);
if(m_selecting)
{
draw::drawRect(render, worldToScreen(m_A), worldToScreen(m_B)-worldToScreen(m_A), sf::Color(50, 100, 255, 100), 3);
draw::drawRect(render, worldToScreen(m_A), worldToScreen(m_B)-worldToScreen(m_A), sf::Color(50, 100, 255, 100));
}
m_gui->drawChildren(render, Vec(0, 0), m_drawDim);
Displayer::instance.draw(render);
draw::drawRect(render, Vec(1, 1), m_drawDim-Vec(1, 1)*2, sf::Color::White);
}
void View::drawGrid(Renderer2D &out) const {
if(!m_is_visible)
return;
const int2 tile_map_size = m_tile_map.dimensions();
int2 p[4] = {
screenToWorld(m_view_pos + int2(0, 0)),
screenToWorld(m_view_pos + int2(0, m_view_size.y)),
screenToWorld(m_view_pos + int2(m_view_size.x, m_view_size.y)),
screenToWorld(m_view_pos + int2(m_view_size.x, 0)) };
int2 offset = screenToWorld(worldToScreen(int3(0, m_height, 0)));
for(int n = 0; n < 4; n++)
p[n] -= offset;
int2 tmin = min(min(p[0], p[1]), min(p[2], p[3]));
int2 tmax = max(max(p[0], p[1]), max(p[2], p[3]));
IRect box(max(tmin, int2(0, 0)), min(tmax, tile_map_size));
Color color(255, 255, 255, 64);
for(int x = box.min.x - box.min.x % m_cell_size; x <= box.max.x; x += m_cell_size)
drawLine(out, int3(x, m_height, box.min.y), int3(x, m_height, box.max.y), color);
for(int y = box.min.y - box.min.y % m_cell_size; y <= box.max.y; y += m_cell_size)
drawLine(out, int3(box.min.x, m_height, y), int3(box.max.x, m_height, y), color);
}
void GameInterface::updateStructurePlacement()
{
if (mPlaceStructure)
{
sf::Vector2f mousePos;
mousePos.x = InputManager::get()->getMousePosition().x;
mousePos.y = InputManager::get()->getMousePosition().y;
mousePos = screenToWorld(mousePos-RenderingManager::get()->getCameraScreenOffset());
mousePos.rotateBy(RenderingManager::get()->getCameraRotation(), RenderingManager::get()->getCameraPosition());
mPlaceStructure->setPosition(mousePos);
GameObject *planet = PlanetGenerator::get()->getPlanet(mPlaceStructure);
sf::Vector2f distance = planet->getPosition()-mousePos;
mPlaceStructure->setRotation(distance.getAngleTrig()+90);
if (InputManager::get()->getKeyState(sf::Keyboard::Escape) == ButtonState::PRESSED)
{
mPlaceStructure->kill();
mPlaceStructure = NULL;
}
if (InputManager::get()->getLMBState() == ButtonState::PRESSED) // Place the structure
{
sf::Packet packet;
packet << PacketType::BUILD_STRUCTURE;
packet << mCurrentStructureType->mTypeName << mPlaceStructure->getPosition().x << mPlaceStructure->getPosition().y
<< mPlaceStructure->getRotation();
NetworkManager::get()->send(packet);
mPlaceStructure->kill();
mPlaceStructure = NULL;
}
}
}
/**
* This function gets information text about a point at pos.
*
* @param pos The position (in client coordinates) to get information
* about.
* @param chunkText This is set to information about the chunk at this
* position.
* @param posText This is set to information about the given position.
* @returns True if information could be obtained.
*/
bool
ChunkWatchControl::getInfoText
(
CPoint const &pos,
std::string &chunkText,
std::string &posText
) const
{
float wx, wz;
if (screenToWorld(pos, &wx, &wz))
{
Vector3 pos3(wx, 0.0f, wz);
posText = sformat("({0}, {1})", wx, wz);
Chunk *chunk =
ChunkManager::instance().cameraSpace()->findChunkFromPoint(pos3);
if (chunk != NULL)
chunkText = chunk->identifier();
else
chunkText = L("WORLDEDITOR/GUI/CONTROLS/CHUNK_WATCH_CONTROL/NOT_LOADED_STRING");
return true;
}
else
{
return false;
}
}
void Player::sendOrder()
{
if(m_selection.size() > 0)
{
if(m_selection[0]->getType() == BALL)
{
if(m_controller.pressed(ORDER))
{
std::vector<Ball*> balls;
for(int i=0; i<m_selection.size(); i++)
{
Ball* ball = (Ball*)m_selection[i];
balls.push_back(ball);
m_world.stopMovement(ball);
}
MovementHandler *handler = new MovementHandler(balls, m_controller);
m_world.addMovement(handler);
}
else if(m_controller.down(ORDER))
{
m_world.updateTarget((Ball*)m_selection[0], screenToWorld(mousePos()));
}
}
else if(m_selection[0]->getType() == BUILDING)
{
Building* building = (Building*)m_selection[0];
building->receiveOrder(m_controller);
}
}
}
//Handle mouse input
void mouse(int mouseButton, int buttonState, int x, int y)
{
GLfloat mouseX,mouseY;
screenToWorld(x,y,mouseX,mouseY);
Point mousePt(mouseX,mouseY,0);
if(sb->getResetButton().pointInButton(mousePt) &&
buttonState == GLUT_DOWN) //did user click on reset button
{
sb->getResetButton().setButtonIsPressed(true);
return;
}
if(sb->getResetButton().pointInButton(mousePt) &&
sb->getResetButton().isButtonPressed() &&
buttonState == GLUT_UP) //did user click on reset button
{
initGame();
initStartupScript();
return;
}
sb->getResetButton().setButtonIsPressed(false);
if (gameStatus!= IN_PLAY)
return;
if( mouseButton == GLUT_LEFT_BUTTON &&
buttonState == GLUT_DOWN)
{
gamePiece tmp = player1Turn?player1GamePiece:player2GamePiece;
Move m= getSlotFromPoint(mousePt);
makeMove(m ,tmp);
}
glutPostRedisplay();
}
void getSelectedTileXY(int mouseX, int mouseY, int& mapX, int& mapY)
{
SDL_Rect rect;
rect.x = mouseX;
rect.y = mouseY;
rect.w = 0;
rect.h = 0;
screenToWorld(rect.x, rect.y);
rect.x -= tileSizeX / 2;
unzoom(rect);
isoToMap(rect.x, rect.y, mapX, mapY);
// const int tileSizeX = 32;
// const int tileWidth = 16;
// const double cst = (2 * tileSizeX*tileWidth);
// const double fx = -camX + tileSizeX;
// const double fy = -camY;//-(tileSizeY*input_scale - tileWidth*input_scale);
// double x = (tileWidth*mouseX + tileSizeX*mouseY + (-fx*tileWidth - fy*tileSizeX));
// double y = (-tileWidth*mouseX + tileSizeX*mouseY + (fx*tileWidth - fy*tileSizeX));
// x /= cst;
// y /= cst;
// mapX = x;
// mapY = y;
std::cout << mouseX << "," << mouseY << "\n";
std::cout << rect.x << "," << rect.y << "\n";
}
void CameraBase::getMouseRay(int cursorX, int cursorY, Ray& out) const
{
out.origin = screenToWorld(cursorX,cursorY);
out.dir = out.origin-m_eyePos; //从From点出发,指向"鼠标所指向的点"的方向
D3DXVec3Normalize(&out.dir,&out.dir);
out.origin += out.dir*m_fZNear;//进行near剪裁
}
const IBox View::computeCursor(const int2 &start, const int2 &end, const int3 &bbox, int height, int offset) const {
float2 height_off = worldToScreen(float3(0, height, 0));
int3 gbox(cellSize(), 1, cellSize());
int3 start_pos = asXZ((int2)( screenToWorld(float2(start + pos()) - height_off) + float2(0.5f, 0.5f)));
int3 end_pos = asXZ((int2)( screenToWorld(float2(end + pos()) - height_off) + float2(0.5f, 0.5f)));
start_pos.y = end_pos.y = height + offset;
{
int apos1 = start_pos.x % gbox.x;
int apos2 = apos1 - gbox.x + bbox.x;
start_pos.x -= apos1 < gbox.x - apos1 || bbox.x >= gbox.x? apos1 : apos2;
}
{
int apos1 = start_pos.z % gbox.z;
int apos2 = apos1 - gbox.z + bbox.z;
start_pos.z -= apos1 < gbox.z - apos1 || bbox.z >= gbox.z? apos1 : apos2;
}
if(end == start)
end_pos = start_pos;
int3 dir(end_pos.x >= start_pos.x? 1 : -1, 1, end_pos.z >= start_pos.z? 1 : -1);
int3 size(::abs(end_pos.x - start_pos.x), 1, ::abs(end_pos.z - start_pos.z));
size += bbox - int3(1, 1, 1);
size.x -= size.x % bbox.x;
size.z -= size.z % bbox.z;
size = max(bbox, size);
if(dir.x < 0)
start_pos.x += bbox.x;
if(dir.z < 0)
start_pos.z += bbox.z;
end_pos = start_pos + dir * size;
if(start_pos.x > end_pos.x) swap(start_pos.x, end_pos.x);
if(start_pos.z > end_pos.z) swap(start_pos.z, end_pos.z);
int2 dims = m_tile_map.dimensions();
start_pos = asXZY(clamp(start_pos.xz(), int2(0, 0), dims), start_pos.y);
end_pos = asXZY(clamp( end_pos.xz(), int2(0, 0), dims), end_pos.y);
return IBox(start_pos, end_pos);
}
bool StageLayer::handleEventMouse(EventMouse *e)
{
auto btn = e->getMouseButton();
auto idx = (int)btn;
switch(e->getMouseCode()) {
// FIX: no need to start with press ok
case MouseCode::SCROLL:
case MouseCode::PRESS:
{
auto const &pos = e->getCursorPos();
if(!inView(pos.x, pos.y))
return false;
auto worldPos = screenToWorld(pos);
e->setCursorWorld(worldPos.x, worldPos.y);
return dispatchEvent(e);
}
case MouseCode::RELEASE:
{
auto l = static_cast<EventMouseListener*>(mouseSlots_[idx].get());
auto ok = l && l->isRunning();
if(ok && l->onRelease) {
auto worldPos = screenToWorld(e->getCursorPos());
e->setCursorWorld(worldPos);
l->onRelease(e);
}
mouseSlots_[idx] = nullptr;
return ok;
}
case MouseCode::MOVE:
{
auto l = static_cast<EventMouseListener*>(mouseSlots_[idx].get());
auto ok = l && l->isRunning();
if(ok && l->onMove) {
auto worldPos = screenToWorld(e->getCursorPos());
e->setCursorWorld(worldPos);
l->onMove(e);
}
return ok;
}
}
return false;
}
void GameInterface::onStructureBuildClick()
{
sf::Vector2f mousePos;
mousePos.x = InputManager::get()->getMousePosition().x;
mousePos.y = InputManager::get()->getMousePosition().y;
mousePos = screenToWorld(mousePos-RenderingManager::get()->getCameraScreenOffset());
mousePos.rotateBy(RenderingManager::get()->getCameraRotation(), RenderingManager::get()->getCameraPosition());
mPlaceStructure = StructureManager::get()->createStructure(mCurrentStructureType->mTypeName, mousePos, 0);
}
//mouse move event
void GlWidget::mouseMoveEvent(QMouseEvent *event)
{
int dx = event->x() - lastPos.x();
int dy = event->y() - lastPos.y();
if(event->x()>0 && event->y()>0 && event->x()<this->width() && event->y()< this->height()){
QPointF clicked=screenToWorld(lastPos.x(),lastPos.y());
QPointF currentClicked=screenToWorld(event->x(),event->y());
if (event->buttons() & Qt::MiddleButton) {
} else if (event->buttons() & Qt::LeftButton) {
// Mouse point to angle conversion
theta -= dy*1.0;
phi -= dx*1.0;
// Spherical to Cartesian conversion.
// Degrees to radians conversion factor 0.0174532
eyeX = r * cos(theta*0.0174532) * cos(phi*0.0174532);
eyeY = r * cos(theta*0.0174532) * sin(phi*0.0174532);
eyeZ = r * sin(theta*0.0174532);
// Reduce theta slightly to obtain another point on the same longitude line on the sphere.
GLfloat dt=0.01;
GLfloat eyeXtemp = r * cos(theta*0.0174532-dt) * cos(phi*0.0174532);
GLfloat eyeYtemp = r * cos(theta*0.0174532-dt) * sin(phi*0.0174532);
GLfloat eyeZtemp = r * sin(theta*0.0174532-dt);
// Connect these two points to obtain the camera's up vector.
upX=eyeXtemp-eyeX;
upY=eyeYtemp-eyeY;
upZ=eyeZtemp-eyeZ;
updateGL();
} else if (event->buttons() & Qt::RightButton){
xMove -= clicked.x()-currentClicked.x();
yMove -= clicked.y()-currentClicked.y();
updateGL();
}
lastPos = event->pos();
}
}
Ray SceneGraph::screenToWorldRay(int x, int y) {
vec4i vp = viewport();
int screenWidth = vp[2];
int screenHeight = vp[3];
//Select Gizmo First
vec3f ns(x, screenHeight - y, 0.0f);
vec3f fs(x, screenHeight - y, 1.0f);
vec3f nw;
vec3f fw;
Ray r;
if (screenToWorld(ns, nw) && screenToWorld(fs, fw)) {
vec3f dir = fw - nw;
r.set(nw, dir.normalized());
} else {
LogError("Unable to convert screen to world!");
}
return r;
}
void Player::update()
{
m_controller.update();
m_gui->updateChildren(m_controller, Vec(0, 0), m_drawDim);
if(m_controller.pressed(SELECT) && !m_gui->isInside(m_controller.mousePos()))
{
m_A = screenToWorld(mousePos());
m_selecting = true;
}
if(m_controller.down(SELECT))
m_B = screenToWorld(mousePos());
else
{
m_A = m_B;
m_selecting = false;
}
if(m_selecting)
{
m_selection = m_world.selectEntitiesInRect(this, m_A, m_B);
}
if(!m_gui->isInside(m_controller.mousePos()) && m_selection.size() > 0)
sendOrder();
}
void EntitiesEditor::computeCursor(int2 start, int2 end, bool floor_mode) {
float2 height_off = worldToScreen(int3(0, 0, 0));
start += m_view.pos();
end += m_view.pos();
Ray ray = screenRay(start);
Flags::Type flags = Flags::all;
if(floor_mode)
flags = flags & ~(Flags::wall_tile | Flags::object_tile);
auto isect = m_tile_map.trace(ray, -1, flags | Flags::visible);
float3 pos = isect.first == -1? (float3)asXZ(screenToWorld(start)) : ray.at(isect.second);
m_cursor_pos = (float3)round(pos);
m_selection = IRect(min(start, end), max(start, end));
}
/**
* This is called when the mouse button is released.
*
* @param flags The flags which shift-key status etc.
* @param point The coordinates of the mouse.
*/
/*afx_msg*/ void ChunkWatchControl::OnLButtonUp(UINT /*flags*/, CPoint point)
{
getDrawConstants();
float x, z;
if (screenToWorld(point, &x, &z))
{
// Find the height at this point
float fheight = TerrainUtils::heightAtPos(x, z, true);
float y = fheight + Options::getOptionInt( "graphics/farclip", 500 )/10.0f;
// Set the view matrix to the new world coords and preserve the
// current orientation:
Matrix view = WorldEditorCamera::instance().currentCamera().view();
view.invert();
view.translation(Vector3(x, y, z));
view.invert();
WorldEditorCamera::instance().currentCamera().view(view);
}
}
void Brick::addToWorld(b2World &world)
{
if(state == ACTIVE)
{
b2Vec2 worldPosition = screenToWorld(position);
b2BodyDef brickBodyDef;
brickBodyDef.position.Set(worldPosition.x, worldPosition.y);
body = world.CreateBody(&brickBodyDef);
b2PolygonShape brickBox;
brickBox.SetAsBox(BRICK_WIDTH/(2*SCALING_FACTOR), BRICK_HEIGHT/(2*SCALING_FACTOR));
b2FixtureDef fixtureDef;
fixtureDef.shape = &brickBox;
fixtureDef.density = 0.0f;
fixtureDef.friction = 0.0f;
fixtureDef.restitution = 1.0f;
body->CreateFixture(&fixtureDef);
body->SetUserData(this);
}
}
Vector SphericalCamera::rasterToWorld(const Vector &rsP, const PTime time) const
{
Vector ssP;
m_rasterToScreen.multVecMatrix(rsP, ssP);
return screenToWorld(ssP, time);
}
bool UI_SDL::doToolEvents(SDL_Event e) {
SDL_Point p;
switch (e.type) {
case SDL_MOUSEMOTION:
p.x = e.motion.x;
p.y = e.motion.y;
switch(currtool) {
case T_Circle:
dragMesh.clear();
//If a center has been picked, draw the temp circle
if(toolstate == 1) {
Vect4 delta = screenToWorld(p) - clicks[0];
double mag = delta.magnitude();
dragMesh.genPrimCircle(clicks[0], mag);
}
break;
case T_Line:
dragMesh.clear();
//If a center has been picked, draw the temp circle
if(toolstate == 1) {
Vect4 end = screenToWorld(p);
dragMesh.genPrimEdge(clicks[0], end);
}
break;
case T_Hermite:
dragMesh.clear();
if(toolstate >= 1) {
Vect4 v[4];
Vect4 curr = screenToWorld(p);
if(toolstate == 1) {
dragMesh.genPrimEdge(clicks[0], curr);
} else {
dragMesh.genPrimEdge(clicks[0], clicks[1]);
if(toolstate == 3) {
dragMesh.genPrimEdge(clicks[2], curr);
dragMesh.genPrimHermite(
clicks[0],
clicks[2],
clicks[1],
curr);
}
}
}
break;
case T_Bezier:
dragMesh.clear();
if(toolstate >= 1) {
Vect4 v[4];
Vect4 curr = screenToWorld(p);
if(toolstate == 1) {
dragMesh.genPrimEdge(clicks[0], curr);
} else {
dragMesh.genPrimEdge(clicks[0], clicks[1]);
if(toolstate == 3) {
dragMesh.genPrimEdge(clicks[2], curr);
dragMesh.genPrimBezier(
clicks[0],
clicks[1],
curr,
clicks[2]);
}
}
}
break;
case T_Box:
dragMesh.clear();
//If a start point has been picked, draw the temp box
if(toolstate == 1) {
Vect4 end = screenToWorld(p);
dragMesh.genPrimBox(end[0], end[1], end[1]);
}
break;
case T_Sphere:
dragMesh.clear();
//If a center has been picked, draw the temp sphere
if(toolstate == 1) {
Vect4 delta = screenToWorld(p) - clicks[0];
double mag = delta.magnitude();
dragMesh.genPrimSphere(mag);
}
break;
case T_Torus:
dragMesh.clear();
//If a start point has been picked, draw the temp torus
if(toolstate == 1) {
Vect4 end = screenToWorld(p);
dragMesh.genPrimTorus(std::abs(end[0]), std::abs(end[1]));
}
break;
default:
break;
}
break;
case SDL_MOUSEBUTTONDOWN:
p.x = e.button.x;
p.y = e.button.y;
switch(currtool) {
//keep track of the starting click
case T_Circle:
case T_Line:
case T_Box:
case T_Sphere:
case T_Torus:
//All of these just store the start point
clicks[0] = screenToWorld(p);
toolstate = 1;
break;
case T_Hermite:
if(toolstate == 0 || toolstate == 2) {
clicks[toolstate] = screenToWorld(p);
toolstate++;
} else {
std::cerr << "ERR in mousedown Hermite\n";
}
break;
case T_Bezier:
if(toolstate == 0 || toolstate == 2) {
clicks[toolstate] = screenToWorld(p);
toolstate++;
} else {
std::cerr << "ERR in mousedown Bezier\n";
}
break;
default:
break;
}
break;
case SDL_MOUSEBUTTONUP:
switch(currtool) {
case T_Circle:
case T_Line:
case T_Sphere:
case T_Box:
case T_Torus:
//Make it so
if(toolstate == 1) {
world->addMesh(new Mesh(dragMesh));
dragMesh.clear();
toolstate = 0;
}
break;
case T_Hermite:
if(toolstate == 1 || toolstate == 3) {
SDL_Point p;
p.x = e.button.x;
p.y = e.button.y;
clicks[toolstate] = screenToWorld(p);
toolstate++;
} else {
std::cerr << "ERR in mouseup Hermite\n";
}
if(toolstate == 4) { //finished
dragMesh.clear();
dragMesh.genPrimHermite(
clicks[0],
clicks[2],
clicks[1],
clicks[3]);
world->addMesh(new Mesh(dragMesh));
dragMesh.clear();
toolstate = 0;
}
break;
case T_Bezier:
if(toolstate == 1 || toolstate == 3) {
SDL_Point p;
p.x = e.button.x;
p.y = e.button.y;
clicks[toolstate] = screenToWorld(p);
toolstate++;
} else {
std::cerr << "ERR in mouseup Bezier\n";
}
if(toolstate == 4) { //finished
dragMesh.clear();
dragMesh.genPrimBezier(
clicks[0],
clicks[1],
clicks[3],
clicks[2]);
world->addMesh(new Mesh(dragMesh));
dragMesh.clear();
toolstate = 0;
}
break;
default:
break;
}
break;
case SDL_KEYDOWN:
switch(e.key.keysym.sym) {
case SDLK_RIGHTBRACKET:
changeTool(1);
break;
case SDLK_LEFTBRACKET:
changeTool(-1);
break;
default:
return false;
}
break;
case SDL_WINDOWEVENT:
switch (e.window.event) {
case SDL_WINDOWEVENT_ENTER:
//uistate.mouseinwindow = 1;
case SDL_WINDOWEVENT_LEAVE:
//uistate.mouseinwindow = 0;
break;
}
return false;
break;
default:
return false;
}
return true;
}
void Game::inputPointer(const PointerState& pointers) {
if (pointers.wasPressed()) {
logic_.place(screenToWorld(pointers.main().getPosition()), static_cast<Rotation>(pattern_rotation_), 2);
}
}
void R_drawWorldDebug()
{
glUseProgramObjectARB(NULL);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glDisable(GL_TEXTURE_2D);
float x0,y0,x1,y1,w,h;
//axis
glLineWidth(4.0f);
glBegin(GL_LINES);
{
glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
x0 = max(-10000,camera.position.x);
x1 = min(10000,camera.position.x+camera.size.x);
glVertex2f(x0, 0);
glVertex2f(x1, 0);
glColor4f(0.0f, 1.0f, 0.0f, 1.0f);
y0 = max(-10000,camera.position.y);
y1 = min(10000,camera.position.y+camera.size.y);
glVertex2f(0, y0);
glVertex2f(0, y1);
}
glEnd();
//grid
glLineWidth(4.0f);
glBegin(GL_LINES);
{
w = tilemap_back.w_tileSize.x;
h = tilemap_back.w_tileSize.y;
for (int y = tilemap_back.Min.y; y < tilemap_back.Max.y; y++)
{
for (int x = tilemap_back.Min.x; x < tilemap_back.Max.x; x++)
{
x0 = tilemap_back.position.x + x * w;
y0 = tilemap_back.position.y + y * h;
glColor4f(0.0f, 0.0f, 0.0f, 0.75f);
glVertex2f(x0, y0);
glVertex2f(x0, y0 + h);
glVertex2f(x0, y0);
glVertex2f(x0 + w, y0);
glColor4f(1.0f, 0.0f, 1.0f, 0.5f);
if(y == tilemap_back.Max.y-1)
{
glVertex2f(x0, y0 + h);
glVertex2f(x0 + w, y0 + h);
}
glColor4f(0.0f, 0.0f, 1.0f, 0.5f);
if(x == tilemap_back.Max.x-1)
{
glVertex2f(x0 + w, y0);
glVertex2f(x0 + w, y0 + h);
}
}
}
}
glEnd();
//highlightedTile
if(PointinRect(Point(input.mouse.lX,input.mouse.lY),s_dstRect))
{
Point cursor(CLAMP(input.mouse.lX,lmenuw,client_rect.w - rmenuw),input.mouse.lY);
Vector2 worldcursor = screenToWorld(cursor,camera,client_rect);
highlightedTile = worldToTile(worldcursor - pselected_tilemap->position, pselected_tilemap->w_tileSize);
highlightedTile.x = CLAMP(highlightedTile.x,0,pselected_tilemap->t_mapSize.x-1);
highlightedTile.y = CLAMP(highlightedTile.y,0,pselected_tilemap->t_mapSize.y-1);
}
float lw = 2.0f;
ScreenRect srcRect,dstRect;
w = pselected_tilemap->w_tileSize.x;
h = pselected_tilemap->w_tileSize.y;
x0 = pselected_tilemap->position.x + highlightedTile.x * w;
y0 = pselected_tilemap->position.y + highlightedTile.y * h;
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
srcRect = atlas_tile.sourceRectangles[selectedBrush];
dstRect = ScreenRect(x0,y0,w,h);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, *(atlas_tile.texture));
glBegin(GL_QUADS);
{
glTexCoord2d(srcRect.fLeft(), srcRect.fTop()); glVertex2f(dstRect.fLeft(), dstRect.fBottom());
glTexCoord2d(srcRect.fRight(), srcRect.fTop()); glVertex2f(dstRect.fRight(), dstRect.fBottom());
glTexCoord2d(srcRect.fRight(), srcRect.fBottom()); glVertex2f(dstRect.fRight(), dstRect.fTop());
glTexCoord2d(srcRect.fLeft(), srcRect.fBottom()); glVertex2f(dstRect.fLeft(), dstRect.fTop());
}
glEnd();
glDisable(GL_TEXTURE_2D);
//image map
if(blayer01loaded)
{
glColor4f(0.0f, 0.5f, 1.0f, 1.0f);
x0 = pselected_tilemap->position.x + selectedTile.x * w;
y0 = pselected_tilemap->position.y + selectedTile.y * h;
R_DrawHorizontalLine(x0 - lw, y0, w + 2*lw, lw);
R_DrawVerticalLine(x0, y0 , h, lw);
R_DrawHorizontalLine(x0 - lw, y0 + h, w + 2*lw, lw);
R_DrawVerticalLine(x0 + w, y0 + h, -h, lw);
glColor4f(1.0f, 1.0f, 0.0f, 1.0f);
x0 = pselected_tilemap->position.x + highlightedTile.x * w;
y0 = pselected_tilemap->position.y + highlightedTile.y * h;
R_DrawHorizontalLine(x0 - lw, y0, w + 2*lw, lw);
R_DrawVerticalLine(x0, y0 , h, lw);
R_DrawHorizontalLine(x0 - lw, y0 + h, w + 2*lw, lw);
R_DrawVerticalLine(x0 + w, y0 + h, -h, lw);
}
glEnable(GL_TEXTURE_2D);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
}
inline Vec2 screenToWorld(const Vec2 &screen)
{return screenToWorld(screen.x,screen.y);}
bool EntitiesEditor::onMouseDrag(const InputState &state, int2 start, int2 current, int key, int is_final) {
bool shift_pressed = state.isKeyPressed(InputKey::lshift);
if(key == 0 && !state.isKeyPressed(InputKey::lctrl)) {
computeCursor(start, current, shift_pressed);
m_is_selecting = !is_final;
if(m_mode == Mode::selecting && is_final && is_final != -1) {
findVisible(m_selected_ids, m_selection);
computeCursor(current, current, shift_pressed);
}
else if(m_mode == Mode::placing) {
if(m_proto->typeId() == EntityId::trigger) {
Trigger *trigger = static_cast<Trigger*>(m_proto.get());
if(m_trigger_mode == 0) {
m_trigger_box = m_view.computeCursor(start, current, int3(1, 1, 1), m_cursor_pos.y, 0);
if(state.isMouseButtonDown(InputButton::right)) {
m_trigger_mode = 1;
m_trigger_offset = current;
}
}
IBox new_box = m_trigger_box;
if(m_trigger_mode == 1) {
int offset = screenToWorld(int2(0, m_trigger_offset.y - current.y)).y;
if(offset < 0)
new_box.min.y += offset;
else
new_box.max.y += offset;
}
trigger->setBox((FBox)new_box);
m_cursor_pos = trigger->pos();
if(is_final > 0) {
m_entity_map.add(PEntity(m_proto->clone()));
}
if(is_final) {
m_trigger_mode = 0;
trigger->setBox(FBox(0, 0, 0, 1, 1, 1) + trigger->pos());
}
}
else if(is_final > 0)
m_entity_map.add(PEntity(m_proto->clone()));
}
return true;
}
else if(key == 1 && m_mode == Mode::selecting) {
if(!m_is_moving) {
m_is_moving_vertically = state.isKeyPressed(InputKey::lshift);
m_is_moving = true;
}
if(m_is_moving_vertically)
m_move_offset = int3(0, screenToWorld(int2(0, start.y - current.y)).y, 0);
else
m_move_offset = asXZY(screenToWorld(current - start), 0);
if(is_final)
m_is_moving = false;
if(is_final > 0) {
for(int n = 0; n < (int)m_selected_ids.size(); n++) {
auto &object = m_entity_map[m_selected_ids[n]];
object.ptr->setPos(object.ptr->pos() + float3(m_move_offset));
m_entity_map.update(m_selected_ids[n]);
}
}
return true;
}
return false;
}
