vrshoot: b2f14e535253 libs/assimp/BlenderDNA.inl

351 inline void Structure :: ResolvePointer( boost::shared_ptr< FileOffset >& out, const Pointer & ptrval, const FileDatabase& db, const Field& /*f*/) const

352 {

353 // Currently used exclusively by PackedFile::data to represent

354 // a simple offset into the mapped BLEND file.

355 out.reset();

356 if (!ptrval.val) {

357 return;

358 }

359

360 // find the file block the pointer is pointing to

361 const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db);

362

363 out = boost::shared_ptr< FileOffset > (new FileOffset());

364 out->val = block->start+ static_cast<size_t>((ptrval.val - block->address.val) );

365 }

366

367 //--------------------------------------------------------------------------------

368 template <template <typename> class TOUT, typename T>

369 void Structure :: ResolvePointer(vector< TOUT<T> >& out, const Pointer & ptrval, const FileDatabase& db, const Field& f) const

370 {

371 // This is a function overload, not a template specialization. According to

372 // the partial ordering rules, it should be selected by the compiler

373 // for array-of-pointer inputs, i.e. Object::mats.

374

375 out.reset();

376 if (!ptrval.val) {

377 return;

378 }

379

380 // find the file block the pointer is pointing to

381 const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db);

382 const size_t num = block->size / (db.i64bit?8:4);

383

384 // keep the old stream position

385 const StreamReaderAny::pos pold = db.reader->GetCurrentPos();

386 db.reader->SetCurrentPos(block->start+ static_cast<size_t>((ptrval.val - block->address.val) ));

387

388 // allocate raw storage for the array

389 out.resize(num);

390 for (size_t i = 0; i< num; ++i) {

391 Pointer val;

392 Convert(val,db);

393

394 // and resolve the pointees

395 ResolvePointer(out[i],val,db,f);

396 }

397

398 db.reader->SetCurrentPos(pold);

399 }

400

401 //--------------------------------------------------------------------------------

402 template <> void Structure :: ResolvePointer<boost::shared_ptr,ElemBase>(boost::shared_ptr<ElemBase>& out,

403 const Pointer & ptrval,

404 const FileDatabase& db,

405 const Field& /*f*/

406 ) const

407 {

408 // Special case when the data type needs to be determined at runtime.

409 // Less secure than in the `strongly-typed` case.

410

411 out.reset();

412 if (!ptrval.val) {

413 return;

414 }

415

416 // find the file block the pointer is pointing to

417 const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db);

418

419 // determine the target type from the block header

420 const Structure& s = db.dna[block->dna_index];

421

422 // try to retrieve the object from the cache

423 db.cache(out).get(s,out,ptrval);

424 if (out) {

425 return;

426 }

427

428 // seek to this location, but save the previous stream pointer.

429 const StreamReaderAny::pos pold = db.reader->GetCurrentPos();

430 db.reader->SetCurrentPos(block->start+ static_cast<size_t>((ptrval.val - block->address.val) ));

431 // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems.

432 // I really ought to improve StreamReader to work with 64 bit indices exclusively.

433

434 // continue conversion after allocating the required storage

435 DNA::FactoryPair builders = db.dna.GetBlobToStructureConverter(s,db);

436 if (!builders.first) {

437 // this might happen if DNA::RegisterConverters hasn't been called so far

438 // or if the target type is not contained in `our` DNA.

439 out.reset();

440 DefaultLogger::get()->warn((Formatter::format(),

441 "Failed to find a converter for the `",s.name,"` structure"

442 ));

443 return;

444 }

445

446 // allocate the object hull

447 out = (s.*builders.first)();

448

449 // cache the object immediately to prevent infinite recursion in a

450 // circular list with a single element (i.e. a self-referencing element).

451 db.cache(out).set(s,out,ptrval);

452

453 // and do the actual conversion

454 (s.*builders.second)(out,db);

455 db.reader->SetCurrentPos(pold);

456

457 // store a pointer to the name string of the actual type

458 // in the object itself. This allows the conversion code

459 // to perform additional type checking.

460 out->dna_type = s.name.c_str();

461

462

463

464 #ifndef ASSIMP_BUILD_BLENDER_NO_STATS

465 ++db.stats().pointers_resolved;

466 #endif

467 }

468

469 //--------------------------------------------------------------------------------

