Camera::Camera(const PxVec3 &eye, const PxVec3& dir) { mEye = eye; mDir = dir.getNormalized(); mMouseX = 0; mMouseY = 0; }
void PxFlyBall::move() { time++; if (time % 3000 < 1600) { PxVec3 v = pxActor->getLinearVelocity(); if (fabs(v.x)< 0.0001 && fabs(v.z)<0.0001) { GLfloat angle = (rand() % 360) / 360.0*PxPi; pxActor->addForce(PxVec3(PxSin(angle) * 50, 0, PxCos(angle) * 50), PxForceMode::eACCELERATION); } else { if (fabs(v.x) < 50 && fabs(v.z) < 50) { PxVec3 nmvec = v.getNormalized(); pxActor->addForce(PxVec3(nmvec.x*50.0, 0, nmvec.z*50.0), PxForceMode::eACCELERATION); } } PxTransform t = pxActor->getGlobalPose(); if(t.p.y<300) pxActor->addForce(PxVec3(0, rand()%200, 0.0), PxForceMode::eACCELERATION); if (particleTime == 0) { addCPSS(); } } //particleTime++; //particleTime = particleTime > 5 ? 0 : particleTime; time = time > 3000 ? 0 : time; }
bool PhysxScene::CheckReachable(physx::PxVec3 src, physx::PxVec3 dst) { PxVec3 dir = dst - src; PxReal max_distance = sqrt(dir.x*dir.x + dir.y*dir.y + dir.z*dir.z); PxRaycastBuffer hit; bool is_hit = px_scene_->raycast(src, dir.getNormalized(), max_distance, hit); return !is_hit; }
void PxMoveBall::move() { PxVec3 v = pxActor->getLinearVelocity(); if (fabs(v.x - 0.0)<0.0001 && fabs(v.z-0.0)<0.0001) { GLfloat angle = (rand() % 360) / 360.0*PxPi; pxActor->addForce(PxVec3(PxSin(angle)*50, 0, PxCos(angle)*50),PxForceMode::eACCELERATION); } else { PxReal speed = v.magnitude(); if (speed <= maxspeed) { PxVec3 nmvec = v.getNormalized(); pxActor->addForce(PxVec3(nmvec.x*50.0, 0, nmvec.z*50.0),PxForceMode::eACCELERATION); } } }
void PxFlyBall::addCPSS() { PxVec3 v = pxActor->getLinearVelocity(); PxTransform trans = pxActor->getGlobalPose(); PxVec3 pos = trans.p; PxVec3 vn = v.getNormalized(); extern GLuint pCPS; extern CircleParticleSys circleParticleSyses[CIRCLE_PARTICLESYS_NUM]; Color4f white(1.0, 1.0, 1.0, 1.0); GLuint tgt = pCPS%CIRCLE_PARTICLESYS_NUM; Vector3f pvn(-v.x, -v.y, -v.z); circleParticleSyses[tgt].init(1.2,white, Vector3f(pos.x, pos.y, pos.z), pvn * 0.2, pvn * 0.4, 0, 3, 1, 2, 1.2, 1.4); circleParticleSyses[tgt].initCircle(2,4, 1.8, 2, PI , PI / 2, 1.2, 1.2); pCPS = pCPS + 1; //pCPS = pCPS == CIRCLE_PARTICLESYS_NUM ? 0 : pCPS; }
void ApplyInverseSquareGravity(PxRigidActor* actor, PxVec3 source, PxReal power) { PxVec3 dir; PxReal distSquared; PxVec3 norm; PxVec3 force; int objectNum = boxes.size(); for(int i = 0; i < objectNum; i++) { //Disables the scene gravity so we can apply our own DisableGravity(boxes[i]->actor); dir = source - boxes[i]->actor->getGlobalPose().p; distSquared = dir.magnitudeSquared(); distSquared = (distSquared < 10) ? 10000 : distSquared; norm = dir.getNormalized(); force = (norm * power) / distSquared; boxes[i]->actor->isRigidBody()->addForce(force, PxForceMode::eACCELERATION); } }
static FVector FindConvexMeshOpposingNormal(const PxLocationHit& PHit, const FVector& TraceDirectionDenorm, const FVector InNormal) { if (IsInvalidFaceIndex(PHit.faceIndex)) { return InNormal; } PxConvexMeshGeometry PConvexMeshGeom; bool bSuccess = PHit.shape->getConvexMeshGeometry(PConvexMeshGeom); check(bSuccess); //should only call this function when we have a convex mesh if (PConvexMeshGeom.convexMesh) { check(PHit.faceIndex < PConvexMeshGeom.convexMesh->getNbPolygons()); const PxU32 PolyIndex = PHit.faceIndex; PxHullPolygon PPoly; bool bSuccessData = PConvexMeshGeom.convexMesh->getPolygonData(PolyIndex, PPoly); if (bSuccessData) { // Account for non-uniform scale in local space normal. const PxVec3 PPlaneNormal(PPoly.mPlane[0], PPoly.mPlane[1], PPoly.mPlane[2]); const PxVec3 PLocalPolyNormal = TransformNormalToShapeSpace(PConvexMeshGeom.scale, PPlaneNormal.getNormalized()); // Convert to world space const PxTransform PShapeWorldPose = PxShapeExt::getGlobalPose(*PHit.shape, *PHit.actor); const PxVec3 PWorldPolyNormal = PShapeWorldPose.rotate(PLocalPolyNormal); const FVector OutNormal = P2UVector(PWorldPolyNormal); #if !(UE_BUILD_SHIPPING || UE_BUILD_TEST) if (!OutNormal.IsNormalized()) { UE_LOG(LogPhysics, Warning, TEXT("Non-normalized Normal (Hit shape is ConvexMesh): %s (LocalPolyNormal:%s)"), *OutNormal.ToString(), *P2UVector(PLocalPolyNormal).ToString()); UE_LOG(LogPhysics, Warning, TEXT("WorldTransform \n: %s"), *P2UTransform(PShapeWorldPose).ToString()); } #endif return OutNormal; } } return InNormal; }
bool PxFabricCookerImpl::cook(const PxClothMeshDesc& desc, PxVec3 gravity, bool useGeodesicTether) { if(!desc.isValid()) { shdfnd::getFoundation().error(PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__, "PxFabricCookerImpl::cook: desc.isValid() failed!"); return false; } gravity = gravity.getNormalized(); mNumParticles = desc.points.count; // assemble points shdfnd::Array<PxVec4> particles; particles.reserve(mNumParticles); PxStrideIterator<const PxVec3> pIt((const PxVec3*)desc.points.data, desc.points.stride); PxStrideIterator<const PxReal> wIt((const PxReal*)desc.invMasses.data, desc.invMasses.stride); for(PxU32 i=0; i<mNumParticles; ++i) particles.pushBack(PxVec4(*pIt++, wIt.ptr() ? *wIt++ : 1.0f)); // build adjacent vertex list shdfnd::Array<PxU32> valency(mNumParticles+1, 0); shdfnd::Array<PxU32> adjacencies; if(desc.flags & PxMeshFlag::e16_BIT_INDICES) gatherAdjacencies<PxU16>(valency, adjacencies, desc.triangles, desc.quads); else gatherAdjacencies<PxU32>(valency, adjacencies, desc.triangles, desc.quads); // build unique neighbors from adjacencies shdfnd::Array<PxU32> mark(valency.size(), 0); shdfnd::Array<PxU32> neighbors; neighbors.reserve(adjacencies.size()); for(PxU32 i=1, j=0; i<valency.size(); ++i) { for(; j<valency[i]; ++j) { PxU32 k = adjacencies[j]; if(mark[k] != i) { mark[k] = i; neighbors.pushBack(k); } } valency[i] = neighbors.size(); } // build map of unique edges and classify shdfnd::HashMap<Pair, Edge> edges; for(PxU32 i=0; i<mNumParticles; ++i) { PxReal wi = particles[i].w; // iterate all neighbors PxU32 jlast = valency[i+1]; for(PxU32 j=valency[i]; j<jlast; ++j) { // add 1-ring edge PxU32 m = neighbors[j]; if(wi + particles[m].w > 0.0f) edges[Pair(PxMin(i, m), PxMax(i, m))].classify(); // iterate all neighbors of neighbor PxU32 klast = valency[m+1]; for(PxU32 k=valency[m]; k<klast; ++k) { PxU32 n = neighbors[k]; if(n != i && wi + particles[n].w > 0.0f) { // add 2-ring edge edges[Pair(PxMin(i, n), PxMax(i, n))].classify( particles[i], particles[m], particles[n]); } } } } // copy classified edges to constraints array // build histogram of constraints per vertex shdfnd::Array<Entry> constraints; constraints.reserve(edges.size()); valency.resize(0); valency.resize(mNumParticles+1, 0); const PxReal sqrtHalf = PxSqrt(0.4f); for(shdfnd::HashMap<Pair, Edge>::Iterator eIt = edges.getIterator(); !eIt.done(); ++eIt) { const Edge& edge = eIt->second; const Pair& pair = eIt->first; if((edge.mStretching + edge.mBending + edge.mShearing) > 0.0f) { PxClothFabricPhaseType::Enum type = PxClothFabricPhaseType::eINVALID; if(edge.mBending > PxMax(edge.mStretching, edge.mShearing)) type = PxClothFabricPhaseType::eBENDING; else if(edge.mShearing > PxMax(edge.mStretching, edge.mBending)) type = PxClothFabricPhaseType::eSHEARING; else { PxVec4 diff = particles[pair.first]-particles[pair.second]; PxReal dot = gravity.dot(reinterpret_cast<const PxVec3&>(diff).getNormalized()); type = fabsf(dot) < sqrtHalf ? PxClothFabricPhaseType::eHORIZONTAL : PxClothFabricPhaseType::eVERTICAL; } ++valency[pair.first]; ++valency[pair.second]; constraints.pushBack(Entry(pair, type)); } } prefixSum(valency.begin(), valency.end(), valency.begin()); PxU32 numConstraints = constraints.size(); // build adjacent constraint list adjacencies.resize(0); adjacencies.resize(valency.back(), 0); for(PxU32 i=0; i<numConstraints; ++i) { adjacencies[--valency[constraints[i].first.first]] = i; adjacencies[--valency[constraints[i].first.second]] = i; } shdfnd::Array<PxU32>::ConstIterator aFirst = adjacencies.begin(); shdfnd::Array<PxU32> colors(numConstraints, numConstraints); // constraint -> color, initialily not colored mark.resize(0); mark.resize(numConstraints+1, PX_MAX_U32); // color -> constraint index shdfnd::Array<PxU32> adjColorCount(numConstraints, 0); // # of neighbors that are already colored shdfnd::Array<ConstraintGraphColorCount> constraintHeap; constraintHeap.reserve(numConstraints); // set of constraints to color (added in edge distance order) // Do graph coloring based on edge distance. // For each constraint, we add its uncolored neighbors to the heap // ,and we pick the constraint with most colored neighbors from the heap. while (1) { PxU32 constraint = 0; while ( (constraint < numConstraints) && (colors[constraint] != numConstraints)) constraint++; // start with the first uncolored constraint if (constraint >= numConstraints) break; constraintHeap.clear(); pushHeap(constraintHeap, ConstraintGraphColorCount((int)constraint, (int)adjColorCount[constraint])); PxClothFabricPhaseType::Enum type = constraints[constraint].second; while (!constraintHeap.empty()) { ConstraintGraphColorCount heapItem = popHeap(constraintHeap); constraint = heapItem.constraint; if (colors[constraint] != numConstraints) continue; // skip if already colored const Pair& pair = constraints[constraint].first; for(PxU32 j=0; j<2; ++j) { PxU32 index = j ? pair.first : pair.second; if(particles[index].w == 0.0f) continue; // don't mark adjacent particles if attached for(shdfnd::Array<PxU32>::ConstIterator aIt = aFirst + valency[index], aEnd = aFirst + valency[index+1]; aIt != aEnd; ++aIt) { PxU32 adjacentConstraint = *aIt; if ((constraints[adjacentConstraint].second != type) || (adjacentConstraint == constraint)) continue; mark[colors[adjacentConstraint]] = constraint; ++adjColorCount[adjacentConstraint]; pushHeap(constraintHeap, ConstraintGraphColorCount((int)adjacentConstraint, (int)adjColorCount[adjacentConstraint])); } } // find smallest color with matching type PxU32 color = 0; while((color < mPhases.size() && mPhases[color].phaseType != type) || mark[color] == constraint) ++color; // create a new color set if(color == mPhases.size()) { PxClothFabricPhase phase(type, mPhases.size()); mPhases.pushBack(phase); mSets.pushBack(0); } colors[constraint] = color; ++mSets[color]; } } #if 0 // PX_DEBUG printf("set[%u] = ", mSets.size()); for(PxU32 i=0; i<mSets.size(); ++i) printf("%u ", mSets[i]); #endif prefixSum(mSets.begin(), mSets.end(), mSets.begin()); #if 0 // PX_DEBUG printf(" = %u\n", mSets.back()); #endif // write indices and rest lengths // convert mSets to exclusive sum PxU32 back = mSets.back(); mSets.pushBack(back); mIndices.resize(numConstraints*2); mRestvalues.resize(numConstraints); for(PxU32 i=0; i<numConstraints; ++i) { PxU32 first = constraints[i].first.first; PxU32 second = constraints[i].first.second; PxU32 index = --mSets[colors[i]]; mIndices[2*index ] = first; mIndices[2*index+1] = second; PxVec4 diff = particles[second] - particles[first]; mRestvalues[index] = reinterpret_cast< const PxVec3&>(diff).magnitude(); } // reorder constraints and rest values for more efficient cache access (linear) shdfnd::Array<PxU32> newIndices(mIndices.size()); shdfnd::Array<PxF32> newRestValues(mRestvalues.size()); // sort each constraint set in vertex order for (PxU32 i=0; i < mSets.size()-1; ++i) { // create a re-ordering list shdfnd::Array<PxU32> reorder(mSets[i+1]-mSets[i]); for (PxU32 r=0; r < reorder.size(); ++r) reorder[r] = r; const PxU32 indicesOffset = mSets[i]*2; const PxU32 restOffset = mSets[i]; ConstraintSorter predicate(&mIndices[indicesOffset]); shdfnd::sort(&reorder[0], reorder.size(), predicate); for (PxU32 r=0; r < reorder.size(); ++r) { newIndices[indicesOffset + r*2] = mIndices[indicesOffset + reorder[r]*2]; newIndices[indicesOffset + r*2+1] = mIndices[indicesOffset + reorder[r]*2+1]; newRestValues[restOffset + r] = mRestvalues[restOffset + reorder[r]]; } } mIndices = newIndices; mRestvalues = newRestValues; PX_ASSERT(mIndices.size() == mRestvalues.size()*2); PX_ASSERT(mRestvalues.size() == mSets.back()); #if 0 // PX_DEBUG for (PxU32 i = 1; i < mSets.size(); i++) { PxClothFabricPhase phase = mPhases[i-1]; printf("%d : type %d, size %d\n", i-1, phase.phaseType, mSets[i] - mSets[i-1]); } #endif if (useGeodesicTether) { PxClothGeodesicTetherCooker tetherCooker(desc); if (tetherCooker.getCookerStatus() == 0) { PxU32 numTethersPerParticle = tetherCooker.getNbTethersPerParticle(); PxU32 tetherSize = mNumParticles * numTethersPerParticle; mTetherAnchors.resize(tetherSize); mTetherLengths.resize(tetherSize); tetherCooker.getTetherData(mTetherAnchors.begin(), mTetherLengths.begin()); } else useGeodesicTether = false; } if (!useGeodesicTether) { PxClothSimpleTetherCooker tetherCooker(desc); mTetherAnchors.resize(mNumParticles); mTetherLengths.resize(mNumParticles); tetherCooker.getTetherData(mTetherAnchors.begin(), mTetherLengths.begin()); } return true; }
void Gu::TriangleMesh::debugVisualize( Cm::RenderOutput& out, const PxTransform& pose, const PxMeshScale& scaling, const PxBounds3& cullbox, const PxU64 mask, const PxReal fscale, const PxU32 numMaterials) const { PX_UNUSED(numMaterials); //bool cscale = !!(mask & ((PxU64)1 << PxVisualizationParameter::eCULL_BOX)); const PxU64 cullBoxMask = PxU64(1) << PxVisualizationParameter::eCULL_BOX; bool cscale = ((mask & cullBoxMask) == cullBoxMask); const PxMat44 midt(PxIdentity); const Cm::Matrix34 absPose(PxMat33(pose.q) * scaling.toMat33(), pose.p); PxU32 nbTriangles = getNbTrianglesFast(); const PxU32 nbVertices = getNbVerticesFast(); const PxVec3* vertices = getVerticesFast(); const void* indices = getTrianglesFast(); const PxDebugColor::Enum colors[] = { PxDebugColor::eARGB_BLACK, PxDebugColor::eARGB_RED, PxDebugColor::eARGB_GREEN, PxDebugColor::eARGB_BLUE, PxDebugColor::eARGB_YELLOW, PxDebugColor::eARGB_MAGENTA, PxDebugColor::eARGB_CYAN, PxDebugColor::eARGB_WHITE, PxDebugColor::eARGB_GREY, PxDebugColor::eARGB_DARKRED, PxDebugColor::eARGB_DARKGREEN, PxDebugColor::eARGB_DARKBLUE, }; const PxU32 colorCount = sizeof(colors)/sizeof(PxDebugColor::Enum); if(cscale) { const Gu::Box worldBox( (cullbox.maximum + cullbox.minimum)*0.5f, (cullbox.maximum - cullbox.minimum)*0.5f, PxMat33(PxIdentity)); // PT: TODO: use the callback version here to avoid allocating this huge array PxU32* results = reinterpret_cast<PxU32*>(PX_ALLOC_TEMP(sizeof(PxU32)*nbTriangles, "tmp triangle indices")); LimitedResults limitedResults(results, nbTriangles, 0); Midphase::intersectBoxVsMesh(worldBox, *this, pose, scaling, &limitedResults); nbTriangles = limitedResults.mNbResults; if (fscale) { const PxU32 fcolor = PxU32(PxDebugColor::eARGB_DARKRED); for (PxU32 i=0; i<nbTriangles; i++) { const PxU32 index = results[i]; PxVec3 wp[3]; getTriangle(*this, index, wp, vertices, indices, absPose, has16BitIndices()); const PxVec3 center = (wp[0] + wp[1] + wp[2]) / 3.0f; PxVec3 normal = (wp[0] - wp[1]).cross(wp[0] - wp[2]); PX_ASSERT(!normal.isZero()); normal = normal.getNormalized(); out << midt << fcolor << Cm::DebugArrow(center, normal * fscale); } } if (mask & (PxU64(1) << PxVisualizationParameter::eCOLLISION_SHAPES)) { const PxU32 scolor = PxU32(PxDebugColor::eARGB_MAGENTA); out << midt << scolor; // PT: no need to output this for each segment! PxDebugLine* segments = out.reserveSegments(nbTriangles*3); for(PxU32 i=0; i<nbTriangles; i++) { const PxU32 index = results[i]; PxVec3 wp[3]; getTriangle(*this, index, wp, vertices, indices, absPose, has16BitIndices()); segments[0] = PxDebugLine(wp[0], wp[1], scolor); segments[1] = PxDebugLine(wp[1], wp[2], scolor); segments[2] = PxDebugLine(wp[2], wp[0], scolor); segments+=3; } } if ((mask & (PxU64(1) << PxVisualizationParameter::eCOLLISION_EDGES)) && mExtraTrigData) visualizeActiveEdges(out, *this, nbTriangles, results, absPose, midt); PX_FREE(results); } else { if (fscale) { const PxU32 fcolor = PxU32(PxDebugColor::eARGB_DARKRED); for (PxU32 i=0; i<nbTriangles; i++) { PxVec3 wp[3]; getTriangle(*this, i, wp, vertices, indices, absPose, has16BitIndices()); const PxVec3 center = (wp[0] + wp[1] + wp[2]) / 3.0f; PxVec3 normal = (wp[0] - wp[1]).cross(wp[0] - wp[2]); PX_ASSERT(!normal.isZero()); normal = normal.getNormalized(); out << midt << fcolor << Cm::DebugArrow(center, normal * fscale); } } if (mask & (PxU64(1) << PxVisualizationParameter::eCOLLISION_SHAPES)) { PxU32 scolor = PxU32(PxDebugColor::eARGB_MAGENTA); out << midt << scolor; // PT: no need to output this for each segment! PxVec3* transformed = reinterpret_cast<PxVec3*>(PX_ALLOC(sizeof(PxVec3)*nbVertices, "PxVec3")); for(PxU32 i=0;i<nbVertices;i++) transformed[i] = absPose.transform(vertices[i]); PxDebugLine* segments = out.reserveSegments(nbTriangles*3); for (PxU32 i=0; i<nbTriangles; i++) { PxVec3 wp[3]; getTriangle(*this, i, wp, transformed, indices, has16BitIndices()); const PxU32 localMaterialIndex = getTriangleMaterialIndex(i); scolor = colors[localMaterialIndex % colorCount]; segments[0] = PxDebugLine(wp[0], wp[1], scolor); segments[1] = PxDebugLine(wp[1], wp[2], scolor); segments[2] = PxDebugLine(wp[2], wp[0], scolor); segments+=3; } PX_FREE(transformed); } if ((mask & (PxU64(1) << PxVisualizationParameter::eCOLLISION_EDGES)) && mExtraTrigData) visualizeActiveEdges(out, *this, nbTriangles, NULL, absPose, midt); } }
void Gu::TriangleMesh::debugVisualize( Cm::RenderOutput& out, const Cm::Matrix34& absPose, const PxBounds3& cullbox, const PxU64 mask, const PxReal fscale) const { bool cscale = !!(mask & ((PxU64)1 << PxVisualizationParameter::eCULL_BOX)); const PxMat44 midt = PxMat44::createIdentity(); const PxU32 nbTriangles = mesh.getNumTriangles(); const PxU32 nbVertices = mesh.getNumVertices(); const PxVec3* vertices = mesh.getVertices(); const void* indices = getTrianglesFast(); const bool has16BitIndices = mesh.has16BitIndices(); if (fscale) { const PxU32 fcolor = PxDebugColor::eARGB_DARKRED; for (PxU32 i=0; i<nbTriangles; i++) { PxVec3 wp[3]; getTriangle(*this, i, wp, vertices, indices, absPose, has16BitIndices); const PxVec3 center = (wp[0] + wp[1] + wp[2]) / 3.0f; PxVec3 normal = (wp[0] - wp[1]).cross(wp[0] - wp[2]); PX_ASSERT(!normal.isZero()); normal = normal.getNormalized(); if (!cscale || cullbox.contains(center)) out << midt << fcolor << Cm::DebugArrow(center, normal * fscale); } } if (mask & ((PxU64)1 << PxVisualizationParameter::eCOLLISION_SHAPES)) { const PxU32 scolor = PxDebugColor::eARGB_MAGENTA; out << midt << scolor; // PT: no need to output this for each segment! // PT: transform vertices only once PxVec3* transformed = (PxVec3*)PX_ALLOC(sizeof(PxVec3)*nbVertices); for(PxU32 i=0;i<nbVertices;i++) transformed[i] = absPose.transform(vertices[i]); for (PxU32 i=0; i<nbTriangles; i++) { PxVec3 wp[3]; getTriangle(*this, i, wp, transformed, indices, has16BitIndices); if (!cscale || (cullbox.contains(wp[0]) && cullbox.contains(wp[1]) && cullbox.contains(wp[2]))) { out.outputSegment(wp[0], wp[1]); out.outputSegment(wp[1], wp[2]); out.outputSegment(wp[2], wp[0]); } } PX_FREE(transformed); } if (mask & ((PxU64)1 << PxVisualizationParameter::eCOLLISION_EDGES)) { const PxU32 ecolor = PxDebugColor::eARGB_YELLOW; for (PxU32 i=0; i<nbTriangles; i++) { PxVec3 wp[3]; getTriangle(*this, i, wp, vertices, indices, absPose, has16BitIndices); const PxU32 flags = mesh.getTrigSharedEdgeFlags(i); if(flags & Gu::ETD_CONVEX_EDGE_01) { if (!cscale || (cullbox.contains(wp[0]) && cullbox.contains(wp[1]))) out << midt << ecolor << Cm::RenderOutput::LINES << wp[0] << wp[1]; } if(flags & Gu::ETD_CONVEX_EDGE_12) { if (!cscale || (cullbox.contains(wp[1]) && cullbox.contains(wp[2]))) out << midt << ecolor << Cm::RenderOutput::LINES << wp[1] << wp[2]; } if(flags & Gu::ETD_CONVEX_EDGE_20) { if (!cscale || (cullbox.contains(wp[0]) && cullbox.contains(wp[2]))) out << midt << ecolor << Cm::RenderOutput::LINES << wp[0] << wp[2]; } } } }
void Enemy::Update(float dT) { UpdateBullets(dT); obj->Update(dT); if(!isDead) { currentMoveTime += dT; if(currentMoveTime > movementSwitchTime) { currentMoveTime = 0; float xspeed = rand()% (int)ceil(movementSpeed); //getal van 0 tot 10 float xfSpeed = xspeed - (int)ceil(movementSpeed)/2; // getal van -5 tot 5 float zspeed = rand()%(int)ceil(movementSpeed); //getal van 0 tot 10 float zfSpeed = zspeed -(int)ceil( movementSpeed)/2; // getal van -5 tot 5 moveDir = D3DXVECTOR3(xfSpeed, 0, zfSpeed); } PxVec3 pos = actor->getGlobalPose().p; PxVec3 pDir = (playerPos - pos); pDir.y = 0; pDir.normalize(); PxVec3 target = PxVec3(moveDir.x,0,moveDir.z); float angle = 90 - (90 * pDir.dot(target.getNormalized())) - 90; //mapping range 1 to -1 into 0-180 if desirable playerRight.y = 0; float direction = playerRight.dot(target.getNormalized()); if(direction < 0 && angle > -45 && angle < 45) { angle = -angle; } Object2D::Animation* cAnim = obj->GetCurrentAnim(); Object2D::Animation anim; if(angle < -45) { cMState = MovementState::Forward; anim = obj->GetAnimation("WalkForward"); if(anim.isFinished || cAnim->AnimationName.compare(anim.AnimationName) != 0) { obj->PlayAnimation("WalkForward"); } } if(angle > -45 && angle < 0 && direction < 0) { cMState = MovementState::Left; anim = obj->GetAnimation("WalkLeft"); if(anim.isFinished || cAnim->AnimationName.compare(anim.AnimationName) != 0) { obj->PlayAnimation("WalkLeft"); } } else if(angle > 0 && angle < 45 && direction > 0) { cMState = MovementState::Right; anim = obj->GetAnimation("WalkRight"); if(anim.isFinished || cAnim->AnimationName.compare(anim.AnimationName) != 0) { obj->PlayAnimation("WalkRight"); } } if(angle > -45 && angle < 0 && direction > 0) { cMState = MovementState::Right; anim = obj->GetAnimation("WalkRight"); if(anim.isFinished || cAnim->AnimationName.compare(anim.AnimationName) != 0) { obj->PlayAnimation("WalkRight"); } } else if(angle > 0 && angle < 45 && direction < 0) { cMState = MovementState::Left; anim = obj->GetAnimation("WalkLeft"); if(anim.isFinished || cAnim->AnimationName.compare(anim.AnimationName) != 0) { obj->PlayAnimation("WalkLeft"); } } if(angle > 45) { cMState = MovementState::Back; anim = obj->GetAnimation("WalkBack"); if(anim.isFinished || cAnim->AnimationName.compare(anim.AnimationName) != 0) { obj->PlayAnimation("WalkBack"); } } CheckShooting(30,dT*1.2f); if(sawPlayer) { cState = Enemy::Moving; int i = 0; CheckFutureCollision(i); Move(moveDir,dT*movementSpeed); } } }
void RenderPhysX3Debug::addConeExt(float r0, float r1, const PxVec3& p0, const PxVec3& p1 , const RendererColor& color, PxU32 renderFlags) { PxVec3 axis = p1 - p0; PxReal length = axis.magnitude(); PxReal rdiff = r0 - r1; PxReal sinAngle = rdiff / length; PxReal x0 = r0 * sinAngle; PxReal x1 = r1 * sinAngle; PxVec3 center = 0.5f * (p0 + p1); if (length < fabs(rdiff)) return; PxReal r0p = sqrt(r0 * r0 - x0 * x0); PxReal r1p = sqrt(r1 * r1 - x1 * x1); if (length == 0.0f) axis = PxVec3(1,0,0); else axis.normalize(); PxVec3 axis1(0.0f); axis1[minArgument(abs(axis))] = 1.0f; axis1 = axis1.cross(axis); axis1.normalize(); PxVec3 axis2 = axis.cross(axis1); axis2.normalize(); PxMat44 m; m.column0 = PxVec4(axis, 0.0f); m.column1 = PxVec4(axis1, 0.0f); m.column2 = PxVec4(axis2, 0.0f); m.column3 = PxVec4(center, 1.0f); PxTransform tr(m); #define NUM_CONE_VERTS 72 const PxU32 nbVerts = NUM_CONE_VERTS; PxVec3 pts0[NUM_CONE_VERTS] ; PxVec3 pts1[NUM_CONE_VERTS]; PxVec3 normals[NUM_CONE_VERTS] ; const float step = PxTwoPi / float(nbVerts); for (PxU32 i = 0; i < nbVerts; i++) { const float angle = float(i) * step; const float x = cosf(angle); const float y = sinf(angle); PxVec3 p = PxVec3(0.0f, x, y); pts0[i] = tr.transform(r0p * p + PxVec3(-0.5f * length + x0,0,0)); pts1[i] = tr.transform(r1p * p + PxVec3(0.5f * length + x1, 0, 0)); normals[i] = tr.q.rotate(p.getNormalized()); normals[i] = x0 * axis + r0p * normals[i]; normals[i].normalize(); } #undef NUM_CONE_VERTS if(renderFlags & RENDER_DEBUG_WIREFRAME) { for(PxU32 i=0;i<nbVerts;i++) { addLine(pts1[i], pts0[i], color); } } if(renderFlags & RENDER_DEBUG_SOLID) { for(PxU32 i=0;i<nbVerts;i++) { const PxU32 j = (i+1) % nbVerts; addTriangle(pts0[i], pts1[j], pts0[j], normals[i], normals[j], normals[j], color); addTriangle(pts0[i], pts1[i], pts1[j], normals[i], normals[i], normals[j], color); } } }
void CurrentApp::Update(float dt) { //Update the camera for movement m_camera->Update(dt); m_particleEmitter->update(dt); glm::vec3 pos = glm::vec3(100 * cos(CurrentTime() * 0.05f) + 150, 80, 100 * sin(CurrentTime() * 0.05f) + 150); m_fairyEmitter->SetPosition(pos); m_light->SetPosition(pos); for (int i = 0; i < 5; ++i) { m_AI[i]->update(dt); } Input* IM = Input::GetInstance(); glm::mat4 cameraWorld = m_camera->GetTransform(); PxVec3 displacement = PxVec3(0, 0, 0); bool notZero = false; bool m_canFly = false; if (IM->IsKeyDown('W')) { displacement -= PxVec3(cameraWorld[2].x, (m_canFly ? cameraWorld[2].y : 0), cameraWorld[2].z); notZero = true; } if (IM->IsKeyDown('A')) { displacement -= PxVec3(cameraWorld[0].x, (m_canFly ? cameraWorld[0].y : 0), cameraWorld[0].z); notZero = true; } if (IM->IsKeyDown('S')) { displacement += PxVec3(cameraWorld[2].x, (m_canFly ? cameraWorld[2].y : 0), cameraWorld[2].z); notZero = true; } if (IM->IsKeyDown('D')) { displacement += PxVec3(cameraWorld[0].x, (m_canFly ? cameraWorld[0].y : 0), cameraWorld[0].z); notZero = true; } if (notZero) displacement = displacement.getNormalized(); if (m_verticleSpeed > -10.0f && !m_canFly || m_verticleSpeed > 0 && m_canFly) m_verticleSpeed -= dt; displacement.y += m_verticleSpeed; PxControllerFilters filters; g_PlayerController->move(displacement, 0.01f, dt, filters); PxExtendedVec3 playerPos = g_PlayerController->getPosition(); PxExtendedVec3 footPos = g_PlayerController->getFootPosition(); //I do these calculations individually inside this vector constructor because PxEtendedVec3 doesn't contain some of the necessary operators to do this. vec3 endPos = vec3(2.0f * playerPos.x - footPos.x, 2.0f * playerPos.y - footPos.y, 2.0f * playerPos.z - footPos.z); m_camera->SetPosition(endPos); //Freeze the physics if (m_freezePhysics == false) { UpdatePhysx(dt); } else { UpdatePhysx(0); } //Generate new map if (Input::GetInstance()->IsKeyPressed('R')) { m_terrain->GenerateFromPerlin(); m_terrain->AddPhysicsShape(g_PhysicsScene, g_Physics); m_nodeMap->GenerateFromTerrain(m_terrain); m_world->Generate(); for (unsigned int i = 0; i < g_PhysXActors.size(); ++i) { PxTransform transform(PxVec3(150, 5 + (1.1f * i), 150)); g_PhysXActors[i]->setGlobalPose(transform); } } if (Input::GetInstance()->IsKeyPressed('N')) { m_nodeMap->GenerateFromTerrain(m_terrain); m_nodeMap->Draw(); } //Freeze Physics if (Input::GetInstance()->IsKeyPressed(GLFW_KEY_PAUSE)) { m_freezePhysics = !m_freezePhysics; } //Hide/Show Cursor if (Input::GetInstance()->IsKeyPressed(KEY_ESCAPE)) { glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL); } if (Input::GetInstance()->IsMousePressed(MOUSE_BUTTON_LEFT)) { glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); } //Deffered/Forward if (Input::GetInstance()->IsKeyPressed(KEY_F5)) { m_isDeffered = !m_isDeffered; } if (Input::GetInstance()->IsKeyPressed(KEY_F6)) { m_drawDebug = !m_drawDebug; } }