main.cpp

#include "mainwindow.h"
#include <QApplication>
#include <QDir>
#include <QThread>
#include <QElapsedTimer>
#include <fenv.h>



#if 0
#include <QDir>
#include "path.h"
#include <QFileSystemWatcher>
#include <QProcess>

class FileShader
{
	QString filepath_source;
	QString filepath_spv;

public:
	FileShader(const QString &filepath_source, const QString &filepath_spv)
	{
		this->filepath_source = filepath_source;
		this->filepath_spv = filepath_spv;
	}

	QString source()
	{
		return filepath_source;
	}

	QString spv()
	{
		return filepath_spv;
	}
};

class DynamicChangeShaderCompiller : public QObject
{
	QFileSystemWatcher fileWatcher;

	QHash<QString, FileShader*> hash;

	void fileChanged(const QString &path)
	{
		//qDebug() << "fileChanged" << path;

		FileShader *fileShader = hash[path];

		if (fileShader == nullptr)
			return;

		QStringList arguments;

		arguments << "-V";
		arguments << fileShader->source();
		arguments << "-o";
		arguments << fileShader->spv();

		QProcess::execute("glslangValidator", arguments);


		fileWatcher.addPath(path);
	}


	void add(const QString &source, const QString &spriv)
	{
		if (spriv.endsWith(".vert") || spriv.endsWith(".frag"))
		{
			qDebug("error DynamicChangeShaderCompiller::add");
			return;
		}

		QDir dir(path::getShaders() + "../" + source);
		QString path_source = dir.absolutePath();
		hash[path_source] = new FileShader(path_source, path::getShaders() + spriv);

		fileWatcher.addPath(path_source);
	}


public:
	DynamicChangeShaderCompiller()
	{
		add("PaintVertex.vert", "PaintVertex.spv");
		add("AnimatedPaintFragment.frag", "AnimatedPaintFragment.spv");
		QObject::connect(&fileWatcher, &QFileSystemWatcher::fileChanged, this, &DynamicChangeShaderCompiller::fileChanged);
	}
};
#endif




#if 0
#include <QAbstractAnimation>

class GameLoop : public QAbstractAnimation {
public:
	GameLoop(QObject *parent = nullptr) : QAbstractAnimation(parent) {
		// Запускаем таймер для подсчета времени между кадрами (Delta Time)
		frameTimer.start();
	}

	// Обязательный метод: возвращает длительность анимации.
	// Возвращаем -1, чтобы цикл шел бесконечно.
	int duration() const override {
		return -1;
	}

	void setGameWidget(MainWindow *widget)
	{
		m_gameWidget = widget;
	}

protected:
	// Этот метод вызывается автоматически на каждом кадре главного цикла
	void updateCurrentTime(int currentTime) override {
		// 1. Считаем Delta Time (время в секундах, прошедшее с прошлого кадра)
		double deltaTime = frameTimer.restart() / 1000.0;

		// Предотвращаем скачки физики при сильных лагах
		if (deltaTime > 0.1) deltaTime = 0.1;

		m_gameWidget->onEnterFrame();
	}

private:
	QElapsedTimer frameTimer;

	MainWindow *m_gameWidget = nullptr;
};
#endif



int main(int argc, char *argv[])
{
	//feenableexcept(FE_INVALID);

#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
	qputenv("QT_ENABLE_HIGHDPI_SCALING", "0");
#endif


	QApplication a(argc, argv);
	QDir::setCurrent(a.applicationDirPath());


	MainWindow w;
	w.show();



	//DynamicChangeShaderCompiller dynamicChangeShaderCompiller;

	//qint64 lastTime = QDateTime::currentMSecsSinceEpoch();

	//int fps = 0;


	QElapsedTimer timer;
	timer.start();

	while (w.isVisible())
	{
		timer.restart();

		QCoreApplication::processEvents(QEventLoop::AllEvents);

		w.onEnterFrame();


		//fps++;

		//qint64 current = QDateTime::currentMSecsSinceEpoch();

		//if (current > lastTime + 1000)
		//{
		//	lastTime = current;
		//	qDebug() << fps;
		//	fps = 0;
		//}

		qint64 elapsed = timer.elapsed();
		if (elapsed < 16) {
			QThread::msleep(16 - elapsed);
		}
	}

	return 0;
}