initial commit

2020-08-25 21:57:31 +03:00
commit 3e29fd4373
166 changed files with 24675 additions and 0 deletions
--- a/core/glmaterial.cpp
+++ b/core/glmaterial.cpp
@@ -0,0 +1,151 @@
+/*
+	QGL Material
+	Ivan Pelipenko peri4ko@yandex.ru
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Lesser General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Lesser General Public License for more details.
+
+	You should have received a copy of the GNU Lesser General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "gltypes.h"
+#include "gltexture_manager.h"
+#include "qglview.h"
+
+using namespace QGLEngineShaders;
+
+
+Map::Map() {
+	bitmap_id = 0;
+	color_amount = 1.f;
+	color_offset = 0.f;
+	bitmap_scale = QPointF(1., 1.);
+	use_bitmap = false;
+	_changed = true;
+	_layer = 0;
+}
+
+
+void Map::setBitmapPath(const QString & p) {
+	bitmap_path = p;
+	_changed = true;
+}
+
+
+void Map::load(TextureManager * tm) {
+	if (bitmap_id == 0)
+		bitmap_id = tm->loadTexture(bitmap_path, true, _type == mtNormal);
+}
+
+
+void Map::copyToQGLMap(QGLMap & m) const {
+	m.amount = color_amount;
+	m.offset = color_offset;
+	m.scale  = QVector2D(bitmap_scale);
+	if (hasBitmap() && use_bitmap) {
+		m.array_index = tarMaps;
+		m.map_index   = _layer;
+	} else {
+		m.array_index = tarEmpty;
+		m.map_index   = (_type == mtNormal ? emrBlue : emrWhite);
+	}
+}
+
+
+
+
+Material::Material(const QString _name)/*: map_reflection(512)*/ {
+	setTypes();
+	name = _name;
+	color_diffuse = Qt::white;
+	color_emission = Qt::black;
+	glass = false;
+	transparency = reflectivity = 0.f;
+	map_roughness.color_amount = 0.75f;
+	map_metalness.color_amount = 0.25f;
+	iof = 1.f;
+	dispersion = 0.05f;
+	_changed = true;
+	_index = 0;
+}
+
+
+uint Material::hash() {
+	return qHash(name);
+}
+
+
+bool Material::hasTransparency() const {
+	return float(color_diffuse.alphaF()) * (1.f - transparency) < 1.f;
+}
+
+
+bool Material::isMapsChanged() const {
+	return map_diffuse  ._changed ||
+		   map_normal   ._changed ||
+		   map_metalness._changed ||
+		   map_roughness._changed ||
+		   map_emission ._changed ||
+		   map_relief   ._changed;
+}
+
+
+bool Material::isMapChanged(int type) const {
+	switch (type) {
+	case mtDiffuse  : return map_diffuse  ._changed;
+	case mtNormal   : return map_normal   ._changed;
+	case mtMetalness: return map_metalness._changed;
+	case mtRoughness: return map_roughness._changed;
+	case mtEmission : return map_emission ._changed;
+	case mtRelief   : return map_relief   ._changed;
+	}
+	return false;
+}
+
+
+void Material::load(TextureManager * tm) {
+	map_diffuse  .load(tm);
+	map_normal   .load(tm);
+	map_metalness.load(tm);
+	map_roughness.load(tm);
+	map_emission .load(tm);
+	map_relief   .load(tm);
+}
+
+
+void Material::setMapsChanged() {
+	map_diffuse  ._changed = true;
+	map_normal   ._changed = true;
+	map_metalness._changed = true;
+	map_roughness._changed = true;
+	map_emission ._changed = true;
+	map_relief   ._changed = true;
+}
+
+
+void Material::setTypes() {
+	map_diffuse  ._type = mtDiffuse  ;
+	map_normal   ._type = mtNormal   ;
+	map_metalness._type = mtMetalness;
+	map_roughness._type = mtRoughness;
+	map_emission ._type = mtEmission ;
+	map_relief   ._type = mtRelief   ;
+}
+
+
+void Material::detectMaps() {
+	map_diffuse  .use_bitmap = !map_diffuse  .bitmap_path.isEmpty();
+	map_normal   .use_bitmap = !map_normal   .bitmap_path.isEmpty();
+	map_metalness.use_bitmap = !map_metalness.bitmap_path.isEmpty();
+	map_roughness.use_bitmap = !map_roughness.bitmap_path.isEmpty();
+	map_emission .use_bitmap = !map_emission .bitmap_path.isEmpty();
+	map_relief   .use_bitmap = !map_relief   .bitmap_path.isEmpty();
+}