SHS/libs
Archived
3
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

git-svn-id: svn://db.shs.com.ru/libs@636 a8b55f48-bf90-11e4-a774-851b48703e85

Browse Source
This commit is contained in:
Пелипенко Иван
2019-11-27 21:49:24 +00:00
parent 988c4e1150
commit 09298fadcd
22 changed files with 291 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
qglengine/formats/loader_assimp.cpp
View File

@@ -81,22 +81,51 @@ Mesh * assimpMesh(const aiMesh * m) {
} }
ObjectBase * assimpObject(const aiNode * n, const QVector<Mesh * > & meshes) { Light * assimpLight(const aiLight * l) {
if (!l) return 0;
Light * ret = new Light();
ret->setName(l->mName.C_Str());
ret->setPos(fromAiVector3D(l->mPosition));
ret->direction = fromAiVector3D(l->mDirection);
ret->decay_const = l->mAttenuationConstant ;
ret->decay_linear = l->mAttenuationLinear ;
ret->decay_quadratic = l->mAttenuationQuadratic;
ret->angle_start = l->mAngleInnerCone * rad2deg;
ret->angle_end = l->mAngleOuterCone * rad2deg;
if (l->mType == aiLightSource_SPOT)
ret->light_type = Light::Cone;
QVector3D col(l->mColorDiffuse.r, l->mColorDiffuse.g, l->mColorDiffuse.b);
ret->intensity = col.length();
col /= ret->intensity;
ret->setColor(QColor::fromRgbF(col[0], col[1], col[2]));
return ret;
}
ObjectBase * assimpObject(const aiNode * n, const QVector<Mesh * > & meshes, const QMap<QString, Light * > & light_by_name) {
if (!n) return 0; if (!n) return 0;
ObjectBase * ret = new ObjectBase(); ObjectBase * ret = 0;
ret->setName(n->mName.C_Str()); QString name = n->mName.C_Str();
Light * light = light_by_name.value(name, 0);
if (light)
ret = light->clone();
else
ret = new ObjectBase();
ret->setName(name);
ret->setTransform(fromAiMatrix4D(n->mTransformation)); ret->setTransform(fromAiMatrix4D(n->mTransformation));
//qDebug() << "add object" << ret << ret->name(); //qDebug() << "add object" << ret << ret->name();
for (uint i = 0; i < n->mNumMeshes; ++i) { if (!light) {
int mi = n->mMeshes[i]; for (uint i = 0; i < n->mNumMeshes; ++i) {
if (meshes[mi]) { int mi = n->mMeshes[i];
ret->setMesh(meshes[mi]); if (meshes[mi]) {
//qDebug() << "set mesh" << mi << ret->mesh(); ret->setMesh(meshes[mi]);
break; //qDebug() << "set mesh" << mi << ret->mesh();
break;
}
} }
} }
for (uint i = 0; i < n->mNumChildren; ++i) { for (uint i = 0; i < n->mNumChildren; ++i) {
ObjectBase * co = assimpObject(n->mChildren[i], meshes); ObjectBase * co = assimpObject(n->mChildren[i], meshes, light_by_name);
if (co) ret->addChild(co); if (co) ret->addChild(co);
} }
@@ -120,14 +149,23 @@ Scene * loadScene(const QString & filepath) {
QVector<Mesh * > meshes; QVector<Mesh * > meshes;
for (uint i = 0; i < ais->mNumMeshes; ++i) for (uint i = 0; i < ais->mNumMeshes; ++i)
meshes << assimpMesh(ais->mMeshes[i]); meshes << assimpMesh(ais->mMeshes[i]);
QVector<Light * > lights;
for (uint i = 0; i < ais->mNumLights; ++i)
lights << assimpLight(ais->mLights[i]);
QMap<QString, Light * > light_by_name;
foreach (Light * l, lights)
light_by_name[l->name()] = l;
ObjectBase * root = assimpObject(ais->mRootNode, meshes); ObjectBase * root = assimpObject(ais->mRootNode, meshes, light_by_name);
if (!root) return 0; if (!root) return 0;
Scene * scene = new Scene(); Scene * scene = new Scene();
scene->setName(root->name()); scene->setName(root->name());
foreach (ObjectBase * o, root->children()) foreach (ObjectBase * o, root->children())
scene->addObject(o); scene->addObject(o);
//foreach (ObjectBase * o, lights)
// scene->addObject(o);
qDeleteAll(lights);
return scene; return scene;
} }

1
qglengine/globject.cpp
View File

@@ -500,6 +500,7 @@ ObjectBase * Light::clone(bool withChildren) {
for (int i = 0; i < children_.size(); ++i) for (int i = 0; i < children_.size(); ++i)
o->addChild(children_[i]->clone(withChildren)); o->addChild(children_[i]->clone(withChildren));
} }
o->color_ = color_;
o->light_type = light_type; o->light_type = light_type;
o->direction = direction; o->direction = direction;
o->angle_start = angle_start; o->angle_start = angle_start;

2
qglengine/globject.h
View File

