/* MapSpecials::processEternitySlopes * Process Eternity slope specials *******************************************************************/ void MapSpecials::processEternitySlopes(SLADEMap* map) { // Eternity plans on having a few slope mechanisms, // which must be evaluated in a specific order. // - Plane_Align, in line order // - vertex triangle slopes, in sector order (wip) // - Plane_Copy, in line order // First things first: reset every sector to flat planes for(unsigned a = 0; a < map->nSectors(); a++) { MapSector* target = map->getSector(a); target->setPlane<FLOOR_PLANE>(plane_t::flat(target->getPlaneHeight<FLOOR_PLANE>())); target->setPlane<CEILING_PLANE>(plane_t::flat(target->getPlaneHeight<CEILING_PLANE>())); } // Plane_Align (line special 181) for(unsigned a = 0; a < map->nLines(); a++) { MapLine* line = map->getLine(a); if(line->getSpecial() != 181) continue; MapSector* sector1 = line->frontSector(); MapSector* sector2 = line->backSector(); if(!sector1 || !sector2) { LOG_MESSAGE(1, "Ignoring Plane_Align on one-sided line %d", line->getIndex()); continue; } if(sector1 == sector2) { LOG_MESSAGE(1, "Ignoring Plane_Align on line %d, which has the same sector on both sides", line->getIndex()); continue; } int floor_arg = line->intProperty("arg0"); if(floor_arg == 1) applyPlaneAlign<FLOOR_PLANE>(line, sector1, sector2); else if(floor_arg == 2) applyPlaneAlign<FLOOR_PLANE>(line, sector2, sector1); int ceiling_arg = line->intProperty("arg1"); if(ceiling_arg == 1) applyPlaneAlign<CEILING_PLANE>(line, sector1, sector2); else if(ceiling_arg == 2) applyPlaneAlign<CEILING_PLANE>(line, sector2, sector1); } // Plane_Copy vector<MapSector*> sectors; for(unsigned a = 0; a < map->nLines(); a++) { MapLine* line = map->getLine(a); if(line->getSpecial() != 118) continue; int tag; MapSector* front = line->frontSector(); MapSector* back = line->backSector(); if((tag = line->intProperty("arg0"))) { sectors.clear(); map->getSectorsByTag(tag, sectors); if(sectors.size()) front->setFloorPlane(sectors[0]->getFloorPlane()); } if((tag = line->intProperty("arg1"))) { sectors.clear(); map->getSectorsByTag(tag, sectors); if(sectors.size()) front->setCeilingPlane(sectors[0]->getCeilingPlane()); } if((tag = line->intProperty("arg2"))) { sectors.clear(); map->getSectorsByTag(tag, sectors); if(sectors.size()) back->setFloorPlane(sectors[0]->getFloorPlane()); } if((tag = line->intProperty("arg3"))) { sectors.clear(); map->getSectorsByTag(tag, sectors); if(sectors.size()) back->setCeilingPlane(sectors[0]->getCeilingPlane()); } // The fifth "share" argument copies from one side of the line to the // other if(front && back) { int share = line->intProperty("arg4"); if((share & 3) == 1) back->setFloorPlane(front->getFloorPlane()); else if((share & 3) == 2) front->setFloorPlane(back->getFloorPlane()); if((share & 12) == 4) back->setCeilingPlane(front->getCeilingPlane()); else if((share & 12) == 8) front->setCeilingPlane(back->getCeilingPlane()); } } }
/* MapSpecials::processZDoomSlopes * Process ZDoom slope specials *******************************************************************/ void MapSpecials::processZDoomSlopes(SLADEMap* map) { // ZDoom has a variety of slope mechanisms, which must be evaluated in a // specific order. // - Plane_Align, in line order // - line slope + sector tilt + vavoom, in thing order // - slope copy things, in thing order // - overwrite vertex heights with vertex height things // - vertex triangle slopes, in sector order // - Plane_Copy, in line order // First things first: reset every sector to flat planes for (unsigned a = 0; a < map->nSectors(); a++) { MapSector* target = map->getSector(a); target->setPlane<FLOOR_PLANE>(plane_t::flat(target->getPlaneHeight<FLOOR_PLANE>())); target->setPlane<CEILING_PLANE>(plane_t::flat(target->getPlaneHeight<CEILING_PLANE>())); } // Plane_Align (line special 181) for (unsigned a = 0; a < map->nLines(); a++) { MapLine* line = map->getLine(a); if (line->getSpecial() != 181) continue; MapSector* sector1 = line->frontSector(); MapSector* sector2 = line->backSector(); if (!sector1 || !sector2) { LOG_MESSAGE(1, "Ignoring Plane_Align on one-sided line %d", line->getIndex()); continue; } if (sector1 == sector2) { LOG_MESSAGE(1, "Ignoring Plane_Align on line %d, which has the same sector on both sides", line->getIndex()); continue; } int floor_arg = line->intProperty("arg0"); if (floor_arg == 1) applyPlaneAlign<FLOOR_PLANE>(line, sector1, sector2); else if (floor_arg == 2) applyPlaneAlign<FLOOR_PLANE>(line, sector2, sector1); int ceiling_arg = line->intProperty("arg1"); if (ceiling_arg == 1) applyPlaneAlign<CEILING_PLANE>(line, sector1, sector2); else if (ceiling_arg == 2) applyPlaneAlign<CEILING_PLANE>(line, sector2, sector1); } // Line slope things (9500/9501), sector tilt things (9502/9503), and // vavoom things (1500/1501), all in the same pass for (unsigned a = 0; a < map->nThings(); a++) { MapThing* thing = map->getThing(a); // Line slope things if (thing->getType() == 9500) applyLineSlopeThing<FLOOR_PLANE>(map, thing); else if (thing->getType() == 9501) applyLineSlopeThing<CEILING_PLANE>(map, thing); // Sector tilt things else if (thing->getType() == 9502) applySectorTiltThing<FLOOR_PLANE>(map, thing); else if (thing->getType() == 9503) applySectorTiltThing<CEILING_PLANE>(map, thing); // Vavoom things else if (thing->getType() == 1500) applyVavoomSlopeThing<FLOOR_PLANE>(map, thing); else if (thing->getType() == 1501) applyVavoomSlopeThing<CEILING_PLANE>(map, thing); } // Slope copy things (9510/9511) for (unsigned a = 0; a < map->nThings(); a++) { MapThing* thing = map->getThing(a); if (thing->getType() == 9510 || thing->getType() == 9511) { int target_idx = map->sectorAt(thing->point()); if (target_idx < 0) continue; MapSector* target = map->getSector(target_idx); // First argument is the tag of a sector whose slope should be copied int tag = thing->intProperty("arg0"); if (!tag) { LOG_MESSAGE(1, "Ignoring slope copy thing in sector %d with no argument", target_idx); continue; } vector<MapSector*> tagged_sectors; map->getSectorsByTag(tag, tagged_sectors); if (tagged_sectors.empty()) { LOG_MESSAGE(1, "Ignoring slope copy thing in sector %d; no sectors have target tag %d", target_idx, tag); continue; } if (thing->getType() == 9510) target->setFloorPlane(tagged_sectors[0]->getFloorPlane()); else target->setCeilingPlane(tagged_sectors[0]->getCeilingPlane()); } } // Vertex height things // These only affect the calculation of slopes and shouldn't be stored in // the map data proper, so instead of actually changing vertex properties, // we store them in a hashmap. VertexHeightMap vertex_floor_heights; VertexHeightMap vertex_ceiling_heights; for (unsigned a = 0; a < map->nThings(); a++) { MapThing* thing = map->getThing(a); if (thing->getType() == 1504 || thing->getType() == 1505) { // TODO there could be more than one vertex at this point MapVertex* vertex = map->vertexAt(thing->xPos(), thing->yPos()); if (vertex) { if (thing->getType() == 1504) vertex_floor_heights[vertex] = thing->floatProperty("height"); else if (thing->getType() == 1505) vertex_ceiling_heights[vertex] = thing->floatProperty("height"); } } } // Vertex heights -- only applies for sectors with exactly three vertices. // Heights may be set by UDMF properties, or by a vertex height thing // placed exactly on the vertex (which takes priority over the prop). vector<MapVertex*> vertices; for (unsigned a = 0; a < map->nSectors(); a++) { MapSector* target = map->getSector(a); vertices.clear(); target->getVertices(vertices); if (vertices.size() != 3) continue; applyVertexHeightSlope<FLOOR_PLANE>(target, vertices, vertex_floor_heights); applyVertexHeightSlope<CEILING_PLANE>(target, vertices, vertex_ceiling_heights); } // Plane_Copy vector<MapSector*> sectors; for (unsigned a = 0; a < map->nLines(); a++) { MapLine* line = map->getLine(a); if (line->getSpecial() != 118) continue; int tag; MapSector* front = line->frontSector(); MapSector* back = line->backSector(); if ((tag = line->intProperty("arg0")) && front) { sectors.clear(); map->getSectorsByTag(tag, sectors); if (sectors.size()) front->setFloorPlane(sectors[0]->getFloorPlane()); } if ((tag = line->intProperty("arg1")) && front) { sectors.clear(); map->getSectorsByTag(tag, sectors); if (sectors.size()) front->setCeilingPlane(sectors[0]->getCeilingPlane()); } if ((tag = line->intProperty("arg2")) && back) { sectors.clear(); map->getSectorsByTag(tag, sectors); if (sectors.size()) back->setFloorPlane(sectors[0]->getFloorPlane()); } if ((tag = line->intProperty("arg3")) && back) { sectors.clear(); map->getSectorsByTag(tag, sectors); if (sectors.size()) back->setCeilingPlane(sectors[0]->getCeilingPlane()); } // The fifth "share" argument copies from one side of the line to the // other if (front && back) { int share = line->intProperty("arg4"); if ((share & 3) == 1) back->setFloorPlane(front->getFloorPlane()); else if ((share & 3) == 2) front->setFloorPlane(back->getFloorPlane()); if ((share & 12) == 4) back->setCeilingPlane(front->getCeilingPlane()); else if ((share & 12) == 8) front->setCeilingPlane(back->getCeilingPlane()); } } }