// We create packets and directly fill each zBuffer tile. Note that we // really store t values void TaskRayTraceHiZ::run(size_t taskID) { const uint32 taskX = taskID % this->taskXNum; const uint32 taskY = taskID / this->taskXNum; const uint32 startX = taskX * this->width; const uint32 startY = taskY * this->height; const uint32 endX = startX + this->width; const uint32 endY = startY + this->height; uint32 tileY = startY / HiZ::Tile::height; for (uint32 y = startY; y < endY; y += RayPacket::height, ++tileY) { uint32 tileX = startX / HiZ::Tile::width; for (uint32 x = startX; x < endX; x += RayPacket::width, ++tileX) { RayPacket pckt; PacketHit hit; gen.generate(pckt, x, y); intersector->traverse(pckt, hit); ssef zmin(inf), zmax(neg_inf); const uint32 tileID = tileX + tileY * zBuffer->tileXNum; PF_ASSERT(tileID < zBuffer->tileNum); HiZ::Tile &tile = zBuffer->tiles[tileID]; for (uint32 chunkID = 0; chunkID < HiZ::Tile::chunkNum; ++chunkID) { //const ssef t = hit.t[chunkID]; const ssef t = hit.t[chunkID] *dot(sse3f(view.x,view.y,view.z), pckt.dir[chunkID]); tile.z[chunkID] = t; zmin = min(zmin, t); zmax = max(zmax, t); } tile.zmin = reduce_min(zmin)[0]; tile.zmax = reduce_max(zmax)[0]; } } }
void Instance::transformBoundingBox() { auto b = i->getBoundingBox(); BoundingBox bb; for(int i = 0; i <= RayTracer::getInstance()->maxTime; ++i) { std::set<double> x,y,z; auto m = makeMatrices(i); auto p = Vector(b.xmin(i),0,0); p = transformLoc(m.first, p); x.insert(p.x); y.insert(p.y); z.insert(p.z); p = Vector(b.xmax(i),0,0); p = transformLoc(m.first, p); x.insert(p.x); y.insert(p.y); z.insert(p.z); p = Vector(0,b.ymin(i),0); p = transformLoc(m.first, p); x.insert(p.x); y.insert(p.y); z.insert(p.z); p = Vector(0,b.ymax(i),0); p = transformLoc(m.first, p); x.insert(p.x); y.insert(p.y); z.insert(p.z); p = Vector(0,0,b.zmin(i)); p = transformLoc(m.first, p); x.insert(p.x); y.insert(p.y); z.insert(p.z); p = Vector(0,0,b.zmax(i)); p = transformLoc(m.first, p); x.insert(p.x); y.insert(p.y); z.insert(p.z); bb.xmin.addFrame(i, *x.begin()); bb.xmax.addFrame(i, *x.rbegin()); bb.ymin.addFrame(i, *y.begin()); bb.ymax.addFrame(i, *y.rbegin()); bb.zmin.addFrame(i, *z.begin()); bb.zmax.addFrame(i, *z.rbegin()); } bbox = bb; }
qreal GraphicsScene::zmin() { qreal mValue = zmax(); QList<QGraphicsItem *> items = QGraphicsScene::items(); for (int o=0;o<items.size();o++) { mValue = qMin(items[o]->zValue(),mValue); } return mValue; }
//------------------------------------------------------------------------------------------------------------------------------------ // called when we want to draw the 3D data in our app. //------------------------------------------------------------------------------------------------------------------------------------ void draw3D() { const float DEG_TO_RAD = PI / 180.0f; const Vec3 xAxis(1.0f, 0, 0); const Vec3 yAxis(0, 1.0f, 0); translate(0, 0, -g_zoom); translate(g_tx, g_ty, 0); rotate(g_rotx * DEG_TO_RAD, xAxis); rotate(g_roty * DEG_TO_RAD, yAxis); // draw the grid on the floor setColour(0.25f, 0.25f, 0.25f); for(float i = -10.0f; i <= 10.1f; i += 1.0f) { Vec3 zmin(i, 0, -10); Vec3 zmax(i, 0, 10); Vec3 xmin(-10, 0, i); Vec3 xmax(10, 0, i); drawLine(xmin, xmax); drawLine(zmin, zmax); } }
int tester() { //description std::vector<std::string> neutrals; std::vector<std::string> ions; neutrals.push_back("N2"); neutrals.push_back("CH4"); neutrals.push_back("C2H"); //ionic system contains neutral system ions = neutrals; ions.push_back("N2+"); Scalar MN(14.008L), MC(12.011), MH(1.008L); Scalar MN2 = 2.L*MN , MCH4 = MC + 4.L*MH, MC2H = 2.L * MC + MH; std::vector<Scalar> Mm; Mm.push_back(MN2); Mm.push_back(MCH4); Mm.push_back(MC2H); //densities std::vector<Scalar> molar_frac; molar_frac.push_back(0.95999L); molar_frac.push_back(0.04000L); molar_frac.push_back(0.00001L); molar_frac.push_back(0.L); Scalar dens_tot(1e12L); //hard sphere radius std::vector<Scalar> hard_sphere_radius; hard_sphere_radius.push_back(2.0675e-8L * 1e-2L); //N2 in cm -> m hard_sphere_radius.push_back(2.3482e-8L * 1e-2L); //CH4 in cm -> m hard_sphere_radius.push_back(0.L); //C2H //zenith angle //not necessary //photon flux //not necessary ////cross-section //not necessary //altitudes Scalar zmin(600.),zmax(1400.),zstep(10.); //binary diffusion Scalar bCN1(1.04e-5 * 1e-4),bCN2(1.76); //cm2 -> m2 Planet::DiffusionType CN_model(Planet::DiffusionType::Wakeham); Scalar bCC1(5.73e16 * 1e-4),bCC2(0.5); //cm2 -> m2 Planet::DiffusionType CC_model(Planet::DiffusionType::Wilson); Scalar bNN1(0.1783 * 1e-4),bNN2(1.81); //cm2 -> m2 Planet::DiffusionType NN_model(Planet::DiffusionType::Massman); /************************ * first level ************************/ //altitude Planet::Altitude<Scalar,std::vector<Scalar> > altitude(zmin,zmax,zstep); //neutrals Antioch::ChemicalMixture<Scalar> neutral_species(neutrals); //ions Antioch::ChemicalMixture<Scalar> ionic_species(ions); //chapman //not needed //binary diffusion Planet::BinaryDiffusion<Scalar> N2N2( Antioch::Species::N2, Antioch::Species::N2 , bNN1, bNN2, NN_model); Planet::BinaryDiffusion<Scalar> N2CH4( Antioch::Species::N2, Antioch::Species::CH4, bCN1, bCN2, CN_model); Planet::BinaryDiffusion<Scalar> CH4CH4( Antioch::Species::CH4, Antioch::Species::CH4, bCC1, bCC2, CC_model); Planet::BinaryDiffusion<Scalar> N2C2H( Antioch::Species::N2, Antioch::Species::C2H); Planet::BinaryDiffusion<Scalar> CH4C2H( Antioch::Species::CH4, Antioch::Species::C2H); std::vector<std::vector<Planet::BinaryDiffusion<Scalar> > > bin_diff_coeff; bin_diff_coeff.resize(2); bin_diff_coeff[0].push_back(N2N2); bin_diff_coeff[0].push_back(N2CH4); bin_diff_coeff[0].push_back(N2C2H); bin_diff_coeff[1].push_back(N2CH4); bin_diff_coeff[1].push_back(CH4CH4); bin_diff_coeff[1].push_back(CH4C2H); /************************ * second level ************************/ //temperature std::vector<Scalar> T0,Tz; read_temperature<Scalar>(T0,Tz,"input/temperature.dat"); std::vector<Scalar> neutral_temperature; linear_interpolation(T0,Tz,altitude.altitudes(),neutral_temperature); Planet::AtmosphericTemperature<Scalar, std::vector<Scalar> > temperature(neutral_temperature, neutral_temperature, altitude); //photon opacity //not needed //reaction sets //not needed /************************ * third level ************************/ //atmospheric mixture Planet::AtmosphericMixture<Scalar,std::vector<Scalar>, std::vector<std::vector<Scalar> > > composition(neutral_species, ionic_species, altitude, temperature); composition.init_composition(molar_frac,dens_tot); composition.set_hard_sphere_radius(hard_sphere_radius); composition.initialize(); //kinetics evaluators //not needed /************************ * fourth level ************************/ //photon evaluator //not needed //molecular diffusion Planet::MolecularDiffusionEvaluator<Scalar,std::vector<Scalar>, std::vector<std::vector<Scalar> > > molecular_diffusion(bin_diff_coeff, composition, altitude, temperature); molecular_diffusion.make_molecular_diffusion(); //eddy diffusion //not needed /************************ * checks ************************/ molar_frac.pop_back();//get the ion outta here Scalar Matm(0.L); for(unsigned int s = 0; s < molar_frac.size(); s++) { Matm += molar_frac[s] * composition.neutral_composition().M(s); } Matm *= 1e-3L; //to kg std::vector<std::vector<Scalar> > densities; calculate_densities(densities, dens_tot, molar_frac, zmin,zmax,zstep, temperature.neutral_temperature(), Mm); //N2, CH4, C2H std::vector<std::vector<Scalar> > Dij; Dij.resize(2); Dij[0].resize(3,0.L); Dij[1].resize(3,0.L); int return_flag(0); for(unsigned int iz = 0; iz < altitude.altitudes().size(); iz++) { Scalar P = pressure(composition.total_density()[iz],temperature.neutral_temperature()[iz]); Scalar T = temperature.neutral_temperature()[iz]; Dij[0][0] = binary_coefficient(T,P,bNN1,bNN2); //N2 N2 Dij[1][1] = binary_coefficient(T,P,bCC1 * Antioch::ant_pow(Planet::Constants::Convention::T_standard<Scalar>(),bCC2 + Scalar(1.L)) * Planet::Constants::Universal::kb<Scalar>() / Planet::Constants::Convention::P_normal<Scalar>(),bCC2 + Scalar(1.L)); //CH4 CH4 Dij[0][1] = binary_coefficient(T,P,bCN1 * Antioch::ant_pow(Planet::Constants::Convention::T_standard<Scalar>(),bCN2),bCN2); //N2 CH4 Dij[0][2] = binary_coefficient(Dij[0][0],Mm[0],Mm[2]); //N2 C2H Dij[1][2] = binary_coefficient(Dij[1][1],Mm[1],Mm[2]); //CH4 C2H Dij[1][0] = Dij[0][1]; //CH4 N2 for(unsigned int s = 0; s < molar_frac.size(); s++) { Scalar tmp(0.L); Scalar M_diff(0.L); for(unsigned int medium = 0; medium < 2; medium++) { if(s == medium)continue; tmp += densities[medium][iz]/Dij[medium][s]; } Scalar Ds = (barometry(zmin,altitude.altitudes()[iz],neutral_temperature[iz],Matm,dens_tot) - densities[s][iz]) / tmp; for(unsigned int j = 0; j < molar_frac.size(); j++) { if(s == j)continue; M_diff += composition.total_density()[iz] * composition.neutral_molar_fraction()[j][iz] * composition.neutral_composition().M(j); } M_diff /= Scalar(molar_frac.size() - 1); Scalar Dtilde = Ds / (Scalar(1.L) - composition.neutral_molar_fraction()[s][iz] * (Scalar(1.L) - composition.neutral_composition().M(s)/M_diff)); return_flag = return_flag || check_test(Dtilde,molecular_diffusion.Dtilde()[s][iz],"D tilde of species at altitude"); } return_flag = return_flag || check_test(Dij[0][0],molecular_diffusion.binary_coefficient(0,0,T,P),"binary molecular coefficient N2 N2 at altitude") || check_test(Dij[0][1],molecular_diffusion.binary_coefficient(0,1,T,P),"binary molecular coefficient N2 CH4 at altitude") || check_test(Dij[0][2],molecular_diffusion.binary_coefficient(0,2,T,P),"binary molecular coefficient N2 C2H at altitude") || check_test(Dij[1][1],molecular_diffusion.binary_coefficient(1,1,T,P),"binary molecular coefficient CH4 CH4 at altitude") || check_test(Dij[1][2],molecular_diffusion.binary_coefficient(1,2,T,P),"binary molecular coefficient CH4 C2H at altitude"); } return return_flag; }
int maxDepth(TreeNode *root) { if (root == NULL) return 0; else return 1 + zmax(maxDepth(root->left), maxDepth(root->right)); }
//------------------------------------------------------------------------------------------------------------------------------------ // called when we want to draw the 3D data in our app. //------------------------------------------------------------------------------------------------------------------------------------ void draw3D() { // draw the grid on the floor setColour(0.25f, 0.25f, 0.25f); for(float i = -10.0f; i <= 10.1f; i += 1.0f) { Vec3 zmin(i, 0, -10); Vec3 zmax(i, 0, 10); Vec3 xmin(-10, 0, i); Vec3 xmax(10, 0, i); drawLine(xmin, xmax); drawLine(zmin, zmax); } // If using the GPU to compute the lighting (which is what you want to do!) if(!g_manualLighting) { // turn on lighting enableLighting(); // set the diffuse material colour (this will be modulated by the effect of the lighting) setColour(1.0f, 1.0f, 1.0f); // draw the cube geometry drawPrimitives(g_pointsVN, 24, kQuads); // turn off lighting disableLighting(); } else { // otherwise, compute the lighting manually. Don't ever do this in practice! It's insane! (But it may be useful for educational purposes) // The direction from the vertex to the light (effectively sunlight in this case!). Vec3 L(-0.6f, 1.0f, -0.2f); // make sure L has been normalised! L = normalize(L); // start drawing some quads begin(kQuads); // loop through each vertex normal for(int i = 0; i < 24; ++i) { // compute N.L // Make sure we clamp this to zero (so that we ignore any negative values). float N_dot_L = std::max(dot(L, g_pointsVN[i].n), 0.0f); // the ambient material colour (always gets added to the final colour) Vec3 Ka(0.2f, 0.2f, 0.2f); // the diffuse material colour Vec3 Kd(1.0f, 1.0f, 1.0f); // Compute the final colour Vec3 colour = Ka + (Kd * N_dot_L); // set the vertex colour setColour(colour); // specify the vertex addVertex(g_pointsVN[i].v); } // finish drawing our quads end(); } // if we are displaying normals if(g_displayNormals) { // make colour pink setColour(1.0f, 0.0f, 1.0f); // loop through each vertex for(int i = 0; i < 24; ++i) { // compute an offset (along the normal direction) from the vertex Vec3 pn = g_pointsVN[i].v + (g_pointsVN[i].n * 0.2f); // draw a line to show the normal drawLine(g_pointsVN[i].v, pn); } } }