int main ()
{
//Remove shared memory on construction and destruction
struct shm_remove
{
//<-
#if 1
shm_remove() { shared_memory_object::remove(test::get_process_id_name()); }
~shm_remove(){ shared_memory_object::remove(test::get_process_id_name()); }
#else
//->
shm_remove() { shared_memory_object::remove("MySharedMemory"); }
~shm_remove(){ shared_memory_object::remove("MySharedMemory"); }
//<-
#endif
//->
} remover;
//<-
#if 1
managed_shared_memory segment(
create_only,
test::get_process_id_name(), //segment name
65536); //segment size in bytes
#else
//->
managed_shared_memory segment(
create_only,
"MySharedMemory", //segment name
65536); //segment size in bytes
//<-
#endif
//->
//Construct shared memory vector
MyVector *myvector =
segment.construct<MyVector>("MyVector")
(IntAllocator(segment.get_segment_manager()));
//Fill vector
myvector->reserve(100);
for(int i = 0; i < 100; ++i){
myvector->push_back(i);
}
//Create the vectorstream. To create the internal shared memory
//basic_string we need to pass the shared memory allocator as
//a constructor argument
MyVectorStream myvectorstream(CharAllocator(segment.get_segment_manager()));
//Reserve the internal string
myvectorstream.reserve(100*5);
//Write all vector elements as text in the internal string
//Data will be directly written in shared memory, because
//internal string's allocator is a shared memory allocator
for(std::size_t i = 0, max = myvector->size(); i < max; ++i){
myvectorstream << (*myvector)[i] << std::endl;
}
//Auxiliary vector to compare original data
MyVector *myvector2 =
segment.construct<MyVector>("MyVector2")
(IntAllocator(segment.get_segment_manager()));
//Avoid reallocations
myvector2->reserve(100);
//Extract all values from the internal
//string directly to a shared memory vector.
std::istream_iterator<int> it(myvectorstream), itend;
std::copy(it, itend, std::back_inserter(*myvector2));
//Compare vectors
assert(std::equal(myvector->begin(), myvector->end(), myvector2->begin()));
//Create a copy of the internal string
MyString stringcopy (myvectorstream.vector());
//Now we create a new empty shared memory string...
MyString *mystring =
segment.construct<MyString>("MyString")
(CharAllocator(segment.get_segment_manager()));
//...and we swap vectorstream's internal string
//with the new one: after this statement mystring
//will be the owner of the formatted data.
//No reallocations, no data copies
myvectorstream.swap_vector(*mystring);
//Let's compare both strings
assert(stringcopy == *mystring);
//Done, destroy and delete vectors and string from the segment
segment.destroy_ptr(myvector2);
segment.destroy_ptr(myvector);
segment.destroy_ptr(mystring);
return 0;
}
int main()
{
// Create a default vector
MyVector sam;
// push some data into sam
cout << "\nPushing three values into sam";
sam.push_back(TEST_VALUE1);
sam.push_back(TEST_VALUE2);
sam.push_back(TEST_VALUE3);
cout << "\nThe values in sam are: ";
// test for out of bounds condition here
// and test exception
for (int i = 0; i < sam.size() + 1; i++)
{
try
{
cout << sam.at(i) << " ";
}
catch (int badIndex)
{
cout << "\nOut of bounds at index " << badIndex << endl;
}
}
cout << "\n--------------\n";
// clear sam and display its size and capacity
sam.clear();
cout << "\nsam has been cleared.";
cout << "\nSam's size is now " << sam.size();
cout << "\nSam's capacity is now " << sam.capacity() << endl;
cout << "---------------\n";
// Push 12 values into the vector - it should grow
cout << "\nPush 12 values into sam.";
for (int i = 0; i < MAX; i++)
sam.push_back(i);
cout << "\nSam's size is now " << sam.size();
cout << "\nSam's capcacity is now " << sam.capacity() << endl;
cout << "---------------\n";
cout << "\nTest to see if contents are correct...";
// display the values in the vector
for (int i = 0; i < sam.size(); i++)
{
cout << sam.at(i) << " ";
}
cout << "\n--------------\n";
cout << "\n\nTest Complete...";
cout << endl;
system("PAUSE");
return 0;
}
//Main function. For parent process argc == 1, for child process argc == 2
int main(int argc, char *argv[])
{
if(argc == 1){ //Parent process
//Remove shared memory on construction and destruction
struct shm_remove
{
//<-
#if 1
shm_remove() { shared_memory_object::remove(test::get_process_id_name()); }
~shm_remove(){ shared_memory_object::remove(test::get_process_id_name()); }
#else
//->
shm_remove() { shared_memory_object::remove("MySharedMemory"); }
~shm_remove(){ shared_memory_object::remove("MySharedMemory"); }
//<-
#endif
//->
} remover;
//<-
(void)remover;
//->
//Create a new segment with given name and size
//<-
#if 1
managed_shared_memory segment(create_only, test::get_process_id_name(), 65536);
#else
//->
managed_shared_memory segment(create_only, "MySharedMemory", 65536);
//<-
#endif
//->
//Initialize shared memory STL-compatible allocator
const ShmemAllocator alloc_inst (segment.get_segment_manager());
//Construct a vector named "MyVector" in shared memory with argument alloc_inst
MyVector *myvector = segment.construct<MyVector>("MyVector")(alloc_inst);
for(int i = 0; i < 100; ++i) //Insert data in the vector
myvector->push_back(i);
//Launch child process
std::string s(argv[0]); s += " child ";
//<-
s += test::get_process_id_name();
//->
if(0 != std::system(s.c_str()))
return 1;
//Check child has destroyed the vector
if(segment.find<MyVector>("MyVector").first)
return 1;
}
else{ //Child process
//Open the managed segment
//<-
#if 1
managed_shared_memory segment(open_only, argv[2]);
#else
//->
managed_shared_memory segment(open_only, "MySharedMemory");
//<-
#endif
//->
//Find the vector using the c-string name
MyVector *myvector = segment.find<MyVector>("MyVector").first;
//Use vector in reverse order
std::sort(myvector->rbegin(), myvector->rend());
//When done, destroy the vector from the segment
segment.destroy<MyVector>("MyVector");
}
return 0;
};
int main ()
{
using namespace boost::interprocess;
//Remove shared memory on construction and destruction
struct shm_remove
{
//<-
#if 1
shm_remove() {
shared_memory_object::remove(test::get_process_id_name());
}
~shm_remove() {
shared_memory_object::remove(test::get_process_id_name());
}
#else
//->
shm_remove() {
shared_memory_object::remove("MySharedMemory");
}
~shm_remove() {
shared_memory_object::remove("MySharedMemory");
}
//<-
#endif
//->
} remover;
//A managed shared memory where we can construct objects
//associated with a c-string
//<-
#if 1
managed_shared_memory segment(create_only,test::get_process_id_name(), 65536);
#else
//->
managed_shared_memory segment(create_only,
"MySharedMemory", //segment name
65536);
//<-
#endif
//->
//Alias an STL-like allocator of ints that allocates ints from the segment
typedef allocator<int, managed_shared_memory::segment_manager>
ShmemAllocator;
//Alias a vector that uses the previous STL-like allocator
typedef vector<int, ShmemAllocator> MyVector;
int initVal[] = {0, 1, 2, 3, 4, 5, 6 };
const int *begVal = initVal;
const int *endVal = initVal + sizeof(initVal)/sizeof(initVal[0]);
//Initialize the STL-like allocator
const ShmemAllocator alloc_inst (segment.get_segment_manager());
//Construct the vector in the shared memory segment with the STL-like allocator
//from a range of iterators
MyVector *myvector =
segment.construct<MyVector>
("MyVector")/*object name*/
(begVal /*first ctor parameter*/,
endVal /*second ctor parameter*/,
alloc_inst /*third ctor parameter*/);
//Use vector as your want
std::sort(myvector->rbegin(), myvector->rend());
// . . .
//When done, destroy and delete vector from the segment
segment.destroy<MyVector>("MyVector");
return 0;
}
int main() {
const std::string Help =
"-------------------------------------------------------------------------\n"
"TestComputeAKV: \n"
"-------------------------------------------------------------------------\n"
"OPTIONS: \n"
"Nth=<int> theta resolution [default 3] \n"
"Nph=<int> phi resolution [default 4] \n"
"Radius=<double> radius of sphere. [default 1.0] \n"
"AKVGuess=MyVector<double> a guess for the values of THETA, thetap, phip \n"
" [default (0.,0.,0.)] \n"
"L_resid_tol=<double> tolerance for L residuals when finding approximate \n"
" Killing vectors. [default 1.e-12] \n"
"v_resid_tol=<double> tolerance for v residuals when finding approximate \n"
" Killing vectors. [default 1.e-12] \n"
"min_thetap = for values less than this, thetap is considered close to \n"
" zero. [default 1.e-5] \n"
"symmetry_tol=<double> abs(THETA) must be less than this value to be \n"
" considered an exact symmetry. [default 1.e-11] \n"
"ResidualSize=<double> determines the tolerance for residuals from the \n"
" multidimensional root finder. [default to 1.e-11] \n"
"Solver = <std::string> which gsl multidimensional root finding algorith \n"
" should be used. [default Newton] \n"
"Verbose=<bool> Print spectral coefficients and warnings if true \n"
" [default false] \n"
;
std::string Options = ReadFileIntoString("Test.input");
OptionParser op(Options,Help);
const int Nth = op.Get<int>("Nth", 3);
const int Nph = op.Get<int>("Nph", 4);
const double rad = op.Get<double>("Radius",1.0);
MyVector<double> AKVGuess =
op.Get<MyVector<double> >("AKVGuess",MyVector<double>(MV::Size(3),0.0));
//must be three-dimensional
REQUIRE(AKVGuess.Size()==3,"AKVGuess has Size " << AKVGuess.Size()
<< ", should be 3.");
const double L_resid_tol = op.Get<double>("L_resid_tol", 1.e-12);
const double v_resid_tol = op.Get<double>("L_resid_tol", 1.e-12);
const double residualSize = op.Get<double>("ResidualSize", 1.e-11);
const double min_thetap = op.Get<double>("min_theta",1.e-5);
const double symmetry_tol = op.Get<double>("symmetry_tol",1.e-11);
const std::string solver = op.Get<std::string>("Solver","Newton");
const bool verbose = op.Get<bool>("Verbose", false);
const MyVector<bool> printDiagnostic = MyVector<bool>(MV::Size(6), true);
//create skm
const StrahlkorperMesh skm(Nth, Nph);
//create surface basis
const SurfaceBasis sb(skm);
//get theta, phi
const DataMesh theta(skm.SurfaceCoords()(0));
const DataMesh phi(skm.SurfaceCoords()(1));
//set the initial guesses to be along particular axes
const int axes = 3; //the number of perpendicular axes
//create conformal factors for every rotation
const int syms = 5; //the number of axisymmetries we are testing
for(int s=4; s<5; s++) { //index over conformal factor symmetries
//for(int s=0; s<syms; s++){//index over conformal factor symmetries
//create conformal factor
const DataMesh Psi = ConstructConformalFactor(theta, phi, s);
//set the initial guesses
double THETA[3] = {AKVGuess[0],0.,0.};
double thetap[3] = {AKVGuess[1],0.,0.};
double phip[3] = {AKVGuess[2],0.,0.};
//save the v, xi solutions along particular axes
MyVector<DataMesh> v(MV::Size(3),DataMesh::Empty);
MyVector<DataMesh> rotated_v(MV::Size(3),DataMesh::Empty);
MyVector<Tensor<DataMesh> > xi(MV::Size(axes),Tensor<DataMesh>(2,"1",DataMesh::Empty));
//save the <v_i|v_j> inner product solutions
double v0v0 = 0.;
double v1v1 = 0.;
double v2v2 = 0.;
double v0v1 = 0.;
double v0v2 = 0.;
double v1v2 = 0.;
//int symmetries[3] = 0; //counts the number of symmetries
//compute some useful quantities
const DataMesh rp2 = rad * Psi * Psi;
const DataMesh r2p4 = rp2*rp2;
const DataMesh llncf = sb.ScalarLaplacian(log(Psi));
const DataMesh Ricci = 2.0 * (1.0-2.0*llncf) / r2p4;
const Tensor<DataMesh> GradRicci = sb.Gradient(Ricci);
for(int a=0; a<axes; a++) { //index over perpendicular axes to find AKV solutions
//if the diagnostics below decide that there is a bad solution for v[a]
//(usually a repeated solution), this flag will indicate that the
//solver should be run again
bool badAKVSolution = false;
//generate a guess for the next axis of symmetry based on prior solutions.
AxisInitialGuess(thetap, phip, a);
//create L
DataMesh L(DataMesh::Empty);
//setup struct with all necessary data
rparams p = {theta, phi, rp2, sb, llncf, GradRicci,
L, v[a], L_resid_tol, v_resid_tol, verbose, true
};
RunAKVsolvers(THETA[a], thetap[a], phip[a], min_thetap,
residualSize, verbose, &p, solver);
std::cout << "Solution found with : THETA[" << a << "] = " << THETA[a] << "\n"
<< " thetap[" << a << "] = " << (180.0/M_PI)*thetap[a] << "\n"
<< " phip[" << a << "] = " << (180.0/M_PI)*phip[a]
<< std::endl;
//check inner products
// <v_i|v_j> = Integral 0.5 * Ricci * Grad(v_i) \cdot Grad(v_j) dA
switch(a) {
case 0:
//compute inner product <v_0|v_0>
v0v0 = AKVInnerProduct(v[0],v[0],Ricci,sb)*sqrt(2.)*M_PI;
//if(v0v0<symmetry_tol) //symmetries++;
std::cout << "<v_0|v_0> = " << v0v0 << std::endl;
std::cout << "-THETA <v_0|v_0> = " << -THETA[a]*v0v0 << std::endl;
break;
case 1:
//compute inner products <v_1|v_1>, <v_0|v_1>
v1v1 = AKVInnerProduct(v[1],v[1],Ricci,sb)*sqrt(2.)*M_PI;
v0v1 = AKVInnerProduct(v[0],v[1],Ricci,sb)*sqrt(2.)*M_PI;
//if(v1v1<symmetry_tol) //symmetries++;
std::cout << "<v_1|v_1> = " << v1v1 << std::endl;
std::cout << "<v_0|v_1> = " << v0v1 << std::endl;
std::cout << "-THETA <v_1|v_1> = " << -THETA[a]*v1v1 << std::endl;
if(fabs(v0v0) == fabs(v1v2)) badAKVSolution = true;
break;
case 2:
//compute inner products <v_2|v_2>, <v_0|v_2>, <v_1|v_2>
v2v2 = AKVInnerProduct(v[2],v[2],Ricci,sb)*sqrt(2.)*M_PI;
v0v2 = AKVInnerProduct(v[0],v[2],Ricci,sb)*sqrt(2.)*M_PI;
v1v2 = AKVInnerProduct(v[1],v[2],Ricci,sb)*sqrt(2.)*M_PI;
//if(v2v2<symmetry_tol) //symmetries++;
std::cout << "<v_2|v_2> = " << v2v2 << std::endl;
std::cout << "<v_0|v_2> = " << v0v2 << std::endl;
std::cout << "<v_1|v_2> = " << v1v2 << std::endl;
std::cout << "-THETA <v_2|v_2> = " << -THETA[a]*v2v2 << std::endl;
if(fabs(v0v0) == fabs(v0v2)) badAKVSolution = true;
if(fabs(v1v1) == fabs(v1v2)) badAKVSolution = true;
break;
}
//Gram Schmidt orthogonalization
switch(a) {
case 1:
if(v0v0<symmetry_tol && v1v1<symmetry_tol) { //two symmetries, v2v2 should also be symmetric
GramSchmidtOrthogonalization(v[0], v0v0, v[1], v0v1);
}
break;
case 2:
if(v0v0<symmetry_tol) {
if(v1v1<symmetry_tol) {
REQUIRE(v2v2<symmetry_tol, "Three symmetries required, but only two found.");
GramSchmidtOrthogonalization(v[0], v0v0, v[2], v0v2);
GramSchmidtOrthogonalization(v[1], v1v1, v[2], v1v2);
} else if(v2v2<symmetry_tol) {
REQUIRE(false, "Three symmetries required, but only two found.");
} else {
GramSchmidtOrthogonalization(v[1], v1v1, v[2], v1v2);
}
} else if(v1v1<symmetry_tol) {
if(v2v2<symmetry_tol) {
REQUIRE(false, "Three symmetries required, but only two found.");
} else {
GramSchmidtOrthogonalization(v[0], v0v0, v[2], v0v2);
}
} else if(v2v2<symmetry_tol) {
GramSchmidtOrthogonalization(v[0], v0v0, v[1], v0v1);
}
break;
}
//create xi (1-form)
xi[a] = ComputeXi(v[a], sb);
//perform diagnostics
//Psi and xi are unscaled and unrotated
KillingDiagnostics(sb, L, Psi, xi[a], rad, printDiagnostic);
//rotate v, Psi for analysis
rotated_v[a] = RotateOnSphere(v[a],theta,phi,
sb,thetap[a],phip[a]);
DataMesh rotated_Psi = RotateOnSphere(Psi,theta,phi,
sb,thetap[a],phip[a]);
//compare scale factors
const double scaleAtEquator =
NormalizeAKVAtOnePoint(sb, rotated_Psi, rotated_v[a], rad, M_PI/2., 0.0);
PrintSurfaceNormalization(sb,rotated_Psi,theta,phi,rotated_v[a],scaleAtEquator,rad);
MyVector<double> scaleInnerProduct = InnerProductScaleFactors(v[a], v[a], Ricci, r2p4, sb);
PrintSurfaceNormalization(sb,rotated_Psi,theta,phi,rotated_v[a],scaleInnerProduct[0],rad);
PrintSurfaceNormalization(sb,rotated_Psi,theta,phi,rotated_v[a],scaleInnerProduct[1],rad);
PrintSurfaceNormalization(sb,rotated_Psi,theta,phi,rotated_v[a],scaleInnerProduct[2],rad);
OptimizeScaleFactor(rotated_v[a], rotated_Psi, rad, sb, theta,
phi, scaleAtEquator, scaleInnerProduct[0], scaleInnerProduct[1], scaleInnerProduct[2]);
//scale v
v[a] *= scaleAtEquator;
//recompute scaled xi (1-form)
xi[a] = ComputeXi(v[a], sb);
if(badAKVSolution) {
v[a] = 0.;
thetap[a] += M_PI/4.;
phip[a] += M_PI/4.;
a--;
std::cout << "This was a bad / repeated solution, and will be recomputed." << std::endl;
}
std::cout << std::endl;
}//end loop over perpendicular AKV axes
std::cout << "\n" << std::endl;
}
// Return 0 for success
return NumberOfTestsFailed;
}
uint64_t count64() {
MessageHandler mh;
mh.begin("counting") << " paths of " << typenameof(spec);
std::vector<Word> tmp(stateWords + 1);
Word* ptmp = tmp.data();
int const n = spec.get_root(state(ptmp));
if (n <= 0) {
mh << " ...";
mh.end(0);
return (n == 0) ? 0 : 1;
}
mh << "\n";
uint64_t total = 0;
size_t maxWidth = 0;
//std::cerr << "\nLevel,Width\n";
std::vector<MemoryPool> pools(n + 1);
MyVector<MyList<Word> > vnodeTable(n + 1);
MyVector<UniqTable> uniqTable;
uniqTable.reserve(n + 1);
for (int i = 0; i <= n; ++i) {
uniqTable.push_back(UniqTable(hasher, hasher));
}
Word* p0 = vnodeTable[n].alloc_front(stateWords + 1);
spec.get_copy(state(p0), state(ptmp));
spec.destruct(state(ptmp));
number64(p0) = 1;
for (int i = n; i > 0; --i) {
MyList<Word>& vnodes = vnodeTable[i];
size_t m = vnodes.size();
//std::cerr << i << "," << m << "\n";
maxWidth = std::max(maxWidth, m);
MyList<Word>& nextVnodes = vnodeTable[i - 1];
UniqTable& nextUniq = uniqTable[i - 1];
Word* pp = nextVnodes.alloc_front(stateWords + 1);
//if (nextUniq.size() < m) nextUniq.rehash(m);
for (; !vnodes.empty(); vnodes.pop_front()) {
Word* p = vnodes.front();
if (number64(p) == 0) {
spec.destruct(state(p));
continue;
}
for (int b = 0; b <= 1; ++b) {
spec.get_copy(state(pp), state(p));
int ii = spec.get_child(state(pp), i, b);
if (ii <= 0) {
spec.destruct(state(pp));
if (ii != 0) {
total += number64(p);
}
}
else if (ii < i - 1) {
Word* qq = vnodeTable[ii].alloc_front(stateWords + 1);
spec.get_copy(state(qq), state(pp));
spec.destruct(state(pp));
Word* qqq = uniqTable[ii].add(qq);
if (qqq == qq) {
number64(qqq) = number64(p);
}
else {
spec.destruct(state(qq));
number64(qqq) += number64(p);
vnodeTable[ii].pop_front();
}
}
else {
assert(ii == i - 1);
Word* ppp = nextUniq.add(pp);
if (ppp == pp) {
number64(ppp) = number64(p);
pp = nextVnodes.alloc_front(stateWords + 1);
}
else {
spec.destruct(state(pp));
number64(ppp) += number64(p);
}
}
}
spec.destruct(state(p));
}
nextVnodes.pop_front();
nextUniq.clear();
pools[i].clear();
spec.destructLevel(i);
mh << ".";
}
mh.end(maxWidth);
return total;
}
std::string count() {
MessageHandler mh;
mh.begin("counting") << " paths of " << typenameof(spec);
std::vector<Word> tmp(stateWords + 1);
Word* ptmp = tmp.data();
int const n = spec.get_root(state(ptmp));
if (n <= 0) {
mh << " ...";
mh.end(0);
return (n == 0) ? "0" : "1";
}
uint64_t totalStorage[n / 63 + 1];
BigNumber total(totalStorage);
total.store(0);
size_t maxWidth = 0;
//std::cerr << "\nLevel,Width\n";
std::vector<MemoryPool> pools(n + 1);
MyVector<MyList<Word> > vnodeTable(n + 1);
MyVector<UniqTable> uniqTable;
uniqTable.reserve(n + 1);
for (int i = 0; i <= n; ++i) {
uniqTable.push_back(UniqTable(hasher, hasher));
}
int numberWords = 1;
Word* p0 = vnodeTable[n].alloc_front(stateWords + 1);
spec.get_copy(state(p0), state(ptmp));
spec.destruct(state(ptmp));
number(p0).store(1);
mh.setSteps(n);
for (int i = n; i > 0; --i) {
MyList<Word>& vnodes = vnodeTable[i];
size_t m = vnodes.size();
//std::cerr << i << "," << m << "\n";
maxWidth = std::max(maxWidth, m);
MyList<Word>& nextVnodes = vnodeTable[i - 1];
UniqTable& nextUniq = uniqTable[i - 1];
int const nextWords = stateWords + numberWords + 1;
Word* pp = nextVnodes.alloc_front(nextWords);
//if (nextUniq.size() < m) nextUniq.rehash(m);
for (; !vnodes.empty(); vnodes.pop_front()) {
Word* p = vnodes.front();
if (number(p).equals(0)) {
spec.destruct(state(p));
continue;
}
for (int b = 0; b <= 1; ++b) {
spec.get_copy(state(pp), state(p));
int ii = spec.get_child(state(pp), i, b);
if (ii <= 0) {
spec.destruct(state(pp));
if (ii != 0) {
total.add(number(p));
}
}
else if (ii < i - 1) {
Word* qq = vnodeTable[ii].alloc_front(
nextWords + (i - ii) / 63);
spec.get_copy(state(qq), state(pp));
spec.destruct(state(pp));
Word* qqq = uniqTable[ii].add(qq);
if (qqq == qq) {
number(qqq).store(number(p));
}
else {
spec.destruct(state(qq));
int w = number(qqq).add(number(p));
if (numberWords < w) {
numberWords = w; //FIXME might be broken at long skip
}
vnodeTable[ii].pop_front();
}
}
else {
assert(ii == i - 1);
Word* ppp = nextUniq.add(pp);
if (ppp == pp) {
number(ppp).store(number(p));
pp = nextVnodes.alloc_front(nextWords);
}
else {
spec.destruct(state(pp));
int w = number(ppp).add(number(p));
if (numberWords < w) {
numberWords = w; //FIXME might be broken at long skip
}
}
}
}
spec.destruct(state(p));
}
nextVnodes.pop_front();
nextUniq.clear();
pools[i].clear();
spec.destructLevel(i);
mh.step();
}
mh.end(maxWidth);
return total;
}
void DrawMissiles(vector<missile*> missiles, myVertex* terrainVertex, Spiders* spiders){
vector<missile*>::iterator it;
vector<int> needToExit;
int i = 0, j = 0;
float tmpSize;
for (it = missiles.begin(); it != missiles.end(); it++){
if ((*it)->needToExit()){
continue;
}
float terrainY = getYFromXZ ((*it)->getX(), (*it)->getZ(), terrainVertex);
if ((*it)->isColliding(terrainY)){
//Utilize "explode XX.tga"
if (explodeModeFlag){
if (!(*it)->tgaNeedToExit()){
(*it)->tgaExplode();
}
else{
needToExit.push_back(i);
}
}
//Utilize "fire1.bmp"
else{
if (!(*it)->needToExit()){
(*it)->explode();
}
else{
needToExit.push_back(i);
}
}
tmpSize = 0;
MyVector tmpPos = MyVectorBuilder::createMyVectorBuilder()
.withX((*it)->getX())
.withY(0)
.withZ((*it)->getZ())
.build();
if ((*it)->getExplodeFrame() == 2){
for (j = 0; j<(int)spiders->getSpiderList().size();j++){
tmpSize = spiders->getSpiderList().at(i).getSize();
if (abs((*it)->getX() - spiders->getSpiderList().at(j).getPosition().getX()) > tmpSize + 20){
continue;
}
if (abs((*it)->getZ() - spiders->getSpiderList().at(j).getPosition().getZ()) > tmpSize + 20){
continue;
}
if (tmpPos.distance(spiders->getSpiderList().at(j).getPosition()) < tmpSize + 20){
spiders->die(j, 1);
}
}
}
}
else{
(*it)->drawMissile();
(*it)->forward();
}
i++;
}
//clear missiles that already exit
//sort (needToExit.begin(), needToExit.end(), myfunction);
//for (i = 0; i < needToExit.size(); i++){
// missiles.erase(missiles.begin()+needToExit.at(i)-i);
//}
//needToExit.clear();
}
// This tests basic segmented vector construction and iteration.
void TestBasics()
{
// A SegmentedVector with a POD element type.
typedef SegmentedVector<int, 1024, InfallibleAllocPolicy> MyVector;
MyVector v;
int i, n;
MOZ_RELEASE_ASSERT(v.IsEmpty());
// Add 100 elements, then check various things.
i = 0;
for ( ; i < 100; i++) {
gDummy = v.Append(mozilla::Move(i));
}
MOZ_RELEASE_ASSERT(!v.IsEmpty());
MOZ_RELEASE_ASSERT(v.Length() == 100);
n = 0;
for (auto iter = v.Iter(); !iter.Done(); iter.Next()) {
MOZ_RELEASE_ASSERT(iter.Get() == n);
n++;
}
MOZ_RELEASE_ASSERT(n == 100);
// Add another 900 elements, then re-check.
for ( ; i < 1000; i++) {
v.InfallibleAppend(mozilla::Move(i));
}
MOZ_RELEASE_ASSERT(!v.IsEmpty());
MOZ_RELEASE_ASSERT(v.Length() == 1000);
n = 0;
for (auto iter = v.Iter(); !iter.Done(); iter.Next()) {
MOZ_RELEASE_ASSERT(iter.Get() == n);
n++;
}
MOZ_RELEASE_ASSERT(n == 1000);
// Pop off all of the elements.
MOZ_RELEASE_ASSERT(v.Length() == 1000);
for (int len = (int)v.Length(); len > 0; len--) {
MOZ_RELEASE_ASSERT(v.GetLast() == len - 1);
v.PopLast();
}
MOZ_RELEASE_ASSERT(v.IsEmpty());
MOZ_RELEASE_ASSERT(v.Length() == 0);
// Fill the vector up again to prepare for the clear.
for (i = 0; i < 1000; i++) {
v.InfallibleAppend(mozilla::Move(i));
}
MOZ_RELEASE_ASSERT(!v.IsEmpty());
MOZ_RELEASE_ASSERT(v.Length() == 1000);
v.Clear();
MOZ_RELEASE_ASSERT(v.IsEmpty());
MOZ_RELEASE_ASSERT(v.Length() == 0);
}
// no need for origin but here to remind that this will give X and Y offset to the point from
// the same center used as polar origin
// <!> have to make it consistent with (i,j) orientation (computer graphics window basis orientation) <!>
MyVector <float> Util::fromPolarToCartesian(MyVector <float> origin, MyVector <float> v)
{
return MyVector <float> (v.getX() * std::cos(v.getY()), v.getX() * std::sin(v.getY()));
}
float Util::norm(MyVector <float> v1, MyVector <float> v2)
{
return norm(v1.getX(), v1.getY(), v2.getX(), v2.getY());
}
/**********************************************************
*
* RenderSpan
*
* parameters IN:
* int y
* EdgeBox ** edgeBox1
* EdgeBox ** edgeBox2
*
*********************************************************/
void RenderSpan (int y, EdgeBox ** edgeBox1, EdgeBox ** edgeBox2)
{
EdgeBox * tempEdgeBox;
int x, z;
double dz, di;
MyVector dw;
if ((*edgeBox1)->x > (*edgeBox2)->x) {
tempEdgeBox = *edgeBox1;
*edgeBox1 = *edgeBox2;
*edgeBox2 = tempEdgeBox;
}
int x1 = (int)(*edgeBox1)->x;
int x2 = (int)(*edgeBox2)->x;
if (x1 != x2) {
int dx = x2 - x1;
double currZ = (*edgeBox1)->z;
double currI = (*edgeBox1)->i;
MyVector currW = (*edgeBox1)->w;
dz = ((*edgeBox2)->z - currZ) / dx;
di = ((*edgeBox2)->i - currI) / dx;
dw.SetX( ((*edgeBox2)->w.GetX() - currW.GetX()) / dx);
dw.SetY( ((*edgeBox2)->w.GetY() - currW.GetY()) / dx);
dw.SetZ( ((*edgeBox2)->w.GetZ() - currW.GetZ()) / dx);
for (x = x1; x <= x2 - 1; x++) {
z = (int)currZ;
if (z < zBufferAt[x][y]) {
zBufferAt[x][y] = z;
RenderPixel (x, y, currI, currW);
}
currZ += dz;
currI += di;
currW.SetX( currW.GetX() + dw.GetX());
currW.SetY( currW.GetY() + dw.GetY());
currW.SetZ( currW.GetZ() + dw.GetZ());
}
}
}
/**********************************************************
*
* AddEdgeToList
*
* parameters IN:
* VertexCell * vertex1
* VertexCell * vertex2
*
*********************************************************/
void AddEdgeToList (VertexCell * vertex1, VertexCell * vertex2)
{
VertexCell * tempVertex;
MyVector dw;
EdgeBox * edgeBox;
if (vertex1->screenPos.GetY() > vertex2->screenPos.GetY()) {
tempVertex = vertex1;
vertex1 = vertex2;
vertex2 = tempVertex;
}
int y1 = vertex1->screenPos.GetY();
int y2 = vertex2->screenPos.GetY();
if (y1 != y2) {
int dy = y2 - y1;
double currX = vertex1->screenPos.GetX();
double currZ = vertex1->screenPos.GetZ();
double currI = lightVector.DotProduct (vertex1->vertexNormal);
MyVector currW = vertex1->worldPos;
double dx = (vertex2->screenPos.GetX() - currX) / dy;
double dz = (vertex2->screenPos.GetZ() - currZ) / dy;
double di = (lightVector.DotProduct (vertex2->vertexNormal) - currI) / dy;
dw.SetX( (vertex2->worldPos.GetX() - currW.GetX()) / dy);
dw.SetY( (vertex2->worldPos.GetY() - currW.GetY()) / dy);
dw.SetZ( (vertex2->worldPos.GetZ() - currW.GetZ()) / dy);
for (int y = y1; y <= y2 - 1; y++) {
edgeBox = new EdgeBox;
edgeBox->x = currX;
edgeBox->z = (int)currZ;
edgeBox->i = currI;
edgeBox->w = currW;
edgeBox->next = edgeListAt[y];
edgeListAt[y] = edgeBox;
currX += dx;
currZ += dz;
currI += di;
currW.SetX( currW.GetX() + dw.GetX());
currW.SetY( currW.GetY() + dw.GetY());
currW.SetZ( currW.GetZ() + dw.GetZ());
}
}
}
/**
* Resizes the table rows.
* @param n the number of rows.
*/
void setNumRows(int n) {
table.resize(n);
}
/**
* Clears and initializes the table.
* @param n the number of rows.
*/
void init(int n = 0) {
table.clear();
table.resize(n);
}
/**
* Gets the number of rows.
* @return the number of rows.
*/
int numRows() const {
return table.size();
}
