Пример #1
0
string Namespace::getData()
{
	string data = "{\"docs\":[";
	DiskLoc nextExtentLoc = firstExtentLoc;
	while (!nextExtentLoc.isNull())
	{
		Extent* extent = db->getExtent(nextExtentLoc);
		int nextRecordOffset = extent->firstRecord;
		while (nextRecordOffset != -1)
		{
			Record* record = extent->getRecord(nextRecordOffset);
			//LOGI(record->data);
			data.append(record->data);

			nextRecordOffset = record->nextRecLoc;

			if (nextRecordOffset != -1)
				data.append(",");
		}

		nextExtentLoc = extent->nextExtent;
	}
	data.append("]}");
	return data;
}
Пример #2
0
void BSplineSelection::getExtent (float& l, float& b, float& cx, float& cy,
float& tol, Graphic* gs) {
    Extent e;
    if (extentCached()) {
	getCachedExtent(e.left, e.bottom, e.cx, e.cy, e.tol);
    } else {
	FullGraphic gstmp;
	concatGSGraphic(ifillbspline, this, gs, &gstmp);
	getExtentGraphic(
            ifillbspline, e.left, e.bottom, e.cx, e.cy, e.tol, &gstmp
        );
	Extent te;
	concatGSGraphic(bspline, this, gs, &gstmp);
	getExtentGraphic(
            bspline, te.left, te.bottom, te.cx, te.cy, te.tol, &gstmp
        );
	e.Merge(te);
	cacheExtent(e.left, e.bottom, e.cx, e.cy, e.tol);
    }
    float right = 2*e.cx - e.left;
    float top = 2*e.cy - e.bottom;
    float dummy = 0;
    transformRect(e.left, e.bottom, right, top, l, b, dummy, dummy, gs);
    transform(e.cx, e.cy, cx, cy, gs);
    tol = MergeArrowHeadTol(e.tol, gs);
}
Пример #3
0
void PolyGraphic::getextent_gs (
    Coord& l, Coord& b, Coord& cx, Coord& cy, float& tol, Graphic31* gs
) {
    Extent e;
    l = b = cx = cy = tol = 0.0;
        
    Graphic31 gstemp;
    Transformer ttemp;
    Extent te;
    gstemp.transformer(&ttemp);

    GlyphIndex count = _body->count();
    for (GlyphIndex i = 0; i < count; i++) {
        Graphic31* gr = (Graphic31*) _body->component(i);
        
        concatgs_(gr, gr, gs, &gstemp);
        concatXform_(gr, nil, gr->transformer(), &ttemp);
        getextent_(gr, te._left, te._bottom, te._cx, te._cy, te._tol, &gstemp);
        e.Merge(te);
    }
    gstemp.transformer(nil); // to avoid deleting ttemp explicitly
    l = e._left; b = e._bottom; cx = l+(e._cx-l)*2.0; cy = b+(e._cy-b)*2.0;
    tol = e._tol;

    Transformer* tx = gs->transformer();
    if (tx != nil) {
        corners(l, b, cx, cy, *tx);
    }
    cx = (cx + l)/2.0;
    cy = (cy + b)/2.0;
}
Пример #4
0
    void RecordStoreV1Base::increaseStorageSize( TransactionExperiment* txn,
                                                 int size,
                                                 int quotaMax ) {
        DiskLoc eloc = _extentManager->allocateExtent( txn,
                                                       _ns,
                                                       isCapped(),
                                                       size,
                                                       quotaMax );

        Extent *e = _extentManager->getExtent( eloc, false );

        invariant( e );

        DiskLoc emptyLoc = e->reuse(txn,  _ns, isCapped() );

        if ( _details->lastExtent().isNull() ) {
            verify( _details->firstExtent().isNull() );
            _details->setFirstExtent( txn, eloc );
            _details->setLastExtent( txn, eloc );
            _details->setCapExtent( txn, eloc );
            verify( e->xprev.isNull() );
            verify( e->xnext.isNull() );
        }
        else {
            verify( !_details->firstExtent().isNull() );
            *txn->writing(&e->xprev) = _details->lastExtent();
            *txn->writing(&_extentManager->getExtent(_details->lastExtent())->xnext) = eloc;
            _details->setLastExtent( txn, eloc );
        }

        _details->setLastExtentSize( txn, e->length );

        addDeletedRec(txn, emptyLoc);
    }