@@ -274,4 +274,6 @@ inline T globject_cast(const ObjectBase * object) {return reinterpret_cast<T>(ob
QDataStream & operator <<(QDataStream & s, const ObjectBase * p); QDataStream & operator <<(QDataStream & s, const ObjectBase * p);
QDataStream & operator >>(QDataStream & s, ObjectBase *& p); QDataStream & operator >>(QDataStream & s, ObjectBase *& p);
inline QList<ObjectBase*> light2objectList(const QList<Light*> & v) {QList<ObjectBase*> ret; foreach (Light*i, v) ret << (ObjectBase*)i; return ret;}
#endif // GLOBJECT_H #endif // GLOBJECT_H

34
qglengine/glprimitives.cpp
View File

@@ -371,3 +371,37 @@ Mesh * Primitive::ellipsoidFrame(int segments_wl, int segments_h, float width, f
return ret; return ret;
} }
Mesh * Primitive::coneFrame(int segments, float width, float length, float height) {
Mesh * ret = new Mesh(GL_LINES);
QVector<QVector3D> & v(ret->vertices ());
QVector<QVector3D> & n(ret->normals ());
QVector<QVector2D> & t(ret->texcoords());
QVector< Vector2i> & ind(ret->indicesLines());
int seg = qMax(segments + 1, 4);
double rx = width / 2., ry = length / 2.;
QVector3D cp;
for (int i = 0; i < seg; i++) {
double a = (double)i / (seg - 1) * M_2PI;
cp.setX(ry * cos(a));
cp.setY(rx * sin(a));
if (i > 0) {
v << QVector3D(0, 0, height);
t << QVector2D((double)(i - 1) / (seg - 1), 1.f);
double ta = ((double)i - 0.5) / (seg - 1) * M_2PI;
n << coneNormal(rx, ry, height, ta);
}
v << cp;
t << QVector2D((double)i / (seg - 1), 0.f);
n << coneNormal(rx, ry, height, a);
int si = v.size() - 1;
if (i > 0) {
ind << Vector2i(si - 1, si);
ind << Vector2i(si - 2, si);
}
}
return ret;
}

2
qglengine/glprimitives.h
View File

@@ -46,6 +46,8 @@ Mesh * cubeFrame(float width = 1., float length = 1., float height = 1.);
Mesh * ellipsoidFrame(int segments_wl, int segments_h, float width = 1., float length = 1., float height = 1.); Mesh * ellipsoidFrame(int segments_wl, int segments_h, float width = 1., float length = 1., float height = 1.);
Mesh * coneFrame(int segments, float width = 1., float length = 1., float height = 1.);
} }
/* /*

18
qglengine/glscene.cpp
View File

@@ -274,7 +274,6 @@ void Scene::removeMaterial(Material * m) {
if (o->material_ == m) if (o->material_ == m)
o->setMaterial(0); o->setMaterial(0);
materials.removeAll(m); materials.removeAll(m);
materials_used.remove(m);
changed_materials.removeAll(m); changed_materials.removeAll(m);
mat_changed = true; mat_changed = true;
} }
@@ -388,9 +387,10 @@ void Scene::prepareTree(ObjectBase * o) {
foreach (ObjectBase * co, o->children_) { foreach (ObjectBase * co, o->children_) {
if (co->isHidden()) continue; if (co->isHidden()) continue;
switch (co->type_) { switch (co->type_) {
case ObjectBase::glLight: case ObjectBase::glLight: {
lights_used << globject_cast<Light * >(co); Light * l = globject_cast<Light * >(co);
break; lights_used[l->light_type] << l;
} break;
case ObjectBase::glMesh: case ObjectBase::glMesh:
if (co->mesh()) { if (co->mesh()) {
geometries_used[co->mesh()] << co; geometries_used[co->mesh()] << co;
@@ -427,15 +427,7 @@ bool Scene::prepare() {
lights_used.clear(); lights_used.clear();
prepareTree(root_); prepareTree(root_);
} }
if (mat_changed) { mat_changed = false;
mat_changed = false;
materials_used.clear();
foreach (ObjectBase * o, aol) {
Material * m = o->material();
if (!m) continue;
materials_used << m;
}
}
return true; return true;
} }

5
qglengine/glscene.h
View File

@@ -102,7 +102,7 @@ protected:
void setTreeChanged(); void setTreeChanged();
void setTreeStructChanged(); void setTreeStructChanged();
void setMaterialsChanged() {mat_changed = true;} void setMaterialsChanged() {mat_changed = true;}
void setLightsChanged() {lights_changed = true;} void setLightsChanged() {lights_changed = tree_changed = true;}
void setObjectMeshChanged(ObjectBase * o); void setObjectMeshChanged(ObjectBase * o);
@@ -116,8 +116,7 @@ protected:
QVector<Material*> materials; QVector<Material*> materials;
QMap<Mesh*, QList<ObjectBase*> > geometries_used; QMap<Mesh*, QList<ObjectBase*> > geometries_used;
QSet<Material*> materials_used; QMap<int, QList<Light*>> lights_used; // by Light::Type
QList<Light*> lights_used;
QVector<Material*> changed_materials; QVector<Material*> changed_materials;
SelectionMode sel_mode_; SelectionMode sel_mode_;

39
qglengine/glshaders.cpp
View File

@@ -24,7 +24,7 @@
using namespace QGLEngineShaders; using namespace QGLEngineShaders;
bool addShader(QOpenGLShaderProgram * prog, QOpenGLShader::ShaderType type, QString & content, const QString & file) { bool addShader(QOpenGLShaderProgram * prog, QOpenGLShader::ShaderType type, QString & content, const QString & file, const QString & defs) {
if (type == 0 || content.isEmpty()) { if (type == 0 || content.isEmpty()) {
content.clear(); content.clear();
return true; return true;
@@ -43,6 +43,7 @@ bool addShader(QOpenGLShaderProgram * prog, QOpenGLShader::ShaderType type, QStr
content.prepend(qgl_geometry_head); content.prepend(qgl_geometry_head);
break; break;
} }
content.prepend(defs);
content.prepend(qgl_common_head); content.prepend(qgl_common_head);
bool ret = prog->addShaderFromSourceCode(type, content.toLatin1()); bool ret = prog->addShaderFromSourceCode(type, content.toLatin1());
if (!ret) qDebug() << "[QGLView] Shader" << file << "Compile error:\n" << prog->log(); if (!ret) qDebug() << "[QGLView] Shader" << file << "Compile error:\n" << prog->log();
@@ -51,59 +52,57 @@ bool addShader(QOpenGLShaderProgram * prog, QOpenGLShader::ShaderType type, QStr
} }
bool QGLEngineShaders::loadShadersMulti(QOpenGLShaderProgram *& prog, const QString & file) { QString prepareDefines(const QStringList & defines) {
if (defines.isEmpty()) return QString();
QString ret;
foreach (QString s, defines)
ret.append("#define " + s + "\n");
return ret;
}
bool QGLEngineShaders::loadShadersMulti(QOpenGLShaderProgram *& prog, const QString & file, const QStringList & defines) {
if (!prog) if (!prog)
prog = new QOpenGLShaderProgram(); prog = new QOpenGLShaderProgram();
prog->removeAllShaders(); prog->removeAllShaders();
QFile f(file); QFile f(file);
if (!f.open(QIODevice::ReadOnly)) return false; if (!f.open(QIODevice::ReadOnly)) return false;
QTextStream ts(&f); QTextStream ts(&f);
QString cur_shader, line, pl; QString cur_shader, line, pl, defs = prepareDefines(defines);
QOpenGLShader::ShaderType type = 0; QOpenGLShader::ShaderType type = 0;
while (!ts.atEnd()) { while (!ts.atEnd()) {
line = ts.readLine(); line = ts.readLine();
pl = line.trimmed().remove(' ').remove('\t').mid(2).toLower(); pl = line.trimmed().remove(' ').remove('\t').mid(2).toLower();
pl.chop(2); pl.chop(2);
if (pl == "vertex" || pl == "vert") { if (pl == "vertex" || pl == "vert") {
if (!addShader(prog, type, cur_shader, file)) return false; if (!addShader(prog, type, cur_shader, file, defs)) return false;
type = QOpenGLShader::Vertex; type = QOpenGLShader::Vertex;
continue; continue;
} }
if (pl == "fragment" || pl == "frag") { if (pl == "fragment" || pl == "frag") {
if (!addShader(prog, type, cur_shader, file)) return false; if (!addShader(prog, type, cur_shader, file, defs)) return false;
type = QOpenGLShader::Fragment; type = QOpenGLShader::Fragment;
continue; continue;
} }
if (pl == "geometry" || pl == "geom") { if (pl == "geometry" || pl == "geom") {
if (!addShader(prog, type, cur_shader, file)) return false; if (!addShader(prog, type, cur_shader, file, defs)) return false;
type = QOpenGLShader::Geometry; type = QOpenGLShader::Geometry;
continue; continue;
} }
if (pl == "tessellation_control") { if (pl == "tessellation_control") {
if (!addShader(prog, type, cur_shader, file)) return false; if (!addShader(prog, type, cur_shader, file, defs)) return false;
type = QOpenGLShader::TessellationControl; type = QOpenGLShader::TessellationControl;
continue; continue;
} }
if (pl == "tessellation_evaluation") { if (pl == "tessellation_evaluation") {
if (!addShader(prog, type, cur_shader, file)) return false; if (!addShader(prog, type, cur_shader, file, defs)) return false;
type = QOpenGLShader::TessellationEvaluation; type = QOpenGLShader::TessellationEvaluation;
continue; continue;
} }
cur_shader.append("\n"); cur_shader.append("\n");
cur_shader.append(line); cur_shader.append(line);
} }
if (!addShader(prog, type, cur_shader, file)) return false; if (!addShader(prog, type, cur_shader, file, defs)) return false;
/// WARNING
/*prog->bindAttributeLocation("qgl_Vertex" , 1 );
prog->bindAttributeLocation("qgl_Normal" , 2 );
prog->bindAttributeLocation("qgl_Tangent" , 3 );
prog->bindAttributeLocation("qgl_Bitangent" , 4 );
prog->bindAttributeLocation("qgl_Texture" , 5 );
prog->bindAttributeLocation("qgl_Material" , 6 );
prog->bindAttributeLocation("qgl_Color" , 7 );
prog->bindAttributeLocation("qgl_ModelViewMatrix" , 8 );
prog->bindAttributeLocation("qgl_ModelViewProjectionMatrix", 12);
prog->bindAttributeLocation("qgl_NormalMatrix" , 16);*/
if (!prog->link()) { if (!prog->link()) {
qDebug() << "[QGLView] Shader" << file << "Link error:\n" << prog->log(); qDebug() << "[QGLView] Shader" << file << "Link error:\n" << prog->log();
return false; return false;

2
qglengine/glshaders.h
View File

@@ -23,7 +23,7 @@
namespace QGLEngineShaders { namespace QGLEngineShaders {
bool loadShadersMulti(QOpenGLShaderProgram *& prog, const QString & file); bool loadShadersMulti(QOpenGLShaderProgram *& prog, const QString & file, const QStringList & defines = QStringList());
void setUniformMatrices(QOpenGLShaderProgram * prog, QMatrix4x4 proj, QMatrix4x4 view, QMatrix4x4 prevproj = QMatrix4x4(), QMatrix4x4 prevview = QMatrix4x4()); void setUniformMatrices(QOpenGLShaderProgram * prog, QMatrix4x4 proj, QMatrix4x4 view, QMatrix4x4 prevproj = QMatrix4x4(), QMatrix4x4 prevview = QMatrix4x4());
void setUniformLights(QOpenGLShaderProgram * prog, const QVector<Light*> & lights, const QMatrix4x4 & mat, int shadow_start); void setUniformLights(QOpenGLShaderProgram * prog, const QVector<Light*> & lights, const QMatrix4x4 & mat, int shadow_start);

3
qglengine/gltexture_manager.h
View File

@@ -31,7 +31,8 @@ public:
TextureManager(QOpenGLExtraFunctions * f_): f(f_) {} TextureManager(QOpenGLExtraFunctions * f_): f(f_) {}
virtual ~TextureManager() {} virtual ~TextureManager() {}
void addSearchPath(const QString & path) {search_pathes << path;} static void addSearchPath(const QString & path) {if (!search_pathes.contains(path)) search_pathes << path;}
static void clearSearchPathes() {search_pathes.clear();}
static QStringList searchPathes() {return search_pathes;} static QStringList searchPathes() {return search_pathes;}
QString findFile(const QString & path); QString findFile(const QString & path);
GLuint loadTexture(const QString & path, bool ownership = true, bool bump = false); GLuint loadTexture(const QString & path, bool ownership = true, bool bump = false);

9
qglengine/qglview.cpp
View File

@@ -88,9 +88,12 @@ QGLView::QGLView(): OpenGLWindow(), renderer_(this), mouse(this) {
//camera().aim_ = camera().pos_; //camera().aim_ = camera().pos_;
ktm_.restart(); ktm_.restart();
//Mesh * m = Primitive::torus(30, 12, 1., 0.1, 90); Mesh * m = Primitive::torus(30, 12, 1., 0.1, 90);
Mesh * m = Primitive::disc(10, 1, 1., true, 90); //Mesh * m = Primitive::coneFrame(10, 1, 1., 2.);
QMatrix4x4 mat; mat.rotate(90, 1,0,0); //QMatrix4x4 mat;
//mat.rotate(90, 0,1,0);
//mat.translate(0, 0, 2);
//mat.rotate(180, 1,0,0);
//m->transformPoints(mat); //m->transformPoints(mat);
ObjectBase * o = new ObjectBase(m); ObjectBase * o = new ObjectBase(m);
o->setColor(Qt::cyan); o->setColor(Qt::cyan);

3
qglengine/qglview_test/qglview_window.cpp
View File

@@ -19,6 +19,7 @@
#include "qglview_window.h" #include "qglview_window.h"
#include "renderer.h" #include "renderer.h"
#include "glwidget.h" #include "glwidget.h"
#include "gltexture_manager.h"
#include <QGraphicsRectItem> #include <QGraphicsRectItem>
#include <QImageReader> #include <QImageReader>
#include <QMessageBox> #include <QMessageBox>
@@ -140,9 +141,11 @@ void QGLViewWindow::loadFile(const QString & path, bool import) {
s->setName(fi.baseName()); s->setName(fi.baseName());
if (import) view->scene()->addScene(s); if (import) view->scene()->addScene(s);
else { else {
TextureManager::clearSearchPathes();
view->scene()->assignFrom(s); view->scene()->assignFrom(s);
view->view()->focusOn(view->scene()->boundingBox()); view->view()->focusOn(view->scene()->boundingBox());
} }
TextureManager::addSearchPath(fi.absoluteDir().path());
delete s; delete s;
} }

69
qglengine/renderer.cpp
View File

@@ -45,9 +45,10 @@ Renderer::Renderer(QGLView * view_): RendererBase(view_),
shader_files[srServiceFill ] = "service_fill.glsl"; shader_files[srServiceFill ] = "service_fill.glsl";
shader_files[srServiceFrame] = "service_frame.glsl"; shader_files[srServiceFrame] = "service_frame.glsl";
shader_files[srGeometryPass] = "ds_geom.glsl"; shader_files[srGeometryPass ] = "ds_geom.glsl";
shader_files[srLightingPass] = "ds_light.glsl"; shader_files[srLightOmniPass] = "ds_light.glsl"; shader_defines[srLightOmniPass] << "FIRST_PASS";
shader_files[srFinalPass ] = "ds_final.glsl"; shader_files[srLightSpotPass] = "ds_light.glsl"; shader_defines[srLightSpotPass] << "SPOT";
shader_files[srFinalPass ] = "ds_final.glsl";
/*shaders << ShaderPair("FXAA", &shader_fxaa) /*shaders << ShaderPair("FXAA", &shader_fxaa)
<< ShaderPair("dsl_pass_0", &shader_ds_0) << ShaderPair("dsl_pass_0", &shader_ds_0)
@@ -102,9 +103,12 @@ void Renderer::reloadShaders() {
QMapIterator<ShaderRole, QString> it(shader_files); QMapIterator<ShaderRole, QString> it(shader_files);
while (it.hasNext()) { while (it.hasNext()) {
it.next(); it.next();
loadShadersMulti(shaders[it.key()], "shaders/" + it.value()); loadShadersMulti(shaders[it.key()], "shaders/" + it.value(), shader_defines.value(it.key()));
} }
need_init_shaders = true; need_init_shaders = true;
view->scene()->setLightsChanged();
view->scene()->setTreeStructChanged();
view->scene()->setMaterialsChanged();
} }
@@ -122,9 +126,12 @@ void Renderer::initShaders() {
if (!need_init_shaders) return; if (!need_init_shaders) return;
need_init_shaders = false; need_init_shaders = false;
initUniformBuffer(shaders.value(srGeometryPass), &buffer_materials , bpMaterials , "QGLMaterialData" ); initUniformBuffer(shaders.value(srGeometryPass), &buffer_materials , bpMaterials , "QGLMaterialData" );
initUniformBuffer(shaders.value(srLightingPass), &buffer_materials , bpMaterials , "QGLMaterialData" ); initUniformBuffer(shaders.value(srLightOmniPass), &buffer_materials , bpMaterials , "QGLMaterialData" );
initUniformBuffer(shaders.value(srLightingPass), &buffer_lights , bpLightParameters, "QGLLightParameterData"); initUniformBuffer(shaders.value(srLightOmniPass), &buffer_lights , bpLightParameters, "QGLLightParameterData");
initUniformBuffer(shaders.value(srLightingPass), &buffer_lights_pos, bpLightPositions , "QGLLightPositionData" ); initUniformBuffer(shaders.value(srLightOmniPass), &buffer_lights_pos, bpLightPositions , "QGLLightPositionData" );
initUniformBuffer(shaders.value(srLightSpotPass), &buffer_materials , bpMaterials , "QGLMaterialData" );
initUniformBuffer(shaders.value(srLightSpotPass), &buffer_lights , bpLightParameters, "QGLLightParameterData");
initUniformBuffer(shaders.value(srLightSpotPass), &buffer_lights_pos, bpLightPositions , "QGLLightPositionData" );
} }
@@ -167,7 +174,7 @@ void Renderer::renderObjects(Scene & scene, RenderPass pass) {
} }
if (mesh->selected_changed && edit_mode) { if (mesh->selected_changed && edit_mode) {
mesh->selected_changed = false; mesh->selected_changed = false;
rend_selection.fillSelectionsBuffer(it.value()); fillSelectionsBuffer(rend_selection.cur_selections_, it.value());
mesh->loadSelections(f, rend_selection.cur_selections_); mesh->loadSelections(f, rend_selection.cur_selections_);
} }
mesh->draw(f, it.value().size()); mesh->draw(f, it.value().size());
@@ -200,16 +207,16 @@ void Renderer::renderScene() {
} }
/// lights /// lights
QList<Light*> ll = scene.lights_used; QMap<int, QList<Light*>> ll = scene.lights_used;
if (is_camera_light) { if (is_camera_light) {
ll << cam_light; ll[Light::Omni] << cam_light;
cam_light->setPos(cam->pos()); cam_light->setPos(cam->pos());
} }
if (scene.lights_changed) { if (scene.lights_changed) {
scene.lights_changed = false; scene.lights_changed = false;
reloadLightsParameters(ll); reloadLightsParameters(ll);
} }
reloadLightsPositions(ll, cam); reloadLightsPositions(cam);
/// selection /// selection
if (edit_mode) { if (edit_mode) {
@@ -233,31 +240,35 @@ void Renderer::renderScene() {
fbo_ds.bindColorTextures(); fbo_ds.bindColorTextures();
fbo_ds.bindDepthTexture(5); fbo_ds.bindDepthTexture(5);
fbo_out.bind(); fbo_out.bind();
if (bindShader(srLightingPass, &prog)) { int ri = 1, wi = 0;
setUniformCamera(prog, cam); typedef QPair<Renderer::ShaderRole, Light::Type> PassPair;
setUniformViewCorners(prog, cam); QVector<PassPair> passes;
for (int i = 0; i < 5; ++i) passes << PassPair(srLightOmniPass, Light::Omni) << PassPair(srLightSpotPass, Light::Cone);
prog->setUniformValue(QString("tex_%1").arg(i).toLatin1().constData(), i); foreach (PassPair pass, passes) {
prog->setUniformValue("tex_d", 5); if (bindShader(pass.first, &prog)) {
prog->setUniformValue("lights_count", ll.size()); setUniformCamera(prog, cam);
glClearFramebuffer(view->backColor(), false); setUniformViewCorners(prog, cam);
renderQuad(prog, quad, cam); for (int i = 0; i < 5; ++i)
/*QVector<float> _fb = fbo_out.grabF(0); prog->setUniformValue(QString("tex_%1").arg(i).toLatin1().constData(), i);
if (!_fb.isEmpty()) { prog->setUniformValue("tex_d", 5);
double sum = 0.; prog->setUniformValue("lights_start", lights_start[pass.second]);
foreach (float f, _fb) sum += f; prog->setUniformValue("lights_count", ll[pass.second].size());
sum /= _fb.size(); prog->setUniformValue("tex_sum", 7);
qDebug() << "sum =" << sum; fbo_out.setWriteBuffer(wi);
}*/ fbo_out.bindColorTexture(ri, 7);
glClearFramebuffer(Qt::black, false);
renderQuad(prog, quad, cam);
piSwap(ri, wi);
}
} }
fbo_out.release(); fbo_out.release();
/// apply hovers and selection frame /// apply hovers and selection frame
if (edit_mode) { if (edit_mode) {
rend_selection.drawSelection(fbo_out); rend_selection.drawSelection(fbo_out, ri);
rend_service.renderService(); rend_service.renderService();
} else { } else {
fbo_out.blit(0, 0, 0, fbo_out.rect(), QRect(QPoint(), view->size())); fbo_out.blit(ri, 0, 0, fbo_out.rect(), QRect(QPoint(), view->size()));
} }
} }

