qt5base-lts/examples/embedded/raycasting/raycasting.cpp
Sergio Ahumada 48e0c4df23 Update copyright year in Digia's license headers
Change-Id: Ic804938fc352291d011800d21e549c10acac66fb
Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-01-18 09:07:35 +01:00

384 lines
13 KiB
C++

/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the demonstration applications of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QtCore>
#include <QtWidgets>
#include <math.h>
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
#define WORLD_SIZE 8
int world_map[WORLD_SIZE][WORLD_SIZE] = {
{ 1, 1, 1, 1, 6, 1, 1, 1 },
{ 1, 0, 0, 1, 0, 0, 0, 7 },
{ 1, 1, 0, 1, 0, 1, 1, 1 },
{ 6, 0, 0, 0, 0, 0, 0, 3 },
{ 1, 8, 8, 0, 8, 0, 8, 1 },
{ 2, 2, 0, 0, 8, 8, 7, 1 },
{ 3, 0, 0, 0, 0, 0, 0, 5 },
{ 2, 2, 2, 2, 7, 4, 4, 4 },
};
#define TEXTURE_SIZE 64
#define TEXTURE_BLOCK (TEXTURE_SIZE * TEXTURE_SIZE)
class Raycasting: public QWidget
{
public:
Raycasting(QWidget *parent = 0)
: QWidget(parent)
, angle(0.5)
, playerPos(1.5, 1.5)
, angleDelta(0)
, moveDelta(0)
, touchDevice(false) {
// http://www.areyep.com/RIPandMCS-TextureLibrary.html
textureImg.load(":/textures.png");
textureImg = textureImg.convertToFormat(QImage::Format_ARGB32);
Q_ASSERT(textureImg.width() == TEXTURE_SIZE * 2);
Q_ASSERT(textureImg.bytesPerLine() == 4 * TEXTURE_SIZE * 2);
textureCount = textureImg.height() / TEXTURE_SIZE;
watch.start();
ticker.start(25, this);
setAttribute(Qt::WA_OpaquePaintEvent, true);
setMouseTracking(false);
}
void updatePlayer() {
int interval = qBound(20, watch.elapsed(), 250);
watch.start();
angle += angleDelta * interval / 1000;
qreal step = moveDelta * interval / 1000;
qreal dx = cos(angle) * step;
qreal dy = sin(angle) * step;
QPointF pos = playerPos + 3 * QPointF(dx, dy);
int xi = static_cast<int>(pos.x());
int yi = static_cast<int>(pos.y());
if (world_map[yi][xi] == 0)
playerPos = playerPos + QPointF(dx, dy);
}
void showFps() {
static QTime frameTick;
static int totalFrame = 0;
if (!(totalFrame & 31)) {
int elapsed = frameTick.elapsed();
frameTick.start();
int fps = 32 * 1000 / (1 + elapsed);
setWindowTitle(QString("Raycasting (%1 FPS)").arg(fps));
}
totalFrame++;
}
void render() {
// setup the screen surface
if (buffer.size() != bufferSize)
buffer = QImage(bufferSize, QImage::Format_ARGB32);
int bufw = buffer.width();
int bufh = buffer.height();
if (bufw <= 0 || bufh <= 0)
return;
// we intentionally cheat here, to avoid detach
const uchar *ptr = buffer.bits();
QRgb *start = (QRgb*)(ptr);
QRgb stride = buffer.bytesPerLine() / 4;
QRgb *finish = start + stride * bufh;
// prepare the texture pointer
const uchar *src = textureImg.bits();
const QRgb *texsrc = reinterpret_cast<const QRgb*>(src);
// cast all rays here
qreal sina = sin(angle);
qreal cosa = cos(angle);
qreal u = cosa - sina;
qreal v = sina + cosa;
qreal du = 2 * sina / bufw;
qreal dv = -2 * cosa / bufw;
for (int ray = 0; ray < bufw; ++ray, u += du, v += dv) {
// every time this ray advances 'u' units in x direction,
// it also advanced 'v' units in y direction
qreal uu = (u < 0) ? -u : u;
qreal vv = (v < 0) ? -v : v;
qreal duu = 1 / uu;
qreal dvv = 1 / vv;
int stepx = (u < 0) ? -1 : 1;
int stepy = (v < 0) ? -1 : 1;
// the cell in the map that we need to check
qreal px = playerPos.x();
qreal py = playerPos.y();
int mapx = static_cast<int>(px);
int mapy = static_cast<int>(py);
// the position and texture for the hit
int texture = 0;
qreal hitdist = 0.1;
qreal texofs = 0;
bool dark = false;
// first hit at constant x and constant y lines
qreal distx = (u > 0) ? (mapx + 1 - px) * duu : (px - mapx) * duu;
qreal disty = (v > 0) ? (mapy + 1 - py) * dvv : (py - mapy) * dvv;
// loop until we hit something
while (texture <= 0) {
if (distx > disty) {
// shorter distance to a hit in constant y line
hitdist = disty;
disty += dvv;
mapy += stepy;
texture = world_map[mapy][mapx];
if (texture > 0) {
dark = true;
if (stepy > 0) {
qreal ofs = px + u * (mapy - py) / v;
texofs = ofs - floor(ofs);
} else {
qreal ofs = px + u * (mapy + 1 - py) / v;
texofs = ofs - floor(ofs);
}
}
} else {
// shorter distance to a hit in constant x line
hitdist = distx;
distx += duu;
mapx += stepx;
texture = world_map[mapy][mapx];
if (texture > 0) {
if (stepx > 0) {
qreal ofs = py + v * (mapx - px) / u;
texofs = ofs - floor(ofs);
} else {
qreal ofs = py + v * (mapx + 1 - px) / u;
texofs = ceil(ofs) - ofs;
}
}
}
}
// get the texture, note that the texture image
// has two textures horizontally, "normal" vs "dark"
int col = static_cast<int>(texofs * TEXTURE_SIZE);
col = qBound(0, col, TEXTURE_SIZE - 1);
texture = (texture - 1) % textureCount;
const QRgb *tex = texsrc + TEXTURE_BLOCK * texture * 2 +
(TEXTURE_SIZE * 2 * col);
if (dark)
tex += TEXTURE_SIZE;
// start from the texture center (horizontally)
int h = static_cast<int>(bufw / hitdist / 2);
int dy = (TEXTURE_SIZE << 12) / h;
int p1 = ((TEXTURE_SIZE / 2) << 12) - dy;
int p2 = p1 + dy;
// start from the screen center (vertically)
// y1 will go up (decrease), y2 will go down (increase)
int y1 = bufh / 2;
int y2 = y1 + 1;
QRgb *pixel1 = start + y1 * stride + ray;
QRgb *pixel2 = pixel1 + stride;
// map the texture to the sliver
while (y1 >= 0 && y2 < bufh && p1 >= 0) {
*pixel1 = tex[p1 >> 12];
*pixel2 = tex[p2 >> 12];
p1 -= dy;
p2 += dy;
--y1;
++y2;
pixel1 -= stride;
pixel2 += stride;
}
// ceiling and floor
for (; pixel1 > start; pixel1 -= stride)
*pixel1 = qRgb(0, 0, 0);
for (; pixel2 < finish; pixel2 += stride)
*pixel2 = qRgb(96, 96, 96);
}
update(QRect(QPoint(0, 0), bufferSize));
}
protected:
void resizeEvent(QResizeEvent*) {
#if defined(Q_OS_WINCE_WM)
touchDevice = true;
#else
touchDevice = false;
#endif
if (touchDevice) {
if (width() < height()) {
trackPad = QRect(0, height() / 2, width(), height() / 2);
centerPad = QPoint(width() / 2, height() * 3 / 4);
bufferSize = QSize(width(), height() / 2);
} else {
trackPad = QRect(width() / 2, 0, width() / 2, height());
centerPad = QPoint(width() * 3 / 4, height() / 2);
bufferSize = QSize(width() / 2, height());
}
} else {
trackPad = QRect();
bufferSize = size();
}
update();
}
void timerEvent(QTimerEvent*) {
updatePlayer();
render();
showFps();
}
void paintEvent(QPaintEvent *event) {
QPainter p(this);
p.setCompositionMode(QPainter::CompositionMode_Source);
p.drawImage(event->rect(), buffer, event->rect());
if (touchDevice && event->rect().intersects(trackPad)) {
p.fillRect(trackPad, Qt::white);
p.setPen(QPen(QColor(224, 224, 224), 6));
int rad = qMin(trackPad.width(), trackPad.height()) * 0.3;
p.drawEllipse(centerPad, rad, rad);
p.setPen(Qt::NoPen);
p.setBrush(Qt::gray);
QPolygon poly;
poly << QPoint(-30, 0);
poly << QPoint(0, -40);
poly << QPoint(30, 0);
p.translate(centerPad);
for (int i = 0; i < 4; ++i) {
p.rotate(90);
p.translate(0, 20 - rad);
p.drawPolygon(poly);
p.translate(0, rad - 20);
}
}
p.end();
}
void keyPressEvent(QKeyEvent *event) {
event->accept();
if (event->key() == Qt::Key_Left)
angleDelta = 1.3 * M_PI;
if (event->key() == Qt::Key_Right)
angleDelta = -1.3 * M_PI;
if (event->key() == Qt::Key_Up)
moveDelta = 2.5;
if (event->key() == Qt::Key_Down)
moveDelta = -2.5;
}
void keyReleaseEvent(QKeyEvent *event) {
event->accept();
if (event->key() == Qt::Key_Left)
angleDelta = (angleDelta > 0) ? 0 : angleDelta;
if (event->key() == Qt::Key_Right)
angleDelta = (angleDelta < 0) ? 0 : angleDelta;
if (event->key() == Qt::Key_Up)
moveDelta = (moveDelta > 0) ? 0 : moveDelta;
if (event->key() == Qt::Key_Down)
moveDelta = (moveDelta < 0) ? 0 : moveDelta;
}
void mousePressEvent(QMouseEvent *event) {
qreal dx = centerPad.x() - event->pos().x();
qreal dy = centerPad.y() - event->pos().y();
angleDelta = dx * 2 * M_PI / width();
moveDelta = dy * 10 / height();
}
void mouseMoveEvent(QMouseEvent *event) {
qreal dx = centerPad.x() - event->pos().x();
qreal dy = centerPad.y() - event->pos().y();
angleDelta = dx * 2 * M_PI / width();
moveDelta = dy * 10 / height();
}
void mouseReleaseEvent(QMouseEvent*) {
angleDelta = 0;
moveDelta = 0;
}
private:
QTime watch;
QBasicTimer ticker;
QImage buffer;
qreal angle;
QPointF playerPos;
qreal angleDelta;
qreal moveDelta;
QImage textureImg;
int textureCount;
bool touchDevice;
QRect trackPad;
QPoint centerPad;
QSize bufferSize;
};
int main(int argc, char **argv)
{
QApplication app(argc, argv);
Raycasting w;
w.setWindowTitle("Raycasting");
w.resize(640, 480);
w.show();
return app.exec();
}