Пример #5
0
    /* get a table scan cursor, but can be forward or reverse direction.
       order.$natural - if set, > 0 means forward (asc), < 0 backward (desc).
    */
    shared_ptr<Cursor> findTableScan(const char *ns, const BSONObj& order, const DiskLoc &startLoc) {
        BSONElement el = order.getField("$natural"); // e.g., { $natural : -1 }

        if ( el.number() >= 0 )
            return DataFileMgr::findAll(ns, startLoc);

        // "reverse natural order"
        NamespaceDetails *d = nsdetails(ns);

        if ( !d )
            return shared_ptr<Cursor>(new BasicCursor(DiskLoc()));

        if ( !d->isCapped() ) {
            if ( !startLoc.isNull() )
                return shared_ptr<Cursor>(new ReverseCursor( startLoc ));
            Extent *e = d->lastExtent().ext();
            while ( e->lastRecord.isNull() && !e->xprev.isNull() ) {
                OCCASIONALLY out() << "  findTableScan: extent empty, skipping ahead" << endl;
                e = e->getPrevExtent();
            }
            return shared_ptr<Cursor>(new ReverseCursor( e->lastRecord ));
        }
        else {
            return shared_ptr<Cursor>( new ReverseCappedCursor( d, startLoc ) );
        }
    }
Пример #6
0
 Extent* MmapV1ExtentManager::getExtent( const DiskLoc& loc, bool doSanityCheck ) const {
     loc.assertOk();
     Extent* e = reinterpret_cast<Extent*>( _getOpenFile( loc.a() )->p() + loc.getOfs() );
     if ( doSanityCheck )
         e->assertOk();
     return e;
 }
Пример #7
0
    DiskLoc _repairExtent( Database* db , string ns, bool forward , DiskLoc eLoc ){
        LogIndentLevel lil;
        
        if ( eLoc.getOfs() <= 0 ){
            error() << "invalid extent ofs: " << eLoc.getOfs() << endl;
            return DiskLoc();
        }
        

        MongoDataFile * mdf = db->getFile( eLoc.a() );

        Extent * e = mdf->debug_getExtent( eLoc );
        if ( ! e->isOk() ){
            warning() << "Extent not ok magic: " << e->magic << " going to try to continue" << endl;
        }
        
        log() << "length:" << e->length << endl;
        
        LogIndentLevel lil2;
        
        DiskLoc loc = forward ? e->firstRecord : e->lastRecord;
        while ( ! loc.isNull() ){
            if ( loc.getOfs() <= 0 ){
                error() << "offset is 0 for record which should be impossible" << endl;
                break;
            }
            log() << loc << endl;
            Record* rec = loc.rec();
            log() << loc.obj() << endl;
            loc = forward ? rec->getNext( loc ) : rec->getPrev( loc );
        }
        return forward ? e->xnext : e->xprev;
        
    }
Пример #8
0
void Namespace::insert(const char* str)
{

	int count = 0;

	bson** bs = json_to_bson(str, count);

	Extent* lastExtent = getLastExtent();
	int success = 0;
	for (int i(0); i < count; i++)
	{
		success = lastExtent->addRecord(bs[i]);

		while (success != 0)
		{
			db->attachExtent(this);

			lastExtent = getLastExtent();
			success = lastExtent->addRecord(bs[i]);
		}

		free(bs[i]);
	}
	free(bs);
}
Пример #9
0
Extent *Extent::create(Iff & iff)
{
	Extent * extent = new Extent();

	extent->load(iff);

	return extent;
}
Пример #10
0
Sawyer::Optional<rose_addr_t>
MemoryMap::findAny(const Extent &limits, const std::vector<uint8_t> &bytesToFind,
                   unsigned requiredPerms, unsigned prohibitedPerms) const {
    if (limits.empty() || bytesToFind.empty())
        return Sawyer::Nothing();
    AddressInterval interval = AddressInterval::hull(limits.first(), limits.last());
    return findAny(interval, bytesToFind, requiredPerms, prohibitedPerms);
}
Пример #11
0
 void NamespaceDetails::dumpExtents() {
     cout << "dumpExtents:" << endl;
     for ( DiskLoc i = _firstExtent; !i.isNull(); i = i.ext()->xnext ) {
         Extent *e = i.ext();
         stringstream ss;
         e->dump(ss);
         cout << ss.str() << endl;
     }
 }
 Extent* DummyExtentManager::getExtent( const DiskLoc& loc, bool doSanityCheck ) const {
     invariant( !loc.isNull() );
     invariant( static_cast<size_t>( loc.a() ) < _extents.size() );
     invariant( loc.getOfs() == 0 );
     Extent* ext = reinterpret_cast<Extent*>( _extents[loc.a()].data );
     if (doSanityCheck)
         ext->assertOk();
     return ext;
 }
