absence_thelab: 1cffe3409164 src/3deng/sceneloader.cpp

327 assert(ch.id == Chunk_Mat_TextureMap || ch.id == Chunk_Mat_TextureMap2 || ch.id == Chunk_Mat_OpacityMap || ch.id == Chunk_Mat_BumpMap || ch.id == Chunk_Mat_ReflectionMap || ch.id == Chunk_Mat_SelfIlluminationMap);

328

329 TexMap map;

330 Percent p = ReadPercent(file);

331 map.intensity = p.FloatPercent;

332

333 switch(ch.id) {

334 case Chunk_Mat_TextureMap:

335 map.type = TextureMap;

336 break;

337

338 case Chunk_Mat_TextureMap2:

339 map.type = DetailMap;

340 break;

341

342 case Chunk_Mat_OpacityMap:

343 map.type = OpacityMap;

344 break;

345

346 case Chunk_Mat_BumpMap:

347 map.type = BumpMap;

348 break;

349

350 case Chunk_Mat_ReflectionMap:

351 map.type = EnvironmentMap;

352 break;

353

354 case Chunk_Mat_SelfIlluminationMap:

355 map.type = LightMap;

356 break;

357 default:

358 assert(0);

359 }

360

361 ChunkHeader chunk = ReadChunkHeader(file);

362 assert(chunk.id == Chunk_Map_FileName);

363

364 map.filename = ReadString(file);

365 return map;

366 }

367

368

369

370

371

372 Material ReadMaterial(HANDLE file, const ChunkHeader &ch) {

373

374 Material mat;

375

376 assert(ch.id == Chunk_Edit_Material);

377

378 ReadCounter = HeaderSize;

379 dword ChunkSize = ch.size;

380

381 while(ReadCounter < ChunkSize) {

382 ChunkHeader chunk = ReadChunkHeader(file);

383

384 Percent p;

385 TexMap map;

386

387 switch(chunk.id) {

388 case Chunk_Mat_Name:

389 mat.name = ReadString(file);

390 break;

391

392 case Chunk_Mat_AmbientColor:

393 mat.Ambient = ReadColor(file);

394 break;

395

396 case Chunk_Mat_DiffuseColor:

397 mat.Diffuse = ReadColor(file);

398 break;

399

400 case Chunk_Mat_SpecularColor:

401 mat.Specular = ReadColor(file);

402 break;

403

404 case Chunk_Mat_Specular:

405 p = ReadPercent(file);

406 mat.Power = (float)p.IntPercent;

407 if(mat.Power > 0.0f) mat.SpecularEnable = true;

408 break;

409

410 case Chunk_Mat_SpecularIntensity:

411 p = ReadPercent(file);

412 mat.Specular.r *= p.FloatPercent;

413 mat.Specular.g *= p.FloatPercent;

414 mat.Specular.b *= p.FloatPercent;

415 break;

416

417 case Chunk_Mat_Transparency:

418 p = ReadPercent(file);

419 mat.Alpha = 1.0f - p.FloatPercent;

420 break;

421

422 case Chunk_Mat_SelfIllumination:

423 p = ReadPercent(file);

424 mat.Emissive = Color(p.FloatPercent);

425 break;

426

427 case Chunk_Mat_TextureMap:

428 case Chunk_Mat_TextureMap2:

429 case Chunk_Mat_OpacityMap:

430 case Chunk_Mat_SelfIlluminationMap:

431 map = ReadTextureMap(file, chunk);

432 mat.SetTexture(gc->texman->LoadTexture((datapath + map.filename).c_str()), map.type);

433 break;

434

435 case Chunk_Mat_ReflectionMap:

436 map = ReadTextureMap(file, chunk);

437 mat.SetTexture(gc->texman->LoadTexture((datapath + map.filename).c_str()), map.type);

438 mat.EnvBlend = map.intensity;

439 break;

440

441 case Chunk_Mat_BumpMap:

442 map = ReadTextureMap(file, chunk);

443 mat.SetTexture(gc->texman->LoadTexture((datapath + map.filename).c_str()), map.type);

444 mat.BumpIntensity = map.intensity;

445 break;

446

447 default:

448 SkipChunk(file, chunk);

449 }

450 }

451

452 return mat;

453 }

454

455

456

457

458

459 ////////////////////////////////////////////////////

460 byte ReadByte(HANDLE file) {

461 byte val;

462 dword numread;

463 ReadFile(file, &val, sizeof(byte), &numread, NULL);

464 if(numread < sizeof(byte)) eof = true;

465 ReadCounter++;

466 return val;

467 }

468

469 word ReadWord(HANDLE file) {

470 word val;

471 dword numread;

472 ReadFile(file, &val, sizeof(word), &numread, NULL);

473 if(numread < sizeof(word)) eof = true;

474 ReadCounter += sizeof(word);

475 return val;

476 }

