void Shader::DrawMesh(Mesh *mesh, glm::mat4 model)
{
// Set model matrix
safe_glUniformMatrix4fv(modelMatrixHandle, glm::value_ptr(model));
safe_glEnableVertexAttribArray(positionHandle);
glBindBuffer(GL_ARRAY_BUFFER, mesh->PositionHandle);
safe_glVertexAttribPointer(positionHandle, 3, GL_FLOAT, GL_FALSE, 0, 0);
safe_glEnableVertexAttribArray(normalHandle);
glBindBuffer(GL_ARRAY_BUFFER, mesh->NormalHandle);
safe_glVertexAttribPointer(normalHandle, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh->IndexHandle);
glUniform3f(lightHandle.Position, light.Position.x, light.Position.y,
light.Position.z);
glUniform3f(lightHandle.Color, light.Color.x, light.Color.y, light.Color.z);
loadMaterial();
glDrawElements(GL_TRIANGLES, mesh->IndexBufferLength, GL_UNSIGNED_SHORT, 0);
safe_glDisableVertexAttribArray(positionHandle);
safe_glDisableVertexAttribArray(normalHandle);
}
scene::scene(string filename){
cout << "Reading scene from " << filename << " ..." << endl;
cout << " " << endl;
char* fname = (char*)filename.c_str();
fp_in.open(fname);
if(fp_in.is_open()){
while(fp_in.good()){
string line;
utilityCore::safeGetline(fp_in,line);
if(!line.empty()){
vector<string> tokens = utilityCore::tokenizeString(line);
if(strcmp(tokens[0].c_str(), "MATERIAL")==0){
loadMaterial(tokens[1]);
cout << " " << endl;
}else if(strcmp(tokens[0].c_str(), "OBJECT")==0){
loadObject(tokens[1]);
cout << " " << endl;
}else if(strcmp(tokens[0].c_str(), "CAMERA")==0){
loadCamera();
cout << " " << endl;
}
}
}
}
}
void WorldData::loadMesh(const char* filename) {
// TODO:> WING_ASSERT buff != 0
Console& con = System::GetRenderer()->getConsole();
//con.log(L"loading mesh: %s", filename);
// prevents attempts to load the same mesh twice
if (mMeshLibrary.contains(filename)) {
//con.log(L">>mesh already loaded, skipped.");
return;
}
int n = mMeshLibrary.size;
Mesh* mesh = &mMeshLibrary.data[n];
char matName[256];
mesh_read(mesh, this, filename, matName);
//con.log(L"n: %d, vert: %p", n, mesh->vertices);
mMeshLibrary.add(filename);
//con.log(L">>loading material: %s", matName);
mesh->materialID = loadMaterial(matName);
//con.log(L">>material loaded, ID: %u", mesh->materialID);
}
void Model::loadEMI(Common::MemoryReadStream &ms) {
char name[64];
int nameLength = ms.readUint32LE();
assert(nameLength < 64);
ms.read(name, nameLength);
// skip over some unkown floats
ms.seek(48, SEEK_CUR);
_numMaterials = ms.readUint32LE();
_materials = new Material*[_numMaterials];
_materialNames = new char[_numMaterials][32];
for (int i = 0; i < _numMaterials; i++) {
nameLength = ms.readUint32LE();
assert(nameLength < 32);
ms.read(_materialNames[i], nameLength);
// I'm not sure what specialty mateials are, but they are handled differently.
if (memcmp(_materialNames[i], "specialty", 9) == 0) {
_materials[i] = 0;
} else {
loadMaterial(i, 0);
}
ms.seek(4, SEEK_CUR);
}
ms.seek(4, SEEK_CUR);
}
void MaterialInfo::on_actNew_triggered()
{
checkSaved(false);
bool needReload = true;
bool ok;
QString result = QInputDialog::getText(NULL, "New Material", "Name:", QLineEdit::Normal, tr(""), &ok);
if (ok && !result.isEmpty() && !result.contains(" "))
{
if (!Magic3D::ResourceManager::getMaterials()->get(result.toStdString()))
{
bool created = false;
Magic3D::ResourceManager::getMaterials()->load(result.toStdString(), created);
mainWindow->updateMaterialsList();
cmbMaterials->clear();
cmbMaterials->addItems(mainWindow->getMaterialList());
cmbMaterials->setCurrentIndex(cmbMaterials->findText(result));
needReload = false;
}
else
{
Utils::message(tr("Invalid Name"), tr("Material named \"") + result + tr("\" already exists!"));
}
}
else if (ok)
{
result.clear();
Utils::message(tr("Invalid Name"), tr("\"") + result + tr("\" is an invalid name!"));
}
if (needReload)
{
loadMaterial();
}
}
void Model::loadBinary(const char *&data, CMap *cmap) {
_numMaterials = READ_LE_UINT32(data + 4);
data += 8;
_materials = new Material*[_numMaterials];
_materialNames = new char[_numMaterials][32];
_materialsShared = new bool[_numMaterials];
for (int i = 0; i < _numMaterials; i++) {
strcpy(_materialNames[i], data);
_materialsShared[i] = false;
_materials[i] = NULL;
loadMaterial(i, cmap);
data += 32;
}
data += 32; // skip name
_numGeosets = READ_LE_UINT32(data + 4);
data += 8;
_geosets = new Geoset[_numGeosets];
for (int i = 0; i < _numGeosets; i++)
_geosets[i].loadBinary(data, _materials);
_numHierNodes = READ_LE_UINT32(data + 4);
data += 8;
_rootHierNode = new ModelNode[_numHierNodes];
for (int i = 0; i < _numHierNodes; i++) {
_rootHierNode[i].loadBinary(data, _rootHierNode, &_geosets[0]);
}
_radius = get_float(data);
_insertOffset = Math::Vector3d::get_vector3d(data + 40);
}
bool MaterialInfo::checkSaved(bool reload)
{
bool result = true;
bool needReload = reload;
if (material && ui->actSave->isEnabled())
{
int ret = Utils::confirmSave("Save Material", tr("The material has been modified."), tr("Do you want to save your changes?"), false);
if (ret == QMessageBox::Save)
{
material->save();
}
else
{
material->load();
needReload = true;
}
ui->actSave->setEnabled(false);
if (needReload)
{
loadMaterial();
}
}
return result;
}
bool SceneLoader::loadMaterials()
{
materialElement=materialsElement->FirstChildElement();
cout<<"Materials:\n";
int nMaterials = 0;
while(materialElement)
{
if(nMaterials == global.maxmaterials)
{
cout<<"Ja chegou limite de maxMaterials\n";
system("pause");
return false;
}
else if(strcmp(materialElement->Value(), "material") == 0)
{
if(!loadMaterial())
return false;
}
else
{
cout<<"Erro parsing material de materials\n";
system("pause");
return false;
}
materialElement = materialElement->NextSiblingElement();
nMaterials++;
}
cout<<endl;
return true;
}
void Model::loadBinary(Common::SeekableReadStream *data, CMap *cmap) {
char v3[4 * 3], f[4];
_numMaterials = data->readUint32LE();
_materials = new Material*[_numMaterials];
_materialNames = new char[_numMaterials][32];
_materialsShared = new bool[_numMaterials];
for (int i = 0; i < _numMaterials; i++) {
data->read(_materialNames[i], 32);
_materialsShared[i] = false;
_materials[i] = NULL;
loadMaterial(i, cmap);
}
data->seek(32, SEEK_CUR); // skip name
data->seek(4, SEEK_CUR);
_numGeosets = data->readUint32LE();
_geosets = new Geoset[_numGeosets];
for (int i = 0; i < _numGeosets; i++)
_geosets[i].loadBinary(data, _materials);
data->seek(4, SEEK_CUR);
_numHierNodes = data->readUint32LE();
_rootHierNode = new ModelNode[_numHierNodes];
for (int i = 0; i < _numHierNodes; i++) {
_rootHierNode[i].loadBinary(data, _rootHierNode, &_geosets[0]);
}
data->read(f, 4);
_radius = get_float(f);
data->seek(36, SEEK_CUR);
data->read(v3, 3 * 4);
_insertOffset = Math::Vector3d::get_vector3d(v3);
}
Scene::Scene(string filename) {
cout << "Reading scene from " << filename << " ..." << endl;
cout << " " << endl;
char* fname = (char*)filename.c_str();
fp_in.open(fname);
if (!fp_in.is_open()) {
cout << "Error reading from file - aborting!" << endl;
throw;
}
while (fp_in.good()) {
string line;
utilityCore::safeGetline(fp_in, line);
if (!line.empty()) {
vector<string> tokens = utilityCore::tokenizeString(line);
if (strcmp(tokens[0].c_str(), "MATERIAL") == 0) {
loadMaterial(tokens[1]);
cout << " " << endl;
} else if (strcmp(tokens[0].c_str(), "OBJECT") == 0) {
loadGeom(tokens[1]);
cout << " " << endl;
} else if (strcmp(tokens[0].c_str(), "CAMERA") == 0) {
loadCamera();
cout << " " << endl;
} else if (strcmp(tokens[0].c_str(), "TEXTURE") == 0) {
loadTexture(tokens[1]);
cout << " " << endl;
}
}
}
}
void MonoTexCube::drawAll()
{
loadMaterial();
loadModel();
draw();
unloadModel();
unloadMaterial();
}
void Model::reload(CMap *cmap) {
// Load the new colormap
for (int i = 0; i < _numMaterials; i++) {
loadMaterial(i, cmap);
}
for (int i = 0; i < _numGeosets; i++)
_geosets[i].changeMaterials(_materials);
_cmap = cmap;
}
Level1Part1::Level1Part1() : MapPart(1)
{
loadMesh("GameResources\\Levels\\level1\\part1\\level1_part1.obj");
loadMaterial();
initGameObjects();
}
Level1Part4::Level1Part4() : MapPart(4)
{
loadMesh("GameResources\\Levels\\level1\\part4\\part.obj");
loadMaterial();
initGameObjects();
}
void CoronaLoader::loadMaterialDefinition(const Ref<XML>& xml)
{
if (xml->name != "materialDefinition")
THROW_RUNTIME_ERROR(xml->loc.str()+": invalid material definition: "+xml->name);
if (xml->children.size() != 1)
THROW_RUNTIME_ERROR(xml->loc.str()+": invalid material definition");
const std::string name = xml->parm("name");
materialMap[name] = loadMaterial(xml->children[0]);
}
MaterialPtr ResourceLoader::getMaterial(const char *fname, CMap *c) {
for (Common::List<Material *>::const_iterator i = _materials.begin(); i != _materials.end(); ++i) {
Material *m = *i;
if (strcmp(fname, m->_fname.c_str()) == 0 && *m->_cmap == *c) {
return m;
}
}
return loadMaterial(fname, c);
}
Resource *ResourceManager::_load(std::string filename)
{
Json::Reader reader(Json::Features::strictMode());
Json::Value root;
if (not reader.parse(readFile(filename), root))
{
std::cout << reader.getFormattedErrorMessages() << std::endl;
return NULL;
}
std::unordered_map<std::string, ResPtr<Resource> > externalResources;
if (root.isMember("external resources"))
{
Json::Value externResVal = root["external resources"];
Json::Value::Members members = externResVal.getMemberNames();
for (Json::Value::Members::iterator it = members.begin(); it != members.end(); ++it)
{
std::string name = *it;
ResPtr<Resource> resource = load(externResVal[name].asString());
externalResources[name] = resource;
}
}
std::string resourceType = root["type"].asString();
if (resourceType == "texture")
{
return loadTexture(getMember(root, "texture"), externalResources);
} else if (resourceType == "model")
{
return loadModel(getMember(root, "model"), externalResources);
} else if (resourceType == "mesh")
{
return loadMesh(getMember(root, "mesh"), externalResources);
} else if (resourceType == "shader")
{
return loadShader(getMember(root, "shader"), externalResources);
} else if (resourceType == "material")
{
return loadMaterial(getMember(root, "material"), externalResources);
} else
{
throw std::runtime_error("Unknown resource type.");
}
}
void MaterialInfo::cmbMaterials_currentIndexChanged(int index)
{
checkSaved(false);
if (index > 0 && cmbMaterials->count() > index && cmbMaterials->itemText(index) != UTILS_NONE)
{
bool created = false;
material = Magic3D::ResourceManager::getMaterials()->load(cmbMaterials->itemText(index).toStdString(), created);
}
else
{
material = NULL;
}
loadMaterial();
}
std::pair<Ref<SceneGraph::MaterialNode>, avector<AffineSpace3fa> > CoronaLoader::loadInstances(const Ref<XML>& xml)
{
if (xml->name != "instance")
THROW_RUNTIME_ERROR(xml->loc.str()+": invalid instance node");
/* create default material */
Ref<SceneGraph::MaterialNode> material = new OBJMaterial;
avector<AffineSpace3fa> xfms;
for (size_t i=0; i<xml->children.size(); i++)
{
Ref<XML> child = xml->children[i];
if (child->name == "material" ) material = loadMaterial(child);
else if (child->name == "transform") xfms.push_back(load<AffineSpace3fa>(child));
else THROW_RUNTIME_ERROR(child->loc.str()+": unknown node: "+child->name);
}
return std::make_pair(material,xfms);
}
bool CResourceLoader::loadMaterialsFromFile(const std::string& name)
{
std::string fullpath;
if (!mResourceGroupManager->getFullPath(name, fullpath))
{
GF_PRINT_CONSOLE_INFO("The material file named %s doesn't exist.\n", name.c_str());
return false;
}
std::vector<IResourceXmlParser::SMaterialCreateParams> createParamsArray;
if (!mResourceXmlParser->parseMaterialFile(fullpath, createParamsArray))
return false;
for (u32 i = 0; i < createParamsArray.size(); i++)
{
loadMaterial(fullpath, createParamsArray[i]);
}
return true;
}
Material *ResourceLoader::loadMaterial(const Common::String &filename, CMap *c) {
Common::String fname = fixFilename(filename, false);
fname.toLowercase();
Common::SeekableReadStream *stream;
stream = openNewStreamFile(fname.c_str(), true);
if (!stream) {
// FIXME: EMI demo references files that aren't included. Return a known material.
// This should be fixed in the data files instead.
if (g_grim->getGameType() == GType_MONKEY4 && g_grim->getGameFlags() & ADGF_DEMO) {
const Common::String replacement("fx/candle.sprb");
warning("Could not find material %s, using %s instead", filename.c_str(), replacement.c_str());
return loadMaterial(replacement, NULL);
}
}
Material *result = new Material(fname, stream, c);
delete stream;
return result;
}
PlayerVisual::PlayerVisual(Vektoria::CPlacement* rotationPlacement, CPlacement* posPlacement) : Visual(rotationPlacement)
{
loadMaterial();
loadMesh();
mPosPlacement = posPlacement;
mLastPositionPlacement = CPlacement();
mLastPositionPlacement.TranslateZ(0.1f);
// Kugel um halben durchmesser anheben
mPosPlacement->TranslateY(0.1f);
// Spotlight
mSpotLightPlacment.AddSpotLight(&mSpotLight);
mSpotLightPlacment.Translate(-0.2f, 15.7f, 7.0f);
mSpotLight.Init(CColor(1.0, 0.5, 0.5), 0.105F, 0.227F);
mSpotLight.SetMaxDistance(120.0F);
mSpotLight.SetMinDistance(0.0F);
mSpotLight.SetSoftShadowOn();
mSpotLight.SetShadowMapResolution(8096, 8096);
mPosPlacement->AddPlacement(&mSpotLightPlacment);
}
void MaterialInfo::setMaterialTexture(int index)
{
if (material)
{
QString fileName = QFileDialog::getOpenFileName(this, tr("Open Texture"), UTILS_DEFAULT_PATH + tr(mainWindow->getProject()->getPathData().c_str()) + tr(M3D_PATH_TEXTURE), tr(MGE_TEXTURE_FILTER) );
if (!fileName.isEmpty())
{
bool ok;
QString text = QInputDialog::getText(this, tr("New Texture"), tr("Texture name:"), QLineEdit::Normal, tr(""), &ok);
if (ok && !text.isEmpty())
{
bool created = false;
material->setTexture(index, Magic3D::ResourceManager::getInstance()->addTexture(Magic3D::eTEXTURE_DIFFUSE, text.toStdString(), Utils::getFileName(fileName).toLocal8Bit().data(), true, true, created));
updateTextureCombo();
loadMaterial();
updateObject();
}
else if (ok)
{
Utils::message(tr("Invalid Name"), tr("\"") + text + tr("\" is an invalid name!"));
}
}
}
}
bool Model::loadModel( const char* filePath, int programID )
{
FILE* file = fopen( filePath, "rb" );
if( !file )
return false;
while( !feof( file ) )
{
std::string line;
char buffer = '\0';
while( !feof( file ) && buffer != '\n' )
{
buffer = (char)fgetc( file );
line += buffer;
}
StringParser lineParser( line, std::string( ", " ) );
std::string type = lineParser.getNextToken();
if( type.compare( "StaticMesh" ) == 0 )
{
Mesh newMesh;
std::string meshData;
int numOfVerts = atoi( lineParser.getNextToken().c_str() );
int numOfTransforms = atoi( lineParser.getNextToken().c_str() );
int transformID = atoi( lineParser.getNextToken().c_str() );
int parentTransformID = atoi( lineParser.getNextToken().c_str() );
newMesh.readMeshData( file, numOfVerts, numOfTransforms, transformID, parentTransformID );
m_Meshs.insert( std::pair< int, Mesh >( newMesh.getTransformID(), newMesh ) );
}
else if( type.compare( "SkeletalMesh" ) == 0 )
{
SkeletalMesh skeletalMesh;
int numOfVerts = atoi( lineParser.getNextToken().c_str() );
skeletalMesh.readSkeletalMeshData( file, numOfVerts );
m_SkeletalMeshs.push_back( skeletalMesh );
}
else if( type.compare( "Bone" ) == 0 )
{
Bone bone;
int boneID = atoi( lineParser.getNextToken().c_str() );
int numOfTransforms = atoi( lineParser.getNextToken().c_str() );
std::vector< Matrix3 > transforms( numOfTransforms );
Matrix3 initialInverse;
fread( &initialInverse, sizeof( Matrix3 ), 1, file );
fread( transforms.data(), sizeof( Matrix3 ), numOfTransforms, file );
bone.initialInverse = initialInverse.convertTo4x4Matrix();
for( int i = 0; i < numOfTransforms; ++i )
{
bone.transforms.push_back( transforms[i].convertTo4x4Matrix() );
}
m_Bones[boneID] = bone;
}
else if( type.compare( "Material" ) == 0 )
{
int materialID = atoi( lineParser.getNextToken().c_str() );
int numOfTextures = atoi( lineParser.getNextToken().c_str() );
std::string materialData;
for( int i = 0; i < numOfTextures; )
{
buffer = (char)fgetc( file );
materialData += buffer;
if( buffer == '\n' )
{
++i;
}
}
m_Materials.push_back( loadMaterial( materialData, numOfTextures, programID ) );
}
}
if( m_Materials.size() == 0 )
{
m_Materials.push_back( Material( programID ) );
}
fclose( file );
std::cout << "Finished loading " << filePath << std::endl;
return true;
}
/*! Renders the scenegraph
This method is responsible for sorting by material and rendering game objects in material priority order
\param root The root of the scenegraph to be rendered
*/
void Renderer::render(Transform *root){
Vector3 cameraPos;
float distance;
GameObject *object;
std::vector<Material*>::iterator mit;
// Single common camera for all rendering
if (camera)
cameraPos = camera->gameObject->getTransform()->getWorldPosition();
else
cameraPos = Vector3(0,0,0);
buildRenderQueue(root);
for (int i=0; i<PRIORITY_LEVELS; i++) {
// temp list of objects requiring sorted draw order (if any)
std::priority_queue<GameObject*, std::vector<GameObject*>, GameObjectCameraDistanceCompare> sorted;
for (mit = materials[i].begin(); mit!=materials[i].end(); mit++){
std::queue<GameObject*> &q = (*mit)->getQueue(); // objects to be drawn
if (!(*mit)->getSortedDraw()) {
// objects for normal unsorted materials are drawn immediately
loadMaterial(*mit);
while (!q.empty()) {
object = q.front();
if (object->isVisible()) {
draw(object);
}
q.pop();
}
unloadMaterial(*mit);
}
else {
// objects to be sorted and drawn later
while (!q.empty()) {
object = q.front();
if (object->isVisible()) {
// Note using squared distance as we only care about relative distance
distance = cameraPos.squaredDistance(object->getTransform()->getWorldPosition());
object->setDistanceToCamera(distance);
sorted.push(object);
}
q.pop();
}
}
}
// Draw sorted objects (if any)
Material *loaded = NULL; // current loaded material
while (!sorted.empty()) {
object = sorted.top();
if (loaded != object->getMaterial()) {
// only load material if changed
loaded = object->getMaterial();
loadMaterial(loaded);
}
draw(object);
sorted.pop();
}
}
}
Object *SceneParser::loadObject(KeyValues *data)
{
const char *format = data->getString("format");
if(!format) {
fprintf(stderr, "Key 'format' not found on Object\n");
return NULL;
}
Mesh *mesh;
if(strcmp("OFF", format) == 0 || strcmp("PLY", format) == 0) {
const char *file = data->getString("file");
if(!file) {
fprintf(stderr, "Key 'file' not found on Object\n");
return NULL;
}
char *filename = resolvePath(file);
MeshData *meshData;
if(strcmp("OFF", format) == 0) {
meshData = MeshLoaderOFF::load(filename);
}
else if(strcmp("PLY", format) == 0) {
meshData = MeshLoaderPLY::load(filename);
}
if(!meshData) {
fprintf(stderr, "Failed to load MeshData of %s\n", filename);
delete[] filename;
return NULL;
}
if(data->getInt("normalize", 1)) {
meshData->normalize();
}
if(data->getInt("normals", 0)) {
meshData->computeNormals();
}
const char *texcoords = data->getString("texcoords");
if(texcoords) {
MeshData::TexCoordsMethod method;
if(strcmp(texcoords, "sphere") == 0) {
method = MeshData::TexCoordsSphere;
}
else if(strcmp(texcoords, "cylinder") == 0) {
method = MeshData::TexCoordsCylinder;
}
meshData->genTexCoords(method);
}
if(data->getInt("tangents", 0)) {
meshData->genTangents();
}
mesh = new Mesh(meshData);
delete meshData;
delete[] filename;
}
else {
fprintf(stderr, "Invalid object format: %s\n", format);
return NULL;
}
Material *material = NULL;
QGLShaderProgram *shaderProgram = new QGLShaderProgram();
KeyValues *key;
bool error = false;
key = data->firstSubKey();
while(key) {
if(strcmp(key->name(), "shader") == 0) {
QGLShader *shader = loadShader(key);
if(shader) {
shaderProgram->addShader(shader);
}
else {
fprintf(stderr, "Failed to load shader\n");
error = true;
break;
}
}
else if (strcmp(key->name(), "material") == 0) {
if(material) {
fprintf(stderr, "Duplicated material definition\n");
}
else {
material = loadMaterial(key);
}
}
key = key->nextKey();
}
if(!shaderProgram->link()) {
fprintf(stderr, "Failed to link shader program\n");
error = true;
}
if(error) {
if(material) {
delete material;
}
delete shaderProgram;
delete mesh;
return NULL;
}
Object *object = new Object(mesh, shaderProgram, material);
object->scale(data->getFloat("scale", 1.0));
float pitch = data->getFloat("pitch", 0.0);
float yaw = data->getFloat("yaw", 0.0);
object->rotation(pitch, yaw);
const char *position = data->getString("position");
if(position) {
object->position(strtoV3D(position));
}
key = data->firstSubKey();
while(key) {
if (strcmp(key->name(), "texture") == 0) {
Texture *texture = loadTexture(key);
if(texture) {
object->addTexture(texture);
}
else {
fprintf(stderr, "Failed to load texture\n");
error = true;
break;
}
}
key = key->nextKey();
}
if(error) {
return object;
}
return object;
}
void WorldState::loadMaterials()
{
// TODO: each load material currently overwrites itself, need to fix shaders and loadMaterial(i)
for (unsigned int i = 0; i < materials.size(); i++)
loadMaterial(i);
}
void Model::loadText(TextSplitter *ts, CMap *cmap) {
ts->expectString("section: header");
int major, minor;
ts->scanString("3do %d.%d", 2, &major, &minor);
ts->expectString("section: modelresource");
ts->scanString("materials %d", 1, &_numMaterials);
_materials = new Material*[_numMaterials];
_materialNames = new char[_numMaterials][32];
_materialsShared = new bool[_numMaterials];
for (int i = 0; i < _numMaterials; i++) {
char materialName[32];
int num;
_materialsShared[i] = false;
_materials[i] = NULL;
ts->scanString("%d: %32s", 2, &num, materialName);
strcpy(_materialNames[num], materialName);
loadMaterial(num, cmap);
}
ts->expectString("section: geometrydef");
ts->scanString("radius %f", 1, &_radius);
ts->scanString("insert offset %f %f %f", 3, &_insertOffset.x(), &_insertOffset.y(), &_insertOffset.z());
ts->scanString("geosets %d", 1, &_numGeosets);
_geosets = new Geoset[_numGeosets];
for (int i = 0; i < _numGeosets; i++) {
int num;
ts->scanString("geoset %d", 1, &num);
_geosets[num].loadText(ts, _materials);
}
ts->expectString("section: hierarchydef");
ts->scanString("hierarchy nodes %d", 1, &_numHierNodes);
_rootHierNode = new ModelNode[_numHierNodes];
for (int i = 0; i < _numHierNodes; i++) {
int num, mesh, parent, child, sibling, numChildren;
unsigned int flags, type;
float x, y, z, pitch, yaw, roll, pivotx, pivoty, pivotz;
char name[64];
ts->scanString(" %d: %x %x %d %d %d %d %d %f %f %f %f %f %f %f %f %f %64s",
18, &num, &flags, &type, &mesh, &parent, &child, &sibling,
&numChildren, &x, &y, &z, &pitch, &yaw, &roll, &pivotx, &pivoty, &pivotz, name);
_rootHierNode[num]._flags = (int)flags;
_rootHierNode[num]._type = (int)type;
if (mesh < 0)
_rootHierNode[num]._mesh = NULL;
else
_rootHierNode[num]._mesh = &_geosets[0]._meshes[mesh];
if (parent >= 0) {
_rootHierNode[num]._parent = &_rootHierNode[parent];
_rootHierNode[num]._depth = _rootHierNode[parent]._depth + 1;
} else {
_rootHierNode[num]._parent = NULL;
_rootHierNode[num]._depth = 0;
}
if (child >= 0)
_rootHierNode[num]._child = &_rootHierNode[child];
else
_rootHierNode[num]._child = NULL;
if (sibling >= 0)
_rootHierNode[num]._sibling = &_rootHierNode[sibling];
else
_rootHierNode[num]._sibling = NULL;
_rootHierNode[num]._numChildren = numChildren;
_rootHierNode[num]._pos = Math::Vector3d(x, y, z);
_rootHierNode[num]._pitch = pitch;
_rootHierNode[num]._yaw = yaw;
_rootHierNode[num]._roll = roll;
_rootHierNode[num]._pivot = Math::Vector3d(pivotx, pivoty, pivotz);
_rootHierNode[num]._meshVisible = true;
_rootHierNode[num]._hierVisible = true;
_rootHierNode[num]._sprite = NULL;
}
if (!ts->isEof() && (gDebugLevel == DEBUG_WARN || gDebugLevel == DEBUG_ALL))
warning("Unexpected junk at end of model text");
}
void CGraphicsModule::initDriver( short width, short height )
{
offsetX = 0;
offsetY = 0;
this->width = width;
this->height = height;
if (!glfwInit()) {
printf("Failed to start GLFW.");
exit(1);
}
#ifdef USE_OPENGL_3
glfwOpenWindowHint( GLFW_OPENGL_VERSION_MAJOR, 3 );
glfwOpenWindowHint( GLFW_OPENGL_VERSION_MINOR, 2 );
glfwOpenWindowHint( GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE );
#endif
glfwOpenWindowHint( GLFW_WINDOW_NO_RESIZE, GL_TRUE );
glfwOpenWindow( width, height, 0, 0, 0, 0, 8, 0, GLFW_WINDOW );
glfwSetWindowTitle( "Spine" );
const GLubyte* version = glGetString(GL_VERSION);
const GLubyte* renderer = glGetString(GL_RENDERER);
const GLubyte* vendor = glGetString(GL_VENDOR);
const GLubyte* glslvers = glGetString(GL_SHADING_LANGUAGE_VERSION);
printf("Version: %s\nRenderer: %s\nVendor: %s\nGLSLVersion: %s\n", version, renderer, vendor, glslvers);
glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK) {
printf( "Error loading glew!" );
exit(1);
} else {
printf( "Using GLEW: %s %d\n", glewGetString(GLEW_VERSION), glewIsSupported("GL_ARB_fragment_program") );
}
// Compile all the shaders.
DirectoryList list = filesystem->getDirectoryList("./shaders/");
for (DirectoryList::iterator i = list.begin(); i != list.end(); ++i) {
char name[50];
char exten[10];
util->getFileName(name, (*i).c_str());
util->getFileExtension(exten, (*i).c_str());
Buffer buffer;
File *file = filesystem->open((*i).c_str());
file->readBuffer(&buffer);
if (strcmp(exten, ".fsh") == 0) {
const char *c_str = buffer.data;
GLuint fragmentShader = glCreateShader( GL_FRAGMENT_SHADER );
glShaderSource( fragmentShader, 1, &c_str, NULL );
glCompileShader( fragmentShader );
shaders[name] = fragmentShader;
GLint status;
glGetShaderiv( fragmentShader, GL_COMPILE_STATUS, &status );
if (status == GL_TRUE) {
printf("Loaded fragment shader: %s (%d)\n", name, fragmentShader);
} else {
char buffer[512];
glGetShaderInfoLog( fragmentShader, 512, NULL, buffer );
printf("Error loading fragment shader: %s (%d)\n", name, fragmentShader);
printf("%s\n", buffer);
}
} else if (strcmp(exten, ".vsh") == 0) {
const char *c_str = buffer.data;
GLuint vertexShader = glCreateShader( GL_VERTEX_SHADER );
glShaderSource( vertexShader, 1, &c_str, NULL );
glCompileShader( vertexShader );
shaders[name] = vertexShader;
GLint status;
glGetShaderiv( vertexShader, GL_COMPILE_STATUS, &status );
if (status == GL_TRUE) {
printf("Loaded vertex shader: %s (%d)\n", name, vertexShader);
} else {
char buffer[512];
glGetShaderInfoLog( vertexShader, 512, NULL, buffer );
printf("Error loading vertex shader: %s (%d)\n", name, vertexShader);
printf("%s\n", buffer);
}
}
delete file;
}
// Compile all the programs.
for (DirectoryList::iterator i = list.begin(); i != list.end(); ++i) {
char exten[10];
util->getFileExtension(exten, (*i).c_str());
if (strcmp(exten, ".kv") == 0) {
char name[50];
util->getFileName(name, (*i).c_str());
util->getFileNameNoExtension(name, name);
Buffer buffer;
File *file = filesystem->open((*i).c_str());
file->readBuffer(&buffer);
KeyValue *kv = util->parseKeyValue(&buffer);
GLuint shaderProgram = glCreateProgram();
KeyValue *shadermembers = kv->getMember("shaders");
if (shadermembers != NULL) {
unsigned int b = 0;
KeyValue *member = shadermembers->getMember(b);
while ((member = shadermembers->getMember(b)) != NULL) {
glAttachShader( shaderProgram, shaders[member->getString()] );
b++;
}
}
KeyValue *fragdatamembers = kv->getMember("fragdata");
if (fragdatamembers != NULL) {
unsigned int b = 0;
KeyValue *member = fragdatamembers->getMember(b);
while ((member = fragdatamembers->getMember(b)) != NULL) {
glBindFragDataLocation( shaderProgram, b, member->getString().c_str());
b++;
}
}
glLinkProgram( shaderProgram );
glUseProgram( shaderProgram );
GLint posAttrib = glGetAttribLocation( shaderProgram, "position" );
glEnableVertexAttribArray( posAttrib );
glVertexAttribPointer( posAttrib, 2, GL_FLOAT, GL_FALSE, 0, 0 );
programs[name] = shaderProgram;
printf("Loaded program: %s (%d)\n", name, shaderProgram);
kv->release();
file->release();
}
}
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glBlendEquation( GL_FUNC_ADD );
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
loadMaterial("disttex.tga");
loadMaterial("8.tga");
// load default textures
ImageData white(1, 1);
white.setPixel(0, 0, Color(255, 255, 255));
loadMaterial("white", &white);
ImageData black(1, 1);
black.setPixel(0, 0, Color(0, 0, 0));
loadMaterial("black", &black);
glfwSetMouseButtonCallback(&MousePressedCallback);
}
vector< shared_ptr<ModelData> > ModelLoader::loadModel(const string& filename,
const QOpenGLShaderProgramPtr& shader)
{
m_shader = shader;
Assimp::Importer Importer;
const aiScene* scene = Importer.ReadFile(filename.c_str(),
aiProcessPreset_TargetRealtime_MaxQuality |
aiProcess_FlipUVs);
if(scene == nullptr)
{
qFatal(qPrintable(QObject::tr("Error parsing : %1 -> %2").arg(filename.c_str()).arg(Importer.GetErrorString())));
exit(1);
}
else if(scene->HasTextures())
{
qFatal("Support for meshes with embedded textures is not implemented");
exit(1);
}
vector<shared_ptr<ModelData>> modelData = vector<shared_ptr<ModelData>>();
modelData.resize(scene->mNumMeshes);
qDebug() << "Model has" << modelData.size() << "meshes";
unsigned int numVertices = 0;
unsigned int numIndices = 0;
for(unsigned int i = 0; i < modelData.size(); i++)
{
numVertices += scene->mMeshes[i]->mNumVertices;
numIndices += scene->mMeshes[i]->mNumFaces * 3;
}
m_positions.reserve(numVertices);
m_colors.reserve(numVertices);
m_normals.reserve(numVertices);
m_texCoords.reserve(numVertices);
m_tangents.reserve(numVertices);
m_indices.reserve(numIndices);
numVertices = 0;
numIndices = 0;
for(unsigned int i = 0; i < modelData.size(); i++)
{
modelData[i] = make_shared<ModelData>();
modelData[i]->meshData = loadMesh(i, numVertices, numIndices, scene->mMeshes[i]);
modelData[i]->textureData = loadTexture(filename, scene->mMaterials[scene->mMeshes[i]->mMaterialIndex]);
modelData[i]->materialData = loadMaterial(i, scene->mMaterials[scene->mMeshes[i]->mMaterialIndex]);
numVertices += scene->mMeshes[i]->mNumVertices;
numIndices += scene->mMeshes[i]->mNumFaces * 3;
}
prepareVertexBuffers();
qDebug() << "Model has" << numVertices << "vertices";
return modelData;
}
