//---------------------------------------------------- void CRocketLauncher::UpdateTPLaser(float frameTime) { m_lastUpdate -= frameTime; bool allowUpdate = true; if(m_lastUpdate<=0.0f) m_lastUpdate = m_Timeout; else allowUpdate = false; const CCamera& camera = gEnv->pRenderer->GetCamera(); //If character not visible, laser is not correctly updated if(CActor* pOwner = GetOwnerActor()) { ICharacterInstance* pCharacter = pOwner->GetEntity()->GetCharacter(0); if(pCharacter && !pCharacter->IsCharacterVisible()) return; } Vec3 offset(-0.06f,0.28f,0.115f); //To match scope position in TP LAW model Vec3 pos = GetEntity()->GetWorldTM().TransformPoint(offset); Vec3 dir = GetEntity()->GetWorldRotation().GetColumn1(); Vec3 hitPos(0,0,0); float laserLength = 0.0f; if(allowUpdate) { IPhysicalEntity* pSkipEntity = NULL; if(GetOwner()) pSkipEntity = GetOwner()->GetPhysics(); const float range = m_LaserRangeTP; // Use the same flags as the AI system uses for visibility. const int objects = ent_terrain|ent_static|ent_rigid|ent_sleeping_rigid|ent_independent; //ent_living; const int flags = (geom_colltype_ray << rwi_colltype_bit) | rwi_colltype_any | (10 & rwi_pierceability_mask) | (geom_colltype14 << rwi_colltype_bit); ray_hit hit; if (gEnv->pPhysicalWorld->RayWorldIntersection(pos, dir*range, objects, flags, &hit, 1, &pSkipEntity, pSkipEntity ? 1 : 0)) { laserLength = hit.dist; m_lastLaserHitPt = hit.pt; m_lastLaserHitSolid = true; } else { m_lastLaserHitSolid = false; m_lastLaserHitPt = pos + dir * range; laserLength = range + 0.1f; } // Hit near plane if (dir.Dot(camera.GetViewdir()) < 0.0f) { Plane nearPlane; nearPlane.SetPlane(camera.GetViewdir(), camera.GetPosition()); nearPlane.d -= camera.GetNearPlane()+0.15f; Ray ray(pos, dir); Vec3 out; m_lastLaserHitViewPlane = false; if (Intersect::Ray_Plane(ray, nearPlane, out)) { float dist = Distance::Point_Point(pos, out); if (dist < laserLength) { laserLength = dist; m_lastLaserHitPt = out; m_lastLaserHitSolid = true; m_lastLaserHitViewPlane = true; } } } hitPos = m_lastLaserHitPt; } else { laserLength = Distance::Point_Point(m_lastLaserHitPt, pos); hitPos = pos + dir * laserLength; } if (m_smoothLaserLength < 0.0f) m_smoothLaserLength = laserLength; else { if (laserLength < m_smoothLaserLength) m_smoothLaserLength = laserLength; else m_smoothLaserLength += (laserLength - m_smoothLaserLength) * min(1.0f, 10.0f * frameTime); } const float assetLength = 2.0f; m_smoothLaserLength = CLAMP(m_smoothLaserLength,0.01f,m_LaserRangeTP); float scale = m_smoothLaserLength / assetLength; // Scale the laser based on the distance. Matrix34 scl; scl.SetIdentity(); scl.SetScale(Vec3(1,scale,1)); scl.SetTranslation(offset); GetEntity()->SetSlotLocalTM( eIGS_Aux1, scl); if (m_dotEffectSlot >= 0) { if (m_lastLaserHitSolid) { Matrix34 dotMatrix = Matrix34::CreateTranslationMat(Vec3(0,m_smoothLaserLength,0)); dotMatrix.AddTranslation(offset); if(m_lastLaserHitViewPlane) dotMatrix.Scale(Vec3(0.2f,0.2f,0.2f)); GetEntity()->SetSlotLocalTM(m_dotEffectSlot,dotMatrix); } else { Matrix34 scaleMatrix; scaleMatrix.SetIdentity(); scaleMatrix.SetScale(Vec3(0.001f,0.001f,0.001f)); GetEntity()->SetSlotLocalTM(m_dotEffectSlot, scaleMatrix); } } }
// line perpendicular to a plane at a specific point Line::Line(const Plane& _plane, const Point& _point) { Line(_plane.getNormalVector(), _point); }
void DrawScene(Window * window) { phong_shader.GLReturnedError("DrawScene() - entering"); #ifdef MOVE mat4 m = rotate(mat4() , radians(window->LocalTime() * 30.0f) , vec3(0.0f , 1.0f , 0.2f)); m = translate(m, vec3(0.0f, 11.5f * cos(window->LocalTime() * 0.5f) + 2.0f, 11.5f * sin(window->LocalTime() * 0.5f) + 2.0f)); #else mat4 m; #endif // MOVE mat4 view_matrix = lookAt(vec3(m * vec4(eye, 1.0f)), cop, up); mat4 model_matrix; mat4 projection_matrix = perspective(radians(window->fovy), window->aspect, window->near_distance, window->far_distance); vec3 z_axis = vec3(0.0f, 0.0f, 1.0f); vec3 y_axis = vec3(0.0f, 1.0f, 0.0f); vec3 ambient = vec3(0.1f, 0.1f, 0.1f); vec3 specular = vec3(1.0f, 1.0f, 1.0f); float c_offset = radians(45.0f); glViewport(0, 0, window->size.x, window->size.y); const int count_of_shapes = 4; for (unsigned int i = 0; i < instances.size(); i++) { model_matrix = translate(mat4(), instances[i].position); model_matrix = rotate(model_matrix, radians(window->LocalTime() * instances[i].rate) + instances[i].offset, y_axis); if (i % count_of_shapes == 3) model_matrix = scale(model_matrix, vec3(0.25f, 0.25f, 0.25f)); phong_shader.Use(model_matrix, view_matrix, projection_matrix); phong_shader.SetMaterial(instances[i].diffuse, specular, 32.0f, ambient); phong_shader.SetLightPosition(vec3(0.0f, 0.0f, 1000.0f)); switch (i % count_of_shapes) { case 0: disc1.Draw(false); break; case 1: disc3.Draw(false); break; case 2: plane2.Draw(false); break; case 3: cube.Draw(false); break; } phong_shader.UnUse(); #ifdef SHOW_NORMALS if (i == 0) { constant_shader.Use(model_matrix, view_matrix, projection_matrix); constant_shader.SetMaterial(vec3(0.0f, 0.0f, 0.8f), specular, 128.0f, vec3(1.0f, 0.0f, 0.0f)); disc1.Draw(true); constant_shader.UnUse(); } #endif } model_matrix = mat4(); mat4 mz = model_matrix; model_matrix = scale(model_matrix, vec3(0.5f, 0.5f, 16.0f)); phong_shader.Use(model_matrix, view_matrix, projection_matrix); phong_shader.SetMaterial(vec3(0.0f, 0.0f, 0.8f), specular, 128.0f, ambient); phong_shader.SetLightPosition(vec3(0.0f, 1000.0f, 0.0f)); cylinder1.Draw(false); phong_shader.UnUse(); #ifdef SHOW_NORMALS constant_shader.Use(model_matrix, view_matrix, projection_matrix); constant_shader.SetMaterial(vec3(0.0f, 0.0f, 0.8f), specular, 128.0f, vec3(1.0f, 1.0f, 1.0f)); cylinder.Draw(true); constant_shader.UnUse(); #endif model_matrix = rotate(mz, radians(90.0f), y_axis); model_matrix = scale(model_matrix, vec3(0.5f, 0.5f, 16.0f)); phong_shader.Use(model_matrix, view_matrix, projection_matrix); phong_shader.SetMaterial(vec3(1.0f, 0.0f, 0.0f), specular, 128.0f, ambient); phong_shader.SetLightPosition(vec3(0.0f, 1000.0f, 0.0f)); cylinder1.Draw(false); phong_shader.UnUse(); model_matrix = rotate(mz, radians(-90.0f), vec3(1.0f, 0.0f, 0.0f)); model_matrix = scale(model_matrix, vec3(0.5f, 0.5f, 16.0f)); phong_shader.Use(model_matrix, view_matrix, projection_matrix); phong_shader.SetMaterial(vec3(0.0f, 1.0f, 0.0f), specular, 128.0f, ambient); phong_shader.SetLightPosition(vec3(0.0f, 1000.0f, 0.0f)); cylinder1.Draw(false); phong_shader.UnUse(); cylinder1.UpdateValues(TestUpdate, window->LocalTime(), nullptr); }
void setupSBA(SysSBA &sys) { // Create camera parameters. frame_common::CamParams cam_params; cam_params.fx = 430; // Focal length in x cam_params.fy = 430; // Focal length in y cam_params.cx = 320; // X position of principal point cam_params.cy = 240; // Y position of principal point cam_params.tx = 0.3; // Baseline // Define dimensions of the image. int maxx = 640; int maxy = 480; // Create a plane containing a wall of points. Plane middleplane; middleplane.resize(3, 2, 10, 5); //middleplane.rotate(PI/4.0, PI/6.0, 1, 0); middleplane.rotate(PI/4.0, 1, 0, 1); middleplane.translate(0.0, 0.0, 5.0); // Create another plane containing a wall of points. Plane mp2; mp2.resize(3, 2, 10, 5); mp2.rotate(0, 0, 0, 1); mp2.translate(0.0, 0.0, 4.0); // Create another plane containing a wall of points. Plane mp3; mp3.resize(3, 2, 10, 5); mp3.rotate(-PI/4.0, 1, 0, 1); mp3.translate(0.0, 0.0, 4.5); // Vector containing the true point positions. vector<Eigen::Vector3d, Eigen::aligned_allocator<Eigen::Vector3d> > normals; points.insert(points.end(), middleplane.points.begin(), middleplane.points.end()); normals.insert(normals.end(), middleplane.points.size(), middleplane.normal); points.insert(points.end(), mp2.points.begin(), mp2.points.end()); normals.insert(normals.end(), mp2.points.size(), mp2.normal); points.insert(points.end(), mp3.points.begin(), mp3.points.end()); normals.insert(normals.end(), mp3.points.size(), mp3.normal); // Create nodes and add them to the system. unsigned int nnodes = 2; // Number of nodes. double path_length = 1.0; // Length of the path the nodes traverse. // Set the random seed. unsigned short seed = (unsigned short)time(NULL); seed48(&seed); unsigned int i = 0; Vector3d inormal0 = middleplane.normal; Vector3d inormal1 = middleplane.normal; Vector3d inormal20 = mp2.normal; Vector3d inormal21 = mp2.normal; Vector3d inormal30 = mp3.normal; Vector3d inormal31 = mp3.normal; for (i = 0; i < nnodes; i++) { // Translate in the x direction over the node path. Vector4d trans(i/(nnodes-1.0)*path_length, 0, 0, 1); #if 1 if (i >= 2) { // perturb a little double tnoise = 0.5; // meters trans.x() += tnoise*(drand48()-0.5); trans.y() += tnoise*(drand48()-0.5); trans.z() += tnoise*(drand48()-0.5); } #endif // Don't rotate. Quaterniond rot(1, 0, 0, 0); #if 1 if (i >= 2) { // perturb a little double qnoise = 0.1; // meters rot.x() += qnoise*(drand48()-0.5); rot.y() += qnoise*(drand48()-0.5); rot.z() += qnoise*(drand48()-0.5); } #endif rot.normalize(); // Add a new node to the system. sys.addNode(trans, rot, cam_params, false); // set normal if (i == 0) { inormal0 = rot.toRotationMatrix().transpose() * inormal0; inormal20 = rot.toRotationMatrix().transpose() * inormal20; inormal30 = rot.toRotationMatrix().transpose() * inormal30; } else { inormal1 = rot.toRotationMatrix().transpose() * inormal1; inormal21 = rot.toRotationMatrix().transpose() * inormal21; inormal31 = rot.toRotationMatrix().transpose() * inormal31; } } double pointnoise = 1.0; // Add points into the system, and add noise. for (i = 0; i < points.size(); i++) { // Add up to .5 points of noise. Vector4d temppoint = points[i]; temppoint.x() += pointnoise*(drand48() - 0.5); temppoint.y() += pointnoise*(drand48() - 0.5); temppoint.z() += pointnoise*(drand48() - 0.5); sys.addPoint(temppoint); } // Each point gets added twice for (i = 0; i < points.size(); i++) { // Add up to .5 points of noise. Vector4d temppoint = points[i]; temppoint.x() += pointnoise*(drand48() - 0.5); temppoint.y() += pointnoise*(drand48() - 0.5); temppoint.z() += pointnoise*(drand48() - 0.5); sys.addPoint(temppoint); } Vector2d proj2d, proj2dp; Vector3d proj, projp, pc, pcp, baseline, baselinep; Vector3d imagenormal(0, 0, 1); Matrix3d covar0; covar0 << sqrt(imagenormal(0)), 0, 0, 0, sqrt(imagenormal(1)), 0, 0, 0, sqrt(imagenormal(2)); Matrix3d covar; Quaterniond rotation; Matrix3d rotmat; unsigned int midindex = middleplane.points.size(); printf("Normal for Middle Plane: [%f %f %f], index %d -> %d\n", middleplane.normal.x(), middleplane.normal.y(), middleplane.normal.z(), 0, midindex-1); int nn = points.size(); // Project points into nodes. for (i = 0; i < points.size(); i++) { int k=i; // Project the point into the node's image coordinate system. sys.nodes[0].setProjection(); sys.nodes[0].project2im(proj2d, points[k]); sys.nodes[1].setProjection(); sys.nodes[1].project2im(proj2dp, points[k]); // Camera coords for right camera baseline << sys.nodes[0].baseline, 0, 0; pc = sys.nodes[0].Kcam * (sys.nodes[0].w2n*points[k] - baseline); proj.head<2>() = proj2d; proj(2) = pc(0)/pc(2); baseline << sys.nodes[1].baseline, 0, 0; pcp = sys.nodes[1].Kcam * (sys.nodes[1].w2n*points[k] - baseline); projp.head<2>() = proj2dp; projp(2) = pcp(0)/pcp(2); // add noise to projections double prnoise = 0.5; // 0.5 pixels proj.head<2>() += Vector2d(prnoise*(drand48() - 0.5),prnoise*(drand48() - 0.5)); projp.head<2>() += Vector2d(prnoise*(drand48() - 0.5),prnoise*(drand48() - 0.5)); // If valid (within the range of the image size), add the stereo // projection to SBA. if (proj.x() > 0 && proj.x() < maxx && proj.y() > 0 && proj.y() < maxy) { // add point cloud shape-holding projections to each node sys.addStereoProj(0, k, proj); sys.addStereoProj(1, k+nn, projp); #ifdef USE_PP // add exact matches if (i == 20 || i == 65 || i == 142) sys.addStereoProj(1, k, projp); #endif #ifdef USE_PPL // add point-plane matches if (i < midindex) sys.addPointPlaneMatch(0, k, inormal0, 1, k+nn, inormal1); else if (i < 2*midindex) sys.addPointPlaneMatch(0, k, inormal20, 1, k+nn, inormal21); else sys.addPointPlaneMatch(0, k, inormal30, 1, k+nn, inormal31); // sys.addStereoProj(0, k+nn, projp); // sys.addStereoProj(1, k, proj); Matrix3d covar; double cv = 0.01; covar << cv, 0, 0, 0, cv, 0, 0, 0, cv; sys.setProjCovariance(0, k+nn, covar); sys.setProjCovariance(1, k, covar); #endif } else { cout << "ERROR! point not in view of nodes" << endl; //return; } } // Add noise to node position. double transscale = 2.0; double rotscale = 0.5; // Don't actually add noise to the first node, since it's fixed. for (i = 1; i < sys.nodes.size(); i++) { Vector4d temptrans = sys.nodes[i].trans; Quaterniond tempqrot = sys.nodes[i].qrot; // Add error to both translation and rotation. temptrans.x() += transscale*(drand48() - 0.5); temptrans.y() += transscale*(drand48() - 0.5); temptrans.z() += transscale*(drand48() - 0.5); tempqrot.x() += rotscale*(drand48() - 0.5); tempqrot.y() += rotscale*(drand48() - 0.5); tempqrot.z() += rotscale*(drand48() - 0.5); tempqrot.normalize(); sys.nodes[i].trans = temptrans; sys.nodes[i].qrot = tempqrot; // These methods should be called to update the node. sys.nodes[i].normRot(); sys.nodes[i].setTransform(); sys.nodes[i].setProjection(); sys.nodes[i].setDr(true); } }
void Frustum::ExtractPlanes(glm::mat4 &clip) { Plane *pPlane = 0; pPlane = &planes[FRUSTUM_PLANE_NEAR]; pPlane->set(clip[0].w + clip[0].z, clip[1].w + clip[1].z, clip[2].w + clip[2].z, clip[3].w + clip[3].z); pPlane->normalize(); // Left clipping plane. pPlane = &planes[FRUSTUM_PLANE_FAR]; pPlane->set(clip[0].w - clip[0].z, clip[1].w - clip[1].z,clip[2].w - clip[2].z,clip[3].w - clip[3].z); pPlane->normalize(); // Left clipping plane. pPlane = &planes[FRUSTUM_PLANE_LEFT]; pPlane->set(clip[0].w + clip[0].x,clip[1].w + clip[1].x,clip[2].w + clip[2].x,clip[3].w + clip[3].x); pPlane->normalize(); pPlane = &planes[FRUSTUM_PLANE_RIGHT]; pPlane->set(clip[0].w - clip[0].x, clip[1].w - clip[1].x, clip[2].w - clip[2].x, clip[3].w - clip[3].x); pPlane->normalize(); pPlane = &planes[FRUSTUM_PLANE_BOTTOM]; pPlane->set(clip[0].w + clip[0].y,clip[1].w + clip[1].y,clip[2].w + clip[2].y,clip[3].w + clip[3].y); pPlane->normalize(); pPlane = &planes[FRUSTUM_PLANE_TOP]; pPlane->set(clip[0].w - clip[0].y, clip[1].w - clip[1].y, clip[2].w - clip[2].y, clip[3].w- clip[3].y); pPlane->normalize(); }
bool Ray::Intersects(const Plane &plane) const { return plane.Intersects(*this, 0); }
void Frustum::ExtractPlanes(ScePspFMatrix4 &clip) { Plane *pPlane = 0; // Left clipping plane. /*pPlane = &planes[FRUSTUM_PLANE_NEAR]; pPlane->set(clip.w.x + clip.z.x,clip.w.y + clip.z.y,clip.w.z + clip.z.z,clip.w.w + clip.z.w); pPlane->normalize(); // Left clipping plane. pPlane = &planes[FRUSTUM_PLANE_FAR]; pPlane->set(clip.w.x - clip.z.x,clip.w.y - clip.z.y,clip.w.z - clip.z.z,clip.w.w - clip.z.w); pPlane->normalize(); // Left clipping plane. pPlane = &planes[FRUSTUM_PLANE_LEFT]; pPlane->set(clip.w.x + clip.x.x,clip.w.y + clip.x.y,clip.w.z + clip.x.z,clip.w.w + clip.x.w); pPlane->normalize(); pPlane = &planes[FRUSTUM_PLANE_RIGHT]; pPlane->set(clip.w.x - clip.x.x,clip.w.y - clip.x.y,clip.w.z - clip.x.z,clip.w.w - clip.x.w); pPlane->normalize(); pPlane = &planes[FRUSTUM_PLANE_BOTTOM]; pPlane->set(clip.w.x + clip.y.x,clip.w.y + clip.y.y,clip.w.z + clip.y.z,clip.w.w + clip.y.w); pPlane->normalize(); pPlane = &planes[FRUSTUM_PLANE_TOP]; pPlane->set(clip.w.x - clip.y.x,clip.w.y - clip.y.y,clip.w.z - clip.y.z,clip.w.w - clip.y.w); pPlane->normalize();*/ // Left clipping plane. pPlane = &planes[FRUSTUM_PLANE_NEAR]; pPlane->set(clip.x.w + clip.x.z,clip.y.w + clip.y.z,clip.z.w + clip.z.z,clip.w.w + clip.w.z); pPlane->normalize(); // Left clipping plane. pPlane = &planes[FRUSTUM_PLANE_FAR]; pPlane->set(clip.x.w - clip.x.z,clip.y.w - clip.y.z,clip.z.w - clip.z.z,clip.w.w - clip.w.z); pPlane->normalize(); // Left clipping plane. pPlane = &planes[FRUSTUM_PLANE_LEFT]; pPlane->set(clip.x.w + clip.x.x,clip.y.w + clip.y.x,clip.z.w + clip.z.x,clip.w.w + clip.w.x); pPlane->normalize(); pPlane = &planes[FRUSTUM_PLANE_RIGHT]; pPlane->set(clip.x.w - clip.x.x,clip.y.w - clip.y.x,clip.z.w - clip.z.x,clip.w.w - clip.w.x); pPlane->normalize(); pPlane = &planes[FRUSTUM_PLANE_BOTTOM]; pPlane->set(clip.x.w + clip.x.y,clip.y.w + clip.y.y,clip.z.w + clip.z.y,clip.w.w + clip.w.y); pPlane->normalize(); pPlane = &planes[FRUSTUM_PLANE_TOP]; pPlane->set(clip.x.w - clip.x.y,clip.y.w - clip.y.y,clip.z.w - clip.z.y,clip.w.w - clip.w.y); pPlane->normalize(); }
int loadSFM(char* fileName, Mesh &mesh) { fstream file(fileName); string buffer; vector<point3> vertices; vector<vec3> normals; vector<point3> faces; // if not opened if (!file.is_open()) { cout << "Unable to open file" << endl; return 0; } // read file line by line while (getline(file, buffer, '\n')) { //if (buffer[0] == 'v') { // fprintf(stdout, "Got v\n"); //} if (buffer[0] != 'v' && buffer[0] != 'f') { continue; } // read each element in this line stringstream currentLine(buffer); string currentColumn; vector<double> triangleElement; while (getline(currentLine, currentColumn, '\ ')) { if (currentColumn[0] != 'v' && currentColumn[0] != 'f') { triangleElement.push_back(stod(currentColumn)); //! stod converts string to double } } if (triangleElement.size() != 3) { fprintf(stdout, "Only read %llu elements from current line \n", triangleElement.size()); return 0; } if (buffer[0] == 'v') { vertices.push_back(point3(triangleElement[0], triangleElement[1], triangleElement[2])); normals.push_back(vec3(0.0)); } else if (buffer[0] == 'f') { faces.push_back(point3(triangleElement[0], triangleElement[1], triangleElement[2])); } else { fprintf(stdout, "buffer[0] is not either 'v' or 'f' \n"); return 0; } } averageNormals(vertices, faces, normals); Plane temp; // store data in mesh for (int i = 0; i < faces.size(); i++) { //! smf index starts from 1 instead of 0, so need to -1 Triangle3D facet; facet.faces[0] = int(faces[i][0]) - 1; facet.faces[1] = int(faces[i][1]) - 1; facet.faces[2] = int(faces[i][2]) - 1; facet.vertices[0] = vertices[facet.faces[0]]; facet.vertices[1] = vertices[facet.faces[1]]; facet.vertices[2] = vertices[facet.faces[2]]; facet.normals[0] = normals[facet.faces[0]]; facet.normals[1] = normals[facet.faces[1]]; facet.normals[2] = normals[facet.faces[2]]; temp.set3Points(facet.vertices[0], facet.vertices[2], facet.vertices[1]); // in this case clock wise is normal direction facet.triangleNormal = temp.normal; facet.centerOfMass = (facet.vertices[0] + facet.vertices[1] + facet.vertices[2]) / 3; mesh.push_back(facet); } return 1; }
//------------------------------------------------------------------ void CLam::UpdateTPLaser(float frameTime, CItem* parent) { FUNCTION_PROFILER(GetISystem(), PROFILE_GAME); const int frameId = gEnv->pRenderer->GetFrameID(); if (s_lastUpdateFrameId != frameId) { // Check how many LAMs to update this frame. float dt = frameTime; // + s_laserUpdateTimeError; const int n = s_lasers.size(); int nActive = 0; for (int i = 0; i < n; ++i) { if (!s_lasers[i]->IsLaserActivated() && !s_lasers[i]->IsLightActivated()) continue; nActive++; } float updatedPerSecond = (nActive / LASER_UPDATE_TIME) + s_laserUpdateTimeError; int updateCount = (int)floorf(updatedPerSecond * dt); if(dt==0.0f) s_laserUpdateTimeError = 0.0f; else s_laserUpdateTimeError = updatedPerSecond - updateCount/dt; s_curLaser %= n; for (int i = 0, j = 0; i < n && j < updateCount ; ++i) { s_curLaser = (s_curLaser + 1) % n; if (!s_lasers[s_curLaser]->IsLaserActivated() && !s_lasers[s_curLaser]->IsLightActivated()) continue; s_lasers[s_curLaser]->SetAllowUpdate(); ++j; } s_lastUpdateFrameId = frameId; } IEntity* pRootEnt = GetEntity(); if (!pRootEnt) return; IEntity *pLaserEntity = m_pEntitySystem->GetEntity(m_pLaserEntityId); // if(!pLaserEntity) // return; const CCamera& camera = gEnv->pRenderer->GetCamera(); Vec3 lamPos = pRootEnt->GetWorldPos(); //pLaserEntity->GetParent()->GetWorldPos(); Vec3 dir = pRootEnt->GetWorldRotation().GetColumn1(); //pLaserEntity->GetParent()->GetWorldRotation().GetColumn1(); bool charNotVisible = false; float dsg1Scale = 1.0f; //If character not visible, laser is not correctly updated if(parent) { if(CActor* pOwner = parent->GetOwnerActor()) { ICharacterInstance* pCharacter = pOwner->GetEntity()->GetCharacter(0); if(pCharacter && !pCharacter->IsCharacterVisible()) charNotVisible = true; } if(parent->GetEntity()->GetClass()==CItem::sDSG1Class) dsg1Scale = 3.0f; } // if (!pLaserEntity->GetParent()) // return; Vec3 hitPos(0,0,0); float laserLength = 0.0f; // HACK??: Use player movement controller locations, or else the laser // pops all over the place when character out of the screen. CActor *pActor = parent->GetOwnerActor(); if (pActor && (!pActor->IsPlayer() || charNotVisible)) { if (IMovementController* pMC = pActor->GetMovementController()) { SMovementState state; pMC->GetMovementState(state); if(!charNotVisible) lamPos = state.weaponPosition; else { float oldZPos = lamPos.z; lamPos = state.weaponPosition; if(m_lastZPos>0.0f) lamPos.z = m_lastZPos; //Stabilize somehow z position (even if not accurate) else lamPos.z = oldZPos; } const float angleMin = DEG2RAD(3.0f); const float angleMax = DEG2RAD(7.0f); const float thr = cosf(angleMax); float dot = dir.Dot(state.aimDirection); if (dot > thr) { float a = acos_tpl(dot); float u = 1.0f - clamp((a - angleMin) / (angleMax - angleMin), 0.0f, 1.0f); dir = dir + u * (state.aimDirection - dir); dir.Normalize(); } } } if(!charNotVisible) m_lastZPos = lamPos.z; lamPos += (dir*0.10f); if (m_allowUpdate) { m_allowUpdate = false; IPhysicalEntity* pSkipEntity = NULL; if(parent->GetOwner()) pSkipEntity = parent->GetOwner()->GetPhysics(); const float range = m_lamparams.laser_range[eIGS_ThirdPerson]*dsg1Scale; // Use the same flags as the AI system uses for visbility. const int objects = ent_terrain|ent_static|ent_rigid|ent_sleeping_rigid|ent_independent; //ent_living; const int flags = (geom_colltype_ray << rwi_colltype_bit) | rwi_colltype_any | (10 & rwi_pierceability_mask) | (geom_colltype14 << rwi_colltype_bit); ray_hit hit; if (gEnv->pPhysicalWorld->RayWorldIntersection(lamPos, dir*range, objects, flags, &hit, 1, &pSkipEntity, pSkipEntity ? 1 : 0)) { laserLength = hit.dist; m_lastLaserHitPt = hit.pt; m_lastLaserHitSolid = true; } else { m_lastLaserHitSolid = false; m_lastLaserHitPt = lamPos + dir * range; laserLength = range + 0.1f; } // Hit near plane if (dir.Dot(camera.GetViewdir()) < 0.0f) { Plane nearPlane; nearPlane.SetPlane(camera.GetViewdir(), camera.GetPosition()); nearPlane.d -= camera.GetNearPlane()+0.15f; Ray ray(lamPos, dir); Vec3 out; m_lastLaserHitViewPlane = false; if (Intersect::Ray_Plane(ray, nearPlane, out)) { float dist = Distance::Point_Point(lamPos, out); if (dist < laserLength) { laserLength = dist; m_lastLaserHitPt = out; m_lastLaserHitSolid = true; m_lastLaserHitViewPlane = true; } } } hitPos = m_lastLaserHitPt; } else { laserLength = Distance::Point_Point(m_lastLaserHitPt, lamPos); hitPos = lamPos + dir * laserLength; } if (m_smoothLaserLength < 0.0f) m_smoothLaserLength = laserLength; else { if (laserLength < m_smoothLaserLength) m_smoothLaserLength = laserLength; else m_smoothLaserLength += (laserLength - m_smoothLaserLength) * min(1.0f, 10.0f * frameTime); } float laserAIRange = 0.0f; if (m_laserActivated && pLaserEntity) { // Orient the laser towards the point point. Matrix34 parentTMInv; parentTMInv = pRootEnt->GetWorldTM().GetInverted(); Vec3 localDir = parentTMInv.TransformPoint(hitPos); float finalLaserLen = localDir.NormalizeSafe(); Matrix33 rot; rot.SetIdentity(); rot.SetRotationVDir(localDir); pLaserEntity->SetLocalTM(rot); laserAIRange = finalLaserLen; const float assetLength = 2.0f; finalLaserLen = CLAMP(finalLaserLen,0.01f,m_lamparams.laser_max_len*dsg1Scale); float scale = finalLaserLen / assetLength; // Scale the laser based on the distance. if (m_laserEffectSlot >= 0) { Matrix33 scl; scl.SetIdentity(); scl.SetScale(Vec3(1,scale,1)); pLaserEntity->SetSlotLocalTM(m_laserEffectSlot, scl); } if (m_dotEffectSlot >= 0) { if (m_lastLaserHitSolid) { Matrix34 mt = Matrix34::CreateTranslationMat(Vec3(0,finalLaserLen,0)); if(m_lastLaserHitViewPlane) mt.Scale(Vec3(0.2f,0.2f,0.2f)); pLaserEntity->SetSlotLocalTM(m_dotEffectSlot, mt); } else { Matrix34 scaleMatrix; scaleMatrix.SetIdentity(); scaleMatrix.SetScale(Vec3(0.001f,0.001f,0.001f)); pLaserEntity->SetSlotLocalTM(m_dotEffectSlot, scaleMatrix); } } } float lightAIRange = 0.0f; if (m_lightActivated) { float range = clamp(m_smoothLaserLength, 0.5f, m_lamparams.light_range[eIGS_ThirdPerson]); lightAIRange = range * 1.5f; if (m_lightID[eIGS_ThirdPerson] && m_smoothLaserLength > 0.0f) { CItem* pLightEffect = this; if (IItem *pOwnerItem = m_pItemSystem->GetItem(GetParentId())) pLightEffect = (CItem *)pOwnerItem; pLightEffect->SetLightRadius(range, m_lightID[eIGS_ThirdPerson]); } } if (laserAIRange > 0.0001f || lightAIRange > 0.0001f) UpdateAILightAndLaser(lamPos, dir, lightAIRange, m_lamparams.light_fov[eIGS_ThirdPerson], laserAIRange); }
float V3d::distAbove(Plane p) { // -ve if below in terms of plane's normal return p.distto(*this); }
int main(int argc, char** argv) { GFXBoilerplate gfx(SCREEN_WIDTH, SCREEN_HEIGHT); gfx.init(); glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS); ////////////// LOAD SH LUT ////////////// Texture2d sh_lut, a_lut, b_lut, len_lut; ifstream in(argc > 1 ? argv[0] : "sh_lut.txt"); if (!in) { cout << "Error loading file " << (argc > 1 ? argv[0] : "sh_lut.txt") << endl; return 1; } int lut_size; in >> lut_size; float* sh_logs = new float[lut_size*N_COEFFS]; float* a_coeffs = new float[lut_size]; float* b_coeffs = new float[lut_size]; float* inv_lens = new float[lut_size]; double tmp; for (int i = 0; i < lut_size*N_COEFFS; i++) { in >> tmp; sh_logs[i] = static_cast<float>(tmp); } for (int i = 0; i < lut_size; i++) { in >> tmp; a_coeffs[i] = static_cast<float>(tmp); } for (int i = 0; i < lut_size; i++) { in >> tmp; b_coeffs[i] = static_cast<float>(tmp); } const float MAX_ZH_LENGTH = 8.845128074703045f; float lengths[lut_size]; for (int i = 0; i < lut_size; i++) { lengths[i] = sh_length(sh_logs+i*N_COEFFS)/MAX_ZH_LENGTH; } for (int i = 0; i < lut_size; i++) { float fx = (float)i/(float)lut_size; int j = 1; while (lengths[j] < fx && j < lut_size) j++; float u = unlerp(lengths[j-1], lengths[j], fx); float x = (float)j - 1.f + u; inv_lens[i] = x/(float)lut_size; } GLuint tex_offset = 0; glActiveTexture(GL_TEXTURE0+(tex_offset++)); sh_lut.build(); sh_lut.load_tex(sh_logs, N_COEFFS, lut_size, GL_R32F, GL_RED, GL_FLOAT); glActiveTexture(GL_TEXTURE0+(tex_offset++)); a_lut.build(); a_lut.load_tex(a_coeffs, 1, lut_size, GL_R32F, GL_RED, GL_FLOAT); glActiveTexture(GL_TEXTURE0+(tex_offset++)); b_lut.build(); b_lut.load_tex(b_coeffs, 1, lut_size, GL_R32F, GL_RED, GL_FLOAT); glActiveTexture(GL_TEXTURE0+(tex_offset++)); len_lut.build(); len_lut.load_tex(inv_lens, 1, lut_size, GL_R32F, GL_RED, GL_FLOAT); delete [] sh_logs; delete [] a_coeffs; delete [] b_coeffs; delete [] inv_lens; ////////////// GENERATE LH CUBEMAPS //////////// const int SQRT_N_SAMPLES = 100; const int N_SAMPLES = SQRT_N_SAMPLES*SQRT_N_SAMPLES; SHSample* samples = new SHSample[N_SAMPLES]; for (int i = 0; i < N_SAMPLES; i++) { samples[i].coeff = new double[N_COEFFS]; } SH_setup_spherical_samples(samples, SQRT_N_SAMPLES, N_BANDS); double *l_coeff = new double[N_COEFFS]; double *h_coeff = new double[N_COEFFS]; auto sky_function = clearsky(M_PI*0.3, M_PI); SH_project_polar_function(sky_function, samples, N_SAMPLES, N_BANDS, l_coeff); const int H_MAP_SIZE = 8; auto h_map_function = [l_coeff, h_coeff, samples](double theta, double phi, double *coeffs) { SH_project_polar_function(h_function(theta, phi), samples, N_SAMPLES, N_BANDS, h_coeff); for (int h = 0; h < N_COEFFS; h++) { h_coeff[h] /= M_PI; } SH_product(h_coeff, l_coeff, coeffs); }; cout << "Loading H map ... " << endl; glActiveTexture(GL_TEXTURE0+(tex_offset++)); CubeMapArray h_map_array = gen_sh_cube_map_array(H_MAP_SIZE, h_map_function, GL_R32F, GL_RED, GL_FLOAT); cout << "done." << endl; delete [] l_coeff; delete [] h_coeff; ///////////////// MAKE SPHERE ... DATA? //////////////// float *radiuses_data = new float[MAX_SPHERES]; float *positions_data = new float[MAX_SPHERES*3]; ///////////////// DO THE OPENGL THING //////////////// glfwSetCursorPosCallback(gfx.window(), mouse_callback); glfwSetKeyCallback(gfx.window(), my_key_callback); Shader* pos_shader = (new Shader()) ->vertex("simple_vert.glsl") ->fragment("pos_frag.glsl") -> build(); Shader* shexp_shader = (new Shader()) ->vertex("pass_vert.glsl") ->fragment("shexp_frag.glsl") ->build(); Shader* sh_shader = (new Shader()) ->vertex("simple_vert.glsl") ->fragment("sh_frag.glsl") ->build(); Shader* main_shader = (new Shader()) ->vertex("simple_vert.glsl") ->fragment("main_frag.glsl") ->build(); Shader* pp_shader = (new Shader()) ->vertex("pass_vert.glsl") ->fragment("pp_pass.glsl") ->build(); Shader* skybox = (new Shader()) ->vertex("skybox_vert.glsl") ->fragment("skybox_frag.glsl") ->build(); GLsizei buf_width = SCREEN_WIDTH/SCALE_DOWN_FACTOR; GLsizei buf_height = SCREEN_HEIGHT/SCALE_DOWN_FACTOR; glActiveTexture(GL_TEXTURE0+33); Texture2d pos_texture; pos_texture.build(); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); pos_texture.load_tex(NULL, buf_width, buf_height, GL_RGB32F, GL_RGB, GL_FLOAT); glActiveTexture(GL_TEXTURE0+34); Texture2d norm_texture; norm_texture.build(); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); norm_texture.load_tex(NULL, buf_width, buf_height, GL_RGB32F, GL_RGB, GL_FLOAT); Framebuffer pos_buffer(buf_width,buf_height); pos_buffer.build(); pos_buffer.bind_to_texture(GL_COLOR_ATTACHMENT0, pos_texture.handle()); pos_buffer.bind_to_texture(GL_COLOR_ATTACHMENT1, norm_texture.handle()); glActiveTexture(GL_TEXTURE0+35); Texture2dArray sh_texture; sh_texture.build(); sh_texture.load_tex(NULL, buf_width, buf_height, N_COEFFS/4, GL_RGBA32F, GL_RGBA, GL_FLOAT); Framebuffer sh_buffer(buf_width,buf_height); sh_buffer.build(); for (int i = 0; i < N_COEFFS/4; i++) { sh_buffer.bind_to_texture_layer(GL_COLOR_ATTACHMENT0+i, sh_texture.handle(), i); } glActiveTexture(GL_TEXTURE0+36); Texture2d shexp_texture; shexp_texture.build(); shexp_texture.load_tex(NULL, buf_width, buf_height, GL_R32F, GL_RED, GL_FLOAT); Framebuffer shexp_buffer(buf_width,buf_height); shexp_buffer.build(); shexp_buffer.bind_to_texture(GL_COLOR_ATTACHMENT0, shexp_texture.handle()); Sphere sph; sph.build(); glActiveTexture(GL_TEXTURE0+42); CubeMap skymap = gen_cube_map(256, sky_function, GL_R32F, GL_RED, GL_FLOAT); NDCQuad all_the_pixels; all_the_pixels.build(); int num_spheres = load_spheres("Humanoid_0000.vsp", positions_data, radiuses_data); Plane pln; pln.build(); Transform plane_transform(vec3(0,0,0),quat(1,0,0,0),vec3(2000)); WorldObject pln_obj(&pln, &plane_transform); WavefrontMesh dude("Humanoid_0000.obj"); dude.build(); Transform dude_transform(vec3(0,0,0), quat(1,0,0,0), vec3(1)); WorldObject dude_obj(&dude, &dude_transform); GLsizei n_objects = 2; WorldObject** objects = new WorldObject*[n_objects]; objects[0] = &pln_obj; objects[1] = &dude_obj; float oracle_factor = 15; float far = 2000.0f; int width, height; float aspect; mat4 projection; sh_shader->use(); sh_shader->updateInt("screen_width", buf_width); sh_shader->updateInt("screen_height", buf_height); sh_shader->updateInt("position", 33); sh_shader->updateInt("normal", 34); sh_shader->updateFloat("oracle_factor", oracle_factor); sh_shader->updateInt("sh_lut", 0); shexp_shader->use(); shexp_shader->updateInt("screen_width", buf_width); shexp_shader->updateInt("screen_height", buf_height); shexp_shader->updateInt("a_lut", 1); shexp_shader->updateInt("b_lut", 2); shexp_shader->updateInt("len_lut", 3); shexp_shader->updateInt("h_maps", 4); shexp_shader->updateFloat("max_zh_len", MAX_ZH_LENGTH); shexp_shader->updateInt("normal", 34); shexp_shader->updateInt("shlogs", 35); main_shader->use(); main_shader->updateInt("shexps", 36); main_shader->updateInt("screen_width", buf_width); main_shader->updateInt("screen_height", buf_height); skybox->use(); skybox->updateInt("map", 42); pp_shader->use(); pp_shader->updateInt("tex1", 35); pp_shader->updateInt("tex2", 36); glEnable(GL_DEPTH_TEST); while (!glfwWindowShouldClose(gfx.window())) { glfwGetFramebufferSize(gfx.window(), &width, &height); aspect = (float)width/(float)height; projection = perspective(45.0f, aspect, 0.5f, far); handleInput(gfx.window()); pos_buffer.use(2); pos_shader->use(); pos_shader->updateMat4("view", camera.getView()); pos_shader->updateMat4("projection", projection); draw_scene(pos_shader, objects, n_objects); sh_buffer.use(N_COEFFS/4); sh_shader->use(); sh_shader->updateMat4("view", camera.getView()); sh_shader->updateMat4("projection", projection); glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); glBlendEquation(GL_FUNC_ADD); glBlendFunc(GL_ONE, GL_ONE); splat_spheres(sh_shader, positions_data, radiuses_data, num_spheres, oracle_factor, &sph); glDisable(GL_BLEND); glEnable(GL_DEPTH_TEST); shexp_buffer.use(1); shexp_shader->use(); all_the_pixels.draw(); Framebuffer::unbind(); glViewport(0, 0, width, height); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); skybox->use(); skybox->updateFloat("aspect", aspect); skybox->updateMat4("view", camera.getView()); skybox->updateMat4("projection", projection); glDepthMask(GL_FALSE); all_the_pixels.draw(); glDepthMask(GL_TRUE); main_shader->use(); main_shader->updateInt("screen_width", width); main_shader->updateInt("screen_height", height); main_shader->updateMat4("view", camera.getView()); main_shader->updateMat4("projection", projection); draw_scene(main_shader, objects, n_objects); //pp_shader->use(); //pp_shader->updateInt("screen_width", width); //pp_shader->updateInt("screen_height", height); //all_the_pixels.draw(); glfwSwapBuffers(gfx.window()); glfwPollEvents(); } sph.destroy(); pln.destroy(); dude.destroy(); sh_shader->destroy(); shexp_shader->destroy(); skybox->destroy(); pos_shader->destroy(); main_shader->destroy(); delete sh_shader; delete shexp_shader; delete skybox; delete pos_shader; delete main_shader; delete [] positions_data; delete [] radiuses_data; delete [] objects; gfx.cleanup(); return 0; }
void thrust_HiForest(Int_t startfile = 0, Int_t endfile = 1, Int_t radius = 3, std::string kFoname="test_output.root", float ptCut = 30.0, float etaCut = 2.0){ TH1::SetDefaultSumw2(); TStopwatch timer; bool debug = false; //Float_t pT_cut = 30; //Int_t radius = 3; //define trees and file TFile * file; //TFile * weight_file; TTree * t; TTree * hiEvt; //TTree * hlt; TTree * skim; //TTree * weight; TTree * thrust_tree; /* //set up the tree to be filled thrust_tree->Branch("pthatweight",&pthatweight,"pthatweight/D"); thrust_tree->Branch("hiBin",&hiBin,"hiBin/I"); thrust_tree->Branch("evt",&evnt,"evt/I"); thrust_tree->Branch("lumi",&lumi,"lumi/I"); thrust_tree->Branch("vz",&vz,"vz/F"); */ //Tree variables Float_t pt[1000]; Int_t jt80; Int_t jt80_pre; Float_t eta[1000]; Int_t jt40; Int_t jt60_pre; Float_t phi[1000]; Int_t jt60; Int_t jt40_pre; // Double_t px[1000]; // Double_t py[1000]; // Double_t pz[1000]; Int_t nref; Float_t vz; Int_t hiBin; Int_t halo; Int_t noise; //Double_t pThat_weight; //Float_t pThat; Float_t dot = 0; Double_t mag = 0; Double_t thrust_temp = 0; Double_t thrust_max = 0; Double_t dot_maj = 0; Double_t dot_min = 0; Double_t min_temp = 0; Double_t maj_temp = 0; Double_t thrust_maj_max =0; Double_t thrust_min_max = 0; TVector3 max_thrust_axis; TVector3 p3Norm; //Float_t max_eta = 0; Float_t temp_eta = 0; //Float_t max_phi = 0; Float_t temp_phi = 0; Int_t max_nref; Int_t jetCount = 0; //in order to sum up the number of jets per event Int_t eventCount = 0;//check to see how many of the events in each file are actually being used //define instream string input_file = "jetRAA_PbPb_data_forest.txt"; ifstream count(input_file.c_str(), ifstream::in); Int_t fileCount = 0; string * filename = new string[10000]; //count up the total number of files and save their names to an array of filenames for initialization purposes string line; while(getline(count, line)){ filename[fileCount] = line; if (debug) cout << filename[fileCount] << endl; fileCount++; } count.close(); TFile * save_File = new TFile(kFoname.c_str(),"RECREATE"); TH1F * h_thrust[nbins_cent], * h_min[nbins_cent], * h_maj[nbins_cent], * h_pT[nbins_cent], * h_pTcut[nbins_cent], * h_nref[nbins_cent], * h_jetCount[nbins_cent], * h_eta[nbins_cent], * h_phi[nbins_cent], * h_TBad[nbins_cent], * h_TminBad[nbins_cent], * h_TmajBad[nbins_cent], * h_TBadpT[nbins_cent], * h_TmajBadpT[nbins_cent],* h_TminBadpT[nbins_cent], * h_etaBad[nbins_cent], * h_phiBad[nbins_cent], * h_nrefBad[nbins_cent], * h_jetCountBad[nbins_cent]; //TH1F * h_weight = new TH1F("weighting", "", 500, 0, 500); //TH1F * h_weightBad = new TH1F("weightingBad", "", 500, 0, 500); //TH1F * h_pthatBad = new TH1F("pthatBad", "", 500, 0, 500); TH1F * h_fileNum = new TH1F("fileNum", "", 45, 0, 45); TH2F * hThrust_vs_Aj[nbins_cent]; for(int i = 0; i<nbins_cent; ++i){ hThrust_vs_Aj[i] = new TH2F(Form("hThrust_vs_Aj_cent%d",i),"",50, 0, 1, 50, 0, 1); h_thrust[i] = new TH1F(Form("thrust_unscaled_cent%d",i), "", 50,0,1); h_min[i] = new TH1F(Form("thrust_min_cent%d",i), "", 50,0,1); h_maj[i] = new TH1F(Form("thrust_maj_cent%d",i), "", 50,0,1); h_pT[i] = new TH1F(Form("pT_cent%d",i), "", 100, 0, 120); h_pTcut[i] = new TH1F(Form("pTcut_cent%d",i), "", 100, 0, 120); //h_40[i] = new TH1F(Form("thrust_40_cent%d",i), "", 50,0,1); //h_60[i] = new TH1F(Form("thrust_60_cent%d",i), "", 50,0,1); //h_80[i] = new TH1F(Form("thrust_80_cent%d",i), "", 50,0,1); h_nref[i] = new TH1F(Form("nref_cent%d",i), "", 12, 0, 12); h_jetCount[i] = new TH1F(Form("jetCount_cent%d",i), "", 12, 0, 12); h_eta[i] = new TH1F(Form("eta_cent%d",i), "", 60, -2, 2); h_phi[i] = new TH1F(Form("phi_cent%d",i), "", 60, -3.15, 3.15); h_TBad[i] = new TH1F(Form("thrust_bad_cent%d",i), "", 50,0,1); h_TminBad[i] = new TH1F(Form("thrust_min_bad_cent%d",i), "", 50,0,1); h_TmajBad[i] = new TH1F(Form("thrust_maj_bad_cent%d",i), "", 50,0,1); h_TBadpT[i] = new TH1F(Form("TBadpT_cent%d",i), "", 100, 0, 120); h_TmajBadpT[i] = new TH1F(Form("TmajBadpT_cent%d",i), "", 100, 0, 120); h_TminBadpT[i] = new TH1F(Form("TminBadpT_cent%d",i), "", 100, 0, 120); h_etaBad[i] = new TH1F(Form("etaBad_cent%d",i), "", 60, -2, 2); h_phiBad[i] = new TH1F(Form("phiBad_cent%d",i), "", 60, -3.15, 3.15); h_nrefBad[i] = new TH1F(Form("nrefBad_cent%d",i), "", 12, 0, 12); h_jetCountBad[i] = new TH1F(Form("jetCountBad_cent%d",i), "", 12, 0, 12); } // For every file in file list, process trees for(int ifile = startfile; ifile < endfile; ifile++){ string s = filename[ifile]; //string w = Form("weights_pbpb_%d.root", ifile+1); file = TFile::Open(s.c_str()); //weight_file = TFile::Open(w.c_str()); if (debug) cout << "\n **** =========================== New File ================================= **** \n "; cout << "File Name: " << filename[ifile] << endl; cout << "File Number: " << endfile-ifile << "/" << endfile-startfile << endl; //cout << "Weight File: " << w << endl; //define trees and file t = (TTree*)file->Get(Form("akPu%dPFJetAnalyzer/t", radius)); hiEvt = (TTree*)file->Get("hiEvtAnalyzer/HiTree"); //hlt = (TTree*)file->Get("hltanalysis/HltTree"); skim = (TTree*)file->Get("skimanalysis/HltTree"); //weight = (TTree*)weight_file->Get("weights"); //Set branches of the tree t->SetBranchAddress("jtpt", &pt); t->SetBranchAddress("jteta", &eta); t->SetBranchAddress("jtphi", &phi); t->SetBranchAddress("nref", &nref); //t->SetBranchAddress("pthat", &pThat); hiEvt->SetBranchAddress("vz", &vz); hiEvt->SetBranchAddress("hiBin", &hiBin); skim->SetBranchAddress("pHBHENoiseFilter", &noise); skim->SetBranchAddress("pcollisionEventSelection",&halo); //hlt->SetBranchAddress("HLT_PAJet80_NoJetID_v1",&jt80); //hlt->SetBranchAddress("HLT_PAJet60_NoJetID_v1",&jt60); //hlt->SetBranchAddress("HLT_PAJet40_NoJetID_v1",&jt40); //hlt->SetBranchAddress("HLT_PAJet80_NoJetID_v1_Prescl",&jt80_pre); //hlt->SetBranchAddress("HLT_PAJet60_NoJetID_v1_Prescl",&jt60_pre); //hlt->SetBranchAddress("HLT_PAJet40_NoJetID_v1_Prescl",&jt40_pre); //weight->SetBranchAddress("pthatweight", &pThat_weight); t->AddFriend(hiEvt); t->AddFriend(skim); //t->AddFriend(hlt); //t->AddFriend(weight); Long64_t nentries = t->GetEntries(); //nentries = 10000; cout << "Events in File: " << nentries << endl; eventCount = 0; save_File->cd(); //event loop for(Long64_t nentry = 0; nentry<nentries; ++nentry){ //for(Long64_t nentry = 6662; nentry<6663; ++nentry){ if(nentry%10000 == 0) cout << nentry << endl; t->GetEntry(nentry); skim->GetEntry(nentry); hiEvt->GetEntry(nentry); //weight->GetEntry(nentry); int cBin = findBin(hiBin);//tells us the centrality of the event. if(cBin==-1 || cBin==nbins_cent) continue; jetCount = 0; bool select = false; //make selection cuts if(TMath::Abs(vz) > 15 || halo == 0 || noise == 0) continue; // apply the pT dijet clean sample selection if(pt[0]< 120 || pt[1] <50) continue; //fill pThat spectra plot //h_weight->Fill(pThat, pThat_weight); //if((TMath::Abs(vz) > 15)) {continue;} // get the pt vector for each event which passes you jet selections based on pT and eta vector <float> pt_v; vector <float> eta_v; vector <float> phi_v; for(int ij = 0; ij<nref; ++ij){ if(pt[ij] > ptCut && fabs(eta[ij]) < etaCut){ pt_v.push_back(pt[ij]); eta_v.push_back(eta[ij]); phi_v.push_back(phi[ij]); } } if (debug) cout<<"Total Number of Jets : "<<nref<<endl; if (debug) cout<<"Number of Selected Jets : "<<pt_v.size()<<endl; int NJets_Sel = pt_v.size(); if(NJets_Sel < 2) { if (debug) cout<<"This event had only 1 Jet"<<endl; continue; } double Aj = (double)(pt_v[0] - pt_v[1])/(pt_v[0]+pt_v[1]); // //intial pT cut // for(int k = 0; k < nref; k++){ // if(pt[k] > 30){ // if((TMath::Abs(eta[k])<2)) select = true; // } // } // if(!select) continue; if(debug) cout<< " \n ******* New Event ******** " << endl; if(debug) cout<< " ******* " << nentry << " ******** " << endl; //reset maximum values eventCount++; thrust_max = 0; vector <double> px; vector <double> py; vector <double> pz; for(Long64_t naxis = 0; naxis < NJets_Sel; ++naxis){ float axis_jet_pt = pt_v[naxis]; float axis_jet_eta = eta_v[naxis]; float axis_jet_phi = phi_v[naxis]; px.push_back((double)axis_jet_pt * TMath::Cos(axis_jet_phi)); py.push_back((double)axis_jet_pt * TMath::Sin(axis_jet_phi)); pz.push_back((double)axis_jet_pt * TMath::SinH(axis_jet_eta)); if(py[naxis] == 0) { if(debug) cout << "PYZERO" << endl; if(debug) cout<< "Jet Variables: "<< "\n \t pT = "<<axis_jet_pt<<"\n \t eta = "<<axis_jet_eta<<"\n \t phi = "<<axis_jet_phi<<endl; } } //PART 1 ==================================================== //Runs through all the jets in an event, checking them to see if they are the axis that maximizes thrust //max axis finding loop for(Long64_t naxis = 0; naxis < NJets_Sel; ++naxis){ float axis_jet_pt = pt_v[naxis]; float axis_jet_eta = eta_v[naxis]; float axis_jet_phi = phi_v[naxis]; //Cut checks //if(debug) cout<< "Jet Variables: "<< "\n \t pT = "<<axis_jet_pt<<"\n \t eta = "<<axis_jet_eta<<"\n \t phi = "<<axis_jet_phi<<endl; // h_pT->Fill(pt[naxis]); // if((pt[naxis] < pT_cut)||(TMath::Abs(eta[naxis]) > 2)) { // continue; // } h_pTcut[cBin]->Fill(axis_jet_pt); // jetCount++; if(debug) cout<< " \n --------- New Test Axis (Thrust)--------- " << endl; //reset values for this particular event thrust_temp = 0; // maj_temp = 0; min_temp = 0; // px[naxis] = pt[naxis]*TMath::Cos(phi[naxis]); // py[naxis] = pt[naxis]*TMath::Sin(phi[naxis]); // pz[naxis] = pt[naxis]*TMath::SinH(eta[naxis]); //calculates axis for this particular jet TVector3 nT (px[naxis], py[naxis], pz[naxis]); if(debug) cout<<"Test Axis Unnormed = {" << nT(0) << ", " << nT(1) << ", " << nT(2)<< "}" << endl; nT = Norm(nT); if(debug) cout<<"Test Axis = {" << nT(0) << ", " << nT(1) << ", " << nT(2)<< "}" << endl; //temp_phi = axis_jet_phi; temp_eta = axis_jet_eta; //resets for next jet loop dot = 0; mag = 0; //PART 2 ==================================================== //Loops through all the jets to find the thrust value for the chosen axis //jet loop for(Long64_t njet = 0; njet < NJets_Sel; ++njet){ // if((pt[njet] < pT_cut)||(TMath::Abs(eta[njet]) > 2)){ continue;} float jet_pt = pt_v[njet]; float jet_eta = eta_v[njet]; float jet_phi = phi_v[njet]; if(debug) cout<< " \n --------- New Jet (Thrust)--------- " << endl; if(debug) cout<< "Jet Variables: "<< "\n \t pT = "<<jet_pt<<"\n \t eta = "<<jet_eta<<"\n \t phi = "<<jet_phi<<endl; //calculate px, py, pz // px[njet] = pt[njet]*TMath::Cos(phi[njet]); // py[njet] = pt[njet]*TMath::Sin(phi[njet]); // pz[njet] = pt[njet]*TMath::SinH(eta[njet]); //define momentum three vector TVector3 p3 (px[njet], py[njet], pz[njet]); //TVector3 p3Norm = Norm(p3); if(debug) cout<<"Jet Axis = {" << p3(0) << ", " << p3(1) << ", " << p3(2)<< "}" << endl; //dots the two vectors for Thrust, Tmin and Tmaj dot += TMath::Abs(p3.Dot(nT)); if(debug) cout<<"dot sum = " << dot << endl; //sum the total p from the individual p magnitudes mag += TMath::Abs(p3.Mag()); if(debug) cout<<"mag sum = " << mag << endl; }//end jet loop //calculate the thrust thrust_temp = ((dot)/mag); //Compare to see if this axis is a new maximum if(debug) cout<< "\ntemp thrust = " << thrust_temp << endl; if(thrust_temp>thrust_max){ thrust_max = thrust_temp; max_thrust_axis = nT; //max_eta = temp_eta; //max_phi = temp_phi; max_nref = naxis; } if(debug) cout<< "max thrust = " << thrust_max << endl; }//end axis loop if (debug) cout << "FINAL THRUST VALUE: " << thrust_max << endl; // FILL BAD THRUST VALUES TO DEBUG ============================= if(thrust_max < 0.47) { //h_TBadpT->Fill(pt[naxis], pThat_weight); h_TBad[cBin]->Fill(thrust_max); h_etaBad[cBin]->Fill(eta_v[max_nref]); h_phiBad[cBin]->Fill(phi_v[max_nref]); h_nrefBad[cBin]->Fill(max_nref); h_jetCountBad[cBin]->Fill(NJets_Sel); //h_weightBad->Fill(pThat_weight); //h_pthatBad->Fill(pThat); h_fileNum->Fill(ifile); if (debug) cout << "______________________________" << endl; if (debug) cout << "| X0X : THRUST LESS THAN 0.5 |" << endl; if (debug) cout << "| Max Thrust: " << thrust_max << endl; //cout << "| Max Thrust: " << thrust_max << endl; if (debug) cout << "______________________________" << endl; } // fill thrust vs Aj plot hThrust_vs_Aj[cBin]->Fill(Aj, thrust_max); //PART 3 ==================================================== //Begin code to select the Thrust Major and Minor axes //define the plane perpendicular to this axis in order to calculate Tmaj and Tmin Plane* perp = new Plane(max_thrust_axis); //reset maximum values for new axis test thrust_maj_max = 0; thrust_min_max = 0; //Thrust maj axis loop for(Long64_t naxis = 0; naxis < NJets_Sel; ++naxis){ // if((pt[naxis] < pT_cut)||(TMath::Abs(eta[naxis]) > 2)){ continue;} if(debug) cout<< " \n --------- New Test Axis (Min/Maj)--------- " << endl; //define the jet axis for this iteration //calculate px, py, pz // px[naxis] = pt[naxis]*TMath::Cos(phi[naxis]); // py[naxis] = pt[naxis]*TMath::Sin(phi[naxis]); // pz[naxis] = pt[naxis]*TMath::SinH(eta[naxis]); //define momentum three vector TVector3 p3 (px[naxis], py[naxis], pz[naxis]); if(debug) cout<<"Jet Axis UnNormed = {" << p3(0) << ", " << p3(1) << ", " << p3(2)<< "}" << endl; p3 = Norm(p3); if(debug) cout<<"Jet Axis Normed = {" << p3(0) << ", " << p3(1) << ", " << p3(2)<< "}" << endl; //define maj_axis and min_axis TVector3 maj_axis = perp->Projection((p3)); if(debug) cout<<"Maj Axis UnNormed = {" << maj_axis(0) << ", " << maj_axis(1) << ", " << maj_axis(2)<< "}" << endl; maj_axis = Norm(maj_axis); TVector3 min_axis = max_thrust_axis.Cross(maj_axis); min_axis = Norm(min_axis); if(debug) cout<<"Jet Axis = {" << p3(0) << ", " << p3(1) << ", " << p3(2)<< "}" << endl; if(debug) cout<<"Maj Axis = {" << maj_axis(0) << ", " << maj_axis(1) << ", " << maj_axis(2)<< "}" << endl; if(debug) cout<<"Min Axis = {" << min_axis(0) << ", " << min_axis(1) << ", " << min_axis(2)<< "}\n" << endl; //reset for new axis test dot_maj = 0; dot_min = 0; mag = 0; //PART 4 ==================================================== //Test the axis defined by the above loop to determine if this axis is the maximum //jet loop for(Long64_t njet = 0; njet < NJets_Sel; ++njet){ //make a ptcut // if((pt[njet] < pT_cut)||(TMath::Abs(eta[njet]) > 2)){ continue;} float jet_pt = pt_v[njet]; float jet_eta = eta_v[njet]; float jet_phi = phi_v[njet]; if(debug) cout<< " \n --------- New Jet (Maj/Min)--------- " << endl; //if(debug) cout<< "Jet Variables: "<< "\n \t pT = "<<pt[njet]<<"\n \t eta = "<<eta[njet]<<"\n \t phi = "<<phi[njet]<<endl; if(debug) cout<< "Jet Variables: "<< "\n \t pT = "<<jet_pt<<"\n \t eta = "<<jet_eta<<"\n \t phi = "<<jet_phi<<endl; //calculate px, py, pz // px[njet] = pt[njet]*TMath::Cos(phi[njet]); // py[njet] = pt[njet]*TMath::Sin(phi[njet]); // pz[njet] = pt[njet]*TMath::SinH(eta[njet]); //define momentum three vector TVector3 p3 (px[njet], py[njet], pz[njet]); TVector3 p3Norm = Norm(p3); if(debug) cout<<"Jet Axis = {" << p3(0) << ", " << p3(1) << ", " << p3(2)<< "}" << endl; //dots the two vectors for Tmin and Tmaj dot_maj += TMath::Abs(p3.Dot(maj_axis)); dot_min += TMath::Abs(p3.Dot(min_axis)); if(debug) cout<<"dot maj sum = " << dot_maj << endl; if(debug) cout<<"dot min sum = " << dot_min << endl; //sum the total p from the individual p magnitudes mag += TMath::Abs(p3.Mag()); if(debug) cout<<"mag sum = " << mag << endl; }//end jet loop //calculate the thrust major and minor for this axis maj_temp = dot_maj/mag; min_temp = dot_min/mag; //test to to see if this particular Tmaj and Tmin are the new maxima if(maj_temp>thrust_maj_max){ thrust_maj_max = maj_temp; thrust_min_max = min_temp; if(debug) cout << "thrust major max = "<< thrust_maj_max<< endl; /* if(maj_temp > 0.5) { h_TmajBadpT->Fill(pt[naxis]); h_TmajBad->Fill(maj_temp); } if(min_temp > 0.5) { h_TminBadpT->Fill(pt[naxis]); h_TminBad->Fill(maj_temp); } */ } }//end of major/minor axis loop timer.Stop(); //fill all the maximum values before finishing // if(jetCount > 1){ h_thrust[cBin]->Fill(thrust_max); h_eta[cBin]->Fill(eta_v[max_nref]); h_phi[cBin]->Fill(phi_v[max_nref]); h_min[cBin]->Fill(thrust_min_max); h_maj[cBin]->Fill(thrust_maj_max); h_nref[cBin]->Fill(nref); h_jetCount[cBin]->Fill(NJets_Sel); if(debug) { if (thrust_max < 0.5) { cout << "FLAG_thrust1: " << thrust_max << " , " << jetCount << endl; } if (thrust_maj_max > 0.5) { cout << "FLAG_maj: " << thrust_maj_max << " , " << jetCount << endl; } if (thrust_min_max > 0.5) { cout << "FLAG_min: " << thrust_min_max << " , " << jetCount << endl; } } //if(jt80) h_80->Fill(thrust_max,jt80_pre * pThat_weight); //if(jt60) h_60->Fill(thrust_max,jt60_pre * pThat_weight); //if(jt40) h_40->Fill(thrust_max,jt40_pre * pThat_weight); //} pt_v.clear(); eta_v.clear(); phi_v.clear(); px.clear(); py.clear(); pz.clear(); }//end of event loop gROOT->GetListOfFiles()->Remove(file); //gROOT->GetListOfFiles()->Remove(weight); cout << "Events Selected: " << eventCount << endl; cout << "File Finished" << endl; }//end file loop //scale the histograms Double_t integral; // integral = h_thrust->Integral(); // h_thrust->Scale(1/integral); //h_thrust->Scale(1./h_thrust->Integral()); //h_maj->Scale(1./h_maj->Integral()); //h_min->Scale(1./h_min->Integral()); // integral = h_maj->Integral(); // h_maj->Scale(1/integral); // integral = h_min->Integral(); // h_min->Scale(1/integral); //integral = h_80->Integral(); //h_80->Scale(integral); //integral = h_60->Integral(); //h_60->Scale(integral); // integral = h_40->Integral(); //h_40->Scale(integral); //Create the plot for Thrust vs. dN/dT //define histograms // TH1F * h_T = DivideByBinWidth(h_thrust[], "thrust_scaled"); // TH1F * h_Tmaj = DivideByBinWidth(h_maj, "thrust_maj_scaled"); // TH1F * h_Tmin = DivideByBinWidth(h_min, "thrust_min_scaled"); //Float_t divEntries = 1./(h_thrust->GetBinWidth(1)); //h_T->Scale(divEntries); //h_Tmaj->Scale(divEntries); //h_Tmin->Scale(divEntries); //h_40 = DivideByBinWidth(h_40, "thrust_40_new"); h_40->Scale(divEntries); //h_60 = DivideByBinWidth(h_60, "thrust_60_new"); h_60->Scale(divEntries); //h_80 = DivideByBinWidth(h_80, "thrust_80_new"); h_80->Scale(divEntries); // h_T->Print("base"); // h_Tmaj->Print("base"); // h_Tmin->Print("base"); // h_pT->Print("base"); // h_pTcut->Print("base"); // //h_40->Print("base"); // //h_60->Print("base"); // //h_80->Print("base"); // h_nref->Print("base"); // h_jetCount->Print("base"); // h_eta->Print("base"); // h_phi->Print("base"); // h_weight->Print("base"); // h_T->Write(); // h_Tmaj->Write(); // h_Tmin->Write(); // h_pT->Write(); // h_pTcut->Write(); // //h_40->Write(); // //h_60->Write(); // //h_80->Write(); // h_nref->Write(); // h_jetCount->Write(); // h_eta->Write(); // h_phi->Write(); // h_weight->Write(); save_File->Write(); save_File->Close(); cout<<endl<<endl<<endl<<endl<<"GOING TO WRITE BAD OUTPUT FILE"<<endl<<endl<<endl<<endl; //if(debug) { // TFile * bad_File = new TFile(kFoname2.c_str(),"RECREATE"); // bad_File->cd(); // h_TBad->Print("base"); // h_TmajBad->Print("base"); // h_TminBad->Print("base"); // h_TBadpT->Print("base"); // h_TmajBadpT->Print("base"); // h_TminBadpT->Print("base"); // h_etaBad->Print("base"); // h_phiBad->Print("base"); // h_nrefBad->Print("base"); // h_jetCountBad->Print("base"); // h_pthatBad->Print("base"); // h_weightBad->Print("base"); // h_fileNum->Print("base"); // h_TBad->Write(); // h_TmajBad->Write(); // h_TminBad->Write(); // h_TBadpT->Write(); // h_TmajBadpT->Write(); // h_TminBadpT->Write(); // h_etaBad->Write(); // h_phiBad->Write(); // h_nrefBad->Write(); // h_jetCountBad->Write(); // h_pthatBad->Write(); // h_weightBad->Write(); // h_fileNum->Write(); // bad_File->Write(); // bad_File->Close(); // // } timer.Stop(); cout<<"Macro finished: "<<endl; cout<<"CPU time (min) = "<<(Float_t)timer.CpuTime()/60<<endl; cout<<"Real time (min) = "<<(Float_t)timer.RealTime()/60<<endl; }//end of plot thrust
void GameManager::Collision(FlyObject* objectA, FlyObject* objectB) { int type_ = 0; if (objectA->Name() == "Player" || objectB->Name() == "Player") { if (objectB->Name() == "Player"){ std::swap(objectA, objectB); } Player* play = static_cast<Player*>(objectA); if (objectB->Name() == "EnemyBomb") { Weapon *bomb = static_cast<Weapon*>(objectB); Produce(_T("Explosion"), Point(objectB->X() + objectB->Width() / 2, objectB->Y() + objectB->Height() / 2)); if (!God()){ play->SubHP(bomb->Power());} if (play->HP() <= 0){ //play->Killed(); OverGame();} bomb->Killed(); } if (objectB->Name() == "Enemy") { Plane *enemy = static_cast<Plane *>(objectB); if (enemy->DetailedName() == "Box" || enemy->DetailedName() == "BossLeft" || enemy->DetailedName() == "BossMid" || enemy->DetailedName() == "BossRight") return; Produce(_T("Explosion"), Point(objectB->X() + objectB->Width() / 2, objectB->Y() + objectB->Height() / 2)); if (!God()) play->SubHP(1); if (play->HP() <= 0) { //play->Killed(); OverGame(); } if (enemy->DetailedName() == "EnemyPrimaryPlane") { factory_.ProduceTool(5, *(enemy->Position()), enemy->DetailedName()); } else if (enemy->DetailedName() == "PropellerPlane") { factory_.ProduceTool(6, *(enemy->Position()), enemy->DetailedName()); } else if (enemy->DetailedName() == "Tank") { factory_.ProduceTool(7, *(enemy->Position()), enemy->DetailedName()); } else if (enemy->DetailedName() == "Box") { factory_.ProduceTool(Rand(5, 7), *(enemy->Position()), enemy->DetailedName()); } enemy->Killed(); } if (objectB->Name() == "Tool") { Tool *tool = static_cast<Tool *>(objectB); play->AddTool(tool->DetailedName(),tool->EnemyName(),tool->AddMark()); tool->DestroyTool(); } } else if (objectA->Name() == "PlayerBomb" || objectB->Name() == "PlayerBomb") { if (objectB->Name() == "PlayerBomb") { std::swap(objectA,objectB); } Weapon* bomb = static_cast<Weapon*>(objectA); if (objectB->Name() == "Enemy") { Plane* enemy = static_cast<Plane*>(objectB); bomb->Killed(); enemy->SubHP(bomb->Power()); if (enemy->HP() <= 0) { Produce(_T("Explosion"),Point(objectB->X() + objectB->Width()/2, objectB->Y() + objectB->Height() / 2)); if (enemy->DetailedName() == "EnemyPrimaryPlane") { factory_.ProduceTool(5, *(enemy->Position()),enemy->DetailedName()); } else if (enemy->DetailedName() == "PropellerPlane") { factory_.ProduceTool(6, *(enemy->Position()), enemy->DetailedName()); } else if (enemy->DetailedName() == "Tank") { factory_.ProduceTool(7, *(enemy->Position()), enemy->DetailedName()); } else if (enemy->DetailedName() == "Box") { factory_.ProduceTool(Rand(5,7), *(enemy->Position()), enemy->DetailedName()); } enemy->Killed(); } } } }
void GameWorld::updategame(float dt){ //CCLOG("update game"); Vector<Plane*> targets2Delete; //CCLOG("111, _targets: %zd.", _targets.size()); Vector<Plane*>::iterator iter;//; for (iter = _targets.begin(); iter != _targets.end(); iter++) { // target的碰撞体积 Plane* target = dynamic_cast<Plane*>(*iter); Rect targetRect = target->boundingBox(); // plane的碰撞矩形 Rect planeRect = _myPlane->boundingBox(); // plane与target的碰撞检测 if(targetRect.intersectsRect(planeRect)){ if(target->getTag() == 4){ CCLOG("package\n"); // if package and plane collide //doubleBulletFlag = true; this->scheduleOnce(schedule_selector(GameWorld::setDoubleBulletFlagF), 5); targets2Delete.pushBack(target); } else { CCLOG("game end."); // if enemy and plane collide auto gameOverScene = GameOverScene::create(); gameOverScene->getLayer()->getLabel()->setString(" "); gameOverScene->getLayer()->setCurrentScore(score); // converts 'int' to 'string' std::stringstream ss; std::string str; ss<<score; ss>>str; const char *pHighScore = str.c_str(); // converts 'const char *' to 'int' const char *highScore = localStorageGetItem("high_score").c_str(); if(highScore != NULL ){ int highScoreInt = std::atoi(highScore); // If higher than the highest score ,your score will replace it; if(highScoreInt<score) CCLOG("high_score: %s.", pHighScore); localStorageSetItem("high_score", pHighScore); }else{ localStorageSetItem("high_score", pHighScore); CCLOG("high_score: %s.", pHighScore); } gameOverScene->getLayer()->getScore()->setString(pHighScore); Director::getInstance()->replaceScene(gameOverScene); } } //CCLOG("222, bullet: %zd.", _bullets.size()); Vector<Sprite*> bullets2Delete; Vector<Sprite*>::iterator iterB; //bullet与target的碰撞 for (iterB = _bullets.begin(); iterB != _bullets.end(); iterB++) { //CCARRAY_FOREACH(_bullets, bulletsIterator){ auto bullet = dynamic_cast<Sprite*>(*iterB); Rect bulletRect = bullet->boundingBox(); if(targetRect.intersectsRect(bulletRect)){ target->attacked++; //CCLOG("target attacked: %d.", target->attacked); bullets2Delete.pushBack(bullet); } } /* CCLOG("333"); for (iterB = bullets2Delete.begin(); iterB != bullets2Delete.end(); iter++) { //CCARRAY_FOREACH(bullets2Delete, bulletsIterator){ auto bullet = dynamic_cast<Sprite*>(*iterB); _bullets.eraseObject(bullet); this->removeChild(bullet); }*/ if(target->attacked >= target->attackedCount){ targets2Delete.pushBack(target); } bullets2Delete.clear(); } //CCLOG("444, targets2Delete: %zd.", targets2Delete.size()); for (iter = targets2Delete.begin(); iter != targets2Delete.end(); iter++) { //CCARRAY_FOREACH(targets2Delete, targetIterator){ auto target = dynamic_cast<Plane*>(*iter); _targets.eraseObject(target); if(target->getTag() == 1){ score+=10; }else if(target->getTag() == 2){ score+=20; }else if(target->getTag() == 3){ score+=50; //CocosDenshion::SimpleAudioEngine::sharedEngine()->playEffect("explosion.mp3"); }else if(target->getTag() == 4){ CCLOG("target is the package"); this->scheduleOnce(schedule_selector(GameWorld::setDoubleBulletFlagF), 5); doubleBulletFlag = true; } this->removeChild(target); std::stringstream ss; std::string str; ss<<score; ss>>str; const char *p = str.c_str(); scoreLabel->setString(p); //CCLOG("888"); } targets2Delete.clear(); //CCLOG("555"); }
/*! * \brief BestFitPlane::setUpResult * \param plane * \return */ bool BestFitPlane::setUpResult(Plane &plane){ //get and check input observations if(!this->inputElements.contains(0) || this->inputElements[0].size() < 3){ emit this->sendMessage(QString("Not enough valid observations to fit the plane %1").arg(plane.getFeatureName()), eWarningMessage); return false; } QList<QPointer<Observation> > inputObservations; foreach(const InputElement &element, this->inputElements[0]){ if(!element.observation.isNull() && element.observation->getIsSolved() && element.observation->getIsValid() && element.shouldBeUsed){ inputObservations.append(element.observation); this->setIsUsed(0, element.id, true); continue; } this->setIsUsed(0, element.id, false); } if(inputObservations.size() < 3){ emit this->sendMessage(QString("Not enough valid observations to fit the plane %1").arg(plane.getFeatureName()), eWarningMessage); return false; } //centroid OiVec centroid(4); foreach(const QPointer<Observation> &obs, inputObservations){ centroid = centroid + obs->getXYZ(); }
void Frustum::CalculateFrustum(float angle, float ratio, float near, float far, Vector3D &camPos, Vector3D &lookAt, Vector3D &up) { Vector3D xVec, yVec, zVec; Vector3D vecN, vecF; Vector3D nearTopLeft, nearTopRight, nearBottomLeft, nearBottomRight; Vector3D farTopLeft, farTopRight, farBottomLeft, farBottomRight; float radians = (float)tan((DEG_TO_RAD(angle)) * 0.5); float nearH = near * radians; float nearW = nearH * ratio; float farH = far * radians; float farW = farH * ratio; zVec = camPos - lookAt; zVec.Normalize(); xVec = up.CrossProduct(zVec); xVec.Normalize(); yVec = zVec.CrossProduct(xVec); vecN = camPos - zVec * near; vecF = camPos - zVec * far; nearTopLeft = vecN + yVec * nearH - xVec * nearW; nearTopRight = vecN + yVec * nearH + xVec * nearW; nearBottomLeft = vecN - yVec * nearH - xVec * nearW; nearBottomRight = vecN - yVec * nearH + xVec * nearW; farTopLeft = vecF + yVec * farH - xVec * farW; farTopRight = vecF + yVec * farH + xVec * farW; farBottomLeft = vecF - yVec * farH - xVec * farW; farBottomRight = vecF - yVec * farH + xVec * farW; m_frustum.clear(); Plane plane; plane.CreatePlaneFromTri(nearTopRight, nearTopLeft, farTopLeft); AddPlane(plane); plane.CreatePlaneFromTri(nearBottomLeft, nearBottomRight, farBottomRight); AddPlane(plane); plane.CreatePlaneFromTri(nearTopLeft, nearBottomLeft, farBottomLeft); AddPlane(plane); plane.CreatePlaneFromTri(nearBottomRight, nearTopRight, farBottomRight); AddPlane(plane); plane.CreatePlaneFromTri(nearTopLeft, nearTopRight, nearBottomRight); AddPlane(plane); plane.CreatePlaneFromTri(farTopRight, farTopLeft, farBottomLeft); AddPlane(plane); }
/////////////////////////////////////////////////////////////////////////////////////////////////// /// CelShadeApp::CelShadeD3D /// /// @brief /// Render a cel-shading demo using Direct3D /// @return /// N/A /////////////////////////////////////////////////////////////////////////////////////////////////// void CelShadeApp::CelShadeD3D() { ID3D11DeviceContext* pContext = m_pDxData->pD3D11Context; ID3D11Device* pDevice = m_pDxData->pD3D11Device; D3DX11_IMAGE_LOAD_INFO imageLoadInfo; memset( &imageLoadInfo, 0, sizeof(D3DX11_IMAGE_LOAD_INFO) ); imageLoadInfo.BindFlags = D3D11_BIND_SHADER_RESOURCE; imageLoadInfo.Format = DXGI_FORMAT_R8G8B8A8_UNORM; DxTextureCreateInfo shadeTexInfo; memset(&shadeTexInfo, 0, sizeof(DxTextureCreateInfo)); shadeTexInfo.flags.RenderTarget = TRUE; shadeTexInfo.flags.ShaderInput = TRUE; shadeTexInfo.format = DXGI_FORMAT_R8G8B8A8_UNORM; shadeTexInfo.width = m_screenWidth; shadeTexInfo.height = m_screenHeight; DxTexture* pShadeTex = DxTexture::Create(pDevice, &shadeTexInfo); DxTextureCreateInfo edgeTexInfo; memset(&edgeTexInfo, 0, sizeof(DxTextureCreateInfo)); edgeTexInfo.flags.RenderTarget = TRUE; edgeTexInfo.flags.ShaderInput = TRUE; edgeTexInfo.format = DXGI_FORMAT_R8G8B8A8_UNORM; edgeTexInfo.width = m_screenWidth; edgeTexInfo.height = m_screenHeight; DxTexture* pEdgeTex = DxTexture::Create(pDevice, &edgeTexInfo); // Samplers ///////////////////////////////////////////////////////////////////////////// // SamplerState PointSampler : register(s0); D3D11_SAMPLER_DESC pointSamplerDesc; memset(&pointSamplerDesc, 0, sizeof(D3D11_SAMPLER_DESC)); pointSamplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT; pointSamplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; pointSamplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; pointSamplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP; pointSamplerDesc.MinLOD = -FLT_MAX; pointSamplerDesc.MaxLOD = FLT_MAX; pointSamplerDesc.MipLODBias = 0.0f; pointSamplerDesc.MaxAnisotropy = 16; ID3D11SamplerState* pPointSampler = NULL; pDevice->CreateSamplerState(&pointSamplerDesc, &pPointSampler); // UINT numVertices = 0, numIndices = 0; VertexPTN* pVB = NULL; UINT* pIB = NULL; ImportPly("Content/dragon_vrip_res3.ply", numVertices, &pVB, numIndices, &pIB); //ImportPly("Content/bun_zipper_res4.ply", numVertices, &pVB, numIndices, &pIB); DxMeshCreateInfo meshCreateInfo = {0}; meshCreateInfo.indexCount = numIndices; meshCreateInfo.pIndexArray = pIB; meshCreateInfo.indexFormat = DXGI_FORMAT_R32_UINT; meshCreateInfo.pVertexArray = pVB; meshCreateInfo.vertexCount = numVertices; meshCreateInfo.vertexElementSize = sizeof(VertexPTN); DxMesh* pMesh = DxMesh::Create(pDevice, &meshCreateInfo); Plane p; DxMeshCreateInfo planeMeshInfo; memset(&planeMeshInfo, 0, sizeof(planeMeshInfo)); planeMeshInfo.pVertexArray = p.GetVB(); planeMeshInfo.vertexCount = p.NumVertices(); planeMeshInfo.vertexElementSize = sizeof(VertexPTN); DxMesh* pPlaneMesh = DxMesh::Create(pDevice, &planeMeshInfo); Cube c; DxMeshCreateInfo cubeMeshInfo; memset(&cubeMeshInfo, 0, sizeof(cubeMeshInfo)); cubeMeshInfo.pVertexArray = c.GetVB(); cubeMeshInfo.vertexCount = c.NumVertices(); cubeMeshInfo.vertexElementSize = sizeof(VertexPT); DxMesh* pCubeMesh = DxMesh::Create(pDevice, &cubeMeshInfo); D3D11_SUBRESOURCE_DATA cbInitData; memset(&cbInitData, 0, sizeof(D3D11_SUBRESOURCE_DATA)); // Camera Buffer CameraBufferData cameraData; memset(&cameraData, 0, sizeof(CameraBufferData)); DxBufferCreateInfo cameraBufferCreateInfo = {0}; cameraBufferCreateInfo.flags.cpuWriteable = TRUE; cameraBufferCreateInfo.elemSizeBytes = sizeof(CameraBufferData); cameraBufferCreateInfo.pInitialData = &cameraData; DxBuffer* pCameraBuffer = DxBuffer::Create(pDevice, &cameraBufferCreateInfo); // Shaders //////////////////////////////////////////////////////////////////////////////////// m_pPosTexTriVS = DxShader::CreateFromFile(pDevice, "PosTexTri", "Content/shaders/CelShade.hlsl", PosTexVertexDesc, PosTexElements); m_pPosTexNormVS = DxShader::CreateFromFile(pDevice, "PosTexNorm", "Content/shaders/CelShade.hlsl", PosTexNormVertexDesc, PosTexNormElements); m_pCelShadePS = DxShader::CreateFromFile(pDevice, "CelShade", "Content/shaders/CelShade.hlsl"); DxShader* pDetectEdges = DxShader::CreateFromFile(pDevice, "DetectEdges", "Content/shaders/CelShade.hlsl"); DxShader* pApplyTexPS = DxShader::CreateFromFile(pDevice, "ApplyTex", "Content/shaders/CelShade.hlsl"); DxShader* pCubeVS = DxShader::CreateFromFile(pDevice, "PosTex", "Content/shaders/CelShade.hlsl", PosTexVertexDesc, PosTexElements); DxShader* pCubePS = DxShader::CreateFromFile(pDevice, "CubePS", "Content/shaders/CelShade.hlsl"); //////////////////////////////////////////////////////////////////////////////////////// pContext->ClearState(); // SET RENDER STATE FLOAT clearColor[4]; clearColor[0] = 0.2f; clearColor[1] = 0.2f; clearColor[2] = 0.2f; clearColor[3] = 1.0f; D3D11_RASTERIZER_DESC shadeDesc; shadeDesc.FillMode = D3D11_FILL_SOLID; shadeDesc.CullMode = D3D11_CULL_BACK; shadeDesc.FrontCounterClockwise = FALSE; shadeDesc.DepthBias = 0; shadeDesc.DepthBiasClamp = 0.0f; shadeDesc.SlopeScaledDepthBias = 0; shadeDesc.DepthClipEnable = false; shadeDesc.ScissorEnable = false; shadeDesc.MultisampleEnable = false; shadeDesc.AntialiasedLineEnable = false; ID3D11RasterizerState* pShadeRS = NULL; pDevice->CreateRasterizerState(&shadeDesc, &pShadeRS); pContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); m_pWindow->Show(); BOOL quit = false; FLOAT yRotationAngle = 0.0f; while (!quit) { ProcessUpdates(); BeginFrame(); CameraBufferData* pCameraData = NULL; // new frame, clear state pContext->ClearState(); pContext->RSSetViewports(1, &m_pDxData->viewport); pContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); pContext->RSSetState(pShadeRS); pContext->PSSetSamplers(0, 1, &pPointSampler); pContext->OMSetRenderTargets(1, &m_pDxData->pAppRenderTargetView, m_pDxData->pAppDepthStencilTex->GetDepthStencilView()); pContext->ClearRenderTargetView(m_pDxData->pAppRenderTargetView, clearColor); pContext->ClearDepthStencilView(m_pDxData->pAppDepthStencilTex->GetDepthStencilView(), D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0, 0); ///// Draw Mesh /////////////////////////////////////////////////////////////////////////// FLOAT viewRotationY = (GetMousePos().x - (m_screenWidth / 2.0f)) /(m_screenWidth / 2.0f); viewRotationY *= (3.14159f / 4.0f); FLOAT viewRotationZ = (GetMousePos().y - (m_screenHeight / 2.0f)) /(m_screenHeight / 2.0f); viewRotationZ *= (3.14159f / 4.0f); pCameraData = reinterpret_cast<CameraBufferData*>(pCameraBuffer->Map(pContext)); pCameraData->worldMatrix = XMMatrixScaling(25, 25, 25) * XMMatrixRotationY(yRotationAngle) * XMMatrixTranslation(m_pCamera->Position().x, m_pCamera->Position().y, m_pCamera->Position().z) ; // translate world +6 in Z to position camera -9 from world origin pCameraData->viewMatrix = m_pCamera->W2C(); pCameraData->projectionMatrix = m_pCamera->C2S(); pCameraBuffer->Unmap(pContext); pCameraBuffer->BindVS(pContext, 0); pMesh->Bind(pContext); m_pPosTexNormVS->Bind(pContext); m_pCelShadePS->Bind(pContext); pMesh->Draw(pContext); ///// Detect Edges /////////////////////////////////////////////////////////////////////////// ///// Draw Light Position //////////////////////////////////////////////////////////////////// //yRotationAngle = 0; pCameraData = reinterpret_cast<CameraBufferData*>(pCameraBuffer->Map(pContext)); pCameraData->worldMatrix = XMMatrixScaling(1, 1, 1); // XMMatrixRotationY(yRotationAngle); // XMMatrixTranslation(-10, 10, 10); // translate world +6 in Z to position camera -9 from world origin pCameraData->viewMatrix = XMMatrixTranslation(0, 0, 10) * m_pCamera->W2C(); pCameraData->projectionMatrix = m_pCamera->C2S(); pCameraBuffer->Unmap(pContext); pCameraBuffer->BindVS(pContext, 0); pCubeVS->Bind(pContext); pCubePS->Bind(pContext); pCubeMesh->Bind(pContext); pCubeMesh->Draw(pContext); ///// Draw UI //////////////////////////////////////////////////////////////////////////////// ///@todo Consider moving the following UI drawing to Draw2D() m_pUI->Begin(); // Draw UI stuff m_pUI->RenderRect(); m_pUI->RenderText(); m_pUI->End(); /// Blend UI onto final image DrawUI(); m_pDxData->pDXGISwapChain->Present(0,0); EndFrame(); Sleep(50); yRotationAngle += 3.14159f / 60.0f; } // Shader Resource Views pCameraBuffer->Destroy(); // Shaders m_pCelShadePS->Destroy(); m_pCelShadePS = NULL; m_pPosTexTriVS->Destroy(); m_pPosTexTriVS = NULL; m_pPosTexNormVS->Destroy(); m_pPosTexNormVS = NULL; pApplyTexPS->Destroy(); pApplyTexPS = NULL; pPlaneMesh->Destroy(); pPlaneMesh = NULL; // Samplers pPointSampler->Release(); // Rasterizer State pShadeRS->Release(); m_pDxData->pD3D11Context->ClearState(); m_pDxData->pD3D11Context->Flush(); }
bool AABB::Intersects(const Plane &plane) const { return plane.Intersects(*this); }
bool Plane::operator==(const Plane &plane) const { return (plane.direction()==_direction && plane.d()==_d ); }
bool Ray::Intersects(const Plane &plane, float *d) const { return plane.Intersects(*this, d); }
//----------------------------------------------------------------------- void ConvexBody::clip( const Plane& pl, bool keepNegative ) { if ( getPolygonCount() == 0 ) return; // current will be used as the reference body ConvexBody current; current.moveDataFromBody(*this); OgreAssert( this->getPolygonCount() == 0, "Body not empty!" ); OgreAssert( current.getPolygonCount() != 0, "Body empty!" ); // holds all intersection edges for the different polygons Polygon::EdgeMap intersectionEdges; // clip all polygons by the intersection plane // add only valid or intersected polygons to *this for ( size_t iPoly = 0; iPoly < current.getPolygonCount(); ++iPoly ) { // fetch vertex count and ignore polygons with less than three vertices // the polygon is not valid and won't be added const size_t vertexCount = current.getVertexCount( iPoly ); if ( vertexCount < 3 ) continue; // current polygon const Polygon& p = current.getPolygon( iPoly ); // the polygon to assemble Polygon *pNew = allocatePolygon(); // the intersection polygon (indeed it's an edge or it's empty) Polygon *pIntersect = allocatePolygon(); // check if polygons lie inside or outside (or on the plane) // for each vertex check where it is situated in regard to the plane // three possibilities appear: Plane::Side clipSide = keepNegative ? Plane::POSITIVE_SIDE : Plane::NEGATIVE_SIDE; // - side is clipSide: vertex will be clipped // - side is !clipSide: vertex will be untouched // - side is NOSIDE: vertex will be untouched Plane::Side *side = OGRE_ALLOC_T(Plane::Side, vertexCount, MEMCATEGORY_SCENE_CONTROL); for ( size_t iVertex = 0; iVertex < vertexCount; ++iVertex ) { side[ iVertex ] = pl.getSide( p.getVertex( iVertex ) ); } // now we check the side combinations for the current and the next vertex // four different combinations exist: // - both points inside (or on the plane): keep the second (add it to the body) // - both points outside: discard both (don't add them to the body) // - first vertex is inside, second is outside: add the intersection point // - first vertex is outside, second is inside: add the intersection point, then the second for ( size_t iVertex = 0; iVertex < vertexCount; ++iVertex ) { // determine the next vertex size_t iNextVertex = ( iVertex + 1 ) % vertexCount; const Vector3& vCurrent = p.getVertex( iVertex ); const Vector3& vNext = p.getVertex( iNextVertex ); // case 1: both points inside (store next) if ( side[ iVertex ] != clipSide && // NEGATIVE or NONE side[ iNextVertex ] != clipSide ) // NEGATIVE or NONE { // keep the second pNew->insertVertex( vNext ); } // case 3: inside -> outside (store intersection) else if ( side[ iVertex ] != clipSide && side[ iNextVertex ] == clipSide ) { // Do an intersection with the plane. We use a ray with a start point and a direction. // The ray is forced to hit the plane with any option available (eigher current or next // is the starting point) // intersect from the outside vertex towards the inside one Vector3 vDirection = vCurrent - vNext; vDirection.normalise(); Ray ray( vNext, vDirection ); std::pair< bool, Real > intersect = ray.intersects( pl ); // store intersection if ( intersect.first ) { // convert distance to vector Vector3 vIntersect = ray.getPoint( intersect.second ); // store intersection pNew->insertVertex( vIntersect ); pIntersect->insertVertex( vIntersect ); } } // case 4: outside -> inside (store intersection, store next) else if ( side[ iVertex ] == clipSide && side[ iNextVertex ] != clipSide ) { // Do an intersection with the plane. We use a ray with a start point and a direction. // The ray is forced to hit the plane with any option available (eigher current or next // is the starting point) // intersect from the outside vertex towards the inside one Vector3 vDirection = vNext - vCurrent; vDirection.normalise(); Ray ray( vCurrent, vDirection ); std::pair< bool, Real > intersect = ray.intersects( pl ); // store intersection if ( intersect.first ) { // convert distance to vector Vector3 vIntersect = ray.getPoint( intersect.second ); // store intersection pNew->insertVertex( vIntersect ); pIntersect->insertVertex( vIntersect ); } pNew->insertVertex( vNext ); } // else: // case 2: both outside (do nothing) } // insert the polygon only, if at least three vertices are present if ( pNew->getVertexCount() >= 3 ) { // in case there are double vertices, remove them pNew->removeDuplicates(); // in case there are still at least three vertices, insert the polygon if ( pNew->getVertexCount() >= 3 ) { this->insertPolygon( pNew ); } else { // delete pNew because it's empty or invalid freePolygon(pNew); pNew = 0; } } else { // delete pNew because it's empty or invalid freePolygon(pNew); pNew = 0; } // insert intersection polygon only, if there are two vertices present if ( pIntersect->getVertexCount() == 2 ) { intersectionEdges.insert( Polygon::Edge( pIntersect->getVertex( 0 ), pIntersect->getVertex( 1 ) ) ); } // delete intersection polygon // vertices were copied (if there were any) freePolygon(pIntersect); pIntersect = 0; // delete side info OGRE_FREE(side, MEMCATEGORY_SCENE_CONTROL); side = 0; } // if the polygon was partially clipped, close it // at least three edges are needed for a polygon if ( intersectionEdges.size() >= 3 ) { Polygon *pClosing = allocatePolygon(); // Analyze the intersection list and insert the intersection points in ccw order // Each point is twice in the list because of the fact that we have a convex body // with convex polygons. All we have to do is order the edges (an even-odd pair) // in a ccw order. The plane normal shows us the direction. Polygon::EdgeMap::iterator it = intersectionEdges.begin(); // check the cross product of the first two edges Vector3 vFirst = it->first; Vector3 vSecond = it->second; // remove inserted edge intersectionEdges.erase( it ); Vector3 vNext; // find mating edge if (findAndEraseEdgePair(vSecond, intersectionEdges, vNext)) { // detect the orientation // the polygon must have the same normal direction as the plane and then n Vector3 vCross = ( vFirst - vSecond ).crossProduct( vNext - vSecond ); bool frontside = ( pl.normal ).directionEquals( vCross, Degree( 1 ) ); // first inserted vertex Vector3 firstVertex; // currently inserted vertex Vector3 currentVertex; // direction equals -> front side (walk ccw) if ( frontside ) { // start with next as first vertex, then second, then first and continue with first to walk ccw pClosing->insertVertex( vNext ); pClosing->insertVertex( vSecond ); pClosing->insertVertex( vFirst ); firstVertex = vNext; currentVertex = vFirst; #ifdef _DEBUG_INTERSECTION_LIST std::cout << "Plane: n=" << pl.normal << ", d=" << pl.d << std::endl; std::cout << "First inserted vertex: " << *next << std::endl; std::cout << "Second inserted vertex: " << *vSecond << std::endl; std::cout << "Third inserted vertex: " << *vFirst << std::endl; #endif } // direction does not equal -> back side (walk cw) else { // start with first as first vertex, then second, then next and continue with next to walk ccw pClosing->insertVertex( vFirst ); pClosing->insertVertex( vSecond ); pClosing->insertVertex( vNext ); firstVertex = vFirst; currentVertex = vNext; #ifdef _DEBUG_INTERSECTION_LIST std::cout << "Plane: n=" << pl.normal << ", d=" << pl.d << std::endl; std::cout << "First inserted vertex: " << *vFirst << std::endl; std::cout << "Second inserted vertex: " << *vSecond << std::endl; std::cout << "Third inserted vertex: " << *next << std::endl; #endif } // search mating edges that have a point in common // continue this operation as long as edges are present while ( !intersectionEdges.empty() ) { if (findAndEraseEdgePair(currentVertex, intersectionEdges, vNext)) { // insert only if it's not the last (which equals the first) vertex if ( !intersectionEdges.empty() ) { currentVertex = vNext; pClosing->insertVertex( vNext ); } } else { // degenerated... break; } } // while intersectionEdges not empty // insert polygon (may be degenerated!) this->insertPolygon( pClosing ); } // mating intersection edge NOT found! else { freePolygon(pClosing); } } // if intersectionEdges contains more than three elements }
Geometry::MeshData Geometry::build_convex_mesh(const DVector<Plane> &p_planes) { MeshData mesh; #define SUBPLANE_SIZE 1024.0 float subplane_size = 1024.0; // should compute this from the actual plane for (int i=0;i<p_planes.size();i++) { Plane p =p_planes[i]; Vector3 ref=Vector3(0.0,1.0,0.0); if (ABS(p.normal.dot(ref))>0.95) ref=Vector3(0.0,0.0,1.0); // change axis Vector3 right = p.normal.cross(ref).normalized(); Vector3 up = p.normal.cross( right ).normalized(); Vector< Vector3 > vertices; Vector3 center = p.get_any_point(); // make a quad clockwise vertices.push_back( center - up * subplane_size + right * subplane_size ); vertices.push_back( center - up * subplane_size - right * subplane_size ); vertices.push_back( center + up * subplane_size - right * subplane_size ); vertices.push_back( center + up * subplane_size + right * subplane_size ); for (int j=0;j<p_planes.size();j++) { if (j==i) continue; Vector< Vector3 > new_vertices; Plane clip=p_planes[j]; if (clip.normal.dot(p.normal)>0.95) continue; if (vertices.size()<3) break; for(int k=0;k<vertices.size();k++) { int k_n=(k+1)%vertices.size(); Vector3 edge0_A=vertices[k]; Vector3 edge1_A=vertices[k_n]; real_t dist0 = clip.distance_to(edge0_A); real_t dist1 = clip.distance_to(edge1_A); if ( dist0 <= 0 ) { // behind plane new_vertices.push_back(vertices[k]); } // check for different sides and non coplanar if ( (dist0*dist1) < 0) { // calculate intersection Vector3 rel = edge1_A - edge0_A; real_t den=clip.normal.dot( rel ); if (Math::abs(den)<CMP_EPSILON) continue; // point too short real_t dist=-(clip.normal.dot( edge0_A )-clip.d)/den; Vector3 inters = edge0_A+rel*dist; new_vertices.push_back(inters); } } vertices=new_vertices; } if (vertices.size()<3) continue; //result is a clockwise face MeshData::Face face; // add face indices for (int j=0;j<vertices.size();j++) { int idx=-1; for (int k=0;k<mesh.vertices.size();k++) { if (mesh.vertices[k].distance_to(vertices[j])<0.001) { idx=k; break; } } if (idx==-1) { idx=mesh.vertices.size(); mesh.vertices.push_back(vertices[j]); } face.indices.push_back(idx); } face.plane=p; mesh.faces.push_back(face); //add edge for(int j=0;j<face.indices.size();j++) { int a=face.indices[j]; int b=face.indices[(j+1)%face.indices.size()]; bool found=false; for(int k=0;k<mesh.edges.size();k++) { if (mesh.edges[k].a==a && mesh.edges[k].b==b) { found=true; break; } if (mesh.edges[k].b==a && mesh.edges[k].a==b) { found=true; break; } } if (found) continue; MeshData::Edge edge; edge.a=a; edge.b=b; mesh.edges.push_back(edge); } } return mesh; }
//---------------------------------------------------------------------------- static void SplitAndDecompose (Tetrahedron kTetra, const Plane& rkPlane, vector<Tetrahedron>& rkInside) { // determine on which side of the plane the points of the tetrahedron lie Real afC[4]; int i, aiP[4], aiN[4], aiZ[4]; int iPositive = 0, iNegative = 0, iZero = 0; for (i = 0; i < 4; i++) { afC[i] = rkPlane.DistanceTo(kTetra[i]); if ( afC[i] > 0.0f ) aiP[iPositive++] = i; else if ( afC[i] < 0.0f ) aiN[iNegative++] = i; else aiZ[iZero++] = i; } // For a split to occur, one of the c_i must be positive and one must // be negative. if ( iNegative == 0 ) { // tetrahedron is completely on the positive side of plane, full clip return; } if ( iPositive == 0 ) { // tetrahedron is completely on the negative side of plane rkInside.push_back(kTetra); return; } // Tetrahedron is split by plane. Determine how it is split and how to // decompose the negative-side portion into tetrahedra (6 cases). Real fW0, fW1, fInvCDiff; Vector3 akIntp[4]; if ( iPositive == 3 ) { // +++- for (i = 0; i < iPositive; i++) { fInvCDiff = 1.0f/(afC[aiP[i]] - afC[aiN[0]]); fW0 = -afC[aiN[0]]*fInvCDiff; fW1 = +afC[aiP[i]]*fInvCDiff; kTetra[aiP[i]] = fW0*kTetra[aiP[i]] + fW1*kTetra[aiN[0]]; } rkInside.push_back(kTetra); } else if ( iPositive == 2 ) { if ( iNegative == 2 ) { // ++-- for (i = 0; i < iPositive; i++) { fInvCDiff = 1.0f/(afC[aiP[i]]-afC[aiN[0]]); fW0 = -afC[aiN[0]]*fInvCDiff; fW1 = +afC[aiP[i]]*fInvCDiff; akIntp[i] = fW0*kTetra[aiP[i]] + fW1*kTetra[aiN[0]]; } for (i = 0; i < iNegative; i++) { fInvCDiff = 1.0f/(afC[aiP[i]]-afC[aiN[1]]); fW0 = -afC[aiN[1]]*fInvCDiff; fW1 = +afC[aiP[i]]*fInvCDiff; akIntp[i+2] = fW0*kTetra[aiP[i]] + fW1*kTetra[aiN[1]]; } kTetra[aiP[0]] = akIntp[2]; kTetra[aiP[1]] = akIntp[1]; rkInside.push_back(kTetra); rkInside.push_back(Tetrahedron(kTetra[aiN[1]],akIntp[3],akIntp[2], akIntp[1])); rkInside.push_back(Tetrahedron(kTetra[aiN[0]],akIntp[0],akIntp[1], akIntp[2])); } else { // ++-0 for (i = 0; i < iPositive; i++) { fInvCDiff = 1.0f/(afC[aiP[i]]-afC[aiN[0]]); fW0 = -afC[aiN[0]]*fInvCDiff; fW1 = +afC[aiP[i]]*fInvCDiff; kTetra[aiP[i]] = fW0*kTetra[aiP[i]] + fW1*kTetra[aiN[0]]; } rkInside.push_back(kTetra); } } else if ( iPositive == 1 ) { if ( iNegative == 3 ) { // +--- for (i = 0; i < iNegative; i++) { fInvCDiff = 1.0f/(afC[aiP[0]]-afC[aiN[i]]); fW0 = -afC[aiN[i]]*fInvCDiff; fW1 = +afC[aiP[0]]*fInvCDiff; akIntp[i] = fW0*kTetra[aiP[0]] + fW1*kTetra[aiN[i]]; } kTetra[aiP[0]] = akIntp[0]; rkInside.push_back(kTetra); rkInside.push_back(Tetrahedron(akIntp[0],kTetra[aiN[1]], kTetra[aiN[2]],akIntp[1])); rkInside.push_back(Tetrahedron(kTetra[aiN[2]],akIntp[1],akIntp[2], akIntp[0])); } else if ( iNegative == 2 ) { // +--0 for (i = 0; i < iNegative; i++) { fInvCDiff = 1.0f/(afC[aiP[0]]-afC[aiN[i]]); fW0 = -afC[aiN[i]]*fInvCDiff; fW1 = +afC[aiP[0]]*fInvCDiff; akIntp[i] = fW0*kTetra[aiP[0]] + fW1*kTetra[aiN[i]]; } kTetra[aiP[0]] = akIntp[0]; rkInside.push_back(kTetra); rkInside.push_back(Tetrahedron(akIntp[1],kTetra[aiZ[0]], kTetra[aiN[1]],akIntp[0])); } else { // +-00 fInvCDiff = 1.0f/(afC[aiP[0]]-afC[aiN[0]]); fW0 = -afC[aiN[0]]*fInvCDiff; fW1 = +afC[aiP[0]]*fInvCDiff; kTetra[aiP[0]] = fW0*kTetra[aiP[0]] + fW1*kTetra[aiN[0]]; rkInside.push_back(kTetra); } } }
void DisplayGrid() { //cout << "dg\n"; Window * window = Window::FindCurrentWindow(windows); if (window->handle == BAD_GL_VALUE) return; glViewport(0 , 0 , window->size.x , window->size.y); vec4 crimson(0.6f , 0.0f , 0.0f , 1.0f); vec3 ambient = vec3(0.0f , 0.0f , 0.0f); vec3 specular = vec3(1.0f , 1.0f , 1.0f); vec3 diffuse = vec3(0.0f , 0.0f , 0.8f); glClearColor(crimson.r , crimson.g , crimson.b , crimson.a); glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); glEnable(GL_DEPTH_TEST); vector<Constellation::PositionData> & pd = gc.GetPositionData(); mat4 s = scale(mat4() , vec3(50.0f , 50.0f , 1.0f)); mat4 view_matrix = lookAt(vec3(0.0f , 0.0f , 150.0f) , vec3(0.0f , 0.0f , 0.0f) , vec3(0.0f , 1.0f , 0.0f)); mat4 projection_matrix = perspective(radians(window->fovy) , window->aspect , window->near_distance , window->far_distance); mat4 r = rotate(mat4() , radians(window->LocalTime() * 0.0f) , vec3(0.0f , 1.0f , 0.0f)); for (vector<Constellation::PositionData>::iterator iter = pd.begin(); iter < pd.end(); iter++) { mat4 model_matrix = rotate(mat4() , radians(window->LocalTime() * 20.0f) , vec3(0.0f , 1.0f , 0.0f)); model_matrix = translate(model_matrix , vec3(s * vec4((*iter).location , 1.0f))); // Beginning of orientation code. // // There is an assumption here (we are aligning z axes) that the shape you're building have // a natural facing down the z axis. // // The following orients the object's z axis along the axis held in outward_direction_vector. // target_dir gets that value. The difference in direction from the z axis to the desired direction // is captured by the dot product. The angle is retrieved with the acos. Then, if there's anything // to do (I suspect the if statement is NOT needed), a rotation axis is made by the cross product // (rotating about it will swing the z axes around). Finally, the rotation is done. vec3 target_dir = normalize((*iter).outward_direction_vector); float rot_angle = acos(dot(target_dir , vec3(0.0f, 0.0f, 1.0f))); if (fabs(rot_angle) > glm::epsilon<float>()) { vec3 rot_axis = normalize(cross(target_dir , vec3(0.0f, 0.0f, 1.0f))); model_matrix = rotate(model_matrix, rot_angle , rot_axis); } // End of orientation code. model_matrix = scale(model_matrix , vec3(2.0f, 2.0f, 1.0f)); phong_shader.Use(model_matrix , view_matrix , projection_matrix); phong_shader.SetMaterial(diffuse , specular , 64.0f , ambient); phong_shader.SetLightPosition(vec3(0.0f , 0.0f , 1000.0f)); phong_shader.SelectSubroutine(PhongShader::PHONG_WITH_TEXTURE); phong_shader.EnableTexture(textures[1] , 0); plane2.Draw(false); phong_shader.UnUse(); if (window->draw_normals) { constant_shader.Use(model_matrix , view_matrix , projection_matrix); constant_shader.SetMaterial(diffuse , specular , 64.0f , vec3(1.0f , 1.0f , 1.0f)); plane2.Draw(true); constant_shader.UnUse(); } // Animate the rotation of the objects within the grid. (*iter).outward_direction_vector = vec3(r * vec4((*iter).outward_direction_vector, 1.0f)); } glutSwapBuffers(); }
void Cube::genCube(float sx, float sy, float sz, int nx, int ny, int nz, bool smoothNormals) { int estimatedNumPoints = 2*(nx+1)*(ny+1) + 2*(nx+1)*(nz+1) + 2*(ny+1)*(nz+1); vertexStream.setNumVertices(estimatedNumPoints); vertexStream.setNumIndices((2*nx*ny + 2*nx*nz + 2*ny*nz) * 6); VertexAttrib* posAttrib = vertexStream.getAttrib("position", TYPE_VEC3); vec3* posBuf = (vec3*)posAttrib->getBuffer(); VertexStreamIndex* indexBuf = vertexStream.getIndices(); //unsigned short* indexBuf2 = vertexStream.getIndices2(); VertexAttrib* normalAttrib = vertexStream.getAttrib("normal", TYPE_VEC3); vec3* normalBuf = (vec3*)normalAttrib->getBuffer(); VertexAttrib* texCoord0Attrib = vertexStream.getAttrib("texCoord0", TYPE_VEC2); vec2* texCoord0Buf = (vec2*)texCoord0Attrib->getBuffer(); //tabela pomocnicza z iloscia segmentow scianki //zrobiona zeby mozna ja bylo uzyac w for(;;){} int def[3][2] = { {ny, nz}, {nx, nz}, {nx, ny} }; int axis[] = { Plane::X, Plane::Y, Plane::Z }; //rozmiary sicanek float size[3][2] = { {sy, sz}, {sx, sz}, {sx, sy} }; //o tyle nalezy przesunac kolejne scianki z pkt (0,0) vec3 shift[] = { vec3(-sx/2, 0, 0), vec3( 0,-sy/2, 0), vec3( 0, 0,-sz/2) }; //o te wartosci przemnazamy scianke orginalna zeby otrzymac jej odbicie po drugiej stronie vec3 mirror[] = { vec3( 1, 1, 1), vec3(-1, 1,-1), vec3( 1, 1,-1), vec3( 1,-1, 1), vec3( 1, 1, 1), vec3( 1,-1,-1) }; // o te wartosci przemnazamy scianke orginalna zeby otrzymac jej odbicie po drugiej stronie vec3 normals[] = { vec3(-1, 0, 0), vec3( 1, 0, 0), vec3( 0,-1, 0), vec3( 0, 1, 0), vec3( 0, 0,-1), vec3( 0, 0, 1) }; int allIndices = 0; int allVertices = 0; for(int axisNum=0; axisNum<3; axisNum++) { //FloatVertexAttrib planePosAttrib = (FloatVertexAttrib)planeVS.getAttribByName("pos"); //float[] planePosBuf = planePosAttrib.getBuffer(); //FloatVertexAttrib planeNormalAttrib = (FloatVertexAttrib)planeVS.getAttribByName("normal"); //planeNormalAttrib.getBuffer(); //FloatVertexAttrib planeTexCoord0Attrib = (FloatVertexAttrib)planeVS.getAttribByName("texCoord0"); //float[] planeTexCoor0Buf = planeTexCoord0Attrib.getBuffer(); //int[] planeIndexBuf = planeVS.getIndexBuffer().getBuffer(); Plane* plane = new Plane(size[axisNum][0], size[axisNum][1], axis[axisNum], def[axisNum][0], def[axisNum][1]); VertexStream planeVS = plane->getVertexStream(); VertexAttrib* planePosAttrib = planeVS.getAttrib("position", TYPE_VEC3); vec3* planePosBuf = (vec3*)planePosAttrib->getBuffer(); VertexAttrib* planeTexCoord0Attrib = planeVS.getAttrib("texCoord0", TYPE_VEC2); vec2* planeTexCoord0Buf = (vec2*)planeTexCoord0Attrib->getBuffer(); VertexStreamIndex* planeIndexBuf = planeVS.getIndices(); int numPlaneVertices = planeVS.getNumVertices();//sizeof(planePosBuf)/sizeof(vec3); int numPlaneIndices = planeVS.getNumIndices();//sizeof(planeIndexBuf)/sizeof(unsigned short); //Log::msg("npv:%d npi:%d", numPlaneVertices, numPlaneIndices); for(int mirrorSide=0; mirrorSide<2; mirrorSide++) { for(int i=0; i<numPlaneVertices; i++) { //posBuf[(allVertices+i)*3+0] = ((planePosBuf[i*3 ]) + shift[axisNum].getX()) * mirror[axisNum*2 + mirrorSide].getX(); //posBuf[(allVertices+i)*3+1] = ((planePosBuf[i*3+1]) + shift[axisNum].getY()) * mirror[axisNum*2 + mirrorSide].getY(); //posBuf[(allVertices+i)*3+2] = ((planePosBuf[i*3+2]) + shift[axisNum].getZ()) * mirror[axisNum*2 + mirrorSide].getZ(); posBuf[allVertices+i] = planePosBuf[i] + shift[axisNum]; posBuf[allVertices+i].x *= mirror[axisNum*2 + mirrorSide].x; posBuf[allVertices+i].y *= mirror[axisNum*2 + mirrorSide].y; posBuf[allVertices+i].z *= mirror[axisNum*2 + mirrorSide].z; if (smoothNormals) { //normalBuf[(allVertices+i)*3 ] = posBuf[(allVertices+i)*3 ]; //normalBuf[(allVertices+i)*3+1] = posBuf[(allVertices+i)*3+1]; //normalBuf[(allVertices+i)*3+2] = posBuf[(allVertices+i)*3+2]; normalBuf[allVertices+i] = vec3(posBuf[allVertices+i]); } else { //normalBuf[(allVertices+i)*3 ] = normals[axisNum*2 + mirrorSide].getX(); //normalBuf[(allVertices+i)*3+1] = normals[axisNum*2 + mirrorSide].getY(); //normalBuf[(allVertices+i)*3+2] = normals[axisNum*2 + mirrorSide].getZ(); normalBuf[allVertices+i] = normals[axisNum*2 + mirrorSide]; } //texCoord0Buf[(allVertices+i)*2 ] = planeTexCoor0Buf[i*2 ]; //texCoord0Buf[(allVertices+i)*2+1] = planeTexCoor0Buf[i*2+1]; texCoord0Buf[allVertices+i] = planeTexCoord0Buf[i]; } for(int i=0; i<numPlaneIndices; i++) { indexBuf[allIndices + i] = allVertices + planeIndexBuf[i]; } allVertices += numPlaneVertices; allIndices += numPlaneIndices; } } }
//circle intersection of direct sphere and direct plane Circle meet( const Sphere& s, const Plane& d){ return (s.dual() ^ d.dual()).dual(); }
/////////////////////////////////////////////////////////////////////////////////////////////////// /// IvyApp::InitDX /// /// @brief /// /// @return /// N/A /////////////////////////////////////////////////////////////////////////////////////////////////// bool IvyApp::InitDX() { bool success = true; m_pDxData = new IvyAppDxData(); memset(&m_pDxData->viewport, 0, sizeof(D3D11_VIEWPORT)); EnumerateAdapters(); DxEnumDisplayDevices(); // Create Swap Chain & Device DXGI_SWAP_CHAIN_DESC sd; ZeroMemory( &sd, sizeof( sd ) ); sd.BufferCount = BufferCount; sd.BufferDesc.Width = m_screenWidth; sd.BufferDesc.Height = m_screenHeight; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.OutputWindow = m_pWindow->GetHwnd(); sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.Windowed = TRUE; D3D_FEATURE_LEVEL FeatureLevelsRequested[2]; FeatureLevelsRequested[0] = D3D_FEATURE_LEVEL_11_0; FeatureLevelsRequested[1] = D3D_FEATURE_LEVEL_10_1; UINT numLevelsRequested = 2; D3D_FEATURE_LEVEL FeatureLevelsSupported; if( DxFAIL (D3D11CreateDeviceAndSwapChain( NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, D3D11_CREATE_DEVICE_DEBUG, FeatureLevelsRequested, numLevelsRequested, D3D11_SDK_VERSION, &sd, &m_pDxData->pDXGISwapChain, &m_pDxData->pD3D11Device, &FeatureLevelsSupported, &m_pDxData->pD3D11Context ))) { success = false; } if (success) { ID3D11Texture2D* pBackBuffer = NULL; // Get a pointer to the back buffer if (DxFAIL(m_pDxData->pDXGISwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer))) { success = false; } else { // Create a render-target view m_pDxData->pD3D11Device->CreateRenderTargetView(pBackBuffer, NULL, &m_pDxData->pAppRenderTargetView ); pBackBuffer->Release(); } } HRESULT hr = S_OK; if (success) { DxTextureCreateInfo depthStencilCreateInfo; memset(&depthStencilCreateInfo, 0, sizeof(DxTextureCreateInfo)); depthStencilCreateInfo.flags.DepthStencil = TRUE; depthStencilCreateInfo.flags.ShaderInput = TRUE; depthStencilCreateInfo.format = DXGI_FORMAT_D24_UNORM_S8_UINT; ///@todo texture doesnt read format currently depthStencilCreateInfo.width = m_screenWidth; depthStencilCreateInfo.height = m_screenHeight; m_pDxData->pAppDepthStencilTex = DxTexture::Create(m_pDxData->pD3D11Device, &depthStencilCreateInfo); } // Setup viewport m_pDxData->viewport.Width = static_cast<FLOAT>(m_screenWidth); m_pDxData->viewport.Height = static_cast<FLOAT>(m_screenHeight); m_pDxData->viewport.MinDepth = 0.0f; m_pDxData->viewport.MaxDepth = 1.0f; m_pDxData->viewport.TopLeftX = 0; m_pDxData->viewport.TopLeftY = 0; // Create UI ///@todo Move UI creation up into IvyApp once the creation of IvyUI exists m_pUI = DxUI::Create(); m_pUIData = new IvyDxUIData(); m_pUIData->pUserInterfaceVS = DxShader::CreateFromFile(m_pDxData->pD3D11Device, "PosTexTri", L"Content/shaders/DxUI.hlsl", PosTexVertexDesc, PosTexElements); m_pUIData->pUserInterfacePS = DxShader::CreateFromFile(m_pDxData->pD3D11Device, "ApplyTex", L"Content/shaders/DxUI.hlsl"); CameraBufferData cameraData; memset(&cameraData, 0, sizeof(CameraBufferData)); DxBufferCreateInfo cameraBufferCreateInfo = {0}; cameraBufferCreateInfo.flags.cpuWriteable = TRUE; cameraBufferCreateInfo.elemSizeBytes = sizeof(CameraBufferData); cameraBufferCreateInfo.pInitialData = &cameraData; m_pUIData->pUserInterfaceCameraBuf = DxBuffer::Create(m_pDxData->pD3D11Device, &cameraBufferCreateInfo); Plane p; DxMeshCreateInfo planeMeshInfo; memset(&planeMeshInfo, 0, sizeof(planeMeshInfo)); planeMeshInfo.pVertexArray = p.GetVB(); planeMeshInfo.vertexCount = p.NumVertices(); planeMeshInfo.vertexElementSize = sizeof(VertexPTN); m_pUIData->pUserInterfaceQuad = DxMesh::Create(m_pDxData->pD3D11Device, &planeMeshInfo); m_pUIData->pUserInterfaceOverlay = m_pUI->CreateSharedTextureOverlay(m_pDxData->pD3D11Device); if (DxFAIL(m_pUIData->pUserInterfaceOverlay->QueryInterface(__uuidof(IDXGIKeyedMutex), (LPVOID*) &m_pUIData->pUserInterfaceMutexD3D))) { success = false; } D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; srvDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; srvDesc.Texture2D.MipLevels = 1; srvDesc.Texture2D.MostDetailedMip = 0; srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; m_pDxData->pD3D11Device->CreateShaderResourceView(m_pUIData->pUserInterfaceOverlay, &srvDesc, &m_pUIData->pUserInterfaceSRV); D3D11_BLEND_DESC uiBlendDesc; memset(&uiBlendDesc, 0, sizeof(D3D11_BLEND_DESC)); uiBlendDesc.AlphaToCoverageEnable = FALSE; uiBlendDesc.IndependentBlendEnable = FALSE; uiBlendDesc.RenderTarget[0].BlendEnable = TRUE; uiBlendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE; uiBlendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA; uiBlendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; uiBlendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE; uiBlendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO; uiBlendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; uiBlendDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; ID3D11BlendState* pUIBlendState = NULL; m_pDxData->pD3D11Device->CreateBlendState(&uiBlendDesc, &m_pUIData->pUserInterfaceBlendState); return success; }