Beispiel #1
0
int loadTexture(const char* buffer, size_t size)
{
    char name[64] = "";
    snprintf(name, 64, "_res%i", _res_loaded++);
    H3DRes res = h3dAddResource(H3DResTypes::Texture, name, 0);
    if(!h3dLoadResource(res, buffer, size))
    {
        dumpMessages();
        throw tgException("unable to load texture resource");
    }

    int handle = TextureManager::addTexture(res);
    dumpMessages();
    return handle;
}
Beispiel #2
0
int loadTexture(const char* filename)
{
    H3DRes res;
    try
    {
        res = _loadResource(H3DResTypes::Texture, filename);
    }
    catch(...)
    {
        dumpMessages();
        throw;
    }
    int handle = TextureManager::addTexture(res);
    dumpMessages();
    return handle;
}
Beispiel #3
0
void setGeo(const char* filename)
{
    H3DRes res;
    try
    {
        res = _loadResource(H3DResTypes::Geometry, filename);
    }
    catch(...)
    {
        dumpMessages();
        throw;
    }
    if(_geometry) h3dUnloadResource(_geometry);
    _geometry = res;

    if(_geometry != 0 && _shader != 0)
        Viewer::newModel(_geometry, _mat_builder->getRes());
    dumpMessages();
}
Beispiel #4
0
void setPipeline(const char* buffer, size_t size)
{
    char name[64] = "";
    snprintf(name, 64, "_res%i", _res_loaded++);
    H3DRes res = h3dAddResource(H3DResTypes::Pipeline, name, 0);
    if(!h3dLoadResource(res, buffer, size))
    {
        dumpMessages();
        throw tgException("unable to load pipeline resource");
    }
    else
    {
        if(_pipeline) h3dUnloadResource(_pipeline);
        _pipeline = res;

        Viewer::newCamera(res);
        dumpMessages();
    }
}
Beispiel #5
0
void setShader(const char* buffer, size_t size)
{
    char name[64] = "";
    snprintf(name, 64, "_res%i", _res_loaded++);
    H3DRes res = h3dAddResource(H3DResTypes::Shader, name, 0);
    if(!h3dLoadResource(res, buffer, size))
    {
        dumpMessages();
        throw tgException("unable to load shader resource");
    }
    else
    {
        if(_shader) h3dUnloadResource(_shader);
        _shader = res;

        _mat_builder->setShader(name);
        _mat_builder->build();
        dumpMessages();
    }
}
Beispiel #6
0
void setGeo(const char* buffer, size_t size)
{
    char name[64] = "";
    snprintf(name, 64, "_res%i", _res_loaded++);
    H3DRes res = h3dAddResource(H3DResTypes::Geometry, name, 0);
    if(!h3dLoadResource(res, buffer, size))
    {
        dumpMessages();
        throw tgException("unable to load shader resource");
    }
    else
    {
        if(_geometry) h3dUnloadResource(_geometry);
        _geometry = res;

        if(_geometry != 0 && _shader != 0)
            Viewer::newModel(_geometry, _mat_builder->getRes());
        dumpMessages();
    }
}
Beispiel #7
0
void setPipeline(const char* filename)
{
    char buffer[64] = "";
    snprintf(buffer, 64, "_res%i", _res_loaded++);
    H3DRes res = h3dAddResource(H3DResTypes::Pipeline, buffer, 0);
    try
    {
        _loadXmlResource(res, filename);
    }
    catch(...)
    {
        dumpMessages();
        throw;
    }
    if(_pipeline) h3dUnloadResource(_pipeline);
    _pipeline = res;

    Viewer::newCamera(res);
    dumpMessages();
}
Beispiel #8
0
void setShader(const char* filename)
{
    H3DRes res;
    char res_name[64];
    snprintf(res_name, 64, "_res%i", _res_loaded++);
    try
    {
        res = _loadResource(res_name, H3DResTypes::Shader, filename);
    }
    catch(...)
    {
        dumpMessages();
        throw;
    }
    if(_shader) h3dUnloadResource(_shader);
    _shader = res;

    _mat_builder->setShader(res_name);
    _mat_builder->build();
    dumpMessages();
}
Beispiel #9
0
void unbindSampler(const char* sampler_name)
{
    const char* res_name = _mat_builder->getSamplerRes(sampler_name);
    _mat_builder->removeSampler(sampler_name);
    _mat_builder->build();
    if(res_name != nullptr)
    {
        H3DRes res = h3dFindResource(H3DResTypes::Texture, res_name);
        if(res != 0)
        {
            TextureManager::removeResource(res);
            if(h3dIsResLoaded(res))
                h3dUnloadResource(res);
            h3dRemoveResource(res);
        }
    }
    dumpMessages();
}
Beispiel #10
0
void bindSampler(int tex, const char* sampler_name)
{
    const char* res_name = _mat_builder->getSamplerRes(sampler_name);
    if(res_name != nullptr)
    {
        H3DRes res = h3dFindResource(H3DResTypes::Texture, res_name);
        if(res != 0)
        {
            TextureManager::removeResource(res);
            if(h3dIsResLoaded(res))
                h3dUnloadResource(res);
            h3dRemoveResource(res);
        }
    }
    H3DRes res = TextureManager::getTexRes(tex);
    res_name = h3dGetResName(res);
    _mat_builder->setSampler(sampler_name, res_name);
    _mat_builder->build();
    dumpMessages();
}
Beispiel #11
0
int main( int argc, char **argv )
{
    app = argv[0];
    QApplication qapp( argc, argv, FALSE );

    QStringList configs;
    QString prefix;
    bool buildIde = TRUE;
    for ( int i = 1; i < qapp.argc(); i++ ) {
        QString arg = qapp.argv()[i];
        if ( arg.startsWith( "--" ) )
            arg = arg.mid( 1 );
        if ( arg == "-help"  ) {
            ; // handled by the configure script
        } else if ( arg == "-thread" ) {
            configs << "thread";
        } else if ( arg == "-prefix" ) {
            if ( i + 1 < qapp.argc() ) {
                prefix = qapp.argv()[++i];
            } else {
                qWarning( "-prefix option requires path argument" );
                exit( 2 );
            }
        } else if ( arg == "-no-ide" ) {
            buildIde = FALSE;
            configs << "noide";
        } else {
            qWarning( "Unknown option: %s", qapp.argv()[i] );
            exit( 1 );
        }
    }

    // these are here in case .qmake.cache is missing
#if defined(QT_MODULE_XML)
    configs.append( "xml" );
#endif
#if defined(QT_MODULE_TABLE)
    configs.append( "table" );
#endif
#if defined(QT_MODULE_SQL)
    configs.append( "sql" );
#endif
#if defined(QT_MODULE_NETWORK)
    configs.append( "network" );
#endif

    qtDir = new QString( getenv( "QTDIR" ) );
    if ( qtDir->isEmpty() ) {
        qWarning( "%s: QTDIR not set", app );
        dumpMessages();
        return 1;
    }
    *qtDir += "/";

    if ( !checkLicense() ) {
        dumpMessages();
        return 1;
    }

    if( !writeQSConfig( buildIde ) ) {
        dumpMessages();
        return 1;
    }

    if ( !prefix )
        copyQSAHeaders();

    //installDocs();

    runQMake( configs, prefix );

    int retVal = processes > 0 ? qapp.exec() : 0;
    if( retVal || errors ) {
        message( "\nThere were errors during configure!" );
    } else if( warnings ) {
        message( "\nThere were errors during configure, but these"
                 "\ndo not appear to be fatal, so you should still be"
                 "\nable to build QSA."
                 "\nRun your make tool to build QSA." );
    } else {
        message( "\n"
                 "Configuration completed successfully\n"
                 "Run your make tool to build QSA" );
    }

    dumpMessages();
    return retVal || errors;
}
Beispiel #12
0
void replaceSamplerRes(const char* old_name, const char* new_name)
{
    _mat_builder->replaceSamplerRes(old_name, new_name);
    _mat_builder->build();
    dumpMessages();
}
Beispiel #13
0
void disableShaderFlag(int flag)
{
    _mat_builder->unsetShaderFlag(flag);
    _mat_builder->build();
    dumpMessages();
}
Beispiel #14
0
void removeUniform(const char* name)
{
    _mat_builder->removeUniform(name);
    _mat_builder->build();
    dumpMessages();
}
Beispiel #15
0
void setUniform(const char* name, float a, float b, float c, float d)
{
    _mat_builder->setUniform(name, a, b, c, d);
    _mat_builder->build();
    dumpMessages();
}
Beispiel #16
0
void setGeo(
    std::vector<float> verts,
    std::vector<float> normals,
    std::vector<float> tangents,
    std::vector<float> binormals,
    std::vector<float> texcoords1,
    std::vector<float> texcoords2,
    std::vector<unsigned> indices,
    bool get_tanspace)
{
    if(indices.size() <= 0)
        throw tgException("no triangle indices supplied");
    else if(indices.size() % 3 != 0)
        throw tgException("triangle indices must come in packs of three");

    unsigned num_verts = verts.size();
    if(num_verts <= 0)
        throw tgException("no vertices supplied");
    else if(num_verts % 3 != 0)
        throw tgException("vertices must have three components each");
    num_verts /= 3;

    std::unique_ptr<int16_t[]> norms, tangs, binorms;
    float *tex1, *tex2;

    if(normals.empty())
    {
        norms = nullptr;
        tangs = nullptr;
        binorms = nullptr;
    }
    else if(normals.size() != num_verts * 3)
        throw tgException("number of normals does not match number of vertices");
    else
    {
        norms.reset(new int16_t[num_verts * 3]);
        for(unsigned i = 0; i < num_verts * 3; ++i)
        {
            norms[i] = (int16_t)(normals[i] * std::numeric_limits<int16_t>::max());
        }

        if(tangents.empty())
            tangs = nullptr;
        else if(tangents.size() != num_verts * 3)
            throw tgException("number of tangents does not match number of vertices");
        else
        {
            tangs.reset(new int16_t[num_verts * 3]);
            for(unsigned i = 0; i < num_verts * 3; ++i)
            {
                tangs[i] = (int16_t)(tangents[i] * std::numeric_limits<int16_t>::max());
            }
        }

        if(binormals.empty())
            binorms = nullptr;
        else if(binormals.size() != num_verts * 3)
            throw tgException("number of binormals does not match number of vertices");
        else
        {
            binorms.reset(new int16_t[num_verts * 3]);
            for(unsigned i = 0; i < num_verts * 3; ++i)
            {
                binorms[i] = (int16_t)(binormals[i] * std::numeric_limits<int16_t>::max());
            }
        }

        if((bool)binorms != (bool)tangs && get_tanspace)
        {
            if((bool)tangs)
            {
                binorms.reset(new int16_t[num_verts * 3]);
                for(unsigned i = 0; i < num_verts * 3; i += 3)
                {
                    Eigen::Vector3f norm(normals[i], normals[i + 1], normals[i + 2]);
                    Eigen::Vector3f tang(tangents[i], tangents[i + 1], tangents[i + 2]);
                    Eigen::Vector3f bin = norm.cross(tang);
                    binorms[i] = (int16_t)(bin[0] * std::numeric_limits<int16_t>::max());
                    binorms[i + 1] = (int16_t)(bin[1] * std::numeric_limits<int16_t>::max());
                    binorms[i + 2] = (int16_t)(bin[2] * std::numeric_limits<int16_t>::max());
                }
            }
            else
            {
                tangs.reset(new int16_t[num_verts * 3]);
                for(unsigned i = 0; i < num_verts * 3; i += 3)
                {
                    Eigen::Vector3f norm(normals[i], normals[i + 1], normals[i + 2]);
                    Eigen::Vector3f bin(binormals[i], binormals[i + 1], binormals[i + 2]);
                    Eigen::Vector3f tang = bin.cross(norm);
                    tangs[i] = (int16_t)(tang[0] * std::numeric_limits<int16_t>::max());
                    tangs[i + 1] = (int16_t)(tang[1] * std::numeric_limits<int16_t>::max());
                    tangs[i + 2] = (int16_t)(tang[2] * std::numeric_limits<int16_t>::max());
                }
            }
        }
    }

    if(texcoords1.empty())
        tex1 = nullptr;
    else if(texcoords1.size() != num_verts * 2)
        throw tgException(
            "number if texcoords stream 1 does not match number of vertices");
    else tex1 = texcoords1.data();

    if(texcoords2.empty())
        tex2 = nullptr;
    else if(texcoords2.size() != num_verts * 2)
        throw tgException(
            "number if texcoords stream 2 does not match number of vertices");
    else tex2 = texcoords2.data();

    H3DRes res;
    try
    {
        res = _makeGeometry(num_verts, verts.data(), norms.get(), tangs.get(),
                            binorms.get(), tex1, tex2, indices.size() / 3, indices.data());
    }
    catch(...)
    {
        dumpMessages();
        throw;
    }

    if(_geometry) h3dUnloadResource(_geometry);
    _geometry = res;

    if(_geometry != 0 && _shader != 0)
        Viewer::newModel(_geometry, _mat_builder->getRes());
    dumpMessages();
}