////  Model.cpp//  interface/src/renderer////  Created by Andrzej Kapolka on 10/18/13.//  Copyright 2013 High Fidelity, Inc.////  Distributed under the Apache License, Version 2.0.//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html// #include <gpu/GPUConfig.h> #include <QMetaType>#include <QRunnable>#include <QThreadPool> #include <glm/gtx/transform.hpp>#include <glm/gtx/norm.hpp> #include <CapsuleShape.h>#include <GeometryUtil.h>#include <gpu/Batch.h>#include <gpu/GLBackend.h>#include <PathUtils.h>#include <PerfStat.h>#include "PhysicsEntity.h"#include <ShapeCollider.h>#include <SphereShape.h>#include <ViewFrustum.h> #include "AbstractViewStateInterface.h"#include "AnimationHandle.h"#include "DeferredLightingEffect.h"#include "GlowEffect.h"#include "Model.h" #include "model_vert.h"#include "model_shadow_vert.h"#include "model_normal_map_vert.h"#include "model_lightmap_vert.h"#include "model_lightmap_normal_map_vert.h"#include "skin_model_vert.h"#include "skin_model_shadow_vert.h"#include "skin_model_normal_map_vert.h" #include "model_frag.h"#include "model_shadow_frag.h"#include "model_normal_map_frag.h"#include "model_normal_specular_map_frag.h"#include "model_specular_map_frag.h"#include "model_lightmap_frag.h"#include "model_lightmap_normal_map_frag.h"#include "model_lightmap_normal_specular_map_frag.h"#include "model_lightmap_specular_map_frag.h"#include "model_translucent_frag.h"  #define GLBATCH( call ) batch._##call//#define GLBATCH( call ) call using namespace std; static int modelPointerTypeId = qRegisterMetaType<QPointer<Model> >();static int weakNetworkGeometryPointerTypeId = qRegisterMetaType<QWeakPointer<NetworkGeometry> >();static int vec3VectorTypeId = qRegisterMetaType<QVector<glm::vec3> >();float Model::FAKE_DIMENSION_PLACEHOLDER = -1.0f; Model::Model(QObject* parent) :    QObject(parent),    _scale(1.0f, 1.0f, 1.0f),    _scaleToFit(false),    _scaleToFitDimensions(0.0f),    _scaledToFit(false),    _snapModelToRegistrationPoint(false),    _snappedToRegistrationPoint(false),    _showTrueJointTransforms(true),    _lodDistance(0.0f),    _pupilDilation(0.0f),    _url("http://invalid.com"),    _blendNumber(0),    _appliedBlendNumber(0),    _calculatedMeshBoxesValid(false),    _calculatedMeshTrianglesValid(false),    _meshGroupsKnown(false),    _renderCollisionHull(false) {        // we may have been created in the network thread, but we live in the main thread    if (_viewState) {        moveToThread(_viewState->getMainThread());    }} Model::~Model() {    deleteGeometry();} gpu::ShaderPointer Model::_program;gpu::ShaderPointer Model::_normalMapProgram;gpu::ShaderPointer Model::_specularMapProgram;gpu::ShaderPointer Model::_normalSpecularMapProgram;gpu::ShaderPointer Model::_translucentProgram; gpu::ShaderPointer Model::_lightmapProgram;gpu::ShaderPointer Model::_lightmapNormalMapProgram;gpu::ShaderPointer Model::_lightmapSpecularMapProgram;gpu::ShaderPointer Model::_lightmapNormalSpecularMapProgram; gpu::ShaderPointer Model::_shadowProgram; gpu::ShaderPointer Model::_skinProgram;gpu::ShaderPointer Model::_skinNormalMapProgram;gpu::ShaderPointer Model::_skinSpecularMapProgram;gpu::ShaderPointer Model::_skinNormalSpecularMapProgram;gpu::ShaderPointer Model::_skinTranslucentProgram; gpu::ShaderPointer Model::_skinShadowProgram; Model::Locations Model::_locations;Model::Locations Model::_normalMapLocations;Model::Locations Model::_specularMapLocations;Model::Locations Model::_normalSpecularMapLocations;Model::Locations Model::_translucentLocations;Model::Locations Model::_shadowLocations; Model::Locations Model::_lightmapLocations;Model::Locations Model::_lightmapNormalMapLocations;Model::Locations Model::_lightmapSpecularMapLocations;Model::Locations Model::_lightmapNormalSpecularMapLocations;  Model::SkinLocations Model::_skinLocations;Model::SkinLocations Model::_skinNormalMapLocations;Model::SkinLocations Model::_skinSpecularMapLocations;Model::SkinLocations Model::_skinNormalSpecularMapLocations;Model::SkinLocations Model::_skinTranslucentLocations;Model::SkinLocations Model::_skinShadowLocations; AbstractViewStateInterface* Model::_viewState = NULL; const GLint MATERIAL_GPU_SLOT = 3; void Model::setScale(const glm::vec3& scale) {    setScaleInternal(scale);    // if anyone sets scale manually, then we are no longer scaled to fit    _scaleToFit = false;    _scaledToFit = false;} void Model::setScaleInternal(const glm::vec3& scale) {    float scaleLength = glm::length(_scale);    float relativeDeltaScale = glm::length(_scale - scale) / scaleLength;     const float ONE_PERCENT = 0.01f;    if (relativeDeltaScale > ONE_PERCENT || scaleLength < EPSILON) {        _scale = scale;        initJointTransforms();        if (_shapes.size() > 0) {            clearShapes();            buildShapes();        }    }} void Model::setOffset(const glm::vec3& offset) {     _offset = offset;         // if someone manually sets our offset, then we are no longer snapped to center    _snapModelToRegistrationPoint = false;     _snappedToRegistrationPoint = false; } void Model::initProgram(gpu::ShaderPointer& program, Model::Locations& locations) {    locations.alphaThreshold = program->getUniforms().findLocation("alphaThreshold");    locations.texcoordMatrices = program->getUniforms().findLocation("texcoordMatrices");    locations.emissiveParams = program->getUniforms().findLocation("emissiveParams");    locations.glowIntensity = program->getUniforms().findLocation("glowIntensity");     locations.specularTextureUnit = program->getTextures().findLocation("specularMap");    locations.emissiveTextureUnit = program->getTextures().findLocation("emissiveMap"); #if (GPU_FEATURE_PROFILE == GPU_CORE)    locations.materialBufferUnit = program->getBuffers().findLocation("materialBuffer");#else    locations.materialBufferUnit = program->getUniforms().findLocation("materialBuffer");#endif } void Model::initSkinProgram(gpu::ShaderPointer& program, Model::SkinLocations& locations) {        initProgram(program, locations);     locations.clusterMatrices = program->getUniforms().findLocation("clusterMatrices");     locations.clusterIndices = program->getInputs().findLocation("clusterIndices");;    locations.clusterWeights = program->getInputs().findLocation("clusterWeights");;} QVector<JointState> Model::createJointStates(const FBXGeometry& geometry) {    QVector<JointState> jointStates;    for (int i = 0; i < geometry.joints.size(); ++i) {        const FBXJoint& joint = geometry.joints[i];        // store a pointer to the FBXJoint in the JointState        JointState state;        state.setFBXJoint(&joint);         jointStates.append(state);    }    return jointStates;}; void Model::initJointTransforms() {    // compute model transforms    int numStates = _jointStates.size();    for (int i = 0; i < numStates; ++i) {        JointState& state = _jointStates[i];        const FBXJoint& joint = state.getFBXJoint();        int parentIndex = joint.parentIndex;        if (parentIndex == -1) {            const FBXGeometry& geometry = _geometry->getFBXGeometry();            // NOTE: in practice geometry.offset has a non-unity scale (rather than a translation)            glm::mat4 parentTransform = glm::scale(_scale) * glm::translate(_offset) * geometry.offset;            state.initTransform(parentTransform);        } else {            const JointState& parentState = _jointStates.at(parentIndex);            state.initTransform(parentState.getTransform());        }    }} void Model::init() {    if (_program.isNull()) {        gpu::Shader::BindingSet slotBindings;        slotBindings.insert(gpu::Shader::Binding(std::string("materialBuffer"), MATERIAL_GPU_SLOT));        slotBindings.insert(gpu::Shader::Binding(std::string("diffuseMap"), 0));        slotBindings.insert(gpu::Shader::Binding(std::string("normalMap"), 1));        slotBindings.insert(gpu::Shader::Binding(std::string("specularMap"), 2));        slotBindings.insert(gpu::Shader::Binding(std::string("emissiveMap"), 3));         // Vertex shaders        auto modelVertex = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(model_vert)));        auto modelNormalMapVertex = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(model_normal_map_vert)));        auto modelLightmapVertex = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(model_lightmap_vert)));        auto modelLightmapNormalMapVertex = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(model_lightmap_normal_map_vert)));        auto modelShadowVertex = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(model_shadow_vert)));        auto skinModelVertex = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(skin_model_vert)));        auto skinModelNormalMapVertex = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(skin_model_normal_map_vert)));        auto skinModelShadowVertex = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(skin_model_shadow_vert)));         // Pixel shaders        auto modelPixel = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(model_frag)));        auto modelNormalMapPixel = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(model_normal_map_frag)));        auto modelSpecularMapPixel = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(model_specular_map_frag)));        auto modelNormalSpecularMapPixel = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(model_normal_specular_map_frag)));        auto modelTranslucentPixel = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(model_translucent_frag)));        auto modelShadowPixel = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(model_shadow_frag)));        auto modelLightmapPixel = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(model_lightmap_frag)));        auto modelLightmapNormalMapPixel = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(model_lightmap_normal_map_frag)));        auto modelLightmapSpecularMapPixel = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(model_lightmap_specular_map_frag)));        auto modelLightmapNormalSpecularMapPixel = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(model_lightmap_normal_specular_map_frag)));          bool makeResult = false;         // Programs        _program = gpu::ShaderPointer(gpu::Shader::createProgram(modelVertex, modelPixel));        makeResult = gpu::Shader::makeProgram(*_program, slotBindings);        initProgram(_program, _locations);         _normalMapProgram = gpu::ShaderPointer(gpu::Shader::createProgram(modelNormalMapVertex, modelNormalMapPixel));        makeResult = gpu::Shader::makeProgram(*_normalMapProgram, slotBindings);        initProgram(_normalMapProgram, _normalMapLocations);         _specularMapProgram = gpu::ShaderPointer(gpu::Shader::createProgram(modelVertex, modelSpecularMapPixel));        makeResult = gpu::Shader::makeProgram(*_specularMapProgram, slotBindings);        initProgram(_specularMapProgram, _specularMapLocations);         _normalSpecularMapProgram = gpu::ShaderPointer(gpu::Shader::createProgram(modelNormalMapVertex, modelNormalSpecularMapPixel));        makeResult = gpu::Shader::makeProgram(*_normalSpecularMapProgram, slotBindings);        initProgram(_normalSpecularMapProgram, _normalSpecularMapLocations);         _translucentProgram = gpu::ShaderPointer(gpu::Shader::createProgram(modelVertex, modelTranslucentPixel));        makeResult = gpu::Shader::makeProgram(*_translucentProgram, slotBindings);        initProgram(_translucentProgram, _translucentLocations);                _shadowProgram = gpu::ShaderPointer(gpu::Shader::createProgram(modelShadowVertex, modelShadowPixel));        makeResult = gpu::Shader::makeProgram(*_shadowProgram, slotBindings);        initProgram(_shadowProgram, _shadowLocations);         _lightmapProgram = gpu::ShaderPointer(gpu::Shader::createProgram(modelLightmapVertex, modelLightmapPixel));        makeResult = gpu::Shader::makeProgram(*_lightmapProgram, slotBindings);        initProgram(_lightmapProgram, _lightmapLocations);         _lightmapNormalMapProgram = gpu::ShaderPointer(gpu::Shader::createProgram(modelLightmapNormalMapVertex, modelLightmapNormalMapPixel));        makeResult = gpu::Shader::makeProgram(*_lightmapNormalMapProgram, slotBindings);        initProgram(_lightmapNormalMapProgram, _lightmapNormalMapLocations);         _lightmapSpecularMapProgram = gpu::ShaderPointer(gpu::Shader::createProgram(modelLightmapVertex, modelLightmapSpecularMapPixel));        makeResult = gpu::Shader::makeProgram(*_lightmapSpecularMapProgram, slotBindings);        initProgram(_lightmapSpecularMapProgram, _lightmapSpecularMapLocations);         _lightmapNormalSpecularMapProgram = gpu::ShaderPointer(gpu::Shader::createProgram(modelLightmapNormalMapVertex, modelLightmapNormalSpecularMapPixel));        makeResult = gpu::Shader::makeProgram(*_lightmapNormalSpecularMapProgram, slotBindings);        initProgram(_lightmapNormalSpecularMapProgram, _lightmapNormalSpecularMapLocations);         _skinProgram = gpu::ShaderPointer(gpu::Shader::createProgram(skinModelVertex, modelPixel));        makeResult = gpu::Shader::makeProgram(*_skinProgram, slotBindings);        initSkinProgram(_skinProgram, _skinLocations);         _skinNormalMapProgram = gpu::ShaderPointer(gpu::Shader::createProgram(skinModelNormalMapVertex, modelNormalMapPixel));        makeResult = gpu::Shader::makeProgram(*_skinNormalMapProgram, slotBindings);        initSkinProgram(_skinNormalMapProgram, _skinNormalMapLocations);         _skinSpecularMapProgram = gpu::ShaderPointer(gpu::Shader::createProgram(skinModelVertex, modelSpecularMapPixel));        makeResult = gpu::Shader::makeProgram(*_skinSpecularMapProgram, slotBindings);        initSkinProgram(_skinSpecularMapProgram, _skinSpecularMapLocations);         _skinNormalSpecularMapProgram = gpu::ShaderPointer(gpu::Shader::createProgram(skinModelNormalMapVertex, modelNormalSpecularMapPixel));        makeResult = gpu::Shader::makeProgram(*_skinNormalSpecularMapProgram, slotBindings);        initSkinProgram(_skinNormalSpecularMapProgram, _skinNormalSpecularMapLocations);                _skinShadowProgram = gpu::ShaderPointer(gpu::Shader::createProgram(skinModelShadowVertex, modelShadowPixel));        makeResult = gpu::Shader::makeProgram(*_skinShadowProgram, slotBindings);        initSkinProgram(_skinShadowProgram, _skinShadowLocations);                _skinTranslucentProgram = gpu::ShaderPointer(gpu::Shader::createProgram(skinModelVertex, modelTranslucentPixel));        makeResult = gpu::Shader::makeProgram(*_skinTranslucentProgram, slotBindings);        initSkinProgram(_skinTranslucentProgram, _skinTranslucentLocations);         (void) makeResult; // quiet compiler    }} void Model::reset() {    if (_jointStates.isEmpty()) {        return;    }    foreach (Model* attachment, _attachments) {        attachment->reset();    }    const FBXGeometry& geometry = _geometry->getFBXGeometry();    for (int i = 0; i < _jointStates.size(); i++) {        _jointStates[i].setRotationInConstrainedFrame(geometry.joints.at(i).rotation, 0.0f);    }        _meshGroupsKnown = false;} bool Model::updateGeometry() {    // NOTE: this is a recursive call that walks all attachments, and their attachments    bool needFullUpdate = false;    for (int i = 0; i < _attachments.size(); i++) {        Model* model = _attachments.at(i);        if (model->updateGeometry()) {            needFullUpdate = true;        }    }     bool needToRebuild = false;    if (_nextGeometry) {        _nextGeometry = _nextGeometry->getLODOrFallback(_lodDistance, _nextLODHysteresis);        _nextGeometry->setLoadPriority(this, -_lodDistance);        _nextGeometry->ensureLoading();        if (_nextGeometry->isLoaded()) {            applyNextGeometry();            needToRebuild = true;        }    }    if (!_geometry) {        // geometry is not ready        return false;    }     QSharedPointer<NetworkGeometry> geometry = _geometry->getLODOrFallback(_lodDistance, _lodHysteresis);    if (_geometry != geometry) {        // NOTE: it is theoretically impossible to reach here after passing through the applyNextGeometry() call above.        // Which means we don't need to worry about calling deleteGeometry() below immediately after creating new geometry.         const FBXGeometry& newGeometry = geometry->getFBXGeometry();        QVector<JointState> newJointStates = createJointStates(newGeometry);        if (! _jointStates.isEmpty()) {            // copy the existing joint states            const FBXGeometry& oldGeometry = _geometry->getFBXGeometry();            for (QHash<QString, int>::const_iterator it = oldGeometry.jointIndices.constBegin();                    it != oldGeometry.jointIndices.constEnd(); it++) {                int oldIndex = it.value() - 1;                int newIndex = newGeometry.getJointIndex(it.key());                if (newIndex != -1) {                    newJointStates[newIndex].copyState(_jointStates[oldIndex]);                }            }        }         deleteGeometry();        _dilatedTextures.clear();        _geometry = geometry;        _meshGroupsKnown = false;        setJointStates(newJointStates);        needToRebuild = true;    } else if (_jointStates.isEmpty()) {        const FBXGeometry& fbxGeometry = geometry->getFBXGeometry();        if (fbxGeometry.joints.size() > 0) {            setJointStates(createJointStates(fbxGeometry));            needToRebuild = true;        }    } else if (!geometry->isLoaded()) {        deleteGeometry();        _dilatedTextures.clear();    }    _geometry->setLoadPriority(this, -_lodDistance);    _geometry->ensureLoading();       if (needToRebuild) {        const FBXGeometry& fbxGeometry = geometry->getFBXGeometry();        foreach (const FBXMesh& mesh, fbxGeometry.meshes) {            MeshState state;            state.clusterMatrices.resize(mesh.clusters.size());            _meshStates.append(state);                 gpu::BufferPointer buffer(new gpu::Buffer());            if (!mesh.blendshapes.isEmpty()) {                buffer->resize((mesh.vertices.size() + mesh.normals.size()) * sizeof(glm::vec3));                buffer->setSubData(0, mesh.vertices.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.vertices.constData());                buffer->setSubData(mesh.vertices.size() * sizeof(glm::vec3),                    mesh.normals.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.normals.constData());            }            _blendedVertexBuffers.push_back(buffer);        }        foreach (const FBXAttachment& attachment, fbxGeometry.attachments) {            Model* model = new Model(this);            model->init();            model->setURL(attachment.url);            _attachments.append(model);        }        needFullUpdate = true;    }    return needFullUpdate;} // virtualvoid Model::setJointStates(QVector<JointState> states) {    _jointStates = states;    initJointTransforms();     int numStates = _jointStates.size();    float radius = 0.0f;    for (int i = 0; i < numStates; ++i) {        float distance = glm::length(_jointStates[i].getPosition());        if (distance > radius) {            radius = distance;        }        _jointStates[i].buildConstraint();    }    for (int i = 0; i < _jointStates.size(); i++) {        _jointStates[i].slaveVisibleTransform();    }    _boundingRadius = radius;} bool Model::findRayIntersectionAgainstSubMeshes(const glm::vec3& origin, const glm::vec3& direction, float& distance,                                                     BoxFace& face, QString& extraInfo, bool pickAgainstTriangles) {     bool intersectedSomething = false;     // if we aren't active, we can't ray pick yet...    if (!isActive()) {        return intersectedSomething;    }        // extents is the entity relative, scaled, centered extents of the entity    glm::vec3 position = _translation;    glm::mat4 rotation = glm::mat4_cast(_rotation);    glm::mat4 translation = glm::translate(position);    glm::mat4 modelToWorldMatrix = translation * rotation;    glm::mat4 worldToModelMatrix = glm::inverse(modelToWorldMatrix);     Extents modelExtents = getMeshExtents(); // NOTE: unrotated        glm::vec3 dimensions = modelExtents.maximum - modelExtents.minimum;    glm::vec3 corner = -(dimensions * _registrationPoint); // since we're going to do the ray picking in the model frame of reference    AABox modelFrameBox(corner, dimensions);     glm::vec3 modelFrameOrigin = glm::vec3(worldToModelMatrix * glm::vec4(origin, 1.0f));    glm::vec3 modelFrameDirection = glm::vec3(worldToModelMatrix * glm::vec4(direction, 0.0f));     // we can use the AABox's ray intersection by mapping our origin and direction into the model frame    // and testing intersection there.    if (modelFrameBox.findRayIntersection(modelFrameOrigin, modelFrameDirection, distance, face)) {         float bestDistance = std::numeric_limits<float>::max();         float distanceToSubMesh;        BoxFace subMeshFace;        int subMeshIndex = 0;         const FBXGeometry& geometry = _geometry->getFBXGeometry();         // If we hit the models box, then consider the submeshes...        foreach(const AABox& subMeshBox, _calculatedMeshBoxes) { 

Lines 1–500 of 2696. Load more