477

478 dword ReadDword(HANDLE file) {

479 dword val;

480 dword numread;

481 ReadFile(file, &val, sizeof(dword), &numread, NULL);

482 if(numread < sizeof(dword)) eof = true;

483 ReadCounter += sizeof(dword);

484 return val;

485 }

486

487 float ReadFloat(HANDLE file) {

488 float val;

489 dword numread;

490 ReadFile(file, &val, sizeof(float), &numread, NULL);

491 if(numread < sizeof(float)) eof = true;

492 ReadCounter += sizeof(float);

493 return val;

494 }

495 /*

496 byte ReadByte(HANDLE file) {

497 byte val;

498 file.read((char*)&val, 1);

499 ReadCounter++;

500 return val;

501 }

502

503 word ReadWord(HANDLE file) {

504 word val;

505 file.read((char*)&val, sizeof(word));

506 ReadCounter += sizeof(word);

507 return val;

508 }

509

510 dword ReadDword(HANDLE file) {

511 dword val;

512 file.read((char*)&val, sizeof(dword));

513 ReadCounter += sizeof(dword);

514 return val;

515 }

516

517 float ReadFloat(HANDLE file) {

518 float val;

519 file.read((char*)&val, sizeof(float));

520 ReadCounter += sizeof(float);

521 return val;

522 }

523 */

524 Vector3 ReadVector(HANDLE file, bool FlipYZ) {

525 Vector3 vector;

526 vector.x = ReadFloat(file);

527 if(!FlipYZ) vector.y = ReadFloat(file);

528 vector.z = ReadFloat(file);

529 if(FlipYZ) vector.y = ReadFloat(file);

530 return vector;

531 }

532

533 string ReadString(HANDLE file) {

534 string str;

535 char c;

536 while(c = (char)ReadByte(file)) {

537 str.push_back(c);

538 }

539 str.push_back('\0');

540 ReadCounter++;

541

542 return str;

543 }

544 /*

545 string ReadString(HANDLE file) {

546 string str;

547 char c;

548 while(c = file.get()) {

549 str.push_back(c);

550 ReadCounter++;

551 }

552 str.push_back('\0');

553 ReadCounter++;

554

555 return str;

556 }

557 */

558

559 Color ReadColor(HANDLE file) {

560 ChunkHeader chunk = ReadChunkHeader(file);

561 if(chunk.id < 0x0010 || chunk.id > 0x0013) return Color(-1.0f, -1.0f, -1.0f);

562

563 Color color;

564

565 if(chunk.id == Chunk_Color_Byte3 || chunk.id == Chunk_Color_GammaByte3) {

566 byte r = ReadByte(file);

567 byte g = ReadByte(file);

568 byte b = ReadByte(file);

569 color = Color(r, g, b);

570 } else {

571 color.r = ReadFloat(file);

572 color.g = ReadFloat(file);

573 color.b = ReadFloat(file);

574 }

575

576 return color;

577 }

578

579 Percent ReadPercent(HANDLE file) {

580 ChunkHeader chunk = ReadChunkHeader(file);

581 Percent p;

582 if(chunk.id != Chunk_PercentInt && chunk.id != Chunk_PercentFloat) return p;

583

584 if(chunk.id == Chunk_PercentInt) {

585 p = Percent(ReadWord(file));

586 } else {

587 p = Percent(ReadFloat(file));

588 }

589

590 return p;

591 }

592

593

594 ChunkHeader ReadChunkHeader(HANDLE file) {

595 ChunkHeader chunk;

596 chunk.id = (ChunkID)ReadWord(file);

597 chunk.size = ReadDword(file);

598 return chunk;

599 }

600

601 void SkipChunk(HANDLE file, const ChunkHeader &chunk) {

602 //file.ignore(chunk.size - HeaderSize);

603 SetFilePointer(file, chunk.size - HeaderSize, 0, FILE_CURRENT);

604 ReadCounter += chunk.size - HeaderSize;

605 }

606

607 void SkipBytes(HANDLE file, dword bytes) {

608 SetFilePointer(file, bytes, 0, FILE_CURRENT);

609 ReadCounter += bytes;

610 }

611

612 Material *FindMaterial(string name) {

613 dword i=0;

614 while(i < MatCount) {

615 if(mat[i].name == name) return &mat[i];

616 i++;

617 }

618

619 return 0;

620 }

621

622 ///////////////////// Read Object Function //////////////////////

