void Bits::set_value(Spot p, int val) {
numbers[idx_of_spot(p)] = val;
int boxid = boxid_of_spot(p);
for(int i=0; i < 9; i++) {
remove_candidate(Spot(p.row, i), val);
remove_candidate(Spot(i, p.col), val);
remove_candidate(spot_of_boxid(boxid, i), val);
}
bits[idx_of_spot(p)] = (1 << (val - 1));
}
// Create a cat, set its age, have it
// meow, tell us its age, then meow again.
int main()
{
Cat Frisky(5);
Frisky.Meow();
std::cout << "Frisky is a cat who is " ;
std::cout << Frisky.GetAge() << " years old.\n";
Frisky.Meow();
Frisky.SetAge(7);
std::cout << "Now Frisky is " ;
std::cout << Frisky.GetAge() << " years old.\n";
//system("PAUSE");
// return 0;
Cat Spot(5);
Spot.Meow();
std::cout << "Spot is a cat who is ";
std::cout << Spot.GetAge() << " years old.\n";
Spot.Meow();
Spot.SetAge(7);
std::cout << "Now Spot is " ;
std::cout << Spot.GetAge() << " years old.\n";
system("PAUSE");
return 0;
}
int Bits::open_bit_of_col(int col) {
int ret = 0;
for(int i=0; i < 9; i++) {
Spot p = Spot(i, col);
if(has_value(p)) { continue; }
ret |= bits[idx_of_spot(p)];
}
return ret;
}
int Bits::open_bit_of_row(int row) {
int ret = 0;
for(int i=0; i < 9; i++) {
Spot p = Spot(row, i);
if(has_value(p)) { continue; }
ret |= bits[idx_of_spot(p)];
}
return ret;
}
std::vector<Spot> Bits::covers_of_spot(Spot p, int val) {
std::vector<Spot> ret;
int boxid = boxid_of_spot(p);
for(int i=0; i < 9; i++) {
Spot boxspot = spot_of_boxid(boxid, i);
Spot rowspot = Spot(p.row, i);
Spot colspot = Spot(i, p.col);
// box
if( get_value(boxspot) == val ) {
ret.push_back(boxspot);
}
if( boxid_of_spot(rowspot) != boxid ) {
if( get_value(rowspot) == val ) {
ret.push_back(rowspot);
}
}
if( boxid_of_spot(colspot) != boxid ) {
if( get_value(colspot) == val ) {
ret.push_back(colspot);
}
}
}
return ret;
}
std::ostream& operator << (std::ostream& os, Grid& grid) {
for(int i=0; i < 9; i++) {
for(int j=0; j < 9; j++) {
int spot = grid.get(Spot(i,j));
if(spot == 0) {
os << ".";
} else {
os << spot;
}
}
//os << std::endl;
}
os << std::endl;
return os;
}
std::ostream& operator << (std::ostream& os, Bits& bits) {
for(int i=0; i < 9; i++) {
for(int j=0; j < 9; j++) {
int spot = bits.get_value(Spot(i,j));
if(spot == 0) {
os << ".";
} else if(spot > 0 && spot <= 9) {
os << spot;
} else {
os << "?";
}
}
}
os << std::endl;
return os;
}
void ControllerManager::setup(Vec2f size, Vec2f single)
{
int id = 0;
for (int y = 0; y < size.y; y += size.y/4) {
for (int x = 0; x < size.x; x += size.x/6) {
mSpots.push_back(Spot(Vec2f(x,y),single,id));
id++;
}
}
mSpots.erase(mSpots.end()-1);
mSpots.erase(mSpots.end()-1);
console() << "Spots: " << mSpots.size() << endl;
for(Spot s : mSpots){
console() << s.getId() << endl;
s.setup();
}
}
std::vector<YWing> find_ywings(Bits* bits) {
std::vector<YWing> ret;
std::vector<Spot> double_spots; // spots with only two candidates
for(int i=0; i < 9; i++) {
for(int j=0; j < 9; j++) {
Spot p = Spot(i, j);
if(bits->count_candidates(p) == 2) {
double_spots.push_back(p);
}
}
}
for(int i=0; i < double_spots.size(); i++){
ywing_process_hinge(bits, double_spots[i], &double_spots, &ret);
}
return ret;
}
bool Bits::valid_now() {
// rows
for(int i=0; i < 9; i++) {
std::vector<bool> exist;
for(int j=0; j < 9; j++) {
exist.push_back(false);
}
for(int j=0; j < 9; j++) {
Spot p = Spot(i, j);
if(has_value(p)) {
int val = get_value(p);
if(exist[val] == false) {
exist[val] == true;
} else {
return false;
}
}
}
}
// cols
for(int i=0; i < 9; i++) {
std::vector<bool> exist;
for(int j=0; j < 9; j++) {
exist.push_back(false);
}
for(int j=0; j < 9; j++) {
Spot p = Spot(j, i);
if(has_value(p)) {
int val = get_value(p);
if(exist[val] == false) {
exist[val] == true;
} else {
return false;
}
}
}
}
// boxes
for(int i=0; i < 9; i++) {
std::vector<bool> exist;
for(int j=0; j < 9; j++) {
exist.push_back(false);
}
for(int j=0; j < 9; j++) {
Spot p = spot_of_boxid(i, j);
if(has_value(p)) {
int val = get_value(p);
if(exist[val] == false) {
exist[val] == true;
} else {
return false;
}
}
}
}
return true;
}
void LPOut::highlight_col(int col, float r, float g, float b) {
highlighted_cols.push_back(Out_Highlight(Spot(0,0), col, r, g, b));
}
void DigitChain::scan_false_color() {
//rows
for(int i=0; i < 9; i++) {
int count_white = 0;
int count_black = 0;
for(int j=0; j < 9; j++) {
int idx = idx_of_digit_vertex(verts, Spot(i, j));
if(idx == -1) { continue; }
if(verts[idx].color == DC_BLACK) {
count_black++;
} else if(verts[idx].color == DC_WHITE) {
count_white++;
}
}
if(count_black > 1) {
black = false;
}
if(count_white > 1) {
white = false;
}
}
//cols
for(int i=0; i < 9; i++) {
int count_white = 0;
int count_black = 0;
for(int j=0; j < 9; j++) {
int idx = idx_of_digit_vertex(verts, Spot(j, i));
if(idx == -1) { continue; }
if(verts[idx].color == DC_BLACK) {
count_black++;
} else if(verts[idx].color == DC_WHITE) {
count_white++;
}
}
if(count_black > 1) {
black = false;
}
if(count_white > 1) {
white = false;
}
}
//boxes
for(int i=0; i < 9; i++) {
int count_white = 0;
int count_black = 0;
for(int j=0; j < 9; j++) {
int idx = idx_of_digit_vertex(verts, spot_of_boxid(i, j));
if(idx == -1) { continue; }
if(verts[idx].color == DC_BLACK) {
count_black++;
} else if(verts[idx].color == DC_WHITE) {
count_white++;
}
}
if(count_black > 1) {
black = false;
}
if(count_white > 1) {
white = false;
}
}
}
DigitVertex::DigitVertex() {
spot = Spot();
color = 0;
peers = std::vector<int>();
links = std::vector<StrongLink>();
}
std::vector<BoxLine> find_boxlines(Bits* bits) {
std::vector<BoxLine> ret;
for(int i = 0; i < 9; i++) {
// for box i
std::vector<Spot> boxspots = spots_of_box(i);
int boxrow = boxspots[0].row;
int boxcol = boxspots[0].col;
// check rows
for(int j=0; j < 3; j++) {
// row is absolute row
int row = boxrow + j;
std::vector<Spot> others;
std::vector<Spot> spots;
std::vector<Spot> empty_spots;
std::vector<Spot> complements;
// classify all necessary spots
for(int k=0; k < 9; k++) {
Spot boxspot = spot_of_boxid(i, k);
Spot rowspot = Spot(row, k);
if(boxid_of_spot(rowspot) != i) {
others.push_back(rowspot);
}
if(boxspot.row == row) {
spots.push_back(boxspot);
if(!bits->has_value(boxspot)) {
empty_spots.push_back(boxspot);
}
} else {
if(!bits->has_value(boxspot)) {
complements.push_back(boxspot);
}
}
}
int emptybits = bits->bit_of_spots(empty_spots);
int otherbits = bits->bit_of_spots(others);
int compbits = bits->bit_of_spots(complements);
int boxedbits = bit_subtract_int(emptybits, otherbits);
if(boxedbits == 0) { continue; }
// we have aligned
int targetbits = boxedbits & compbits;
if(targetbits == 0) { continue; }
// and will remove candidates
std::vector<int> vals = vals_of_int(targetbits);
// identify targets
std::vector<Target> targets;
for(int k=0; k < complements.size(); k++) {
Spot comp = complements[k];
std::vector<int> candidates;
for(int m=0; m < vals.size(); m++) {
int mbit = vals[m];
if(bits->has_candidate(comp, mbit)) {
candidates.push_back(mbit);
}
}
if(candidates.size() > 0) {
targets.push_back(Target(comp, candidates, 0));
}
}
// identify subset
std::vector<Spot> subset;
for(int k=0; k < empty_spots.size(); k++) {
bool part = false;
for(int m=0; m < vals.size(); m++) {
int mbit = vals[m];
if(bits->has_candidate(empty_spots[k], mbit)) {
part = true;
}
}
if(part) {
subset.push_back(empty_spots[k]);
}
}
// identify keys
// OLD NOTE: mostly copied from pointing.cpp
KeyRank keyrank;
for(int k=0; k < others.size(); k++) {
Spot spot = others[k];
for(int m=0; m < vals.size(); m++) {
int mbit = vals[m];
keyrank.add_possible_covers(bits, spot, mbit);
}
}
ret.push_back(BoxLine(targets, keyrank.keys, subset, vals, BOXLINE_ROW));
}
// check cols
for(int j=0; j < 3; j++) {
// col is absolute col
int col = boxcol + j;
std::vector<Spot> others;
std::vector<Spot> spots;
std::vector<Spot> empty_spots;
std::vector<Spot> complements;
// classify all necessary spots
for(int k=0; k < 9; k++) {
Spot boxspot = spot_of_boxid(i, k);
Spot rowspot = Spot(k, col);
if(boxid_of_spot(rowspot) != i) {
others.push_back(rowspot);
}
if(boxspot.col == col) {
spots.push_back(boxspot);
if(!bits->has_value(boxspot)) {
empty_spots.push_back(boxspot);
}
} else {
if(!bits->has_value(boxspot)) {
complements.push_back(boxspot);
}
}
}
int emptybits = bits->bit_of_spots(empty_spots);
int otherbits = bits->bit_of_spots(others);
int compbits = bits->bit_of_spots(complements);
int boxedbits = bit_subtract_int(emptybits, otherbits);
if(boxedbits == 0) { continue; }
// we have aligned
int targetbits = boxedbits & compbits;
if(targetbits == 0) { continue; }
// and will remove candidates
std::vector<int> vals = vals_of_int(targetbits);
// identify targets
std::vector<Target> targets;
for(int k=0; k < complements.size(); k++) {
Spot comp = complements[k];
std::vector<int> candidates;
for(int m=0; m < vals.size(); m++) {
int mbit = vals[m];
if(bits->has_candidate(comp, mbit)) {
candidates.push_back(mbit);
}
}
if(candidates.size() > 0) {
targets.push_back(Target(comp, candidates, 0));
}
}
// identify subset
std::vector<Spot> subset;
for(int k=0; k < empty_spots.size(); k++) {
bool part = false;
for(int m=0; m < vals.size(); m++) {
int mbit = vals[m];
if(bits->has_candidate(empty_spots[k], mbit)) {
part = true;
}
}
if(part) {
subset.push_back(empty_spots[k]);
}
}
// identify keys
// OLD NOTE: mostly copied from pointing.cpp
KeyRank keyrank;
for(int k=0; k < others.size(); k++) {
Spot spot = others[k];
for(int m=0; m < vals.size(); m++) {
int mbit = vals[m];
keyrank.add_possible_covers(bits, spot, mbit);
}
}
ret.push_back(BoxLine(targets, keyrank.keys, subset, vals, BOXLINE_COL));
}
}
return ret;
}
void ywing_process_hinge(Bits* bits, Spot hinge, std::vector<Spot>* double_spots, std::vector<YWing>* ret) {
int hinge_bits = bits->bit_of_spot(hinge);
for(int i=0; i < double_spots->size(); i++) {
Spot wing1 = (*double_spots)[i];
int wing1_bits = bits->bit_of_spot(wing1);
// only consider wings that aren't the hinge, but are visible to the hinge, and have exactly 1 candidate in common with the hinge
if(spot_equal(wing1,hinge) || !spot_visible(wing1,hinge) || count_bits(hinge_bits & wing1_bits) != 1 ) {
continue;
}
for(int j=i+1; j < double_spots->size(); j++) {
Spot wing2 = (*double_spots)[j];
int wing2_bits = bits->bit_of_spot(wing2);
// only consider wings that aren't the hinge, but are visible to the hinge, and have exactly 1 candidate in common with the hinge and the other wing
if(spot_equal(wing2,hinge) || !spot_visible(wing2,hinge) || count_bits(hinge_bits & wing2_bits) != 1 || count_bits(wing1_bits & wing2_bits) != 1 || count_bits(hinge_bits & wing1_bits & wing2_bits) != 0) {
continue;
}
// now we have two unique wings that can see the hinge, and each has only one candidate shared between each other
// the candidate we can exclude is the shared candidate between the two wings
int shared_candidate = first_bits(wing1_bits & wing2_bits);
// determine all spots that are visible to both wing1 and wing2 (same row, column, or box)
std::vector<Spot> shared_spots;
for(int ia=0; ia < 9; ia++) {
for(int ib=0; ib < 9; ib++) {
Spot p = Spot(ia,ib);
// exclude the hinge and wing spots
if(spot_equal(p,hinge) || spot_equal(p,wing1) || spot_equal(p,wing2)) { continue; }
if((p.row == wing1.row || p.col == wing1.col || boxid_of_spot(p) == boxid_of_spot(wing1)) && (p.row == wing2.row || p.col == wing2.col || boxid_of_spot(p) == boxid_of_spot(wing2))) {
shared_spots.push_back(p);
}
}
}
// NOTE: potentially more-efficient version commented out, didn't figure out the best way to make this compile.
// if(wing1.row == wing2.row) {
// shared_spots = spots_union(shared_spots,spots_of_row(wing1.row));
// }
// if(wing1.col == wing2.col) {
// shared_spots = spots_union(shared_spots,spots_of_col(wing1.col));
// }
// if(boxid_of_spot(wing1) == boxid_of_spot(wing2)) {
// shared_spots = spots_union(shared_spots,spots_of_box(boxid_of_spot(wing1)));
// }
// remove any excluded spots (hinge,wings) from our list
// std::vector<Spot> excluded_spots;
// excluded_spots.push_back(hinge);
// excluded_spots.push_back(wing1);
// excluded_spots.push_back(wing2);
// shared_spots = spots_subtract(shared_spots,excluded_spots);
// candidate array (if necessary)
std::vector<int> candidates;
candidates.push_back(shared_candidate);
std::vector<Target> targets;
for(int k=0; k < shared_spots.size(); k++) {
Spot target_spot = shared_spots[k];
if(bits->has_candidate(target_spot,shared_candidate) && bits->count_candidates(target_spot) > 1) {
targets.push_back(Target(target_spot, candidates, 0));
}
}
if(targets.size() > 0) {
KeyRank keyrank;
std::vector<Spot> wings;
wings.push_back(wing1);
wings.push_back(wing2);
ret->push_back(YWing(targets, keyrank.keys, hinge, wings));
}
}
}
}
void LPOut::highlight_row(int row, float r, float g, float b) {
highlighted_rows.push_back(Out_Highlight(Spot(0,0), row, r, g, b));
}
bool TileBuilder::loadMap(uint32 mapID, uint32 tileX, uint32 tileY, MeshData &meshData, Spot portion)
{
char mapFileName[255];
sprintf(mapFileName, "maps/%03u%02u%02u.map", mapID, tileY, tileX);
FILE* mapFile = fopen(mapFileName, "rb");
if(!mapFile)
return true;
GridMapFileHeader fheader;
fread(&fheader, sizeof(GridMapFileHeader), 1, mapFile);
if(fheader.versionMagic != *((uint32 const*)(MAP_VERSION_MAGIC)))
{
fclose(mapFile);
printf("%s is the wrong version, please extract new .map files\n", mapFileName);
return false;
}
GridMapHeightHeader hheader;
fseek(mapFile, fheader.heightMapOffset, SEEK_SET);
fread(&hheader, sizeof(GridMapHeightHeader), 1, mapFile);
bool haveTerrain = !(hheader.flags & MAP_HEIGHT_NO_HEIGHT);
bool haveLiquid = fheader.liquidMapOffset && !m_skipLiquid;
// no data in this map file
if(!haveTerrain && !haveLiquid)
{
fclose(mapFile);
return true;
}
// data used later
uint16 holes[16][16];
uint8* liquid_type = 0;
G3D::Array<int> ltriangles;
G3D::Array<int> ttriangles;
// terrain data
if(haveTerrain)
{
int i;
float heightMultiplier;
float V9[V9_SIZE_SQ], V8[V8_SIZE_SQ];
if(hheader.flags & MAP_HEIGHT_AS_INT8)
{
uint8 v9[V9_SIZE_SQ];
uint8 v8[V8_SIZE_SQ];
fread(v9, sizeof(uint8), V9_SIZE_SQ, mapFile);
fread(v8, sizeof(uint8), V8_SIZE_SQ, mapFile);
heightMultiplier = (hheader.gridMaxHeight - hheader.gridHeight) / 255;
for(i = 0; i < V9_SIZE_SQ; ++i)
V9[i] = (float)v9[i]*heightMultiplier + hheader.gridHeight;
if(m_hiResHeightMaps)
for(i = 0; i < V8_SIZE_SQ; ++i)
V8[i] = (float)v8[i]*heightMultiplier + hheader.gridHeight;
}
else if(hheader.flags & MAP_HEIGHT_AS_INT16)
{
uint16 v9[V9_SIZE_SQ];
uint16 v8[V8_SIZE_SQ];
fread(v9, sizeof(uint16), V9_SIZE_SQ, mapFile);
fread(v8, sizeof(uint16), V8_SIZE_SQ, mapFile);
heightMultiplier = (hheader.gridMaxHeight - hheader.gridHeight) / 65535;
for(i = 0; i < V9_SIZE_SQ; ++i)
V9[i] = (float)v9[i]*heightMultiplier + hheader.gridHeight;
if(m_hiResHeightMaps)
for(i = 0; i < V8_SIZE_SQ; ++i)
V8[i] = (float)v8[i]*heightMultiplier + hheader.gridHeight;
}
else
{
fread(V9, sizeof(float), V9_SIZE_SQ, mapFile);
if(m_hiResHeightMaps)
fread(V8, sizeof(float), V8_SIZE_SQ, mapFile);
}
// hole data
memset(holes, 0, fheader.holesSize);
fseek(mapFile, fheader.holesOffset, SEEK_SET);
fread(holes, fheader.holesSize, 1, mapFile);
int count = meshData.solidVerts.size() / 3;
float xoffset = (float(tileX)-32)*GRID_SIZE;
float yoffset = (float(tileY)-32)*GRID_SIZE;
float coord[3];
for(i = 0; i < V9_SIZE_SQ; ++i)
{
getHeightCoord(i, GRID_V9, xoffset, yoffset, coord, V9);
meshData.solidVerts.append(coord[0]);
meshData.solidVerts.append(coord[2]);
meshData.solidVerts.append(coord[1]);
}
if(m_hiResHeightMaps)
for(i = 0; i < V8_SIZE_SQ; ++i)
{
getHeightCoord(i, GRID_V8, xoffset, yoffset, coord, V8);
meshData.solidVerts.append(coord[0]);
meshData.solidVerts.append(coord[2]);
meshData.solidVerts.append(coord[1]);
}
int triInc, j, indices[3], loopStart, loopEnd, loopInc;
getLoopVars(portion, loopStart, loopEnd, loopInc);
triInc = m_hiResHeightMaps ? 1 : BOTTOM-TOP;
for(i = loopStart; i < loopEnd; i+=loopInc)
for(j = TOP; j <= BOTTOM; j+=triInc)
{
getHeightTriangle(i, Spot(j), indices);
ttriangles.append(indices[2] + count);
ttriangles.append(indices[1] + count);
ttriangles.append(indices[0] + count);
}
}
// liquid data
if(haveLiquid)
{
do
{
GridMapLiquidHeader lheader;
fseek(mapFile, fheader.liquidMapOffset, SEEK_SET);
fread(&lheader, sizeof(GridMapLiquidHeader), 1, mapFile);
float* liquid_map = 0;
if (!(lheader.flags & MAP_LIQUID_NO_TYPE))
{
liquid_type = new uint8 [16*16];
fread(liquid_type, sizeof(uint8), 16*16, mapFile);
}
if (!(lheader.flags & MAP_LIQUID_NO_HEIGHT))
{
liquid_map = new float [lheader.width*lheader.height];
fread(liquid_map, sizeof(float), lheader.width*lheader.height, mapFile);
}
if(!liquid_type && !liquid_map)
break;
int count = meshData.liquidVerts.size() / 3;
float xoffset = (float(tileX)-32)*GRID_SIZE;
float yoffset = (float(tileY)-32)*GRID_SIZE;
float coord[3];
int row, col;
// generate coordinates
if (!(lheader.flags & MAP_LIQUID_NO_HEIGHT))
{
int j = 0;
for(int i = 0; i < V9_SIZE_SQ; ++i)
{
row = i / V9_SIZE;
col = i % V9_SIZE;
if((row < (lheader.offsetY) || row >= (lheader.offsetY + lheader.height)) ||
(col < (lheader.offsetX) || col >= (lheader.offsetX + lheader.width)))
{
// dummy vert using invalid height
meshData.liquidVerts.append((xoffset+col*GRID_PART_SIZE)*-1, -500.f, (yoffset+row*GRID_PART_SIZE)*-1);
continue;
}
getLiquidCoord(i, j, xoffset, yoffset, coord, liquid_map);
meshData.liquidVerts.append(coord[0]);
meshData.liquidVerts.append(coord[2]);
meshData.liquidVerts.append(coord[1]);
j++;
}
}
else
{
for(int i = 0; i < V9_SIZE_SQ; ++i)
{
row = i / V9_SIZE;
col = i % V9_SIZE;
meshData.liquidVerts.append((xoffset+col*GRID_PART_SIZE)*-1, lheader.liquidLevel, (yoffset+row*GRID_PART_SIZE)*-1);
}
}
delete [] liquid_map;
int indices[3], loopStart, loopEnd, loopInc, triInc;
getLoopVars(portion, loopStart, loopEnd, loopInc);
triInc = BOTTOM-TOP;
// generate triangles
for(int i = loopStart; i < loopEnd; i+=loopInc)
for(int j = TOP; j <= BOTTOM; j+= triInc)
{
getHeightTriangle(i, Spot(j), indices, true);
ltriangles.append(indices[2] + count);
ltriangles.append(indices[1] + count);
ltriangles.append(indices[0] + count);
}
}while(0);
}
fclose(mapFile);
// now that we have gathered the data, we can figure out which parts to keep:
// liquid above ground
// ground above any liquid type
// ground below <1.5 yard of water
int loopStart, loopEnd, loopInc, tTriCount;
bool useTerrain, useLiquid;
float* lverts = meshData.liquidVerts.getCArray();
float* tverts = meshData.solidVerts.getCArray();
int* ltris = ltriangles.getCArray();
int* ttris = ttriangles.getCArray();
getLoopVars(portion, loopStart, loopEnd, loopInc);
tTriCount = m_hiResHeightMaps ? 4 : 2;
if(ltriangles.size() || ttriangles.size())
{
for(int i = loopStart; i < loopEnd; i+=loopInc)
{
for(int j = 0; j < 2; ++j)
{
// default is true, will change to false if needed
useTerrain = true;
useLiquid = true;
uint8 liquidType;
// if there is no liquid, don't use liquid
if(!liquid_type ||
!meshData.liquidVerts.size() ||
!ltriangles.size())
useLiquid = false;
else
{
liquidType = getLiquidType(i, (const uint8 (*)[16])liquid_type);
switch(liquidType)
{
case 0:
// unknown liquid gets no terrain type
liquidType = 0;
break;
case MAP_LIQUID_TYPE_WATER:
case MAP_LIQUID_TYPE_OCEAN:
// merge different types of water
liquidType = NAV_WATER;
break;
case MAP_LIQUID_TYPE_MAGMA:
liquidType = NAV_MAGMA;
break;
case MAP_LIQUID_TYPE_SLIME:
liquidType = NAV_SLIME;
break;
case MAP_LIQUID_TYPE_DARK_WATER:
// players should not be here, so logically neither should creatures
useTerrain = false;
useLiquid = false;
break;
}
}
// if there is no terrain, don't use terrain
if(!ttriangles.size())
useTerrain = false;
// liquid is rendered as quads. If any triangle has invalid height,
// don't render any of the triangles in that quad
// contrib/extractor uses -500.0 for invalid height
if(useLiquid)
if((&lverts[ltris[0]*3])[1] == -500.f ||
(&lverts[ltris[1]*3])[1] == -500.f ||
(&lverts[ltris[2]*3])[1] == -500.f)
{
useLiquid = false;
}
// if there is a hole here, don't use the terrain
if(useTerrain)
useTerrain = !isHole(i, holes);
if(useTerrain && useLiquid)
{
// get the indexes of the corners of the quad
int idx1, idx2, idx3;
if(j == 0)
{
idx1 = 0;
idx2 = 1;
idx3 = tTriCount; // accesses index from next triangle on low res
}
else
{
idx1 = 0;
idx2 = 3*tTriCount/2-2;
idx3 = 3*tTriCount/2-1;
}
if(useTerrain &&
(&lverts[ltris[0]*3])[1] - 1.5f > (&tverts[ttris[idx1]*3])[1] &&
(&lverts[ltris[1]*3])[1] - 1.5f > (&tverts[ttris[idx2]*3])[1] &&
(&lverts[ltris[2]*3])[1] - 1.5f > (&tverts[ttris[idx3]*3])[1])
useTerrain = false; // if the whole terrain triangle is 1.5yds under liquid, don't use it
else if(useLiquid &&
(&lverts[ltris[0]*3])[1] < (&tverts[ttris[idx1]*3])[1] &&
(&lverts[ltris[1]*3])[1] < (&tverts[ttris[idx2]*3])[1] &&
(&lverts[ltris[2]*3])[1] < (&tverts[ttris[idx3]*3])[1])
useLiquid = false; // if the whole liquid triangle is under terrain, don't use it
}
if(useLiquid)
{
meshData.liquidType.append(liquidType);
for(int k = 0; k < 3; ++k)
meshData.liquidTris.append(ltris[k]);
}
if(useTerrain)
for(int k = 0; k < 3*tTriCount/2; ++k)
meshData.solidTris.append(ttris[k]);
// advance to next set of triangles
ltris += 3;
ttris += 3*tTriCount/2;
}
}
}
delete [] liquid_type;
return true;
}
void LPOut::highlight_box(int boxid, float r, float g, float b) {
highlighted_boxes.push_back(Out_Highlight(Spot(0,0), boxid, r, g, b));
}
Key::Key() {
spot = Spot();
multiplicity = 1;
}
