mirror of
https://github.com/rwengine/openrw.git
synced 2024-11-22 10:22:52 +01:00
329 lines
7.4 KiB
C++
329 lines
7.4 KiB
C++
#include "ViewerWidget.hpp"
|
|
#include <data/Model.hpp>
|
|
#include <render/GameRenderer.hpp>
|
|
#include <render/OpenGLRenderer.hpp>
|
|
#include <glm/gtc/type_ptr.hpp>
|
|
#include <QMouseEvent>
|
|
#include <objects/GameObject.hpp>
|
|
#include <engine/Animator.hpp>
|
|
#include <data/Skeleton.hpp>
|
|
#include <QFileDialog>
|
|
#include <algorithm>
|
|
|
|
#include <objects/InstanceObject.hpp>
|
|
#include <objects/CharacterObject.hpp>
|
|
#include <objects/VehicleObject.hpp>
|
|
|
|
|
|
ViewerWidget::ViewerWidget(QWidget* parent, const QGLWidget* shareWidget, Qt::WindowFlags f)
|
|
: QGLWidget(parent, shareWidget, f)
|
|
, gworld(nullptr)
|
|
, activeModel(nullptr)
|
|
, selectedFrame(nullptr)
|
|
, dummyObject(nullptr)
|
|
, currentObjectID(0)
|
|
, _lastModel(nullptr)
|
|
, canimation(nullptr)
|
|
, viewDistance(1.f)
|
|
, dragging(false)
|
|
, moveFast(false)
|
|
, _frameWidgetDraw(nullptr)
|
|
, _frameWidgetGeom(nullptr)
|
|
{
|
|
setFocusPolicy(Qt::StrongFocus);
|
|
}
|
|
|
|
struct WidgetVertex {
|
|
float x, y, z;
|
|
static const AttributeList vertex_attributes() {
|
|
return {
|
|
{ATRS_Position, 3, sizeof(WidgetVertex), 0ul}
|
|
};
|
|
}
|
|
};
|
|
|
|
std::vector<WidgetVertex> widgetVerts = {
|
|
{-.5f, 0.f, 0.f},
|
|
{ .5f, 0.f, 0.f},
|
|
{ 0.f,-.5f, 0.f},
|
|
{ 0.f, .5f, 0.f},
|
|
{ 0.f, 0.f,-.5f},
|
|
{ 0.f, 0.f, .5f}
|
|
};
|
|
|
|
void ViewerWidget::initializeGL()
|
|
{
|
|
QGLWidget::initializeGL();
|
|
timer.setInterval(16);
|
|
connect(&timer, SIGNAL(timeout()), SLOT(updateGL()));
|
|
timer.start();
|
|
|
|
_frameWidgetDraw = new DrawBuffer;
|
|
_frameWidgetDraw->setFaceType(GL_LINES);
|
|
_frameWidgetGeom = new GeometryBuffer;
|
|
_frameWidgetGeom->uploadVertices(widgetVerts);
|
|
_frameWidgetDraw->addGeometry(_frameWidgetGeom);
|
|
|
|
glGenTextures(1, &whiteTex);
|
|
glBindTexture(GL_TEXTURE_2D, whiteTex);
|
|
GLuint tex = 0xFFFFFFFF;
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, &tex);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
}
|
|
|
|
void ViewerWidget::resizeGL(int w, int h)
|
|
{
|
|
QGLWidget::resizeGL(w, h);
|
|
glViewport(0, 0, w, h);
|
|
}
|
|
|
|
void ViewerWidget::paintGL()
|
|
{
|
|
glClearColor(0.3f, 0.3f, 0.3f, 1.f);
|
|
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
|
|
|
|
glViewport(0, 0, width(), height());
|
|
|
|
if( world() == nullptr ) return;
|
|
|
|
auto& r = *renderer;
|
|
|
|
r.setViewport(width(), height());
|
|
|
|
if(dummyObject && dummyObject->animator && dummyObject->skeleton) {
|
|
dummyObject->animator->tick(1.f/60.f);
|
|
dummyObject->skeleton->interpolate(1.f);
|
|
}
|
|
|
|
gworld->_work->update();
|
|
|
|
r.getRenderer()->invalidate();
|
|
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
glm::mat4 m(1.f);
|
|
|
|
r.getRenderer()->useProgram(r.worldProg);
|
|
|
|
ViewCamera vc;
|
|
|
|
float viewFov = glm::radians(45.f);
|
|
|
|
vc.frustum.far = 500.f;
|
|
vc.frustum.near = 0.1f;
|
|
vc.frustum.fov = viewFov;
|
|
vc.frustum.aspectRatio = width()/(height()*1.f);
|
|
|
|
Model* model = activeModel;
|
|
if( model != _lastModel ) {
|
|
_lastModel = model;
|
|
emit modelChanged(_lastModel);
|
|
}
|
|
|
|
glm::vec3 eye(sin(viewAngles.x) * cos(viewAngles.y), cos(viewAngles.x) * cos(viewAngles.y), sin(viewAngles.y));
|
|
|
|
if( model )
|
|
{
|
|
glm::mat4 proj = vc.frustum.projection();
|
|
glm::mat4 view = glm::lookAt(eye * viewDistance, glm::vec3(0.f, 0.f, 0.f), glm::vec3(0.f, 0.f, 1.f));
|
|
|
|
r.getRenderer()->setSceneParameters({ proj, view, glm::vec4(0.15f), glm::vec4(0.7f), glm::vec4(1.f), glm::vec4(0.f), 90.f, vc.frustum.far });
|
|
|
|
r.getRenderer()->invalidate();
|
|
|
|
r.setupRender();
|
|
|
|
r.renderModel(model, m, dummyObject);
|
|
|
|
drawFrameWidget(model->frames[model->rootFrameIdx]);
|
|
r.renderPostProcess();
|
|
}
|
|
else if (world()->allObjects.size() > 0)
|
|
{
|
|
vc.frustum.fov = glm::radians(90.f);
|
|
vc.frustum.far = 1000.f;
|
|
vc.position = viewPosition;
|
|
vc.rotation = glm::angleAxis(glm::half_pi<float>() + viewAngles.x, glm::vec3(0.f, 0.f, 1.f))
|
|
* glm::angleAxis(viewAngles.y, glm::vec3(0.f, 1.f, 0.f));
|
|
r.renderWorld(world(), vc, 0.f);
|
|
}
|
|
}
|
|
|
|
void ViewerWidget::drawFrameWidget(ModelFrame* f, const glm::mat4& m)
|
|
{
|
|
auto thisM = m * f->getTransform();
|
|
if(f->getGeometries().size() == 0)
|
|
{
|
|
Renderer::DrawParameters dp;
|
|
dp.count = _frameWidgetGeom->getCount();
|
|
dp.start = 0;
|
|
dp.ambient = 1.f;
|
|
dp.diffuse = 1.f;
|
|
if( f == selectedFrame )
|
|
{
|
|
dp.colour = {255, 255, 0, 255};
|
|
// Sorry!
|
|
glLineWidth(10.f);
|
|
}
|
|
else
|
|
{
|
|
dp.colour = {255, 255, 255, 255};
|
|
glLineWidth(1.f);
|
|
}
|
|
dp.textures = { whiteTex };
|
|
renderer->getRenderer()->drawArrays(thisM, _frameWidgetDraw, dp);
|
|
}
|
|
|
|
for(auto c : f->getChildren()) {
|
|
drawFrameWidget(c, thisM);
|
|
}
|
|
}
|
|
|
|
GameWorld* ViewerWidget::world()
|
|
{
|
|
return gworld;
|
|
}
|
|
|
|
void ViewerWidget::showObject(qint16 item)
|
|
{
|
|
currentObjectID = item;
|
|
|
|
if( dummyObject ) gworld->destroyObject( dummyObject );
|
|
|
|
auto def = world()->data->objectTypes[item];
|
|
|
|
if( def )
|
|
{
|
|
if(def->class_type == ObjectData::class_id)
|
|
{
|
|
dummyObject = gworld->createInstance(item, {});
|
|
}
|
|
else if(def->class_type == CharacterData::class_id)
|
|
{
|
|
dummyObject = gworld->createPedestrian(item, {});
|
|
}
|
|
else if(def->class_type == VehicleData::class_id)
|
|
{
|
|
dummyObject = gworld->createVehicle(item, {});
|
|
}
|
|
RW_CHECK(dummyObject != nullptr, "Dummy Object is null");
|
|
if (dummyObject != nullptr) {
|
|
activeModel = dummyObject->model->resource;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ViewerWidget::showModel(Model* model)
|
|
{
|
|
if( dummyObject ) gworld->destroyObject( dummyObject );
|
|
dummyObject = nullptr;
|
|
activeModel = model;
|
|
}
|
|
|
|
void ViewerWidget::selectFrame(ModelFrame* frame)
|
|
{
|
|
selectedFrame = frame;
|
|
}
|
|
|
|
void ViewerWidget::exportModel()
|
|
{
|
|
QString toSv = QFileDialog::getSaveFileName(this,
|
|
"Export Model",
|
|
QDir::homePath(),
|
|
"Model (*.DFF)");
|
|
|
|
if( toSv.size() == 0 ) return;
|
|
|
|
#if 0
|
|
auto it = world()->objectTypes.find(currentObjectID);
|
|
if( it != world()->objectTypes.end() ) {
|
|
for( auto& archive : world()->data.archives ) {
|
|
for(size_t i = 0; i < archive.second.getAssetCount(); ++i) {
|
|
auto& assetI = archive.second.getAssetInfoByIndex(i);
|
|
std::string q(assetI.name);
|
|
std::transform(q.begin(), q.end(), q.begin(), ::tolower);
|
|
if( q.find(it->second->modelName) != q.npos ) {
|
|
archive.second.saveAsset(q, toSv.toStdString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void ViewerWidget::dataLoaded(GameWorld *world)
|
|
{
|
|
gworld = world;
|
|
}
|
|
|
|
void ViewerWidget::setRenderer(GameRenderer *render)
|
|
{
|
|
renderer = render;
|
|
}
|
|
|
|
void ViewerWidget::keyPressEvent(QKeyEvent* e)
|
|
{
|
|
if (e->key() == Qt::Key_Shift)
|
|
moveFast = true;
|
|
|
|
glm::vec3 movement;
|
|
if (e->key() == Qt::Key_W)
|
|
movement.y += moveFast ? 10.f : 1.f;
|
|
if (e->key() == Qt::Key_S)
|
|
movement.y -= moveFast ? 10.f : 1.f;
|
|
if (e->key() == Qt::Key_A)
|
|
movement.x -= moveFast ? 10.f : 1.f;
|
|
if (e->key() == Qt::Key_D)
|
|
movement.x += moveFast? 10.f : 1.f;
|
|
|
|
if (movement.length() > 0.f)
|
|
{
|
|
movement = (glm::angleAxis(viewAngles.x, glm::vec3(0.f, 0.f, 1.f))
|
|
* glm::angleAxis(viewAngles.y, glm::vec3(-1.f, 0.f, 0.f))) * movement;
|
|
viewPosition += movement;
|
|
}
|
|
}
|
|
|
|
void ViewerWidget::keyReleaseEvent(QKeyEvent* e)
|
|
{
|
|
if (e->key() == Qt::Key_Shift)
|
|
moveFast = false;
|
|
}
|
|
|
|
Model* ViewerWidget::currentModel() const
|
|
{
|
|
return activeModel;
|
|
}
|
|
|
|
GameObject* ViewerWidget::currentObject() const
|
|
{
|
|
return dummyObject;
|
|
}
|
|
|
|
void ViewerWidget::mousePressEvent(QMouseEvent* e)
|
|
{
|
|
dragging = true;
|
|
dstart = e->localPos();
|
|
dastart = viewAngles;
|
|
}
|
|
|
|
void ViewerWidget::mouseReleaseEvent(QMouseEvent*)
|
|
{
|
|
dragging = false;
|
|
}
|
|
|
|
void ViewerWidget::mouseMoveEvent(QMouseEvent* e)
|
|
{
|
|
if(dragging) {
|
|
auto d = e->localPos() - dstart;
|
|
viewAngles = dastart + glm::vec2(d.x(), d.y()) * 0.01f;
|
|
}
|
|
}
|
|
|
|
void ViewerWidget::wheelEvent(QWheelEvent* e)
|
|
{
|
|
viewDistance = qMax(viewDistance - e->angleDelta().y() / 240.f, 0.5f);
|
|
}
|
|
|