Sphere::Sphere(glm::vec3 position, Material* material, double radius, GLuint nLats, GLuint nLongs, GLuint shaderProgram)
: Object(position, material, shaderProgram)
, m_radius(radius)
, m_nLats(nLats)
, m_nLongs(nLongs)
{
setupObject();
}
Light::Light(glm::vec3 aPosition, Material* aMaterial, AttenuationProperties attenuationProp, GLuint aShaderProgram)
: Object(aPosition, aMaterial, aShaderProgram)
, m_attenuationProperties(attenuationProp)
, m_radius(1)
, m_nLats(100)
, m_nLongs(40)
{
setupObject();
}
void GameTrack::addObject(GameCar* obj,bool is_static) {
setupObject(obj,is_static);
obj->update(manager, 0); //get true pos and bb
obj->quad_node_type=QUAD_NODE_TYPE_OBJECT;
if(is_static) {
quadtree->putNode(obj);
}
else {
quadtree->putDynamicNode(obj);
}
}
void CreatureUI::loadOutfit()
{
Creature* n = (Creature*)this;
unloadGfx();
setupObject();
if (!m_obj)
return;
Outfit_t outfit = n->getOutfit();
for(uint32_t i = 0; i < m_obj->numsprites ; i++){
Sprite* spr;
if(m_obj->blendframes > 1){
// a templated creature!
// behold the magic!
if((i / (m_obj->height * m_obj->width)) % 2 ) {
// if it's a template, then let's just put a NULL in there
m_gfx.insert(m_gfx.end(), NULL);
continue;
}
else{
// so it's not a template, but regular graphics.
// great! let's colorize it using a template.
ASSERT(i + m_obj->height * m_obj->width < m_obj->numsprites);
ASSERT(m_obj->imageData)
spr = g_engine->createSprite("Tibia.spr", m_obj->imageData[i]);
Sprite* templatespr = g_engine->createSprite("Tibia.spr", m_obj->imageData[i + m_obj->height * m_obj->width]);
spr->templatedColorize(templatespr, outfit.m_lookhead, outfit.m_lookbody, outfit.m_looklegs, outfit.m_lookfeet);
delete templatespr;
}
}
else{
// it's not templated.
// so sad. let's just load regular graphics
ASSERT(m_obj->imageData)
spr = g_engine->createSprite("Tibia.spr", m_obj->imageData[i]);
}
m_gfx.insert(m_gfx.end(), spr);
}
}
TreeWidgetContents TreeWidgetEditor::fillContentsFromTreeWidget(QTreeWidget *treeWidget)
{
TreeWidgetContents treeCont;
treeCont.fromTreeWidget(treeWidget, false);
treeCont.applyToTreeWidget(ui.treeWidget, iconCache(), true);
treeCont.m_headerItem.applyToListWidget(m_columnEditor->listWidget(), iconCache(), true);
m_columnEditor->setupEditor(treeWidget, treeHeaderPropList);
QList<QtVariantProperty*> rootProperties;
rootProperties.append(setupPropertyGroup(tr("Per column properties"), treeItemColumnPropList));
rootProperties.append(setupPropertyGroup(tr("Common properties"), treeItemCommonPropList));
m_rootProperties = rootProperties;
m_propertyBrowser->setPropertiesWithoutValueMarked(true);
m_propertyBrowser->setRootIsDecorated(false);
setupObject(treeWidget);
if (ui.treeWidget->topLevelItemCount() > 0)
ui.treeWidget->setCurrentItem(ui.treeWidget->topLevelItem(0));
updateEditor();
return treeCont;
}
void GameTrack::addCar(GameCar* car) {
setupObject(car,false);
sim->object_wake(car->physic_object);
//sim->add_car(car->physic_object,car->physic_object->get_pos(),car->physic_object->get_angle());
//sim->car_add_shape_quad(car->physic_object,cpv(0,0),dvectToCpVect(car->getSize()),0);
num_cars++;
car->setLap(0);
car->setScore(0);
car->setRank(0);
cars.push_back(car);
car->quad_node_type=QUAD_NODE_TYPE_OBJECT;
/*
if(num_cars==1) {
objects[0]->object->set_pos(dvectToCpVect(car->getPos()+car->getHeadingVect()*(2)));
sim->object_attach(car->physic_object,objects[0]->object,cpv(-0.5*4,0),cpv(1*4,0));
}
*/
quadtree->putDynamicNode(car);
car->initEngine(manager);
}
void AbstractItemEditor::setupEditor(QWidget *object, PropertyDefinition *propList)
{
setupProperties(propList);
setupObject(object);
}
bool Scene::loadScene(std::string sceneName) {
//Get scene file path
std::string file = PathReader::getPath("", sceneName.c_str(), "xml");
//Load scene file.
tinyxml2::XMLDocument doc;
doc.LoadFile(file.c_str());
//Invalid xml.
if(doc.ErrorID() != XML_NO_ERROR) {
cubeMappingSkybox = nullptr;
light = nullptr;
errorDescription = "Scene file doesn't exists.";
return true;
}
//Variable used to flag the scene as erroneous.
bool errorsInScene = false;
//Get scene type.
//Assume spectral as default.
std::string sceneType = doc.RootElement()->Attribute("type");
sceneType = sceneType == "" ? "Spectral" : sceneType;
//Read camera.
XMLElement* cameraElement = doc.RootElement()->FirstChildElement("camera");
errorsInScene = errorsInScene || setupCamera(cameraElement);
//Light.
const XMLElement* lightElement = doc.RootElement()->FirstChildElement("light");
const XMLElement* lightOrigin = lightElement->FirstChildElement("origin");
if(lightElement) {
std::string lightType = lightElement->Attribute("type");
if(sceneType == "RGB") {
bool rgbLightCreation = setupRGBLight(lightElement, lightOrigin, lightType);
errorsInScene = errorsInScene || rgbLightCreation;
} else {
bool spectralLightCreation = setupSpectralLight(lightElement, lightOrigin, lightType);
errorsInScene = errorsInScene || spectralLightCreation;
}
} else {
errorDescription = errorDescription + "The scene doesn't contain any light.\n";
errorsInScene = true;
}
//Eventually set a cube mapping skybox.
setupSkyboxWithCubeMapping(doc);
//Objects
XMLElement *objectsElement = doc.RootElement()->FirstChildElement("objects");
if(!objectsElement) {
errorDescription = errorDescription + "The scene doesn't contain any object.\n";
errorsInScene = true;
}
//Init geometric objects.
for(XMLElement *objectElement = objectsElement->FirstChildElement("object");
objectElement != NULL;
objectElement = objectElement->NextSiblingElement("object")) {
std::string type = objectElement->Attribute("type");
//Object creation
Model* object;
bool objectCreation = setupObject(&object, objectElement);
errorsInScene = errorsInScene || objectCreation;
//Object material creation.
const XMLElement* material = objectElement->FirstChildElement("material");
if(sceneType == "RGB") {
bool materialRGBCreation = setupRGBObjectMaterial(object, material);
errorsInScene = errorsInScene || materialRGBCreation;
} else {
bool materialBRDFCreation = setupBRDFObjectMaterial(object, material);
errorsInScene = errorsInScene || materialBRDFCreation;
}
//add object.
objects.push_back(object);
}
//Init polygonal mesh.
for(XMLElement *objectElement = objectsElement->FirstChildElement("mesh");
objectElement != NULL;
objectElement = objectElement->NextSiblingElement("mesh")) {
const XMLElement* objFile = objectElement->FirstChildElement("objFile");
bool backFaceCulling = false;
if(attributesExist(objFile, {"backFaceCulling"})) {
backFaceCulling = objFile->FindAttribute("backFaceCulling")->BoolValue();
}
std::string objName = objFile->Attribute("name");
std::string objFilePath = PathReader::getPath("OBJs", objName.c_str(), "obj");
ObjParser objParser;
objParser.parseObj(objFilePath.c_str(), backFaceCulling);
std::vector<Model *> pList = objParser.getPolygonalShapes();
const XMLElement* material = objectElement->FirstChildElement("material");
for(std::vector<Model *>::size_type i = 0; i != pList.size(); i++) {
if(sceneType == "RGB") {
bool materialRGBCreation = setupRGBObjectMaterial(pList[i], material);
errorsInScene = errorsInScene || materialRGBCreation;
} else {
bool materialBRDFCreation = setupBRDFObjectMaterial(pList[i], material);
errorsInScene = errorsInScene || materialBRDFCreation;
}
}
//Setup AABB.
const XMLElement* aabbElement = objectElement->FirstChildElement("aabb");
AxisAlignedBoundingBox aabb;
setupAABB(aabb, aabbElement);
//Create mesh.
Model* mesh = new PolygonalMesh(pList, aabb);
//Add mesh.
objects.push_back(mesh);
}
//SCLT specific configuration.
errorsInScene = errorsInScene || setupSCLTParameter(doc, sceneType);
return errorsInScene;
}