Пример #13
0
char* Namespace::getNextRecordData(int &recordSize)
{
	Record *rec;

	if (extentCursor.isNull()) // the first time after connection the extent cursor will be null
	{
		extentCursor = firstExtentLoc; // so, get the first extent of the colection
		if (_DEBUG)
			LOGI("getting first extent");
	}

	if (extentCursor.isNull()) // if first extent is null, then no extents exist
		return NULL;  // no extents

	Extent* extent = db->getExtent(extentCursor);

	if (recordCursor == -1)	// the first time the record cursor will be null as well
	{
		recordCursor = extent->firstRecord;	// get the first record of the extent

		if (recordCursor == -1)	// if first record is null, then no records exist
			return NULL;  // no records

		rec = extent->getRecord(recordCursor);
	}
	else // else, the cursor shows the previous record, should take the next one and return its data
	{
		rec = extent->getRecord(recordCursor);

		if (rec->nextRecLoc == -1) // if its next record is null, then go to next extent
		{
			if (extent->nextExtent.isNull()) // if the next extent is null, then no more extents
			{
				return NULL;  // no more records
			}
			else							// proceed with the next extent
			{
				extentCursor = extent->nextExtent;
				recordCursor = -1;
				return getNextRecordData(recordSize);
			}
		}
		else
		{
			recordCursor = rec->nextRecLoc;	// next record exists, so put the cursor on it
			if (_DEBUG)
				LOGI("getting next record");
			rec = extent->getRecord(recordCursor);
		}
	}

	int bsonSize = 0;
	bson_little_endian32( &bsonSize, rec->data);
	char *val = (char*) malloc((bsonSize + 128) * sizeof(char));
	int cur = 0;
	return bson_to_json(val, rec->data, 0, true, 0, recordSize, cur);
}
Пример #14
0
 virtual void firstExtent(const Extent &e) {
     series.setType(e.getTypePtr());
     const ExtentType::Ptr extent_type(e.getTypePtr());
     fields.reserve(extent_type->getNFields());
     for (uint32_t i = 0; i < extent_type->getNFields(); ++i) {
         string field_name(extent_type->getFieldName(i));
         fields.push_back(GeneralField::make(series, field_name));
         into.columns.push_back(TableColumn(field_name, 
                                            extent_type->getFieldTypeStr(field_name)));
     }
     into.__isset.columns = true;
 }
