DialogObjectEdit::DialogObjectEdit(QWidget *parent) :
QDialog(parent),
ui(new Ui::DialogObjectEdit)
{
ui->setupUi(this);
fillObjectGraphicsList();
if (dataExchanger->editModeNPC == 1) {
std::cout << "DialogObjectEdit::DialogObjectEdit - editing existing Obj, id: " << dataExchanger->selectedNPC << std::endl;
loadObjectData(dataExchanger->selectedNPC);
} else {
std::cout << "DialogObjectEdit::DialogObjectEdit - adding new Obj, id: " << dataExchanger->selectedNPC << std::endl;
}
QObject::connect(ui->npcPreviewAreaWidget, SIGNAL(clickedIn()), this, SLOT(setObjectFrame()));
}
static EERIE_3DSCENE * ScnToEerie(const char * adr, size_t size, const res::path & fic) {
(void)size; // TODO use size
LogDebug("Loading Scene " << fic);
size_t pos = 0;
EERIE_3DSCENE * seerie = allocStructZero<EERIE_3DSCENE>();
Clear3DScene(seerie);
const TSCN_HEADER * psth = reinterpret_cast<const TSCN_HEADER *>(adr + pos);
pos += sizeof(TSCN_HEADER);
LogDebug("SCNtoEERIE " << fic << " Version " << psth->version << " Nb Textures " << psth->nb_maps);
if(psth->version < 3008 || psth->version > 3024) {
LogError << "ScnToEerie: invalid version in " << fic << ": found " << psth->version
<< " expected 3008 to 3024";
free(seerie);
return NULL;
}
seerie->nbtex = psth->nb_maps;
const res::path temp = "graph/obj3d/textures";
if(psth->type_write == 0) {
seerie->texturecontainer = allocStructZero<TextureContainer *>(psth->nb_maps);
for(long i = 0; i < psth->nb_maps; i++) {
const THEO_TEXTURE * tt = reinterpret_cast<const THEO_TEXTURE *>(adr + pos);
pos += sizeof(THEO_TEXTURE);
res::path mapsname = temp / res::path::load(util::loadString(tt->texture_name)).remove_ext();
seerie->texturecontainer[i] = TextureContainer::Load(mapsname, TextureContainer::Level);
}
} else {
if((psth->type_write & SAVE_MAP_BMP) || (psth->type_write & SAVE_MAP_TGA)) {
seerie->texturecontainer = allocStructZero<TextureContainer *>(psth->nb_maps);
for(long i = 0; i < psth->nb_maps; i++) {
res::path name;
if(psth->version >= 3019) {
const THEO_SAVE_MAPS_IN_3019 * tsmi3019 = reinterpret_cast<const THEO_SAVE_MAPS_IN_3019 *>(adr + pos);
pos += sizeof(THEO_SAVE_MAPS_IN_3019);
name = res::path::load(util::loadString(tsmi3019->texture_name)).remove_ext();
} else {
const THEO_SAVE_MAPS_IN * tsmi = reinterpret_cast<const THEO_SAVE_MAPS_IN *>(adr + pos);
pos += sizeof(THEO_SAVE_MAPS_IN);
name = res::path::load(util::loadString(tsmi->texture_name)).remove_ext();
}
if(!name.empty()) {
seerie->texturecontainer[i] = TextureContainer::Load(temp / name, TextureContainer::Level);
}
}
}
}
// read objects
pos = psth->object_seek;
s32 nbo = *reinterpret_cast<const s32 *>(adr + pos);
pos += sizeof(s32);
seerie->nbobj = nbo;
seerie->objs = allocStructZero<EERIE_3DOBJ *>(nbo);
seerie->point0 = Vec3f(-999999999999.f);
long id = 0;
for(long i = 0; i < nbo; i++) {
const TSCN_OBJHEADER * ptoh = reinterpret_cast<const TSCN_OBJHEADER *>(adr + pos);
pos += sizeof(TSCN_OBJHEADER);
seerie->objs[id] = new EERIE_3DOBJ();
// TODO most is done in the constructor already
seerie->objs[id]->clear();
seerie->objs[id]->texturecontainer.resize(seerie->nbtex);
std::copy(seerie->texturecontainer, seerie->texturecontainer + seerie->nbtex, seerie->objs[id]->texturecontainer.begin());
long objVersion;
if(psth->version < 3013) {
objVersion = 3004;
} else if(psth->version < 3015) {
objVersion = 3005;
} else if(psth->version < 3019) {
objVersion = 3006;
} else if(psth->version < 3023) {
objVersion = 3008;
} else {
objVersion = 3011;
}
loadObjectData(seerie->objs[id], adr, &pos, objVersion);
seerie->cub.xmin = std::min(seerie->cub.xmin, seerie->objs[id]->cub.xmin + seerie->objs[id]->pos.x);
seerie->cub.xmax = std::max(seerie->cub.xmax, seerie->objs[id]->cub.xmax + seerie->objs[id]->pos.x);
seerie->cub.ymin = std::min(seerie->cub.ymin, seerie->objs[id]->cub.ymin + seerie->objs[id]->pos.y);
seerie->cub.ymax = std::max(seerie->cub.ymax, seerie->objs[id]->cub.ymax + seerie->objs[id]->pos.y);
seerie->cub.zmin = std::min(seerie->cub.zmin, seerie->objs[id]->cub.zmin + seerie->objs[id]->pos.z);
seerie->cub.zmax = std::max(seerie->cub.zmax, seerie->objs[id]->cub.zmax + seerie->objs[id]->pos.z);
std::string name = boost::to_lower_copy(util::loadString(ptoh->object_name));
if(name == "map_origin") {
seerie->point0 = seerie->objs[id]->point0 + seerie->objs[id]->pos;
delete seerie->objs[id];
seerie->nbobj--;
id--;
} else {
seerie->objs[id]->name = name;
}
id++;
pos = ptoh->next_obj;
}
pos = psth->light_seek; // ambient
pos += sizeof(SavedColor); // ignore ambient color
s32 nbl = *reinterpret_cast<const s32 *>(adr + pos);
pos += sizeof(s32);
seerie->light = NULL;
seerie->nblight = nbl;
for(long i = 0; i < nbl; i++) {
TSCN_LIGHT_3024 sl3024;
const TSCN_LIGHT_3024 * tsl3024;
if(psth->version >= 3024) {
tsl3024 = reinterpret_cast<const TSCN_LIGHT_3024 *>(adr + pos);
pos += sizeof(TSCN_LIGHT_3024);
} else if(psth->version >= 3019) {
const TSCN_LIGHT_3019 * tsl3019 = reinterpret_cast<const TSCN_LIGHT_3019 *>(adr + pos);
pos += sizeof(TSCN_LIGHT_3019);
memset(&sl3024, 0, sizeof(TSCN_LIGHT_3024));
sl3024.red = tsl3019->red;
sl3024.green = tsl3019->green;
sl3024.blue = tsl3019->blue;
sl3024.pos = tsl3019->pos;
sl3024.hotspot = tsl3019->hotspot;
sl3024.falloff = tsl3019->falloff;
sl3024.intensity = tsl3019->intensity;
tsl3024 = &sl3024;
} else {
const TSCN_LIGHT * tsl = reinterpret_cast<const TSCN_LIGHT *>(adr + pos);
pos += sizeof(TSCN_LIGHT);
memset(&sl3024, 0, sizeof(TSCN_LIGHT_3024));
sl3024.red = tsl->red;
sl3024.green = tsl->green;
sl3024.blue = tsl->blue;
sl3024.pos = tsl->pos;
sl3024.hotspot = tsl->hotspot;
sl3024.falloff = tsl->falloff;
sl3024.intensity = tsl->intensity;
tsl3024 = &sl3024;
}
EERIE_LIGHT light;
light.rgb.r = (float)tsl3024->red * ( 1.0f / 255 );
light.rgb.g = (float)tsl3024->green * ( 1.0f / 255 );
light.rgb.b = (float)tsl3024->blue * ( 1.0f / 255 );
light.pos = tsl3024->pos.toVec3();
light.fallstart = (float)tsl3024->hotspot;
light.fallend = (float)tsl3024->falloff;
float t = light.fallend - light.fallstart;
if(t < 150.f) {
light.fallend += 150.f - t;
}
light.intensity = (float)tsl3024->intensity;
light.exist = 1;
light.treat = 1;
light.m_isIgnitionLight = false;
EERIE_LIGHT_GlobalAdd(&light);
}
return seerie;
}
// Converts a Theo Object to an EERIE object
static EERIE_3DOBJ * TheoToEerie(const char * adr, long size, const res::path & texpath, const res::path & fic) {
LogWarning << "TheoToEerie " << fic;
if(!adr)
return NULL;
res::path txpath = texpath.empty() ? "graph/obj3d/textures" : texpath;
if(size < 10) {
return NULL;
}
size_t pos = 0;
const THEO_HEADER * pth = reinterpret_cast<const THEO_HEADER *>(adr + pos);
pos += sizeof(THEO_HEADER);
if(pth->version < 3003 || pth->version > 3011) {
LogError << "TheoToEerie: invalid version in " << fic << ": found " << pth->version
<< " expected 3004 to 3011";
return NULL;
}
EERIE_3DOBJ * eerie = new EERIE_3DOBJ;
eerie->clear();
eerie->file = fic;
if(pth->type_write == 0) {
// read the texture
LogError << "WARNING object " << fic << " SAVE MAP IN OBJECT = INVALID... Using Dummy Textures...";
eerie->texturecontainer.resize(pth->nb_maps);
for(long i = 0; i < pth->nb_maps; i++) {
pos += sizeof(THEO_TEXTURE);
eerie->texturecontainer[i] = GetAnyTexture();
}
} else {
if((pth->type_write & SAVE_MAP_BMP) || (pth->type_write & SAVE_MAP_TGA)) {
eerie->texturecontainer.resize(pth->nb_maps);
for(long i = 0; i < pth->nb_maps; i++) {
res::path name;
if(pth->version >= 3008) {
const THEO_SAVE_MAPS_IN_3019 * tsmi3019 = reinterpret_cast<const THEO_SAVE_MAPS_IN_3019 *>(adr + pos);
pos += sizeof(THEO_SAVE_MAPS_IN_3019);
name = res::path::load(util::loadString(tsmi3019->texture_name)).remove_ext();
} else {
const THEO_SAVE_MAPS_IN * tsmi = reinterpret_cast<const THEO_SAVE_MAPS_IN *>(adr + pos);
pos += sizeof(THEO_SAVE_MAPS_IN);
name = res::path::load(util::loadString(tsmi->texture_name)).remove_ext();
}
if(!name.empty()) {
eerie->texturecontainer[i] = TextureContainer::Load(txpath / name, TextureContainer::Level);
}
}
}
}
pos = pth->object_seek;
loadObjectData(eerie, adr, &pos, pth->version);
eerie->angle = Anglef::ZERO;
eerie->pos = Vec3f_ZERO;
// NORMALS CALCULATIONS
//Compute Faces Areas
for(size_t i = 0; i < eerie->facelist.size(); i++) {
const Vec3f & p0 = eerie->vertexlist[eerie->facelist[i].vid[0]].v;
const Vec3f & p1 = eerie->vertexlist[eerie->facelist[i].vid[1]].v;
const Vec3f & p2 = eerie->vertexlist[eerie->facelist[i].vid[2]].v;
eerie->facelist[i].temp = glm::distance((p0 + p1) * .5f, p2) * glm::distance(p0, p1) * .5f;
}
for(size_t i = 0; i < eerie->facelist.size(); i++) {
CalcObjFaceNormal(
&eerie->vertexlist[eerie->facelist[i].vid[0]].v,
&eerie->vertexlist[eerie->facelist[i].vid[1]].v,
&eerie->vertexlist[eerie->facelist[i].vid[2]].v,
&eerie->facelist[i]
);
float area = eerie->facelist[i].temp;
for(long j = 0; j < 3; j++) {
float mod = area * area;
Vec3f nrml = eerie->facelist[i].norm * mod;
float count = mod;
for(size_t i2 = 0; i2 < eerie->facelist.size(); i2++) {
if(i != i2) {
float area2 = eerie->facelist[i].temp;
for(long j2 = 0; j2 < 3; j2++) {
if(closerThan(eerie->vertexlist[eerie->facelist[i2].vid[j2]].v, eerie->vertexlist[eerie->facelist[i].vid[j]].v, .1f)) {
mod = (area2 * area2);
nrml += eerie->facelist[i2].norm * mod;
count += mod;
}
}
}
}
count = 1.f / count;
eerie->vertexlist[eerie->facelist[i].vid[j]].vert.p = nrml * count;
}
}
for(size_t i = 0; i < eerie->facelist.size(); i++) {
for(long j = 0; j < 3; j++) {
eerie->vertexlist[eerie->facelist[i].vid[j]].norm = eerie->vertexlist[eerie->facelist[i].vid[j]].vert.p;
}
}
// Apply Normals Spherical correction for NPC head
long neck_orgn = GetGroupOriginByName(eerie, "neck");
long head_idx = EERIE_OBJECT_GetGroup(eerie, "head");
if(head_idx >= 0 && neck_orgn >= 0) {
VertexGroup & headGroup = eerie->grouplist[head_idx];
Vec3f center = Vec3f_ZERO;
Vec3f origin = eerie->vertexlist[neck_orgn].v;
float count = (float)headGroup.indexes.size();
if(count > 0.f) {
for(size_t idx = 0 ; idx < headGroup.indexes.size(); idx++) {
center += eerie->vertexlist[ headGroup.indexes[idx] ].v;
}
center = (center * (1.f / count) + origin + origin) * (1.0f / 3);
float max_threshold = glm::distance(origin, center);
for(size_t i = 0; i < headGroup.indexes.size(); i++) {
EERIE_VERTEX * ev = &eerie->vertexlist[headGroup.indexes[i]];
float d = glm::distance(ev->v, origin);
float factor = 1.f;
if(d < max_threshold) {
factor = d / max_threshold;
}
float ifactor = 1.f - factor;
Vec3f fakenorm;
fakenorm = ev->v - center;
fakenorm = glm::normalize(fakenorm);
ev->norm = ev->norm * ifactor + fakenorm * factor;
ev->norm = glm::normalize(ev->norm);
}
}
}
// NORMALS CALCULATIONS END
//***********************************************************
eerie->m_skeleton = NULL;
EERIE_CreateCedricData(eerie);
return eerie;
}
static int HostStatsFetchData(void)
{
DWORD o;
PPERF_OBJECT_TYPE objPtr = NULL;
DWORD res;
DWORD oldBufferSize = BufferSize;
const char * qstr;
qstr = LEVEL1_QUERY_STRING;
while ((res = RegQueryValueEx(HKEY_PERFORMANCE_DATA, qstr,
NULL, NULL,
(LPBYTE)PerfData,
&BufferSize)) == ERROR_MORE_DATA) {
oldBufferSize += 4096;
BufferSize = oldBufferSize;
PerfData = (PPERF_DATA_BLOCK)realloc(PerfData, BufferSize);
}
if (res != ERROR_SUCCESS) {
fprintf(stderr,
"Can't get Windows performance data. RegQueryValueEx returned %ld, errorno \"%d\"\n",
GetLastError(),
res);
return -1;
}
#ifdef NTDBG
fprintf(stderr, "buffersize is %ld\n", BufferSize);
fflush(stderr);
#endif
ProcessObj = NULL;
ProcessorObj = NULL;
MemoryObj = NULL;
SystemObj = NULL;
ObjectsObj = NULL;
objPtr = FirstObject(PerfData);
for (o=0; o < PerfData->NumObjectTypes; o++) {
#ifdef NTDBG
fprintf(stderr, "Object %ld\n", objPtr->ObjectNameTitleIndex);
fflush(stderr);
#endif
switch (objPtr->ObjectNameTitleIndex) {
case PROCESS_OBJ_ID: ProcessObj = objPtr; break;
case PROCESSOR_OBJ_ID: ProcessorObj = objPtr; break;
case MEMORY_OBJ_ID: MemoryObj = objPtr; break;
case SYSTEM_OBJ_ID: SystemObj = objPtr; break;
case OBJECTS_OBJ_ID: ObjectsObj = objPtr; break;
case NETWORK_OBJ_ID: NetworkObj = objPtr; break;
case UDP_OBJ_ID: UdpObj = objPtr; break;
}
objPtr = NextObject(objPtr);
}
if ( ProcessObj == NULL ||
ProcessorObj == NULL ||
MemoryObj == NULL ||
SystemObj == NULL ||
ObjectsObj == NULL ||
NetworkObj == NULL ||
UdpObj == NULL )
{
return -1;
}
loadProcessData();
loadProcessorData();
loadSystemData();
loadMemoryData();
loadObjectData();
loadUdpData();
loadCpuData();
loadNetworkData();
return 0;
}
void DebugObjectLoadingState::update()
{
if (!_toLoad.empty()) loadObjectData();
}
