285 lines
11 KiB
C++
285 lines
11 KiB
C++
/*
|
|
QGLView
|
|
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 "qglview.h"
|
|
|
|
QStringList GLTextureManagerBase::search_pathes(".");
|
|
|
|
|
|
bool GLCubeTexture::create() {
|
|
// qDebug("create");
|
|
destroy();
|
|
glGenTextures(1, &id_);
|
|
glBindTexture(GL_TEXTURE_CUBE_MAP, id_);
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR /*_MIPMAP_LINEAR*/);
|
|
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
// glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
|
|
// glClearError();
|
|
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, format_, size, size, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
|
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, format_, size, size, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
|
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, format_, size, size, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
|
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, format_, size, size, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
|
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, format_, size, size, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
|
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, format_, size, size, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
|
// qDebug() << glGetError();
|
|
changed_ = false;
|
|
return id_ > 0;
|
|
}
|
|
|
|
|
|
void GLCubeTexture::load() {
|
|
if (isEmpty()) return;
|
|
create();
|
|
if (!path(0).isEmpty()) loadFront(path(0));
|
|
if (!path(1).isEmpty()) loadBack(path(1));
|
|
if (!path(2).isEmpty()) loadLeft(path(2));
|
|
if (!path(3).isEmpty()) loadRight(path(3));
|
|
if (!path(4).isEmpty()) loadTop(path(4));
|
|
if (!path(5).isEmpty()) loadBottom(path(5));
|
|
}
|
|
|
|
|
|
void GLCubeTexture::loadFromDirectory(const QString & dir) {
|
|
QDir d(dir);
|
|
QFileInfoList sl;
|
|
sl = d.entryInfoList(QStringList("front.*"), QDir::Files | QDir::NoDotAndDotDot);
|
|
if (!sl.isEmpty()) loadFront(sl[0].absoluteFilePath());
|
|
sl = d.entryInfoList(QStringList("back.*"), QDir::Files | QDir::NoDotAndDotDot);
|
|
if (!sl.isEmpty()) loadBack(sl[0].absoluteFilePath());
|
|
sl = d.entryInfoList(QStringList("left.*"), QDir::Files | QDir::NoDotAndDotDot);
|
|
if (!sl.isEmpty()) loadLeft(sl[0].absoluteFilePath());
|
|
sl = d.entryInfoList(QStringList("right.*"), QDir::Files | QDir::NoDotAndDotDot);
|
|
if (!sl.isEmpty()) loadRight(sl[0].absoluteFilePath());
|
|
sl = d.entryInfoList(QStringList("top.*"), QDir::Files | QDir::NoDotAndDotDot);
|
|
if (!sl.isEmpty()) loadTop(sl[0].absoluteFilePath());
|
|
sl = d.entryInfoList(QStringList("bottom.*"), QDir::Files | QDir::NoDotAndDotDot);
|
|
if (!sl.isEmpty()) loadBottom(sl[0].absoluteFilePath());
|
|
}
|
|
|
|
|
|
void GLCubeTexture::loadPathesFromDirectory(const QString & dir) {
|
|
QDir d(dir);
|
|
QFileInfoList sl;
|
|
sl = d.entryInfoList(QStringList("front.*"), QDir::Files | QDir::NoDotAndDotDot);
|
|
if (!sl.isEmpty()) pathes[0] = sl[0].absoluteFilePath();
|
|
sl = d.entryInfoList(QStringList("back.*"), QDir::Files | QDir::NoDotAndDotDot);
|
|
if (!sl.isEmpty()) pathes[1] = sl[0].absoluteFilePath();
|
|
sl = d.entryInfoList(QStringList("left.*"), QDir::Files | QDir::NoDotAndDotDot);
|
|
if (!sl.isEmpty()) pathes[2] = sl[0].absoluteFilePath();
|
|
sl = d.entryInfoList(QStringList("right.*"), QDir::Files | QDir::NoDotAndDotDot);
|
|
if (!sl.isEmpty()) pathes[3] = sl[0].absoluteFilePath();
|
|
sl = d.entryInfoList(QStringList("top.*"), QDir::Files | QDir::NoDotAndDotDot);
|
|
if (!sl.isEmpty()) pathes[4] = sl[0].absoluteFilePath();
|
|
sl = d.entryInfoList(QStringList("bottom.*"), QDir::Files | QDir::NoDotAndDotDot);
|
|
if (!sl.isEmpty()) pathes[5] = sl[0].absoluteFilePath();
|
|
}
|
|
|
|
|
|
QString GLTextureManagerBase::findFile(const QString & path) {
|
|
return ::findFile(path, search_pathes);
|
|
}
|
|
|
|
|
|
GLuint GLTextureManagerBase::loadTexture(const QString & path, bool ownership, bool bump) {
|
|
QString p = findFile(path);
|
|
if (p.isEmpty()) return 0;
|
|
int tid = textureID(p, bump);
|
|
if (tid > 0) {
|
|
// qDebug() << "[TextureManager] Found" << path << "as" << tid;
|
|
return tid;
|
|
}
|
|
QImage image(p);
|
|
if (bump) convertToNormal(image);
|
|
// qDebug() << p << image.width() << image.height() << image.format() << bump;
|
|
/// tid = currentQGLView->bindTexture(image, GL_TEXTURE_2D/*, GL_RGBA, __GLContext__::MipmapBindOption*/);
|
|
// GLuint tid = 0;
|
|
GLuint _tid = tid;
|
|
createGLTexture(_tid, image); /// currentQGLView->bindTexture(image, GL_TEXTURE_2D);
|
|
tid = _tid;
|
|
if (tid == 0) {
|
|
qDebug() << "[TextureManager] Can`t load" << p;
|
|
return tid;
|
|
}
|
|
qDebug() << "[TextureManager] Loaded" << p << "as" << tid;
|
|
if (ownership) tex_ids[bump ? 1 : 0].insert(p, tid);
|
|
return tid;
|
|
}
|
|
|
|
|
|
GLuint GLTextureManagerBase::loadTexture(const QImage & im, bool ownership, bool bump) {
|
|
if (im.isNull()) return 0;
|
|
QImage image(im);
|
|
if (bump) convertToNormal(image);
|
|
GLuint tid = 0;
|
|
createGLTexture(tid, im); /// currentQGLView->bindTexture(image, GL_TEXTURE_2D);
|
|
if (tid == 0) {
|
|
qDebug() << "[TextureManager] Can`t load image";
|
|
return tid;
|
|
}
|
|
// qDebug() << "[TextureManager] Loaded image as" << tid;
|
|
if (ownership) tex_ids[bump ? 1 : 0].insert(QString(), tid);
|
|
return tid;
|
|
}
|
|
|
|
|
|
void GLTextureManagerBase::reloadTexture(GLuint tid, const QString & path) {
|
|
QString p = findFile(path);
|
|
if (p.isEmpty() || (tid == 0)) return;
|
|
QImage image(p);
|
|
createGLTexture(tid, image);
|
|
if (tid == 0) {
|
|
qDebug() << "[TextureManager] Can`t load" << p;
|
|
return;
|
|
}
|
|
qDebug() << "[TextureManager] Reloaded" << p << "as" << tid;
|
|
}
|
|
|
|
|
|
void GLTextureManagerBase::reloadTexture(GLuint tid, const QImage & im) {
|
|
if (im.isNull() || (tid == 0)) return;
|
|
QImage image(im);
|
|
createGLTexture(tid, image);
|
|
qDebug() << "[TextureManager] Reloaded" << tid;
|
|
}
|
|
|
|
|
|
Vector3d colorVector(QRgb c) {
|
|
return Vector3d(((uchar *)(&c))[0] / 255., ((uchar *)(&c))[1] / 255., ((uchar *)(&c))[2] / 255.);
|
|
}
|
|
|
|
|
|
void GLTextureManagerBase::convertToNormal(QImage & im) {
|
|
if (im.isNull()) return;
|
|
QImage sim = im.convertToFormat(QImage::Format_ARGB32);
|
|
float sum[3] = {0., 0., 0.};
|
|
llong a = 0;
|
|
const uchar * sd = sim.constBits();
|
|
for (int i = 0; i < sim.height(); i++) {
|
|
for (int j = 0; j < sim.width(); j++) {
|
|
sum[2] += sd[a] / 255.f - 0.5f;
|
|
++a;
|
|
sum[1] += sd[a] / 255.f - 0.5f;
|
|
++a;
|
|
sum[0] += sd[a] / 255.f - 0.5f;
|
|
++a;
|
|
++a;
|
|
}
|
|
}
|
|
float wh = sim.width() * sim.height();
|
|
sum[0] /= wh;
|
|
sum[1] /= wh;
|
|
sum[2] /= wh;
|
|
qDebug() << sum[0] << sum[1] << sum[2];
|
|
if ((qAbs(sum[0]) <= 0.05f) && (qAbs(sum[1]) <= 0.05f) && (sum[2] >= 0.25f)) /// already normal
|
|
return;
|
|
qDebug() << "convert to bump";
|
|
QImage dim = QImage(sim.width(), sim.height(), QImage::Format_ARGB32);
|
|
int tx, ty, w = sim.width(), h = sim.height();
|
|
a = 0;
|
|
uchar * dd = dim.bits();
|
|
for (int i = 0; i < sim.height(); i++) {
|
|
for (int j = 0; j < sim.width(); j++) {
|
|
tx = j - 1;
|
|
tx = tx < 0 ? w + tx : tx % w;
|
|
ty = i - 1;
|
|
ty = ty < 0 ? h + ty : ty % h;
|
|
Vector3d p[3], res;
|
|
p[0] = colorVector(sim.pixel(j, i));
|
|
p[1] = colorVector(sim.pixel(j, ty));
|
|
p[2] = colorVector(sim.pixel(tx, i));
|
|
res.y = piClamp(0.5f + (p[0].length() - p[1].length()) / 2.f, 0.f, 1.f);
|
|
res.x = piClamp(0.5f + (p[0].length() - p[2].length()) / 2.f, 0.f, 1.f);
|
|
tx = (j + 1) % w;
|
|
ty = (i + 1) % h;
|
|
p[1] = colorVector(sim.pixel(j, ty));
|
|
p[2] = colorVector(sim.pixel(tx, i));
|
|
res.y = piClamp(0.5f + (p[0].length() - p[1].length()) / 2.f, 0.f, 1.f);
|
|
res.x = piClamp(0.5f + (p[0].length() - p[2].length()) / 2.f, 0.f, 1.f);
|
|
res.z = 1.;
|
|
dd[a] = res.z * 255;
|
|
++a;
|
|
dd[a] = res.x * 255;
|
|
++a;
|
|
dd[a] = res.y * 255;
|
|
++a;
|
|
dd[a] = 255;
|
|
++a;
|
|
}
|
|
}
|
|
im = dim;
|
|
// im.save("_bump.png");
|
|
}
|
|
|
|
|
|
Material::Material(): map_reflection(512) {
|
|
color_diffuse = color_specular = Qt::white;
|
|
color_self_illumination = Qt::black;
|
|
glass = false;
|
|
transparency = reflectivity = 0.f;
|
|
map_specularity.color_amount = 0.5f;
|
|
map_specular.color_amount = 1.f;
|
|
iof = 1.f;
|
|
dispersion = 0.05f;
|
|
}
|
|
|
|
|
|
void Material::apply(QOpenGLShaderProgram * prog) {
|
|
if (prog) {
|
|
setUniformMaterial(prog, *this);
|
|
} else {
|
|
GLfloat mat_diffuse[4] = {1.0f, 1.0f, 1.0f, 1.0f};
|
|
GLfloat mat_specular[4] = {0.9f, 0.9f, 0.9f, 1.0f};
|
|
GLfloat mat_emission[4] = {0.f, 0.f, 0.f, 1.0f};
|
|
mat_diffuse[0] = map_diffuse.color_amount * color_diffuse.redF();
|
|
mat_diffuse[1] = map_diffuse.color_amount * color_diffuse.greenF();
|
|
mat_diffuse[2] = map_diffuse.color_amount * color_diffuse.blueF();
|
|
mat_diffuse[3] = map_diffuse.color_amount * color_diffuse.alphaF() * (1.f - transparency);
|
|
mat_specular[0] = map_specular.color_amount * color_specular.redF();
|
|
mat_specular[1] = map_specular.color_amount * color_specular.greenF();
|
|
mat_specular[2] = map_specular.color_amount * color_specular.blueF();
|
|
mat_emission[0] = map_self_illumination.color_amount * color_self_illumination.redF();
|
|
mat_emission[1] = map_self_illumination.color_amount * color_self_illumination.greenF();
|
|
mat_emission[2] = map_self_illumination.color_amount * color_self_illumination.blueF();
|
|
glColor4f(mat_diffuse[0], mat_diffuse[1], mat_diffuse[2], mat_diffuse[3]);
|
|
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
|
|
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
|
|
// qDebug() << (map_specularity.color_amount)*128.;
|
|
glMaterialf(GL_FRONT, GL_SHININESS, (map_specularity.color_amount) * 128.f);
|
|
glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);
|
|
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_diffuse);
|
|
}
|
|
}
|
|
|
|
|
|
void Material::loadTextures(GLTextureManagerBase * tm) {
|
|
// qDebug() << "load textures";
|
|
if (!tm) return;
|
|
if (!map_diffuse.bitmap_path.isEmpty()) map_diffuse.bitmap_id = tm->loadTexture(map_diffuse.bitmap_path);
|
|
if (!map_normal.bitmap_path.isEmpty()) map_normal.bitmap_id = tm->loadTexture(map_normal.bitmap_path, true, true);
|
|
if (!map_relief.bitmap_path.isEmpty()) map_relief.bitmap_id = tm->loadTexture(map_relief.bitmap_path);
|
|
if (!map_specularity.bitmap_path.isEmpty()) map_specularity.bitmap_id = tm->loadTexture(map_specularity.bitmap_path);
|
|
if (!map_specular.bitmap_path.isEmpty()) map_specular.bitmap_id = tm->loadTexture(map_specular.bitmap_path);
|
|
if (!map_self_illumination.bitmap_path.isEmpty()) map_self_illumination.bitmap_id = tm->loadTexture(map_self_illumination.bitmap_path);
|
|
// if (!map_diffuse_2.bitmap_path.isEmpty()) map_diffuse_2.bitmap_id = tm->loadTexture(map_diffuse_2.bitmap_path);
|
|
map_reflection.load();
|
|
}
|