REAL putItem(sparseVector *sparse, int targetIndex, REAL value)
{
REAL last = 0.0;
int posIndex;
if(targetIndex < 0) {
posIndex = -targetIndex;
if(posIndex > sparse->count)
return(last);
targetIndex = sparse->index[posIndex];
}
else
posIndex = findIndex(targetIndex, sparse->index, sparse->count, BLAS_BASE);
if(fabs(value) < MACHINEPREC)
value = 0;
if(targetIndex == sparse->index[0])
sparse->value[0] = value;
if(posIndex < 0) {
if(value != 0) {
if(sparse->count == sparse->size)
resizeVector(sparse, sparse->size + RESIZEDELTA);
posIndex = -posIndex;
sparse->count++;
if(posIndex < sparse->count)
moveVector(sparse, posIndex+1, posIndex, sparse->count-posIndex);
sparse->value[posIndex] = value;
sparse->index[posIndex] = targetIndex;
}
}
else {
if(value == 0) {
last = sparse->value[posIndex];
if(sparse->count > posIndex)
moveVector(sparse, posIndex, posIndex+1, sparse->count-posIndex);
sparse->count--;
}
else {
sparse->value[posIndex] = value;
sparse->index[posIndex] = targetIndex;
}
}
#ifdef DEBUG_SPARSELIB
verifyVector(sparse);
#endif
return(last);
}
void MoveTool::mouseReleaseEvent(const QList<QGraphicsItem*> &itemList,
QGraphicsSceneMouseEvent *event)
{
if (m_moveManipulator.isActive()) {
if (m_movingItems.isEmpty())
return;
QLineF moveVector(event->scenePos(), m_moveManipulator.beginPoint());
if (moveVector.length() < QApplication::startDragDistance())
{
QPointF beginPoint(m_moveManipulator.beginPoint());
m_moveManipulator.end(beginPoint);
// m_selectionIndicator.show();
m_resizeIndicator.show();
m_movingItems.clear();
view()->changeToSelectionTool(event);
} else {
m_moveManipulator.end(event->scenePos());
m_selectionIndicator.show();
m_resizeIndicator.show();
m_movingItems.clear();
}
}
AbstractFormEditorTool::mouseReleaseEvent(itemList, event);
}
void
GLWidget::moveView(const QPoint &screenDelta)
{
slotUnlockView();
MapPoint mapDelta = screenPointToRelativeMapPoint(screenDelta);
Vec2f moveVector(-mapDelta.x, mapDelta.y);
_mapView.move(moveVector);
_updateViewCtx();
updateGL();
}
void ExplosionEffectsManager::ExplosionEffect::run(TweensManager* tweensManager, const FinishCallback& finishCallback)
{
Random& random = Random::getInstance();
float maxDuration = -1.0f;
SequenceTween* longestSequence = nullptr;
for (int i=0; i<N_BITS; ++i)
{
float angle = (i * (360.0f / N_BITS));
auto sprite = sprites[i];
sprite->setScale(1.0f);
sprite->setRotation(angle);
float dist = (40.0f + random.next() * 30.0f);
Vec2 moveVector(std::cos(angle)*dist, std::sin(angle)*dist);
Vec2 endPosition = (sprite->getPosition() + moveVector);
float speed = (125.0f + random.next() * 25.0f);
float movementDuration = (dist / speed);
float endDelay = 0.0f;
auto sequenceTween = new SequenceTween();
auto moveAndFade = new ConcurrentTween();
moveAndFade->addTween(new EaseTween(new MoveTween(sprite, endPosition, movementDuration), EaseFunctions::easeIn));
moveAndFade->addTween(new RotateTween(sprite, 2.0f*speed, movementDuration));
moveAndFade->addTween(new EaseTween(new ScaleTween(sprite, 0.25f, movementDuration), EaseFunctions::easeOut));
sequenceTween->addTween(moveAndFade);
sequenceTween->addTween(new DelayTween(endDelay));
sequenceTween->addTween(new VisibilityTween(sprite, false));
tweensManager->addTween(sequenceTween);
float tweenDuration = (movementDuration + endDelay);
if (tweenDuration > maxDuration)
{
maxDuration = tweenDuration;
longestSequence = sequenceTween;
}
}
longestSequence->addTween(new FunctionTween(finishCallback));
}
void MainLoop()
{
if (this->cameraTransform != 0)
{
// Free flight navigation - as it would be in a non reference point environments like space
MwMatrix m;
MwMatrix::CreateRotationY(m, -this->mouseDeltaX / 100.0f);
MwMatrix::Multiply(this->cameraTransform->manual, m, this->cameraTransform->manual);
MwMatrix::CreateRotationX(m, this->mouseDeltaY / 100.0f);
MwMatrix::Multiply(this->cameraTransform->manual, m, this->cameraTransform->manual);
MwVector3 moveVector(
this->keys['D'] ? -1.0f : this->keys['A'] ? 1.0f : 0.0f,
this->keys[VK_SPACE] ? 1.0f : this->keys[VK_SHIFT] ? -1.0f : 0.0f,
this->keys['W'] ? 1.0f : this->keys['S'] ? -1.0f : 0.0f);
MwVector3::Scale(moveVector, moveVector, this->engine->timer->time * 10.0f);
MwMatrix::CreateTranslation(m, moveVector);
MwMatrix::Multiply(this->cameraTransform->manual, m, this->cameraTransform->manual);
}
this->engine->RenderWorld();
};
void clearVector(sparseVector *sparse, int indexStart, int indexEnd)
{
int i;
i = sparse->count;
if(i==0) return;
if(indexStart<=0)
indexStart=sparse->index[1];
if(indexEnd<=0)
indexEnd=sparse->index[i];
if(indexStart>indexEnd) return;
if(sparse->index[0]>=indexStart && sparse->index[0]<=indexEnd) {
sparse->value[0] = 0;
}
if(indexStart<=sparse->index[1] && indexEnd>=sparse->index[i])
sparse->count = 0;
else {
while(i>0 && sparse->index[i]>indexEnd) i--;
indexEnd = i;
while(i>0 && sparse->index[i]>=indexStart) i--;
indexStart = i+1;
if(indexEnd>=indexStart) {
i = sparse->count-indexEnd;
moveVector(sparse, indexStart, indexEnd+1, i);
sparse->count -= indexEnd-indexStart+1;
}
}
#ifdef DEBUG_SPARSELIB
verifyVector(sparse);
#endif
}
int main(int argc, char** argv) {
unsigned int WINDOW_WIDTH = 800;
unsigned int WINDOW_HEIGHT = 600;
std::string LEVEL_TILE_SHEET_FILENAME = "assets/tileset.png";
std::string LEVEL_FILE = "assets/mapEditorLevel.level";
const std::string LEVEL_FIlE_EXPORT = "assets/mapEditorLevelExport.level";
const char* tileArgs[] = {"assets/TileData/redGrass.tile", "assets/TileData/redGrassWebTL.tile", "assets/TileData/redGrassWebT.tile",
"assets/TileData/redGrassWebTR.tile", "assets/TileData/redGrassWebML.tile", "assets/TileData/redGrassWebM.tile",
"assets/TileData/redGrassWebMR.tile", "assets/TileData/redGrassWebBL.tile", "assets/TileData/redGrassWebB.tile",
"assets/TileData/redGrassWebBR.tile", "assets/TileData/spikyBush.tile", "assets/TileData/spikyTree.tile",
"assets/TileData/spikyBush.tile", "assets/TileData/noCollisionTile.tile", "assets/TileData/noCollisionTile.tile",
"assets/TileData/spikyBush.tile", "assets/TileData/noCollisionTile.tile", "assets/TileData/noCollisionTile.tile",
"assets/TileData/spikyBush.tile", "assets/TileData/spikyBush.tile", "assets/TileData/noCollisionTile.tile",
"assets/TileData/noCollisionTile.tile", "assets/TileData/noCollisionTile.tile", "assets/TileData/noCollisionTile.tile",
"assets/TileData/water.tile", "assets/TileData/water.tile", "assets/TileData/waterBL.tile",
"assets/TileData/waterB.tile", "assets/TileData/waterBR.tile", "assets/TileData/waterL.tile",
"assets/TileData/waterR.tile",
"assets/TileData/waterTL.tile", "assets/TileData/waterT.tile", "assets/TileData/waterTR.tile",
"assets/TileData/noCollisionTile.tile", "assets/TileData/noCollisionTile.tile", "assets/TileData/noCollisionTile.tile",
"assets/TileData/noCollisionTile.tile", "assets/TileData/noCollisionTile.tile", "assets/TileData/noCollisionTile.tile",
"assets/TileData/noCollisionTile.tile", "assets/TileData/noCollisionTile.tile", "assets/TileData/noCollisionTile.tile",
"assets/TileData/noCollisionTile.tile", "assets/TileData/noCollisionTile.tile", "assets/TileData/noCollisionTile.tile"};
const std::vector<std::string> TILE_FILEPATHS(tileArgs, tileArgs + 46);
sf::Vector2f position;
sf::View view;
sf::RenderWindow window(sf::VideoMode(WINDOW_WIDTH, WINDOW_HEIGHT, 32), "MapViewer", sf::Style::Titlebar | sf::Style::Close);
view.setSize(WINDOW_WIDTH, WINDOW_HEIGHT);
window.setFramerateLimit(60);
SpriteView levelView;
Level level;
int curTile = 1;
sf::Vector2i tilePos;
sf::Vector2i mousePos;
if (!level.init(LEVEL_FILE)) {
fprintf(stderr, "Error: Unable to load level. Program exiting\n");
std::exit(-1);
}
if (!levelView.init(LEVEL_TILE_SHEET_FILENAME, level.tileLength, level.tileLength)) {
fprintf(stderr, "Error: Unable to load level tile sheet. Program exiting\n");
std::exit(-1);
}
// start main loop
while(window.isOpen()) {
// process events
sf::Event event;
while(window.pollEvent(event)) {
// Exit
if(event.type == sf::Event::Closed) {
window.close();
}
if(event.type == sf::Event::KeyReleased){
if(event.key.code == sf::Keyboard::M){
curTile = curTile + 1;
}
if(event.key.code == sf::Keyboard::N){
curTile = curTile - 1;
}
}
}
// get movement vector from keyboard
sf::Vector2f moveVector(0.0f, 0.0f);
float factor = 1.0f;
float baseSpeed = 5.0f;
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down)) {
moveVector.y += 1.0f;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up)) {
moveVector.y -= 1.0f;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right)) {
moveVector.x += 1.0f;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) {
moveVector.x -= 1.0f;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Tab)) {
factor = 2.0f;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::LShift)) {
factor = 4.0f;
}
if (sf::Keyboard::isKeyPressed(sf::Keyboard::LControl)) {
factor = 8.0f;
}
//update position based on factor and movement vector
position += moveVector * (factor * baseSpeed);
//allow for selecting which tile is being placed
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Num0)) {
curTile = 0;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Num1)) {
curTile = 1;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Num2)) {
curTile = 2;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Num3)) {
curTile = 3;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Num4)) {
curTile = 4;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Num5)) {
curTile = 5;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Num6)) {
curTile = 6;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Num7)) {
curTile = 7;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Num8)) {
curTile = 8;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Num9)) {
curTile = 9;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Q)) {
curTile = 10;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::W)) {
curTile = 11;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::E)) {
curTile = 12;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::R)) {
curTile = 13;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::T)) {
curTile = 14;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Y)) {
curTile = 15;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::U)) {
curTile = 16;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::I)) {
curTile = 17;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::O)) {
curTile = 18;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::P)) {
curTile = 19;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::A)) {
curTile = 20;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::S)) {
curTile = 21;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::D)) {
curTile = 22;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::F)) {
curTile = 23;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::G)) {
curTile = 24;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::H)) {
curTile = 25;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::J)) {
curTile = 26;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::K)) {
curTile = 27;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::L)) {
curTile = 28;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Z)) {
curTile = 29;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::X)) {
curTile = 30;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::C)) {
curTile = 31;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::V)) {
curTile = 32;
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::B)) {
curTile = 33;
}
//handle tile placement
if(sf::Mouse::isButtonPressed(sf::Mouse::Left)){
mousePos = sf::Mouse::getPosition(window);
tilePos = getTilePosition(position, mousePos);
if (tilePos.x < 0 || tilePos.x >= level.width || tilePos.y < 0 || tilePos.y >= level.height) {
} else {
switch(curTile) {
case 0:
level.tiles[tilePos.x][tilePos.y].resource = 0;
break;
case 1:
level.tiles[tilePos.x][tilePos.y].resource = 1;
break;
case 2:
level.tiles[tilePos.x][tilePos.y].resource = 2;
break;
case 3:
level.tiles[tilePos.x][tilePos.y].resource = 3;
break;
case 4:
level.tiles[tilePos.x][tilePos.y].resource = 4;
break;
case 5:
level.tiles[tilePos.x][tilePos.y].resource = 5;
break;
case 6:
level.tiles[tilePos.x][tilePos.y].resource = 6;
break;
case 7:
level.tiles[tilePos.x][tilePos.y].resource = 7;
break;
case 8:
level.tiles[tilePos.x][tilePos.y].resource = 8;
break;
case 9:
level.tiles[tilePos.x][tilePos.y].resource = 9;
break;
case 10:
level.tiles[tilePos.x][tilePos.y].resource = 10;
break;
case 11:
level.tiles[tilePos.x][tilePos.y].resource = 11;
break;
case 12:
level.tiles[tilePos.x][tilePos.y].resource = 12;
break;
case 13:
level.tiles[tilePos.x][tilePos.y].resource = 13;
break;
case 14:
level.tiles[tilePos.x][tilePos.y].resource = 14;
break;
case 15:
level.tiles[tilePos.x][tilePos.y].resource = 15;
break;
case 16:
level.tiles[tilePos.x][tilePos.y].resource = 16;
break;
case 17:
level.tiles[tilePos.x][tilePos.y].resource = 17;
break;
case 18:
level.tiles[tilePos.x][tilePos.y].resource = 18;
break;
case 19:
level.tiles[tilePos.x][tilePos.y].resource = 19;
break;
case 20:
level.tiles[tilePos.x][tilePos.y].resource = 20;
break;
case 21:
level.tiles[tilePos.x][tilePos.y].resource = 21;
break;
case 22:
level.tiles[tilePos.x][tilePos.y].resource = 22;
break;
case 23:
level.tiles[tilePos.x][tilePos.y].resource = 23;
break;
case 24:
level.tiles[tilePos.x][tilePos.y].resource = 24;
break;
case 25:
level.tiles[tilePos.x][tilePos.y].resource = 25;
break;
case 26:
level.tiles[tilePos.x][tilePos.y].resource = 26;
break;
case 27:
level.tiles[tilePos.x][tilePos.y].resource = 27;
break;
case 28:
level.tiles[tilePos.x][tilePos.y].resource = 28;
break;
case 29:
level.tiles[tilePos.x][tilePos.y].resource = 29;
break;
case 30:
level.tiles[tilePos.x][tilePos.y].resource = 30;
break;
case 31:
level.tiles[tilePos.x][tilePos.y].resource = 31;
break;
case 32:
level.tiles[tilePos.x][tilePos.y].resource = 32;
break;
case 33:
level.tiles[tilePos.x][tilePos.y].resource = 33;
break;
case 34:
level.tiles[tilePos.x][tilePos.y].resource = 34;
break;
case 35:
level.tiles[tilePos.x][tilePos.y].resource = 35;
break;
case 36:
level.tiles[tilePos.x][tilePos.y].resource = 36;
break;
case 37:
level.tiles[tilePos.x][tilePos.y].resource = 37;
break;
case 38:
level.tiles[tilePos.x][tilePos.y].resource = 38;
break;
case 39:
level.tiles[tilePos.x][tilePos.y].resource = 39;
break;
case 40:
level.tiles[tilePos.x][tilePos.y].resource = 40;
break;
case 41:
level.tiles[tilePos.x][tilePos.y].resource = 41;
break;
case 42:
level.tiles[tilePos.x][tilePos.y].resource = 42;
break;
case 43:
level.tiles[tilePos.x][tilePos.y].resource = 43;
break;
case 44:
level.tiles[tilePos.x][tilePos.y].resource = 44;
break;
case 45:
level.tiles[tilePos.x][tilePos.y].resource = 45;
break;
case 46:
level.tiles[tilePos.x][tilePos.y].resource = 46;
break;
case 47:
level.tiles[tilePos.x][tilePos.y].resource = 47;
break;
}
}
}
//handle tile rotation
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Key::LAlt)){
mousePos = sf::Mouse::getPosition(window);
tilePos = getTilePosition(position, mousePos);
level.tiles[tilePos.x][tilePos.y].rotation += 1;
if (level.tiles[tilePos.x][tilePos.y].rotation == 4) {
level.tiles[tilePos.x][tilePos.y].rotation = 0;
}
}
//spacebar exports to file
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Space)){
level.exportToFile(LEVEL_FIlE_EXPORT, &TILE_FILEPATHS);
window.clear(sf::Color::White);
}
// draw the level
window.clear(sf::Color::Black);
view.setCenter(position);
window.setView(view);
// TODO: get a better number than 5 for what to draw around the player based on tile size and game window
int xLow = std::max(0, int(position.x / level.tileLength) - 5) ;
int xHigh = std::min(level.width - 1, int(position.x / level.tileLength) + 5);
int yLow = std::max(0, int(position.y / level.tileLength) - 5);
int yHigh = std::min(level.height - 1, int(position.y / level.tileLength) + 5);
for (int x = xLow; x <= xHigh; x++) {
for (int y = yLow; y <= yHigh; y++) {
levelView.updateSprite(level.tileVector[level.tiles[x][y].resource].tileMapPosition);
levelView.position = sf::Vector2f(x * level.tileLength, y * level.tileLength);
levelView.draw(&window);
}
}
window.display();
}
return 0;
}
void swapItems(sparseVector *sparse, int firstIndex, int secondIndex)
{
int i,j,ki,kj;
REAL hold;
if(firstIndex == secondIndex)
return;
if(firstIndex > secondIndex) {
i = firstIndex;
firstIndex = secondIndex;
secondIndex = i;
}
/* XXX WTF
if(FALSE) {
i = 1;
ki = 0;
while(i <= sparse->count && (ki = sparse->index[i])<firstIndex) i++;
j = i;
kj = 0;
while(j <= sparse->count && (kj = sparse->index[j])<secondIndex) j++;
}
else*/ {
i = findIndex(firstIndex, sparse->index, sparse->count, BLAS_BASE);
if(i < 0)
i = -i;
j = findIndex(secondIndex, sparse->index, sparse->count, BLAS_BASE);
if(j < 0)
j = -j;
}
if(i > sparse->count)
ki = 0;
else
ki = sparse->index[i];
if(j > sparse->count)
kj = 0;
else
kj = sparse->index[j];
if(ki == firstIndex && kj == secondIndex) { /* Found both -> swap in place */
hold = sparse->value[i];
sparse->value[i] = sparse->value[j];
sparse->value[j] = hold;
if(sparse->index[0] == firstIndex)
sparse->value[0] = sparse->value[i];
else if(sparse->index[0] == secondIndex)
sparse->value[0] = sparse->value[j];
}
else if(ki == firstIndex) { /* Found first, but not the second -> shift left */
j--;
if(i < j) {
hold = sparse->value[i];
moveVector(sparse, i, i+1, j-i);
sparse->value[j] = hold;
}
sparse->index[j] = secondIndex;
if(sparse->index[0] == firstIndex)
sparse->value[0] = 0;
else if(sparse->index[0] == secondIndex)
sparse->value[0] = sparse->value[j];
}
else if(kj == secondIndex) { /* Found second, but not the first -> shift right */
if(i < j) {
hold = sparse->value[j];
moveVector(sparse, i+1, i, j-i);
sparse->value[i] = hold;
}
sparse->index[i] = firstIndex;
if(sparse->index[0] == firstIndex)
sparse->value[0] = sparse->value[i];
else if(sparse->index[0] == secondIndex)
sparse->value[0] = 0;
}
#ifdef DEBUG_SPARSELIB
verifyVector(sparse);
#endif
}
void motionCallback(int x, int y)
{
if (selectedView == FRONT)
{
controlPoints[selectedPoint[0]][selectedPoint[1]][0] = ToLocalX(x);
controlPoints[selectedPoint[0]][selectedPoint[1]][1] = ToLocalY(y - height/2);
}
else if (selectedView == UP)
{
controlPoints[selectedPoint[0]][selectedPoint[1]][0] = ToLocalX(x);
controlPoints[selectedPoint[0]][selectedPoint[1]][2] = -ToLocalY(y);
}
else if (selectedView == LEFT)
{
controlPoints[selectedPoint[0]][selectedPoint[1]][2] = -ToLocalX(x - width/2);
controlPoints[selectedPoint[0]][selectedPoint[1]][1] = ToLocalY(y - height/2);
}
else if (selectedView == ROTATE)
{
Vector3d lastP = getMousePoint(lastX, lastY, width / 2.0f, height / 2.0f, radius);
Vector3d currentP = getMousePoint(x - width / 2.0f, y, width / 2.0f, height / 2.0f, radius);
if (mouseButton == GLUT_LEFT_BUTTON)
{
Vector3d rotateVector;
rotateVector.cross(currentP, lastP);
double angle = -currentP.angle(lastP) * 2;
rotateVector = unProjectToEye(rotateVector, eye, center, upVector);
Vector3d dEye;
dEye.sub(center, eye);
dEye = rotate(dEye, rotateVector, -angle);
upVector = rotate(upVector, rotateVector, -angle);
eye.sub(center, dEye);
}
else if (mouseButton == GLUT_RIGHT_BUTTON) {
Vector3d dEye;
dEye.sub(center, eye);
double offset = 0.025;
if ((y - lastY) < 0) {
dEye.scale(1 - offset);
}
else {
dEye.scale(1 + offset);
}
eye.sub(center, dEye);
}
else if (mouseButton == GLUT_MIDDLE_BUTTON) {
double dx = x - width / 2.0f - lastX;
double dy = y - lastY;
if (dx != 0 || dy != 0)
{
Vector3d moveVector(dx, dy, 0);
moveVector = unProjectToEye(moveVector, eye, center, upVector);
moveVector.normalize();
double eyeDistance = Vector3d(eye).distance(Vector3d(center));
moveVector.scale(std::sqrt(dx*dx + dy*dy) / 1000 * eyeDistance);
center.add(moveVector);
eye.add(moveVector);
}
}
lastX = x - width / 2;
lastY = y;
}
EvaluateSurface();
glutPostRedisplay();
}