void mandelbrot_cpu_seq(Extent ext, int* dest, const int max_iter, Rectangle mi)
{
	for (int y = 0; y < ext.get_height(); y++)
	{
		for (int x = 0; x < ext.get_width(); x++)
		{
			const int i = ext.checked_index(x, y);
			const float x0 = scale(x, ext.get_width(), mi.x0, mi.x1);
			const float y0 = scale(y, ext.get_height(), mi.y0, mi.y1);
			dest[i] = mandelbrot(x0, y0, max_iter);
		}
	}
}
Пример #16
0
Record* Namespace::getNextRecord()
{
	Record *rec;
	if (extentCursor.isNull()) // the first time after connection the extent cursor will be null
	{
		extentCursor = firstExtentLoc; // so, get the first extent of the colection
		if (_DEBUG)
			LOGI("getting first extent");
	}

	if (extentCursor.isNull()) // if first extent is null, then no extents exist
		return NULL;  // no extents

	Extent* extent = db->getExtent(extentCursor);

	if (recordCursor == -1)	// the first time the record cursor will be null as well
	{
		recordCursor = extent->firstRecord;	// get the first record of the extent

		if (recordCursor == -1)	// if first record is null, then no records exist
			return NULL;  // no records

		rec = extent->getRecord(recordCursor);
	}
	else // else, the cursor shows the previous record, should take the next one and return its data
	{
		rec = extent->getRecord(recordCursor);

		if (rec->nextRecLoc == -1) // if its next record is null, then go to next extent
		{
			if (extent->nextExtent.isNull()) // if the next extent is null, then no more extents
			{
				return NULL;  // no more records
			}
			else							// proceed with the next extent
			{
				extentCursor = extent->nextExtent;
				recordCursor = -1;
				return getNextRecord();
			}
		}
		else
		{
			recordCursor = rec->nextRecLoc;	// next record exists, so put the cursor on it
			if (_DEBUG)
				LOGI("getting next record");
			rec = extent->getRecord(recordCursor);
		}
	}
	return rec;
}
Пример #17
0
//--------------------------------------------------------------------------------------------------------
void CFuncNavBlocker::UpdateBlocked()
{
	NavAreaCollector collector( true );
	Extent extent;
	extent.Init( this );
	TheNavMesh->ForAllAreasOverlappingExtent( collector, extent );

	for ( int i=0; i<collector.m_area.Count(); ++i )
	{
		CNavArea *area = collector.m_area[i];
		area->UpdateBlocked( true );
	}

}
Пример #18
0
char* Namespace::getNextBatch(int &count)
{
	if (_DEBUG)
		LOGI("get next batch");

	int batchSize = 0;
	int sizes[count];
	int jsonSize = 0;
	char *records[count]; //= (char**)malloc(count*sizeof(char*));

	int lastRetrievedRecord = -1, recordSize, skip = 0;

	int i = 0;
	Extent *extent = getFirstExtent();
	while (extent != NULL)
	{
		lastRetrievedRecord = -1;
		Record *record = extent->getFirstRecord();
		while (record != NULL && i < count)
		{
			recordSize = 0;

			int bsonSize = 0;
			bson_little_endian32( &bsonSize, record->data);
			//FORCE_LOG_INT("bsonSize: ", bsonSize);
			char *val = (char*) malloc((bsonSize + 100) * sizeof(char));
			int cur = 0;
			val = bson_to_json(val, record->data, 0, true, bsonSize, recordSize,
					cur);

			records[i] = val;
			batchSize += recordSize;
			sizes[i] = recordSize;
			jsonSize += recordSize;

			record = extent->getRecord(record->nextRecLoc);

			i++;
		}

		extent = db->getExtent(extent->nextExtent);
	}

	count = i;
	FORCE_LOG_INT("count: ", i);

	return serializeJSON(records, jsonSize, count, sizes);
}
Пример #19
0
    void firstExtent(const Extent &b_e) {
        ExtentSeries a_series;

        a_series.setExtent(a_input.getSharedExtent());
        b_series.setType(b_e.getTypePtr());
        if (a_series.getSharedExtent() == NULL) {
            requestError("a_table is empty?");
        }

        // Three possible sources for values in the output:
        // 
        // 1) the a value fields, so from the hash-map
        // 2a) the b fields, as one of the a eq fields.
        // 2b) the b fields, as one of the b values or eq fields
        // 
        // We do not try to optimize the extraction and just create a new general field for each
        // extraction so if the hash-map has duplicate columns, there will be duplicate fields.
        vector<GeneralField::Ptr> a_eq_fields;
        HashUnique<string> known_a_eq_fields;

        BOOST_FOREACH(const CMap::value_type &vt, eq_columns) {
            SINVARIANT(a_series.getTypePtr()->getFieldType(vt.first)
                       == b_series.getTypePtr()->getFieldType(vt.second));
            a_eq_fields.push_back(GeneralField::make(a_series, vt.first));
            b_eq_fields.push_back(GeneralField::make(b_series, vt.second));
            known_a_eq_fields.add(vt.first);
        }
Пример #20
0
 void set(Extent &e, uint8_t *row_pos, T val) {
     DEBUG_SINVARIANT(&e != NULL);
     uint8_t *byte_pos = row_pos + offset;
     DEBUG_SINVARIANT(e.insideExtentFixed(byte_pos));
     *reinterpret_cast<T *>(byte_pos) = val;
     setNull(e, row_pos, false);
 }
Пример #21
0
 /** add a record to the end of the linked list chain within this extent. 
     require: you must have already declared write intent for the record header.        
 */
 void addRecordToRecListInExtent(Record *r, DiskLoc loc) {
     dassert( loc.rec() == r );
     Extent *e = r->myExtent(loc);
     if ( e->lastRecord.isNull() ) {
         Extent::FL *fl = getDur().writing(e->fl());
         fl->firstRecord = fl->lastRecord = loc;
         r->prevOfs() = r->nextOfs() = DiskLoc::NullOfs;
     }
     else {
         Record *oldlast = e->lastRecord.rec();
         r->prevOfs() = e->lastRecord.getOfs();
         r->nextOfs() = DiskLoc::NullOfs;
         getDur().writingInt(oldlast->nextOfs()) = loc.getOfs();
         getDur().writingDiskLoc(e->lastRecord) = loc;
     }
 }
Пример #22
0
 virtual void firstExtent(const Extent &e) {
     skip_after_count.resize(getMaxUnifiedId()+1);
     skip_after_skip.resize(getMaxUnifiedId() +1);
     const ExtentType::Ptr type = e.getTypePtr();
     if (type->versionCompatible(0,0) || type->versionCompatible(1,0)) {
         packet_at.setFieldName("packet-at");
         is_request.setFieldName("is-request");
         op_id.setFieldName("op-id");
         nfs_version.setFieldName("nfs-version");
         transaction_id.setFieldName("transaction-id");
         payload_length.setFieldName("payload-length");
         record_id.setFieldName("record-id");
     } else if (type->versionCompatible(2,0)) {
         packet_at.setFieldName("packet_at");
         is_request.setFieldName("is_request");
         op_id.setFieldName("op_id");
         nfs_version.setFieldName("nfs_version");
         transaction_id.setFieldName("transaction_id");
         payload_length.setFieldName("payload_length");
         record_id.setFieldName("record_id");
     } else {
         FATAL_ERROR(format("can only handle v[0,1,2].*; not %d.%d")
                     % type->majorVersion() % type->minorVersion());
     }
 }
Пример #23
0
    shared_ptr<Cursor> DataFileMgr::findAll(const StringData& ns, const DiskLoc &startLoc) {
        NamespaceDetails * d = nsdetails( ns );
        if ( ! d )
            return shared_ptr<Cursor>(new BasicCursor(DiskLoc()));

        DiskLoc loc = d->firstExtent();
        if ( loc.isNull() )
            return shared_ptr<Cursor>(new BasicCursor(DiskLoc()));
        Extent *e = getExtent(loc);

        DEBUGGING {
            out() << "listing extents for " << ns << endl;
            DiskLoc tmp = loc;
            set<DiskLoc> extents;

            while ( 1 ) {
                Extent *f = getExtent(tmp);
                out() << "extent: " << tmp.toString() << endl;
                extents.insert(tmp);
                tmp = f->xnext;
                if ( tmp.isNull() )
                    break;
                f = f->getNextExtent();
            }

            out() << endl;
            d->dumpDeleted(&extents);
        }

        if ( d->isCapped() )
            return shared_ptr<Cursor>( ForwardCappedCursor::make( d , startLoc ) );

        if ( !startLoc.isNull() )
            return shared_ptr<Cursor>(new BasicCursor( startLoc ));

        while ( e->firstRecord.isNull() && !e->xnext.isNull() ) {
            /* todo: if extent is empty, free it for reuse elsewhere.
               that is a bit complicated have to clean up the freelists.
            */
            RARELY out() << "info DFM::findAll(): extent " << loc.toString() << " was empty, skipping ahead. ns:" << ns << endl;
            // find a nonempty extent
            // it might be nice to free the whole extent here!  but have to clean up free recs then.
            e = e->getNextExtent();
        }
        return shared_ptr<Cursor>(new BasicCursor( e->firstRecord ));
    }
Пример #24
0
    /* special version of insert for transaction logging -- streamlined a bit.
       assumes ns is capped and no indexes
    */
    Record* DataFileMgr::fast_oplog_insert(NamespaceDetails *d, const char *ns, int len) {
        verify( d );
        RARELY verify( d == nsdetails(ns) );
        DEV verify( d == nsdetails(ns) );

        massert( 16509,
                 str::stream()
                 << "fast_oplog_insert requires a capped collection "
                 << " but " << ns << " is not capped",
                 d->isCapped() );

        //record timing on oplog inserts
        boost::optional<TimerHolder> insertTimer;
        //skip non-oplog collections
        if (NamespaceString::oplog(ns)) {
            insertTimer = boost::in_place(&oplogInsertStats);
            oplogInsertBytesStats.increment(len); //record len of inserted records for oplog
        }

        int lenWHdr = len + Record::HeaderSize;
        DiskLoc loc = d->alloc(ns, lenWHdr);
        verify( !loc.isNull() );

        Record *r = loc.rec();
        verify( r->lengthWithHeaders() >= lenWHdr );

        Extent *e = r->myExtent(loc);
        if ( e->lastRecord.isNull() ) {
            Extent::FL *fl = getDur().writing( e->fl() );
            fl->firstRecord = fl->lastRecord = loc;

            Record::NP *np = getDur().writing(r->np());
            np->nextOfs = np->prevOfs = DiskLoc::NullOfs;
        }
        else {
            Record *oldlast = e->lastRecord.rec();
            Record::NP *np = getDur().writing(r->np());
            np->prevOfs = e->lastRecord.getOfs();
            np->nextOfs = DiskLoc::NullOfs;
            getDur().writingInt( oldlast->nextOfs() ) = loc.getOfs();
            e->lastRecord.writing() = loc;
        }

        d->incrementStats( r->netLength(), 1 );
        return r;
    }
Пример #25
0
void Picture::getExtent (
    float& l, float& b, float& cx, float& cy, float& tol, Graphic* gs
) {
    Extent e;
    float right, top, dummy1, dummy2;

    if (extentCached()) {
	getCachedExtent(e._left, e._bottom, e._cx, e._cy, e._tol);

    } else {
	if (IsEmpty()) {
	    l = b = cx = cy = tol = 0.0;
	    return;

	} else {
            Iterator i;
            FullGraphic gstemp;
            Transformer ttemp;
            Extent te;
    
            gstemp.SetTransformer(&ttemp);
            First(i);
	    Graphic* gr = GetGraphic(i);
	    concatGSGraphic(gr, gr, gs, &gstemp);
            concatTransformerGraphic(gr, nil, gr->GetTransformer(), &ttemp);
	    getExtentGraphic(gr, e._left,e._bottom,e._cx,e._cy,e._tol,&gstemp);

            for (Next(i); !Done(i); Next(i)) {
		gr = GetGraphic(i);
		concatGSGraphic(gr, gr, gs, &gstemp);
                concatTransformerGraphic(gr,nil, gr->GetTransformer(), &ttemp);
		getExtentGraphic(
                    gr, te._left, te._bottom, te._cx, te._cy, te._tol, &gstemp
                );
		e.Merge(te);
	    }
	    cacheExtent(e._left, e._bottom, e._cx, e._cy, e._tol);
            gstemp.SetTransformer(nil); // to avoid deleting ttemp explicitly
	}
    }
    right = 2*e._cx - e._left;
    top = 2*e._cy - e._bottom;
    transformRect(e._left, e._bottom, right, top, l, b, dummy1, dummy2, gs);
    transform(e._cx, e._cy, cx, cy, gs);
    tol = e._tol;
}
Пример #26
0
/** Write just the specified regions back to the file */
void
SgAsmGenericSection::unparse(std::ostream &f, const ExtentMap &map) const
{
    for (ExtentMap::const_iterator i=map.begin(); i!=map.end(); ++i) {
        Extent e = i->first;
        assert(e.first()+e.size() <= get_size());
        const unsigned char *extent_data;
        if (e.first() >= p_data.size()) {
            extent_data = NULL;
        } else if (e.first() + e.size() > p_data.size()) {
            extent_data = &p_data[e.first()];
        } else {
            extent_data = &p_data[e.first()];
        }
        if (extent_data)
            write(f, e.first(), e.size(), extent_data);
    }
}
Пример #27
0
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
Vector RandomNavAreaPositionWithin( const Vector &mins, const Vector &maxs, float minimumarea, int maxtries )
{
	if( maxtries < 0 )
		maxtries = 1;

	Vector random;
	CNavArea *pArea = NULL;
	Extent extent;

	for( int i = 0; i < maxtries; i++ )
	{
		random.Init( 
			mins.x + ((float)rand() / RAND_MAX) * (maxs.x - mins.x),
			mins.y + ((float)rand() / RAND_MAX) * (maxs.y - mins.y),
			maxs.z
		);
		pArea = TheNavMesh->GetNearestNavArea( random, false, 10000.0f, false, false );
		if( pArea )
		{
			pArea->GetExtent( &extent );
			if( extent.Area() >= minimumarea )
				break;
		}

		// Reset
		pArea = NULL;
	}


	if( !pArea )
	{
		if( g_pynavmesh_debug.GetBool() )
			DevMsg("RandomNavAreaPosition: No area found within Mins: %f %f %f, Maxs: %f %f %f, Random: %f %f %f\n", 
					mins.x, mins.y, mins.z, maxs.x, maxs.y, maxs.z, random.x, random.y, random.z);
		return vec3_origin;
	}
	Vector vRandomPoint = pArea->GetRandomPoint();
	vRandomPoint.z += 32.0f;

	if( g_pynavmesh_debug.GetBool() )
		DevMsg("RandomNavAreaPosition: Found position %f %f %f\n", vRandomPoint.x, vRandomPoint.y, vRandomPoint.z);

	return vRandomPoint;
}
Пример #28
0
//--------------------------------------------------------------------------------------------------------
void CFuncNavBlocker::BlockNav( void )
{
	if ( m_blockedTeamNumber == TEAM_ANY )
	{
		for ( int i=0; i<MAX_NAV_TEAMS; ++i )
		{
			m_isBlockingNav[ i ] = true;
		}
	}
	else
	{
		int teamNumber = m_blockedTeamNumber % MAX_NAV_TEAMS;
		m_isBlockingNav[ teamNumber ] = true;
	}

	Extent extent;
	extent.Init( this );
	TheNavMesh->ForAllAreasOverlappingExtent( *this, extent );
}
Пример #29
0
//--------------------------------------------------------------------------------------------------------
// Reevaluate all func_nav_cost entities and update the nav decoration accordingly.
// This is required to handle overlapping func_nav_cost entities.
void CFuncNavCost::UpdateAllNavCostDecoration( void )
{
	int i, j;

	// first, clear all avoid decoration from the mesh
	for( i=0; i<TheNavAreas.Count(); ++i )
	{
		TheNavAreas[i]->ClearAllNavCostEntities();
	}

	// now, mark all areas with active cost entities overlapping them
	for( i=0; i<gm_masterCostVector.Count(); ++i )
	{
		CFuncNavCost *cost = gm_masterCostVector[i];

		if ( !cost || !cost->IsEnabled() )
		{
			continue;
		}

		Extent extent;
		extent.Init( cost );

		CUtlVector< CNavArea * > overlapVector;
		TheNavMesh->CollectAreasOverlappingExtent( extent, &overlapVector );

		Ray_t ray;
		trace_t tr;
		ICollideable *pCollide = cost->CollisionProp();

		for( j=0; j<overlapVector.Count(); ++j )
		{
			ray.Init( overlapVector[j]->GetCenter(), overlapVector[j]->GetCenter() );

			enginetrace->ClipRayToCollideable( ray, MASK_ALL, pCollide, &tr );
			
			if ( tr.startsolid )
			{
				overlapVector[j]->AddFuncNavCostEntity( cost );
			}
		}
	}
}
Пример #30
0
 bool val(const Extent &e, uint8_t *row_pos) const {
     DEBUG_SINVARIANT(&e != NULL);
     uint8_t *byte_pos = row_pos + offset;
     DEBUG_SINVARIANT(e.insideExtentFixed(byte_pos));
     if (nullable && isNull(e, row_pos)) {
         return default_value;
     } else {
         return *byte_pos & bit_mask ? true : false; 
     }
 }