470 const FileBlockHead* Structure :: LocateFileBlockForAddress(const Pointer & ptrval, const FileDatabase& db) const

471 {

472 // the file blocks appear in list sorted by

473 // with ascending base addresses so we can run a

474 // binary search to locate the pointee quickly.

475

476 // NOTE: Blender seems to distinguish between side-by-side

477 // data (stored in the same data block) and far pointers,

478 // which are only used for structures starting with an ID.

479 // We don't need to make this distinction, our algorithm

480 // works regardless where the data is stored.

481 vector<FileBlockHead>::const_iterator it = std::lower_bound(db.entries.begin(),db.entries.end(),ptrval);

482 if (it == db.entries.end()) {

483 // this is crucial, pointers may not be invalid.

484 // this is either a corrupted file or an attempted attack.

485 throw DeadlyImportError((Formatter::format(),"Failure resolving pointer 0x",

486 std::hex,ptrval.val,", no file block falls into this address range"

487 ));

488 }

489 if (ptrval.val >= (*it).address.val + (*it).size) {

490 throw DeadlyImportError((Formatter::format(),"Failure resolving pointer 0x",

491 std::hex,ptrval.val,", nearest file block starting at 0x",

492 (*it).address.val," ends at 0x",

493 (*it).address.val + (*it).size

494 ));

495 }

496 return &*it;

497 }

498

499 // ------------------------------------------------------------------------------------------------

500 // NOTE: The MSVC debugger keeps showing up this annoying `a cast to a smaller data type has

501 // caused a loss of data`-warning. Avoid this warning by a masking with an appropriate bitmask.

502

503 template <typename T> struct signless;

504 template <> struct signless<char> {typedef unsigned char type;};

505 template <> struct signless<short> {typedef unsigned short type;};

506 template <> struct signless<int> {typedef unsigned int type;};

507

508 template <typename T>

509 struct static_cast_silent {

510 template <typename V>

511 T operator()(V in) {

512 return static_cast<T>(in & static_cast<typename signless<T>::type>(-1));

513 }

514 };

515

516 template <> struct static_cast_silent<float> {

517 template <typename V> float operator()(V in) {

518 return static_cast<float> (in);

519 }

520 };

521

522 template <> struct static_cast_silent<double> {

523 template <typename V> double operator()(V in) {

524 return static_cast<double>(in);

525 }

526 };

527

528 // ------------------------------------------------------------------------------------------------

529 template <typename T> inline void ConvertDispatcher(T& out, const Structure& in,const FileDatabase& db)

530 {

531 if (in.name == "int") {

532 out = static_cast_silent<T>()(db.reader->GetU4());

533 }

534 else if (in.name == "short") {

535 out = static_cast_silent<T>()(db.reader->GetU2());

536 }

537 else if (in.name == "char") {

538 out = static_cast_silent<T>()(db.reader->GetU1());

539 }

540 else if (in.name == "float") {

541 out = static_cast<T>(db.reader->GetF4());

542 }

543 else if (in.name == "double") {

544 out = static_cast<T>(db.reader->GetF8());

545 }

546 else {

547 throw DeadlyImportError("Unknown source for conversion to primitive data type: "+in.name);

548 }

549 }

550

551 // ------------------------------------------------------------------------------------------------

552 template <> inline void Structure :: Convert<int> (int& dest,const FileDatabase& db) const

553 {

554 ConvertDispatcher(dest,*this,db);

555 }

556

557 // ------------------------------------------------------------------------------------------------

558 template <> inline void Structure :: Convert<short> (short& dest,const FileDatabase& db) const

559 {

560 // automatic rescaling from short to float and vice versa (seems to be used by normals)

561 if (name == "float") {

562 dest = static_cast<short>(db.reader->GetF4() * 32767.f);

563 //db.reader->IncPtr(-4);

564 return;

565 }

566 else if (name == "double") {

567 dest = static_cast<short>(db.reader->GetF8() * 32767.);

568 //db.reader->IncPtr(-8);

569 return;

570 }

571 ConvertDispatcher(dest,*this,db);

572 }

573

574 // ------------------------------------------------------------------------------------------------

575 template <> inline void Structure :: Convert<char> (char& dest,const FileDatabase& db) const

