void VertexClosestJointInfo::calcShortestDistance(){ // calc closest influence MDagPath closestInfluence; MVector pointPos(this->vertPosition()); static_cast<ClosestJointGeometryInfo *>(&this->geometry)->influenceFinder.findClosestInfluence(pointPos,closestInfluence, static_cast<WeightsByClosestJoint * >(this->geometry.engine)->useIntersectionRanking); this->initializeSecondaryWeightsBuffers(); // write weights now double *prevWeight = this->skinWeights; double *currWeight = this->nextSkinWeights; for (size_t i=0,count=this->geometry.numVertWeights();i<count;i++,currWeight++,prevWeight++){ MDagPath currPath; if (!this->geometry.getLogicalInfluencePath(geometry.inflPhysicalToLogical[i],currPath)) continue; if (currPath==closestInfluence){ // in special case, when influence is locked, but still is the closest one, // it gets it's current weight + all free weight *currWeight = this->geometry.inflLocked[i]?*prevWeight+this->totalFreeWeight:this->totalFreeWeight; } else { *currWeight = this->geometry.inflLocked[i]?*prevWeight:0.0; } } this->swapWeightsBuffers(); }
ManualObject *Debugging::createPathgridPoints(const ESM::Pathgrid *pathgrid) { ManualObject *result = mSceneMgr->createManualObject(); const float height = POINT_MESH_BASE * sqrtf(2); result->begin(PATHGRID_POINT_MATERIAL, RenderOperation::OT_TRIANGLE_STRIP); bool first = true; uint32 startIndex = 0; for(ESM::Pathgrid::PointList::const_iterator it = pathgrid->mPoints.begin(); it != pathgrid->mPoints.end(); it++, startIndex += 6) { Vector3 pointPos(it->mX, it->mY, it->mZ); if (!first) { // degenerate triangle from previous octahedron result->index(startIndex - 4); // 2nd point of previous octahedron result->index(startIndex); // start point of current octahedron } result->position(pointPos + Vector3(0, 0, height)); // 0 result->position(pointPos + Vector3(-POINT_MESH_BASE, -POINT_MESH_BASE, 0)); // 1 result->position(pointPos + Vector3(POINT_MESH_BASE, -POINT_MESH_BASE, 0)); // 2 result->position(pointPos + Vector3(POINT_MESH_BASE, POINT_MESH_BASE, 0)); // 3 result->position(pointPos + Vector3(-POINT_MESH_BASE, POINT_MESH_BASE, 0)); // 4 result->position(pointPos + Vector3(0, 0, -height)); // 5 result->index(startIndex + 0); result->index(startIndex + 1); result->index(startIndex + 2); result->index(startIndex + 5); result->index(startIndex + 3); result->index(startIndex + 4); // degenerates result->index(startIndex + 4); result->index(startIndex + 5); result->index(startIndex + 5); // end degenerates result->index(startIndex + 1); result->index(startIndex + 4); result->index(startIndex + 0); result->index(startIndex + 3); result->index(startIndex + 2); first = false; } result->end(); result->setVisibilityFlags (RV_Debug); return result; }
int PrinceEngine::getMob(Common::Array<Mob> &mobList, bool usePriorityList, int posX, int posY) { Common::Point pointPos(posX, posY); int mobListSize; if (usePriorityList) { mobListSize = _mobPriorityList.size(); } else { mobListSize = mobList.size(); } for (int mobNumber = 0; mobNumber < mobListSize; mobNumber++) { Mob *mob = nullptr; if (usePriorityList) { mob = &mobList[_mobPriorityList[mobNumber]]; } else { mob = &mobList[mobNumber]; } if (mob->_visible) { continue; } int type = mob->_type & 7; switch (type) { case 0: case 1: //normal_mob if (!mob->_rect.contains(pointPos)) { continue; } break; case 3: //mob_obj if (mob->_mask < kMaxObjects) { int nr = _objSlot[mob->_mask]; if (nr != 0xFF) { Object &obj = *_objList[nr]; Common::Rect objectRect(obj._x, obj._y, obj._x + obj._width, obj._y + obj._height); if (objectRect.contains(pointPos)) { Graphics::Surface *objSurface = obj.getSurface(); byte *pixel = (byte *)objSurface->getBasePtr(posX - obj._x, posY - obj._y); if (*pixel != 255) { break; } } } } continue; break; case 2: case 5: //check_ba_mob if (!_backAnimList[mob->_mask].backAnims.empty()) { int currentAnim = _backAnimList[mob->_mask]._seq._currRelative; Anim &backAnim = _backAnimList[mob->_mask].backAnims[currentAnim]; if (backAnim._animData != nullptr) { if (!backAnim._state) { Common::Rect backAnimRect(backAnim._currX, backAnim._currY, backAnim._currX + backAnim._currW, backAnim._currY + backAnim._currH); if (backAnimRect.contains(pointPos)) { int phase = backAnim._showFrame; int phaseFrameIndex = backAnim._animData->getPhaseFrameIndex(phase); Graphics::Surface *backAnimSurface = backAnim._animData->getFrame(phaseFrameIndex); byte pixel = *(byte *)backAnimSurface->getBasePtr(posX - backAnim._currX, posY - backAnim._currY); if (pixel != 255) { if (type == 5) { if (mob->_rect.contains(pointPos)) { break; } } else { break; } } } } } } continue; break; default: //not_part_ba continue; break; } if (usePriorityList) { return _mobPriorityList[mobNumber]; } else { return mobNumber; } } return -1; }
void LeafModel::updateLeafCards (ATOM_Node *treeNode) { const float overlapEpsl = 0.1f; leaves.resize (0); ATOM_BBox bbox; bbox.beginExtend (); // compute leaf bounding box for (unsigned i = 0; i < treeNode->getNumChildren(); ++i) { const ATOM_Matrix4x4f &matrixTest = treeNode->getChild (i)->getO2T (); ATOM_Vector3f center(matrixTest.m30, matrixTest.m31, matrixTest.m32); float radius = matrixTest.m00; bbox.extend (center + ATOM_Vector3f(-radius, radius, -radius)); bbox.extend (center + ATOM_Vector3f(-radius, radius, radius)); bbox.extend (center + ATOM_Vector3f(-radius, -radius, -radius)); bbox.extend (center + ATOM_Vector3f(-radius, -radius, radius)); bbox.extend (center + ATOM_Vector3f( radius, radius, -radius)); bbox.extend (center + ATOM_Vector3f( radius, radius, radius)); bbox.extend (center + ATOM_Vector3f( radius, -radius, -radius)); bbox.extend (center + ATOM_Vector3f( radius, -radius, radius)); } ATOM_Vector3f bboxBounds = bbox.getMax() - bbox.getMin (); float interval = bboxBounds.x * bboxBounds.y * bboxBounds.z / density; interval = ATOM_pow (interval, 0.333f); unsigned dimX = bboxBounds.x / interval + 1; unsigned dimY = bboxBounds.y / interval + 1; unsigned dimZ = bboxBounds.z / interval + 1; // test points float leafWidth = width; float leafHeight = height; for (unsigned i = 0; i < dimX; ++i) for (unsigned j = 0; j < dimY; ++j) for (unsigned k = 0; k < dimZ; ++k) { ATOM_Vector3f pointPos(interval * i, interval * j, interval * k); pointPos += bbox.getMin(); bool contains = false; for (unsigned s = 0; s < treeNode->getNumChildren(); ++s) { const ATOM_Matrix4x4f &matrixTestAgainst = treeNode->getChild(s)->getO2T (); ATOM_Vector3f center(matrixTestAgainst.m30, matrixTestAgainst.m31, matrixTestAgainst.m32); float radius = matrixTestAgainst.m00; float dist = (center - pointPos).getLength(); if (dist <= radius) { contains = true; break; } } if (contains) { if (randomRange > 0.f) { float rx = float(rand())/float(RAND_MAX) - 0.5f; float ry = float(rand())/float(RAND_MAX) - 0.5f; float rz = float(rand())/float(RAND_MAX) - 0.5f; pointPos += ATOM_Vector3f(rx * randomRange, ry * randomRange, rz * randomRange); } float widthV = sizeV * (float(rand())/float(RAND_MAX)); float heightV = widthV * (height / width); addLeafCards (&pointPos, 1, flip ? (rand() < RAND_MAX / 2) : false, widthV, heightV); } } }
qreal DrawingPolyItem::pointY(int index) const { return pointPos(index).y(); }
osg::ref_ptr<osg::Geometry> Pathgrid::createPathgridPoints(const ESM::Pathgrid *pathgrid) { osg::ref_ptr<osg::Geometry> geom = new osg::Geometry; const float height = POINT_MESH_BASE * sqrtf(2); osg::ref_ptr<osg::Vec3Array> vertices = new osg::Vec3Array; osg::ref_ptr<osg::UShortArray> indices = new osg::UShortArray; bool first = true; unsigned short startIndex = 0; for(ESM::Pathgrid::PointList::const_iterator it = pathgrid->mPoints.begin(); it != pathgrid->mPoints.end(); ++it, startIndex += 6) { osg::Vec3f pointPos(MWMechanics::PathFinder::MakeOsgVec3(*it)); if (!first) { // degenerate triangle from previous octahedron indices->push_back(startIndex - 4); // 2nd point of previous octahedron indices->push_back(startIndex); // start point of current octahedron } float pointMeshBase = static_cast<float>(POINT_MESH_BASE); vertices->push_back(pointPos + osg::Vec3f(0, 0, height)); // 0 vertices->push_back(pointPos + osg::Vec3f(-pointMeshBase, -pointMeshBase, 0)); // 1 vertices->push_back(pointPos + osg::Vec3f(pointMeshBase, -pointMeshBase, 0)); // 2 vertices->push_back(pointPos + osg::Vec3f(pointMeshBase, pointMeshBase, 0)); // 3 vertices->push_back(pointPos + osg::Vec3f(-pointMeshBase, pointMeshBase, 0)); // 4 vertices->push_back(pointPos + osg::Vec3f(0, 0, -height)); // 5 indices->push_back(startIndex + 0); indices->push_back(startIndex + 1); indices->push_back(startIndex + 2); indices->push_back(startIndex + 5); indices->push_back(startIndex + 3); indices->push_back(startIndex + 4); // degenerates indices->push_back(startIndex + 4); indices->push_back(startIndex + 5); indices->push_back(startIndex + 5); // end degenerates indices->push_back(startIndex + 1); indices->push_back(startIndex + 4); indices->push_back(startIndex + 0); indices->push_back(startIndex + 3); indices->push_back(startIndex + 2); first = false; } geom->setVertexArray(vertices); geom->addPrimitiveSet(new osg::DrawElementsUShort(osg::PrimitiveSet::TRIANGLE_STRIP, indices->size(), &(*indices)[0])); osg::ref_ptr<osg::Vec4Array> colors = new osg::Vec4Array; colors->push_back(osg::Vec4(1.f, 0.f, 0.f, 1.f)); geom->setColorArray(colors, osg::Array::BIND_OVERALL); return geom; }