void PlyFileParser::ParseDataLine(QString line, ElementInfo elementInfo, double scale, Vector3D translation)
{
QString qElementName = QString::fromStdString(elementInfo.elementName);
if (QString::compare(qElementName, "vertex", Qt::CaseInsensitive) == 0)
{
Vector3D vertex = ParseVertex(line, scale, translation);
VertexCache.append(vertex);
}
else if (QString::compare(qElementName, "triangle", Qt::CaseInsensitive) == 0 || QString::compare(qElementName, "face", Qt::CaseInsensitive) == 0)
{
Triangle* triangle = ParseTriangle(line);
ModelCache.append(triangle);
}
else if (elementInfo.elementName == "sphere")
{
Sphere* sphere = ParseSphere(line);
ModelCache.append(sphere);
}
}
void ParseTextMap(MapData *map)
{
char *buffer = new char[map->Size(ML_TEXTMAP)];
isTranslated = true;
isExtended = false;
floordrop = false;
map->Read(ML_TEXTMAP, buffer);
sc.OpenMem(Wads.GetLumpFullName(map->lumpnum), buffer, map->Size(ML_TEXTMAP));
delete [] buffer;
sc.SetCMode(true);
if (sc.CheckString("namespace"))
{
sc.MustGetStringName("=");
sc.MustGetString();
namespc = sc.String;
switch(namespc)
{
case NAME_ZDoom:
namespace_bits = Zd;
isTranslated = false;
break;
case NAME_ZDoomTranslated:
level.flags2 |= LEVEL2_DUMMYSWITCHES;
namespace_bits = Zdt;
break;
case NAME_Vavoom:
namespace_bits = Va;
isTranslated = false;
break;
case NAME_Hexen:
namespace_bits = Hx;
isTranslated = false;
break;
case NAME_Doom:
namespace_bits = Dm;
P_LoadTranslator("xlat/doom_base.txt");
level.flags2 |= LEVEL2_DUMMYSWITCHES;
floordrop = true;
break;
case NAME_Heretic:
namespace_bits = Ht;
P_LoadTranslator("xlat/heretic_base.txt");
level.flags2 |= LEVEL2_DUMMYSWITCHES;
floordrop = true;
break;
case NAME_Strife:
namespace_bits = St;
P_LoadTranslator("xlat/strife_base.txt");
level.flags2 |= LEVEL2_DUMMYSWITCHES|LEVEL2_RAILINGHACK;
floordrop = true;
break;
default:
Printf("Unknown namespace %s. Using defaults for %s\n", sc.String, GameTypeName());
switch (gameinfo.gametype)
{
default: // Shh, GCC
case GAME_Doom:
case GAME_Chex:
namespace_bits = Dm;
P_LoadTranslator("xlat/doom_base.txt");
break;
case GAME_Heretic:
namespace_bits = Ht;
P_LoadTranslator("xlat/heretic_base.txt");
break;
case GAME_Strife:
namespace_bits = St;
P_LoadTranslator("xlat/strife_base.txt");
break;
case GAME_Hexen:
namespace_bits = Hx;
isTranslated = false;
break;
}
}
sc.MustGetStringName(";");
}
else
{
Printf("Map does not define a namespace.\n");
}
while (sc.GetString())
{
if (sc.Compare("thing"))
{
FMapThing th;
unsigned userdatastart = MapThingsUserData.Size();
ParseThing(&th);
MapThingsConverted.Push(th);
if (userdatastart < MapThingsUserData.Size())
{ // User data added
MapThingsUserDataIndex[MapThingsConverted.Size()-1] = userdatastart;
// Mark end of the user data for this map thing
FMapThingUserData ud;
ud.Property = NAME_None;
ud.Value = 0;
MapThingsUserData.Push(ud);
}
}
else if (sc.Compare("linedef"))
{
line_t li;
ParseLinedef(&li, ParsedLines.Size());
ParsedLines.Push(li);
}
else if (sc.Compare("sidedef"))
{
side_t si;
intmapsidedef_t st;
ParseSidedef(&si, &st, ParsedSides.Size());
ParsedSides.Push(si);
ParsedSideTextures.Push(st);
}
else if (sc.Compare("sector"))
{
sector_t sec;
ParseSector(&sec, ParsedSectors.Size());
ParsedSectors.Push(sec);
}
else if (sc.Compare("vertex"))
{
vertex_t vt;
vertexdata_t vd;
ParseVertex(&vt, &vd);
ParsedVertices.Push(vt);
ParsedVertexDatas.Push(vd);
}
else
{
Skip();
}
}
// Catch bogus maps here rather than during nodebuilding
if (ParsedVertices.Size() == 0) I_Error("Map has no vertices.\n");
if (ParsedSectors.Size() == 0) I_Error("Map has no sectors. \n");
if (ParsedLines.Size() == 0) I_Error("Map has no linedefs.\n");
if (ParsedSides.Size() == 0) I_Error("Map has no sidedefs.\n");
// Create the real vertices
numvertexes = ParsedVertices.Size();
vertexes = new vertex_t[numvertexes];
memcpy(vertexes, &ParsedVertices[0], numvertexes * sizeof(*vertexes));
// Create the real vertex datas
numvertexdatas = ParsedVertexDatas.Size();
vertexdatas = new vertexdata_t[numvertexdatas];
memcpy(vertexdatas, &ParsedVertexDatas[0], numvertexdatas * sizeof(*vertexdatas));
// Create the real sectors
numsectors = ParsedSectors.Size();
sectors = new sector_t[numsectors];
memcpy(sectors, &ParsedSectors[0], numsectors * sizeof(*sectors));
sectors[0].e = new extsector_t[numsectors];
for(int i = 0; i < numsectors; i++)
{
sectors[i].e = §ors[0].e[i];
}
// Create the real linedefs and decompress the sidedefs
ProcessLineDefs();
}
CPass* CMaterialLoader::ParsePass(Json::Value& json, Json::Value& root) {
const char* szVertexProgram = json["vertex_program"].asCString();
const char* szFragmentProgram = json["fragment_program"].asCString();
Json::Value& diffuseJson = json["diffuse"];
Json::Value& ambientJson = json["ambient"];
Json::Value& specularJson = json["specular"];
Json::Value& emissiveJson = json["emissive"];
Json::Value& textureUnitJson = json["texture_unit"];
// 创建颜色
CColorF diffuse = CColorF(diffuseJson[0].asFloat(),
diffuseJson[1].asFloat(),
diffuseJson[2].asFloat(),
diffuseJson[3].asFloat());
CColorF ambient = CColorF(ambientJson[0].asFloat(),
ambientJson[1].asFloat(),
ambientJson[2].asFloat(),
ambientJson[3].asFloat());
CColorF specular = CColorF(specularJson[0].asFloat(),
specularJson[1].asFloat(),
specularJson[2].asFloat(),
specularJson[3].asFloat());
CColorF emissive = CColorF(emissiveJson[0].asFloat(),
emissiveJson[1].asFloat(),
emissiveJson[2].asFloat(),
emissiveJson[3].asFloat());
// 创建纹理
CTexture* pTexture = NULL;
if (!textureUnitJson.isNull()) {
const char* texture = textureUnitJson["texture"].asCString();
std::string filter_mode = textureUnitJson["filter_mode"].asString();
std::string address_mode = textureUnitJson["address_mode"].asString();
pTexture = XENEW(CTexture);
if (!pTexture) {
return NULL;
}
if (filter_mode == "nearest") {
pTexture->SetFilter(ITexture::E_Nearest);
} else if (filter_mode == "linear") {
pTexture->SetFilter(ITexture::E_Linear);
}
if (address_mode == "repeat") {
pTexture->SetAddress(ITexture::E_Repeat);
} else if (address_mode == "clamp") {
pTexture->SetAddress(ITexture::E_Clamp);
}
if (!pTexture->Load(texture)) {
XELOG("material parse pass load texture error: %s", texture);
XEDELETE(pTexture);
return NULL;
}
}
// 创建program
CCgProgram* pProgram = XENEW(CCgProgram);
if (!pProgram) {
XEDELETE(pTexture);
return NULL;
}
// 创建vertex
CCg* pVertex = ParseVertex(szVertexProgram, root);
if (!pVertex) {
XELOG("material parse pass load vertex error: %s", szVertexProgram);
XEDELETE(pTexture);
XEDELETE(pProgram);
return NULL;
}
pProgram->AddCg(pVertex);
// 创建fragment
CCg* pFragment = ParseFragment(szFragmentProgram, root);
if (!pFragment) {
XELOG("material parse pass load fragment error: %s", szFragmentProgram);
XEDELETE(pTexture);
XEDELETE(pProgram);
XEDELETE(pVertex);
return NULL;
}
pProgram->AddCg(pFragment);
pProgram->Compile();
// 创建pass
CPass* pPass = XENEW(CPass);
if (!pPass) {
XEDELETE(pTexture);
XEDELETE(pProgram);
XEDELETE(pVertex);
XEDELETE(pFragment);
return NULL;
}
pPass->Init(pTexture, diffuse, ambient, specular, emissive, pProgram);
return pPass;
}