576 {

577 // automatic rescaling from char to float and vice versa (seems useful for RGB colors)

578 if (name == "float") {

579 dest = static_cast<char>(db.reader->GetF4() * 255.f);

580 return;

581 }

582 else if (name == "double") {

583 dest = static_cast<char>(db.reader->GetF8() * 255.f);

584 return;

585 }

586 ConvertDispatcher(dest,*this,db);

587 }

588

589 // ------------------------------------------------------------------------------------------------

590 template <> inline void Structure :: Convert<float> (float& dest,const FileDatabase& db) const

591 {

592 // automatic rescaling from char to float and vice versa (seems useful for RGB colors)

593 if (name == "char") {

594 dest = db.reader->GetI1() / 255.f;

595 return;

596 }

597 // automatic rescaling from short to float and vice versa (used by normals)

598 else if (name == "short") {

599 dest = db.reader->GetI2() / 32767.f;

600 return;

601 }

602 ConvertDispatcher(dest,*this,db);

603 }

604

605 // ------------------------------------------------------------------------------------------------

606 template <> inline void Structure :: Convert<double> (double& dest,const FileDatabase& db) const

607 {

608 if (name == "char") {

609 dest = db.reader->GetI1() / 255.;

610 return;

611 }

612 else if (name == "short") {

613 dest = db.reader->GetI2() / 32767.;

614 return;

615 }

616 ConvertDispatcher(dest,*this,db);

617 }

618

619 // ------------------------------------------------------------------------------------------------

620 template <> inline void Structure :: Convert<Pointer> (Pointer& dest,const FileDatabase& db) const

621 {

622 if (db.i64bit) {

623 dest.val = db.reader->GetU8();

624 //db.reader->IncPtr(-8);

625 return;

626 }

627 dest.val = db.reader->GetU4();

628 //db.reader->IncPtr(-4);

629 }

630

631 //--------------------------------------------------------------------------------

632 const Structure& DNA :: operator [] (const std::string& ss) const

633 {

634 std::map<std::string, size_t>::const_iterator it = indices.find(ss);

635 if (it == indices.end()) {

636 throw Error((Formatter::format(),

637 "BlendDNA: Did not find a structure named `",ss,"`"

638 ));

639 }

640

641 return structures[(*it).second];

642 }

643

644 //--------------------------------------------------------------------------------

645 const Structure* DNA :: Get (const std::string& ss) const

646 {

647 std::map<std::string, size_t>::const_iterator it = indices.find(ss);

648 return it == indices.end() ? NULL : &structures[(*it).second];

649 }

650

651 //--------------------------------------------------------------------------------

652 const Structure& DNA :: operator [] (const size_t i) const

653 {

654 if (i >= structures.size()) {

655 throw Error((Formatter::format(),

656 "BlendDNA: There is no structure with index `",i,"`"

657 ));

658 }

659

660 return structures[i];

661 }

662

663 //--------------------------------------------------------------------------------

664 template <template <typename> class TOUT> template <typename T> void ObjectCache<TOUT> :: get (

665 const Structure& s,

666 TOUT<T>& out,

667 const Pointer& ptr

668 ) const {

669

670 if(s.cache_idx == static_cast<size_t>(-1)) {

671 s.cache_idx = db.next_cache_idx++;

672 caches.resize(db.next_cache_idx);

673 return;

674 }

675

676 typename StructureCache::const_iterator it = caches[s.cache_idx].find(ptr);

677 if (it != caches[s.cache_idx].end()) {

678 out = boost::static_pointer_cast<T>( (*it).second );

679

680 #ifndef ASSIMP_BUILD_BLENDER_NO_STATS

681 ++db.stats().cache_hits;

682 #endif

683 }

684 // otherwise, out remains untouched

685 }

686

687

688 //--------------------------------------------------------------------------------

689 template <template <typename> class TOUT> template <typename T> void ObjectCache<TOUT> :: set (

690 const Structure& s,

691 const TOUT<T>& out,

692 const Pointer& ptr

693 ) {

694 if(s.cache_idx == static_cast<size_t>(-1)) {

695 s.cache_idx = db.next_cache_idx++;

696 caches.resize(db.next_cache_idx);

697 }

698 caches[s.cache_idx][ptr] = boost::static_pointer_cast<ElemBase>( out );

699

700 #ifndef ASSIMP_BUILD_BLENDER_NO_STATS

701 ++db.stats().cached_objects;

702 #endif

703 }

704

705 }}

706 #endif