623 int ReadObject(HANDLE file, const ChunkHeader &ch, void **obj) {

624 if(!obj || !gc) return -1;

625

626 ReadCounter = HeaderSize; // reset the global read counter

627

628 string name = ReadString(file);

629

630 ChunkHeader chunk;

631 chunk = ReadChunkHeader(file);

632 if(chunk.id == Chunk_Obj_TriMesh) {

633 // object is a trimesh... load it

634 Vertex *varray;

635 Triangle *tarray;

636 dword VertexCount=0, TriCount=0;

637 Material mat;

638 Base base;

639 Vector3 translation;

640

641 bool curve = true;

642

643 dword ObjChunkSize = ch.size;

644

645 while(ReadCounter < ObjChunkSize) { // make sure we only read subchunks of this object chunk

646 //assert(!file.eof());

647 assert(!eof);

648 chunk = ReadChunkHeader(file);

649

650 switch(chunk.id) {

651 case Chunk_TriMesh_VertexList:

652 VertexCount = (dword)ReadWord(file);

653 varray = new Vertex[VertexCount];

654

655 for(dword i=0; i<VertexCount; i++) {

656 varray[i].pos = ReadVector(file);

657 }

658

659 break;

660

661 case Chunk_TriMesh_FaceDesc:

662 curve = false; // it is a real object not a curve since it has triangles

663 TriCount = (dword)ReadWord(file);

664 tarray = new Triangle[TriCount];

665

666 for(dword i=0; i<TriCount; i++) {

667 tarray[i].vertices[0] = (Index)ReadWord(file); //

668 tarray[i].vertices[2] = (Index)ReadWord(file); // flip order to CW

669 tarray[i].vertices[1] = (Index)ReadWord(file); //

670 ReadWord(file); // discard edge visibility flags

671 }

672 break;

673

674 case Chunk_Face_Material:

675 mat = *FindMaterial(ReadString(file));

676

677 SkipBytes(file, ReadWord(file)<<1);

678 break;

679

680 case Chunk_TriMesh_TexCoords:

681 assert((dword)ReadWord(file) == VertexCount);

682

683 for(dword i=0; i<VertexCount; i++) {

684 varray[i].tex[0].u = varray[i].tex[1].u = ReadFloat(file);

685 varray[i].tex[0].v = varray[i].tex[1].v = -ReadFloat(file);

686 }

687 break;

688

689 case Chunk_TriMesh_SmoothingGroup:

690 // **TODO** abide by smoothing groups duplicate vertices, weld others etc

691 SkipChunk(file, chunk);

692 break;

693

694 case Chunk_TriMesh_WorldTransform:

695 base.i = ReadVector(file);

696 base.k = ReadVector(file); // flip

697 base.j = ReadVector(file);

698 translation = ReadVector(file);

699 break;

700

701 default:

702 SkipChunk(file, chunk);

703 }

704 }

705

706 if(curve) {

707 CatmullRomSpline *spline = new CatmullRomSpline;

708 spline->name = name;

709 for(dword i=0; i<VertexCount; i++) {

710 spline->AddControlPoint(varray[i].pos);

711 }

712

713 *obj = spline;

714 return OBJ_CURVE;

715 } else {

716

717 base.i.Normalize();

718 base.j.Normalize();

719 base.k.Normalize();

720 Matrix3x3 RotXForm = base.CreateRotationMatrix();

721 RotXForm.OrthoNormalize();

722

723 for(dword i=0; i<VertexCount; i++) {

724 varray[i].pos.Translate(-translation.x, -translation.y, -translation.z);

725 varray[i].pos.Transform(RotXForm.Transposed());

726 }

727

728 Object *object = new Object(gc);

729 object->name = name;

730 object->GetTriMesh()->SetData(varray, tarray, VertexCount, TriCount);

731 object->material = mat;

732 object->SetRotation(RotXForm);

733 object->SetTranslation(translation.x, translation.y, translation.z);

734 *obj = object;

735

736 return OBJ_MESH;

737 }

738 } else {

739

740 if(chunk.id == Chunk_Obj_Light) {

741

742 dword ObjChunkSize = ch.size;

743

744 Vector3 pos = ReadVector(file);

745 Color color = ReadColor(file);

746

747 Vector3 SpotTarget;

748 float InnerCone, OuterCone;

749 bool spot = false;

750 bool att = false;

751 bool CastShadows = false;

752 float AttEnd = 10000.0f;

753 float Intensity = 1.0f;

754

755 while(ReadCounter < ObjChunkSize) {

756

757 chunk = ReadChunkHeader(file);

758

759 switch(chunk.id) {

760 case Chunk_Light_SpotLight:

761 spot = true;

762 SpotTarget = ReadVector(file);

763 InnerCone = ReadFloat(file) / 180.0f;

764 OuterCone = ReadFloat(file) / 180.0f;

765 break;

766

767 case Chunk_Light_Attenuation:

768 att = true;

769 break;

770

771 case Chunk_Light_AttenuationEnd:

772 AttEnd = ReadFloat(file);

773 break;

774

775 case Chunk_Light_Intensity:

776 Intensity = ReadFloat(file);

777 break;

778

779 case Chunk_Spot_CastShadows:

780 CastShadows = true;

781 break;

782

783 default:

784 SkipChunk(file, chunk);

785 }

786 }

787

788 Light *light;

789 if(spot) {

790 light = new TargetSpotLight(pos, SpotTarget, InnerCone, OuterCone);

791 } else {

792 light = new PointLight(pos);

793 }

794 light->SetColor(color);

795 light->SetShadowCasting(CastShadows);

796 light->SetIntensity(Intensity);

797 light->name = name;

798

799 *obj = light;

800 return spot ? OBJ_SPLIGHT : OBJ_PTLIGHT;

801 }

802

803 if(chunk.id == Chunk_Obj_Camera) {

804 Camera *cam = new Camera;

805 Vector3 pos = ReadVector(file);

806 Vector3 targ = ReadVector(file);

807 float roll = ReadFloat(file);

808 float FOV = ReadFloat(file);

809

810 Vector3 up = VECTOR3_J;

811 Vector3 view = targ - pos;

812 up.Rotate(view.Normalized(), roll);

813

814 cam->SetCamera(pos, targ, up);

815 cam->name = name;

816 cam->SetFOV(DEGTORAD(FOV) / 1.33333f);

817

818 *obj = cam;

819 return OBJ_CAMERA;

820 }

821 }

822

823 return -1; // should have already left by now, if not something is wrong

824 }