4
qglengine/renderer.h
View File

@@ -52,7 +52,8 @@ class Renderer: public RendererBase {
// Deferred shading // Deferred shading
srGeometryPass, srGeometryPass,
srLightingPass, srLightOmniPass,
srLightSpotPass,
srFinalPass, srFinalPass,
}; };
enum DeferredBufferRole { enum DeferredBufferRole {
@@ -95,6 +96,7 @@ private:
QOpenGLShaderProgram * shader_shadow, * shader_ssr, * shader_ssr_blur, * shader_ssr_merge; QOpenGLShaderProgram * shader_shadow, * shader_ssr, * shader_ssr_blur, * shader_ssr_merge;
QOpenGLShaderProgram * shader_ssao_blur, * shader_ssao_merge, * shader_dof;*/ QOpenGLShaderProgram * shader_ssao_blur, * shader_ssao_merge, * shader_dof;*/
QMap<ShaderRole, QString> shader_files; QMap<ShaderRole, QString> shader_files;
QMap<ShaderRole, QStringList> shader_defines;
QMap<ShaderRole, QOpenGLShaderProgram*> shaders; QMap<ShaderRole, QOpenGLShaderProgram*> shaders;
RendererMaterial rend_mat; RendererMaterial rend_mat;

36
qglengine/renderer_base.cpp
View File

@@ -123,6 +123,21 @@ void RendererBase::setUniformViewCorners(QOpenGLShaderProgram * prog, Camera * c
} }
void RendererBase::fillSelectionsBuffer(QVector<uchar> & buffer, const QList<ObjectBase *> & ol) {
buffer.resize(ol.size());
for (int i = 0; i < ol.size(); ++i) {
buffer[i] = (ol[i]->isSelected(true) ? 1 : 0);
}
}
void RendererBase::fillSelectionsBuffer(QVector<uchar> & buffer, bool yes, int size) {
buffer.resize(size);
for (int i = 0; i < size; ++i)
buffer[i] = (yes ? 1 : 0);
}
void RendererBase::reloadMaterials(Scene & scene) { void RendererBase::reloadMaterials(Scene & scene) {
//qDebug() << "reloadMaterias"; //qDebug() << "reloadMaterias";
QList<Map*> maps[2]; QList<Map*> maps[2];
@@ -199,12 +214,21 @@ void RendererBase::reloadMaterials(Scene & scene) {
} }
void RendererBase::reloadLightsParameters(const QList<Light*> & lights) { void RendererBase::reloadLightsParameters(const QMap<int, QList<Light*>> & lights) {
cur_lights_params_.resize(qMin(lights.size(), max_lights)); lights_start.clear();
lights_start[Light::Omni] = 0;
QMapIterator<int, QList<Light*>> it(lights);
current_lights.clear();
while (it.hasNext()) {
it.next();
lights_start[it.key()] = current_lights.size();
current_lights.append(it.value());
}
cur_lights_params_.resize(qMin(current_lights.size(), max_lights));
//qDebug() << "reloadLightsParameters" << cur_lights_params_.size(); //qDebug() << "reloadLightsParameters" << cur_lights_params_.size();
for (int i = 0; i < cur_lights_params_.size(); ++i) { for (int i = 0; i < cur_lights_params_.size(); ++i) {
QGLLightParameter & so(cur_lights_params_[i]); QGLLightParameter & so(cur_lights_params_[i]);
Light * l = lights[i]; Light * l = current_lights[i];
double ang_start = l->angle_start / 2.f, ang_end = l->angle_end / 2.f; double ang_start = l->angle_start / 2.f, ang_end = l->angle_end / 2.f;
if (l->light_type == Light::Omni) if (l->light_type == Light::Omni)
ang_start = ang_end = 180.; ang_start = ang_end = 180.;
@@ -227,12 +251,12 @@ void RendererBase::reloadLightsParameters(const QList<Light*> & lights) {
} }
void RendererBase::reloadLightsPositions(const QList<Light *> & lights, Camera * cam) { void RendererBase::reloadLightsPositions(Camera * cam) {
cur_lights_pos_.resize(qMin(lights.size(), max_lights)); cur_lights_pos_.resize(qMin(current_lights.size(), max_lights));
QMatrix4x4 mat = cam->viewMatrix() * cam->offsetMatrix(); QMatrix4x4 mat = cam->viewMatrix() * cam->offsetMatrix();
for (int i = 0; i < cur_lights_pos_.size(); ++i) { for (int i = 0; i < cur_lights_pos_.size(); ++i) {
QGLLightPosition & so(cur_lights_pos_[i]); QGLLightPosition & so(cur_lights_pos_[i]);
Light * l = lights[i]; Light * l = current_lights[i];
QMatrix4x4 m = mat * l->worldTransform(); QMatrix4x4 m = mat * l->worldTransform();
QVector4D pos(0, 0, 0, 1.), dir(l->direction, 1);//, dir0(light->dir0), dir1(light->dir1); QVector4D pos(0, 0, 0, 1.), dir(l->direction, 1);//, dir0(light->dir0), dir1(light->dir1);
pos = m * pos; pos = m * pos;

8
qglengine/renderer_base.h
View File

@@ -36,9 +36,11 @@ protected:
void setUniformMaps (QOpenGLShaderProgram * prog); void setUniformMaps (QOpenGLShaderProgram * prog);
void setUniformCamera (QOpenGLShaderProgram * prog, Camera * cam, bool matrices = true, QSize viewport = QSize()); void setUniformCamera (QOpenGLShaderProgram * prog, Camera * cam, bool matrices = true, QSize viewport = QSize());
void setUniformViewCorners(QOpenGLShaderProgram * prog, Camera * cam, QSize viewport = QSize()); void setUniformViewCorners(QOpenGLShaderProgram * prog, Camera * cam, QSize viewport = QSize());
void fillSelectionsBuffer(QVector<uchar> & buffer, const QList<ObjectBase *> & ol);
void fillSelectionsBuffer(QVector<uchar> & buffer, bool yes, int size);
void reloadMaterials(Scene & scene); void reloadMaterials(Scene & scene);
void reloadLightsParameters(const QList<Light*> & lights); void reloadLightsParameters(const QMap<int, QList<Light*>> & lights);
void reloadLightsPositions (const QList<Light*> & lights, Camera * cam); void reloadLightsPositions (Camera * cam);
void markReloadTextures(); void markReloadTextures();
void setMapsSize(QSize sz); void setMapsSize(QSize sz);
void initQuad(Mesh * mesh, QMatrix4x4 mat = QMatrix4x4()); void initQuad(Mesh * mesh, QMatrix4x4 mat = QMatrix4x4());
@@ -55,6 +57,8 @@ protected:
Texture2DArray textures_empty, textures_maps; Texture2DArray textures_empty, textures_maps;
QSize maps_size; QSize maps_size;
uint maps_hash; uint maps_hash;
QMap<int, int> lights_start;
QList<Light*> current_lights;
}; };

9
qglengine/renderer_material.cpp
View File

@@ -81,17 +81,18 @@ void RendererMaterial::renderMaterial(Material * m) {
fbo_mat_thumb.bindColorTextures(); fbo_mat_thumb.bindColorTextures();
fbo_mat_thumb.bindDepthTexture(5); fbo_mat_thumb.bindDepthTexture(5);
fbo_mat_thumb.setWriteBuffer(5); fbo_mat_thumb.setWriteBuffer(5);
if (r->bindShader(Renderer::srLightingPass, &prog)) { if (r->bindShader(Renderer::srLightOmniPass, &prog)) {
r->setUniformCamera(prog, mat_camera, true, fbo_mat_thumb.size()); r->setUniformCamera(prog, mat_camera, true, fbo_mat_thumb.size());
r->setUniformViewCorners(prog, mat_camera, fbo_mat_thumb.size()); r->setUniformViewCorners(prog, mat_camera, fbo_mat_thumb.size());
for (int i = 0; i < 5; ++i) for (int i = 0; i < 5; ++i)
prog->setUniformValue(QString("tex_%1").arg(i).toLatin1().constData(), i); prog->setUniformValue(QString("tex_%1").arg(i).toLatin1().constData(), i);
prog->setUniformValue("tex_d", 5); prog->setUniformValue("tex_d", 5);
prog->setUniformValue("lights_start", 0);
prog->setUniformValue("lights_count", 1); prog->setUniformValue("lights_count", 1);
QList<Light*> mat_l; QMap<int, QList<Light*>> mat_l;
mat_l << mat_light; mat_l[Light::Omni] << mat_light;
r->reloadLightsParameters(mat_l); r->reloadLightsParameters(mat_l);
r->reloadLightsPositions(mat_l, mat_camera); r->reloadLightsPositions(mat_camera);
glClearFramebuffer(r->view->backColor(), false); glClearFramebuffer(r->view->backColor(), false);
r->renderQuad(prog, r->quad, mat_camera); r->renderQuad(prog, r->quad, mat_camera);
r->view->scene()->setLightsChanged(); r->view->scene()->setLightsChanged();

34
qglengine/renderer_selection.cpp
View File

@@ -62,29 +62,18 @@ void RendererSelection::generateObjectsID(Scene & scene) {
o->id_ = id; o->id_ = id;
} }
} }
foreach (ObjectBase * o, scene.lights_used) { QMapIterator<int, QList<Light*>> lit(scene.lights_used);
uint id = qHash(o); while (lit.hasNext()) {
ids[id] = o; lit.next();
o->id_ = id; foreach (ObjectBase * o, lit.value()) {
uint id = qHash(o);
ids[id] = o;
o->id_ = id;
}
} }
} }
void RendererSelection::fillSelectionsBuffer(const QList<ObjectBase *> & ol) {
cur_selections_.resize(ol.size());
for (int i = 0; i < ol.size(); ++i) {
cur_selections_[i] = (ol[i]->isSelected(true) ? 1 : 0);
}
}
void RendererSelection::fillSelectionsBuffer(bool yes, int size) {
cur_selections_.resize(size);
for (int i = 0; i < size; ++i)
cur_selections_[i] = (yes ? 1 : 0);
}
void RendererSelection::renderSelection(Scene & scene) { void RendererSelection::renderSelection(Scene & scene) {
QOpenGLShaderProgram * prog = 0; QOpenGLShaderProgram * prog = 0;
QGLView * view = r->view; QGLView * view = r->view;
@@ -120,12 +109,7 @@ void RendererSelection::renderSelection(Scene & scene) {
view->glClear(GL_DEPTH_BUFFER_BIT); view->glClear(GL_DEPTH_BUFFER_BIT);
RendererService & rs(r->rend_service); RendererService & rs(r->rend_service);
rs.fillOmniObjects(); rs.drawLights();
rs.omni_mesh->loadObjects(view, rs.cur_objects);
fillSelectionsBuffer(light2objectList(scene.lights_used));
rs.omni_mesh->loadSelections(view, cur_selections_);
rs.omni_mesh->draw(view, rs.cur_objects.size());
rs.drawCurrentHandleObjects(); rs.drawCurrentHandleObjects();
//mouse_rect = fbo_selection.rect(); //mouse_rect = fbo_selection.rect();

4
qglengine/renderer_selection.h
View File

@@ -27,6 +27,7 @@ class RendererSelection {
friend class QGLView; friend class QGLView;
friend class MouseController; friend class MouseController;
friend class Renderer; friend class Renderer;
friend class RendererService;
public: public:
RendererSelection(Renderer * r_); RendererSelection(Renderer * r_);
@@ -44,12 +45,9 @@ protected:
}; };
void generateObjectsID(Scene & scene); void generateObjectsID(Scene & scene);
void fillSelectionsBuffer(const QList<ObjectBase *> & ol);
void fillSelectionsBuffer(bool yes, int size);
void renderSelection(Scene & scene); void renderSelection(Scene & scene);
void renderSelectionFrame(); void renderSelectionFrame();
void drawSelection(Framebuffer & fbo_out, int index_out = 0); void drawSelection(Framebuffer & fbo_out, int index_out = 0);
QList<ObjectBase*> light2objectList(const QList<Light*> & v) {QList<ObjectBase*> ret; foreach (Light*i, v) ret << (ObjectBase*)i; return ret;}
private: private:
Renderer * r; Renderer * r;

24
qglengine/renderer_service.cpp
View File

@@ -60,6 +60,15 @@ RendererService::RendererService(Renderer * r_): r(r_) {
omni_mesh_f = Primitive::ellipsoidFrame(2, 1); omni_mesh_f = Primitive::ellipsoidFrame(2, 1);
omni_mesh ->scalePoints(1.5); omni_mesh ->scalePoints(1.5);
omni_mesh_f->scalePoints(1.5); omni_mesh_f->scalePoints(1.5);
cone_mesh = Primitive::cone(8, 1., 1., 1.);
cone_mesh_f = Primitive::coneFrame(8, 1., 1., 1.);
QMatrix4x4 mat;
mat.rotate(90, 0,1,0);
mat.translate(0,0,2);
mat.rotate(180, 1,0,0);
cone_mesh ->transformPoints(mat);
cone_mesh_f->transformPoints(mat);
box_mesh ->scalePoints(1.3); box_mesh ->scalePoints(1.3);
omni_mesh ->scalePoints(1.3); omni_mesh ->scalePoints(1.3);
@@ -98,6 +107,8 @@ RendererService::~RendererService() {
delete box_mesh_f; delete box_mesh_f;
delete omni_mesh; delete omni_mesh;
delete omni_mesh_f; delete omni_mesh_f;
delete cone_mesh;
delete cone_mesh_f;
delete axis_camera; delete axis_camera;
delete axis_mesh; delete axis_mesh;
delete handle_move_mesh; delete handle_move_mesh;
@@ -143,7 +154,7 @@ void RendererService::fillXYZObjects() {
void RendererService::fillOmniObjects() { void RendererService::fillOmniObjects() {
QList<Light*> ll = r->view->scene()->lights_used; QList<Light*> ll = r->view->scene()->lights_used.value(Light::Omni);
Object o; Object o;
cur_objects.clear(); cur_objects.clear();
foreach (Light * l, ll) { foreach (Light * l, ll) {
@@ -247,6 +258,15 @@ void RendererService::drawCurrentHandleObjects() {
} }
void RendererService::drawLights() {
fillOmniObjects();
omni_mesh->loadObjects(r->view, cur_objects);
r->fillSelectionsBuffer(r->rend_selection.cur_selections_, light2objectList(r->view->scene_->lights_used.value(Light::Omni)));
omni_mesh->loadSelections(r->view, r->rend_selection.cur_selections_);
omni_mesh->draw(r->view, cur_objects.size());
}
void RendererService::setObjectsColor(QVector<Object> & ol, QColor col) { void RendererService::setObjectsColor(QVector<Object> & ol, QColor col) {
QVector4D cv = QColor2QVector(col); QVector4D cv = QColor2QVector(col);
for (int i = 0; i < ol.size(); ++i) for (int i = 0; i < ol.size(); ++i)
@@ -279,7 +299,7 @@ void RendererService::renderService() {
setObjectsColor(cur_objects, Qt::black); setObjectsColor(cur_objects, Qt::black);
prog->setUniformValue("line_width", 1.f); prog->setUniformValue("line_width", 1.f);
prog->setUniformValue("z_offset", -1.E-3f); prog->setUniformValue("z_offset", -1.E-2f);
omni_mesh_f->loadObjects(f, cur_objects); omni_mesh_f->loadObjects(f, cur_objects);
omni_mesh_f->draw(f, cur_objects.size()); omni_mesh_f->draw(f, cur_objects.size());

3
qglengine/renderer_service.h
View File

@@ -71,6 +71,7 @@ public:
void fillHandleObjects(QVector3D center, HandleMesh ids[], const QVector<QMatrix4x4> & mats, const QVector<QVector4D> & colors, QMatrix4x4 add_mat, int count = 3); void fillHandleObjects(QVector3D center, HandleMesh ids[], const QVector<QMatrix4x4> & mats, const QVector<QVector4D> & colors, QMatrix4x4 add_mat, int count = 3);
bool calculateCenter(); bool calculateCenter();
void drawCurrentHandleObjects(); void drawCurrentHandleObjects();
void drawLights();
void setObjectsColor(QVector<QGLEngineShaders::Object> & ol, QColor col); void setObjectsColor(QVector<QGLEngineShaders::Object> & ol, QColor col);
void renderService(); void renderService();
void setCurrentAction(HandleAction ha) {current_action = ha;} void setCurrentAction(HandleAction ha) {current_action = ha;}
@@ -81,7 +82,7 @@ private:
Mesh * axis_mesh, * handle_move_mesh, * handle_rotate_mesh, * handle_scale_mesh; Mesh * axis_mesh, * handle_move_mesh, * handle_rotate_mesh, * handle_scale_mesh;
Mesh * handle_ms_2_mesh, * handle_scale_3_mesh; Mesh * handle_ms_2_mesh, * handle_scale_3_mesh;
Mesh * box_mesh_f, * omni_mesh_f, * box_mesh, * omni_mesh; Mesh * box_mesh_f, * omni_mesh_f, * cone_mesh_f, * box_mesh, * omni_mesh, * cone_mesh;
QMatrix4x4 v_mat, axis_mat; QMatrix4x4 v_mat, axis_mat;
QVector3D selection_center; QVector3D selection_center;
QVector<QMatrix4x4> mat_xyz, mat_ms2; QVector<QMatrix4x4> mat_xyz, mat_ms2;

95
qglengine/shaders/ds_light.glsl
View File

@@ -17,8 +17,8 @@ in vec3 view_dir;
uniform vec2 dt; uniform vec2 dt;
uniform float z_near; uniform float z_near;
uniform sampler2D tex_0, tex_1, tex_2, tex_3, tex_4; uniform sampler2D tex_0, tex_1, tex_2, tex_3, tex_4;
uniform sampler2D tex_d; uniform sampler2D tex_d, tex_sum;
uniform int lights_count; uniform int lights_start, lights_count;
const vec3 luma = vec3(0.299, 0.587, 0.114); const vec3 luma = vec3(0.299, 0.587, 0.114);
const float _pe = 2.4e-7; const float _pe = 2.4e-7;
@@ -36,45 +36,45 @@ void calcLight(in int index, in vec3 n, in vec3 v) {
halfV = normalize(ldir + v); halfV = normalize(ldir + v);
NdotL = max(dot(n, ldir), 1E-6); NdotL = max(dot(n, ldir), 1E-6);
NdotH = max(dot(n, halfV), 1E-6); NdotH = max(dot(n, halfV), 1E-6);
spot = step(1.01E-6, NdotL) * qgl_light_parameter[index].intensity; spot = step(1.001E-6, NdotL) * qgl_light_parameter[index].intensity;
/*if (qgl_Light[index].endAngle <= 90.) { #ifdef SPOT
float scos = max(dot(-ldir, qgl_Light[index].direction.xyz), 0.); float scos = max(dot(-ldir, qgl_light_position[index].direction.xyz), 0.);
spot *= scos * step(qgl_Light[index].endAngleCos, scos); spot *= scos * step(qgl_light_parameter[index].endAngleCos, scos);
spot *= smoothstep(qgl_Light[index].endAngleCos, qgl_Light[index].startAngleCos, scos); spot *= smoothstep(qgl_light_parameter[index].endAngleCos, qgl_light_parameter[index].startAngleCos, scos);
//lwdir = mat3(mat_viewi) * qgl_Light[index].direction.xyz; /*//lwdir = mat3(mat_viewi) * qgl_Light[index].direction.xyz;
//bn = normalize(cross(lwdir, vec3(1, 0, 0))); //bn = normalize(cross(lwdir, vec3(1, 0, 0)));
//bn2 = normalize(cross(lwdir, bn)); //bn2 = normalize(cross(lwdir, bn));
float ds = ldist/200.;//max(abs(sdist) / 5000, 0.02); float ds = ldist/200.;//max(abs(sdist) / 5000, 0.02);
//spot *= clamp(1. - sdist, 0, 1); //spot *= clamp(1. - sdist, 0, 1);
vds = ds * bn.xyz; vds = ds * bn.xyz;
vds2 = ds * bn2.xyz; vds2 = ds * bn2.xyz;
float shadow = getShadow(index, pos.xyz, vec3(0)) * 3.; float shadow = getShadow(index, pos.xyz, vec3(0)) * 3.;
shadow += getShadow(index, pos.xyz, vds ) * 2.; shadow += getShadow(index, pos.xyz, vds ) * 2.;
shadow += getShadow(index, pos.xyz, - vds ) * 2.; shadow += getShadow(index, pos.xyz, - vds ) * 2.;
shadow += getShadow(index, pos.xyz, - vds2 ) * 2.; shadow += getShadow(index, pos.xyz, - vds2 ) * 2.;
shadow += getShadow(index, pos.xyz, + vds2 ) * 2.; shadow += getShadow(index, pos.xyz, + vds2 ) * 2.;
//shadow += getShadow(index, pos.xyz, vds - vds2 ) * 1.5; //shadow += getShadow(index, pos.xyz, vds - vds2 ) * 1.5;
//shadow += getShadow(index, pos.xyz, vds + vds2 ) * 1.5; //shadow += getShadow(index, pos.xyz, vds + vds2 ) * 1.5;
//shadow += getShadow(index, pos.xyz, - vds - vds2 ) * 1.5; //shadow += getShadow(index, pos.xyz, - vds - vds2 ) * 1.5;
//shadow += getShadow(index, pos.xyz, - vds + vds2 ) * 1.5; //shadow += getShadow(index, pos.xyz, - vds + vds2 ) * 1.5;
//shadow += getShadow(index, pos.xyz, vds + vds ); //shadow += getShadow(index, pos.xyz, vds + vds );
//shadow += getShadow(index, pos.xyz, - vds - vds ); //shadow += getShadow(index, pos.xyz, - vds - vds );
//shadow += getShadow(index, pos.xyz, - vds2 - vds2); //shadow += getShadow(index, pos.xyz, - vds2 - vds2);
//shadow += getShadow(index, pos.xyz, + vds2 + vds2); //shadow += getShadow(index, pos.xyz, + vds2 + vds2);
//shadow += getShadow(index, pos.xyz, vds + vds - vds2 ); //shadow += getShadow(index, pos.xyz, vds + vds - vds2 );
//shadow += getShadow(index, pos.xyz, - vds - vds - vds2 ); //shadow += getShadow(index, pos.xyz, - vds - vds - vds2 );
//shadow += getShadow(index, pos.xyz, vds + vds + vds2 ); //shadow += getShadow(index, pos.xyz, vds + vds + vds2 );
//shadow += getShadow(index, pos.xyz, - vds - vds + vds2 ); //shadow += getShadow(index, pos.xyz, - vds - vds + vds2 );
//shadow += getShadow(index, pos.xyz, vds - vds2 - vds2); //shadow += getShadow(index, pos.xyz, vds - vds2 - vds2);
//shadow += getShadow(index, pos.xyz, vds + vds2 + vds2); //shadow += getShadow(index, pos.xyz, vds + vds2 + vds2);
//shadow += getShadow(index, pos.xyz, - vds - vds2 - vds2); //shadow += getShadow(index, pos.xyz, - vds - vds2 - vds2);
//shadow += getShadow(index, pos.xyz, - vds + vds2 + vds2); //shadow += getShadow(index, pos.xyz, - vds + vds2 + vds2);
//shadow += shadow += getShadow(index, pos.xyz, vds+vds2)*10; //shadow += shadow += getShadow(index, pos.xyz, vds+vds2)*10;
spot *= mix(1., shadow / 11., shadow_on); spot *= mix(1., shadow / 11., shadow_on);*/
}*/ #endif
//spot /= (qgl_Light[index].constantAttenuation + ldist * (qgl_Light[index].linearAttenuation + ldist * qgl_Light[index].quadraticAttenuation)); spot /= (qgl_light_parameter[index].constantAttenuation +
//li += spot * gl_LightSource[index].diffuse.rgb * light_diffuse(0, ldir, n); ldist * (qgl_light_parameter[index].linearAttenuation +
//si += spot * qgl_Light[index].color.rgb * shm_diff * light_specular(0, ldir, n, halfV, v, sh_pow); ldist * qgl_light_parameter[index].quadraticAttenuation));
float NdotLs = NdotL*NdotL; float NdotLs = NdotL*NdotL;
float NdotHs = NdotH*NdotH; float NdotHs = NdotH*NdotH;
@@ -106,7 +106,6 @@ void main(void) {
pos.w = 1; pos.w = 1;
pos.xyz = view_dir * z; pos.xyz = view_dir * z;
//pos.z = -pos.z;
vec3 v = normalize(-pos.xyz); vec3 v = normalize(-pos.xyz);
//vec2 sp = gl_FragCoord.xy * dt * 2 - vec2(1, 1); //vec2 sp = gl_FragCoord.xy * dt * 2 - vec2(1, 1);
@@ -127,14 +126,14 @@ void main(void) {
li = vec3(0.);//qgl_AmbientLight.color.rgb * qgl_AmbientLight.intensity; li = vec3(0.);//qgl_AmbientLight.color.rgb * qgl_AmbientLight.intensity;
si = vec3(0.); si = vec3(0.);
for (int i = 0; i < lights_count; ++i) for (int i = 0; i < lights_count; ++i)
calcLight(i, normal, v); calcLight(lights_start + i, normal, v);
// calcLight(0, n, v, v2);
//calcLight(0, normal, v);
qgl_FragColor.rgb = max(vec3(0), li * diffuse + si * specular + emission); vec4 result = vec4(max(vec3(0), li * diffuse + si * specular + emission), 1);
#ifndef FIRST_PASS
result += texelFetch(tex_sum, tc, 0);
#endif
qgl_FragColor = result;
//qgl_FragColor.rgb = vec3(1); //qgl_FragColor.rgb = vec3(1);
qgl_FragColor.a = 1;
//qgl_FragData[4] = vec4(speed.xy, bn.yz); //qgl_FragData[4] = vec4(speed.xy, bn.yz);