825

826

827 ////////////////////////////////////////////////////////////////////////////////

828 // functions to save/load normals from file

829

830 void WriteByte(HANDLE file, byte val) {

831 dword junk;

832 WriteFile(file, &val, sizeof(byte), &junk, 0);

833 }

834

835 void WriteDword(HANDLE file, dword val) {

836 dword junk;

837 WriteFile(file, &val, sizeof(dword), &junk, 0);

838 assert(junk == sizeof(dword));

839 }

840

841 void WriteFloat(HANDLE file, float val) {

842 dword junk;

843 WriteFile(file, &val, sizeof(float), &junk, 0);

844 assert(junk == sizeof(float));

845 }

846

847 void WriteString(HANDLE file, string str) {

848 dword junk;

849 for(dword i=0; i<(dword)str.size(); i++) {

850 WriteFile(file, &str[i], sizeof(char), &junk, 0);

851 }

852 }

853

854

855 void SaveNormalsToFile(const char *fname, Scene *scene) {

856

857 HANDLE file = CreateFile(fname, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);

858 assert(file);

859

860 WriteDword(file, (dword)scene->GetObjectsList()->size());

861

862 std::list<Object*>::iterator objiter = scene->GetObjectsList()->begin();

863 while(objiter != scene->GetObjectsList()->end()) {

864 WriteString(file, (*objiter)->name);

865 dword VertexCount = (*objiter)->GetTriMesh()->GetVertexCount();

866 WriteDword(file, VertexCount);

867

868 const Vertex *varray = (*objiter)->GetTriMesh()->GetVertexArray();

869 for(dword i=0; i<VertexCount; i++) {

870 WriteFloat(file, varray[i].normal.x);

871 WriteFloat(file, varray[i].normal.y);

872 WriteFloat(file, varray[i].normal.z);

873 }

874

875 objiter++;

876 }

877

878 CloseHandle(file);

879 }

880

881 bool LoadNormalsFromFile(const char *fname, Scene *scene) {

882

883 HANDLE file = CreateFile(fname, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);

884 if(!file) return false;

885

886 eof = false;

887 ReadCounter = 0;

888

889 dword FileSize = SetFilePointer(file, 0, 0, FILE_END) - SetFilePointer(file, 0, 0, FILE_BEGIN);

890

891 SetFilePointer(file, 0, 0, FILE_BEGIN);

892

893 dword ObjectCount = ReadDword(file);

894 if(ObjectCount != scene->GetObjectsList()->size()) { // detect changes

895 CloseHandle(file);

896 return false;

897 }

898

899 while(SceneLoader::ReadCounter < FileSize) {

900 string name = ReadString(file);

901 dword VertexCount = ReadDword(file);

902

903 Object *obj = scene->GetObject(name.c_str());

904 if(!obj) {

905 CloseHandle(file);

906 return false;

907 }

908

909 if(VertexCount != obj->GetTriMesh()->GetVertexCount()) { // again detect changes

910 CloseHandle(file);

911 return false;

912 }

913

914 Vertex *varray = obj->GetTriMesh()->GetModVertexArray();

915 for(dword i=0; i<VertexCount; i++) {

916 varray[i].normal = ReadVector(file, false);

917 }

918 }

919

920 CloseHandle(file);

921 return true;

922 }

923