FPhysXFormatDataReader::FPhysXFormatDataReader( FByteBulkData& InBulkData )
	: TriMesh( NULL )
	, TriMeshNegX( NULL )
{
	// Read cooked physics data
	uint8* DataPtr = (uint8*)InBulkData.Lock( LOCK_READ_ONLY );
	FBufferReader Ar( DataPtr, InBulkData.GetBulkDataSize(), false );
	
	uint8 bLittleEndian = true;
	int32 NumConvexElementsCooked = 0;
	int32 NumMirroredElementsCooked = 0;
	uint8 bTriMeshCooked = false;
	uint8 bMirroredTriMeshCooked = false;

	Ar << bLittleEndian;
	Ar.SetByteSwapping( PLATFORM_LITTLE_ENDIAN ? !bLittleEndian : !!bLittleEndian );
	Ar << NumConvexElementsCooked;	
	Ar << NumMirroredElementsCooked;
	Ar << bTriMeshCooked;
	Ar << bMirroredTriMeshCooked;
	
	ConvexMeshes.Empty( NumConvexElementsCooked );
	ConvexMeshesNegX.Empty( NumMirroredElementsCooked );

	for( int32 ElementIndex = 0; ElementIndex < NumConvexElementsCooked; ElementIndex++ )
	{
		PxConvexMesh* ConvexMesh = ReadConvexMesh( Ar, DataPtr, InBulkData.GetBulkDataSize() );
		ConvexMeshes.Add( ConvexMesh );
	}

	for( int32 ElementIndex = 0; ElementIndex < NumMirroredElementsCooked; ElementIndex++ )
	{
		PxConvexMesh* ConvexMeshNegX = ReadConvexMesh( Ar, DataPtr, InBulkData.GetBulkDataSize() );
		ConvexMeshesNegX.Add( ConvexMeshNegX );
	}

	if( bTriMeshCooked )
	{
		TriMesh = ReadTriMesh( Ar, DataPtr, InBulkData.GetBulkDataSize() );
		check(TriMesh);	
	}

	if( bMirroredTriMeshCooked )
	{
		TriMeshNegX = ReadTriMesh( Ar, DataPtr, InBulkData.GetBulkDataSize() );
		check(TriMeshNegX);	
	}

	InBulkData.Unlock();
}
FPhysXFormatDataReader::FPhysXFormatDataReader( FByteBulkData& InBulkData, FBodySetupUVInfo* UVInfo )
{
	// Read cooked physics data
	uint8* DataPtr = (uint8*)InBulkData.Lock( LOCK_READ_ONLY );
	FBufferReader Ar( DataPtr, InBulkData.GetBulkDataSize(), false );
	
	uint8 bLittleEndian = true;
	int32 NumConvexElementsCooked = 0;
	int32 NumMirroredElementsCooked = 0;
	int32 NumTriMeshesCooked = 0;

	Ar << bLittleEndian;
	Ar.SetByteSwapping( PLATFORM_LITTLE_ENDIAN ? !bLittleEndian : !!bLittleEndian );
	Ar << NumConvexElementsCooked;	
	Ar << NumMirroredElementsCooked;
	Ar << NumTriMeshesCooked;
	
	ConvexMeshes.Empty(NumConvexElementsCooked);
	for( int32 ElementIndex = 0; ElementIndex < NumConvexElementsCooked; ElementIndex++ )
	{
		PxConvexMesh* ConvexMesh = ReadConvexMesh( Ar, DataPtr, InBulkData.GetBulkDataSize() );
		ConvexMeshes.Add( ConvexMesh );
	}

	ConvexMeshesNegX.Empty(NumMirroredElementsCooked);
	for( int32 ElementIndex = 0; ElementIndex < NumMirroredElementsCooked; ElementIndex++ )
	{
		PxConvexMesh* ConvexMeshNegX = ReadConvexMesh( Ar, DataPtr, InBulkData.GetBulkDataSize() );
		ConvexMeshesNegX.Add( ConvexMeshNegX );
	}

	TriMeshes.Empty(NumTriMeshesCooked);
	for(int32 ElementIndex = 0; ElementIndex < NumTriMeshesCooked; ++ElementIndex)
	{
		PxTriangleMesh* TriMesh = ReadTriMesh( Ar, DataPtr, InBulkData.GetBulkDataSize() );
		TriMeshes.Add(TriMesh);
	}

	// Init UVInfo pointer
	check(UVInfo);
	Ar << *UVInfo;

	InBulkData.Unlock();
}
Exemple #3
0
Mesh* Load3ds(string URL, Entity* parent_ent){
  int Size;
  //Local OldDir:String
  unsigned char Red, Green, Blue;
  //unsigned char Percent;
  //Local Pixmap:TPixmap
  Stream = File::ReadResourceFile(URL);
  if (Stream == 0) return 0;

  //Size = Stream.Size()
  fseek(Stream->pFile, 0, SEEK_END); // seek to end of file
  Size = ftell(Stream->pFile); // get current file pointer
  fseek(Stream->pFile, 0, SEEK_SET);

  // Read Main-Chunk
  ReadChunk();
  if (ChunkID != M3D_3DS_MAIN || ChunkSize != Size) {
    Stream->CloseFile();
    //Print "No 3DS File"
    return 0;
  }
  // Find 3DEditor-Chunk
  while (Stream->Eof()==0){
    ReadChunk();
    if (ChunkID == M3D_3DS_3DEDITOR){
      break;
    }else{
      SkipChunk();
    }
  }

  //OldDir = CurrentDir()
  //If String(URL) <> "" Then ChangeDir(ExtractDir(String(URL)))
  mesh = Mesh::CreateMesh();
  while (Stream->Eof()==0){
    ReadChunk();
    switch (ChunkID){
    case M3D_3DS_OBJECTBLOCK:
      ReadCString(); // ' ObjectName
      break;
    case M3D_3DS_BrushBLOCK:
      ReadBrushBlock();
      break;
    case M3D_3DS_TRIMESH:
      ReadTriMesh();
      break;
    case M3D_3DS_VERTEXLIST:
      ReadVertexList();
      break;
    case M3D_3DS_FACELIST:
      ReadFaceList();
      break;
    case M3D_3DS_FACEMATLIST:
      ReadFaceMatList();
      break;
    case M3D_3DS_TEXCOORDS:
      ReadTexCoords();
      break;
    case M3D_3DS_BrushNAME:
      //Loader.Brush = CreateBrush()
      brush->name = ReadCString();
      break;
    case M3D_3DS_BrushAMBIENT:
      //ReadChunk();
      //ReadRGB(ChunkID, Red, Green, Blue);
      //brush->SetAmbientColor(Red, Green, Blue);
      break;
    case M3D_3DS_BrushDIFFUSE:
      ReadChunk();
      ReadRGB(ChunkID, Red, Green, Blue);
      brush->BrushColor(Red, Green, Blue);
      break;
    case M3D_3DS_BrushSPECULAR:
      //'Loader.ReadChunk()
      //'Loader.ReadRGB(Loader.ChunkID, Red, Green, Blue)
      //'Loader.Brush.SetSpecularColor(Red, Green, Blue)
      break;
    case M3D_3DS_BrushSHININESS:
      //'Loader.ReadChunk()
      //'Percent = Loader.ReadPercent(Loader.ChunkID)
      //'Loader.Brush.BrushShininess(Percent)
      break;
    case M3D_3DS_MAPFILENAME:
      LoadMap();
      break;
    case M3D_3DS_MAPVSCALE:
      texture->v_scale = Stream->ReadFloat();
      break;
    case M3D_3DS_MAPUSCALE:
      texture->u_scale = Stream->ReadFloat();
      break;
    case M3D_3DS_MAPUOFFSET:
      texture->u_pos = Stream->ReadFloat();
      break;
    case M3D_3DS_MAPVOFFSET:
      texture->v_pos = Stream->ReadFloat();
      break;
    case M3D_3DS_MAPROTATION:
      texture->angle = Stream->ReadFloat();
      break;
    default:
      if ((ChunkID == M3D_3DS_TEXTUREMAP1) || (ChunkID == M3D_3DS_TEXTUREMAP2)) {
        ReadMap(ChunkID);
      }else{
        SkipChunk();
      }
    }
  }
  Stream->CloseFile();

  if (surface!=0){
    MovedTris.sort();
    int CheckSurface=0;
    for(list<int>::const_reverse_iterator it = MovedTris.rbegin(); it != MovedTris.rend(); it++){
      surface->RemoveTri(*it);
      CheckSurface=1;
    }
    MovedTris.clear();

    if (surface->no_tris==0 && CheckSurface !=0) {
      delete surface;
      mesh->surf_list.remove(surface);
      mesh->no_surfs=mesh->no_surfs-1;
    }
  }


//    ChangeDir(OldDir)
//    Loader.Surface.UpdateVertices()
//    Loader.Surface.UpdateTriangles()
  mesh->UpdateNormals();
  /*Loader.Mesh.UpdateBuffer()
  Print Loader.Surface.Tris.Length
  Print Loader.Surface.no_verts
  'Loader.Mesh.FlipMesh()*/

  mesh->class_name="Mesh";
  mesh->AddParent(*parent_ent);
  Entity::entity_list.push_back(mesh);
  if(mesh->parent!=0){
    mesh->mat.Overwrite(mesh->parent->mat);
    mesh->UpdateMat();
  }else{
    mesh->UpdateMat(true);
  }
  return mesh;
}
void SceneImporter<real>::ReadScene( std::istream& stream, Scene<real>& oScene )
{
	// Read the 'Scene' token
	ReadNextExactToken( stream, "Scene" );
	ReadNextExactToken( stream, "{" );

	// Read scene components
	std::string token = ReadNextToken( stream );

	while( token != "}" )
	{
		if ( token == "SceneInfo" )
		{
			ReadNextExactToken( stream, "(" );
			ReadSceneInfo( stream, oScene );
			ReadNextExactToken( stream, ")" );
			ReadNextExactToken( stream, ";" );
		}
		else if ( token == "TurntableCamera" )
		{
			std::string name = ReadNextToken( stream );
			ReadNextExactToken( stream, "(" );
			Camera<real>* camera = ReadTurntableCamera( stream, name );
			ReadNextExactToken( stream, ")" );
			ReadNextExactToken( stream, ";" );

			oScene.AddObject( camera, true );
		}
		else if ( token == "DirectionalLight" )
		{
			std::string name = ReadNextToken( stream );
			ReadNextExactToken( stream, "(" );
			Light<real>* light = ReadDirectionalLight( stream, name );
			ReadNextExactToken( stream, ")" );
			ReadNextExactToken( stream, ";" );

			oScene.AddObject( light, true );
		}
		else if ( token == "PointLight" )
		{
			std::string name = ReadNextToken( stream );
			ReadNextExactToken( stream, "(" );
			Light<real>* light = ReadPointLight( stream, name );
			ReadNextExactToken( stream, ")" );
			ReadNextExactToken( stream, ";" );

			oScene.AddObject( light, true );
		}
		else if ( token == "SpotLight" )
		{
			std::string name = ReadNextToken( stream );
			ReadNextExactToken( stream, "(" );
			Light<real>* light = ReadSpotLight( stream, name );
			ReadNextExactToken( stream, ")" );
			ReadNextExactToken( stream, ";" );

			oScene.AddObject( light, true );
		}
		else if ( token == "BlinnPhongMaterial" )
		{
			std::string name = ReadNextToken( stream );
			ReadNextExactToken( stream, "(" );
			Material* material = ReadBlinnPhongMaterial( stream, name );
			ReadNextExactToken( stream, ")" );
			ReadNextExactToken( stream, ";" );

			oScene.AddObject( material, true );
		}
		else if ( token == "EnvironmentMaterial" )
		{
			std::string name = ReadNextToken( stream );
			ReadNextExactToken( stream, "(" );
			Material* material = ReadEnvironmentMaterial( stream, name );
			ReadNextExactToken( stream, ")" );
			ReadNextExactToken( stream, ";" );

			oScene.AddObject( material, true );
		}
		else if ( token == "CubeMap" )
		{
			std::string name = ReadNextToken( stream );
			ReadNextExactToken( stream, "(" );
			Texture<real>* cubeMap = ReadCubeMap( stream, name );
			ReadNextExactToken( stream, ")" );
			ReadNextExactToken( stream, ";" );

			oScene.AddObject( cubeMap, true );
		}
		else if ( token == "Texture2D" )
		{
			std::string name = ReadNextToken( stream );
			ReadNextExactToken( stream, "(" );
			Texture<real>* texture = ReadTexture2D( stream, name );
			ReadNextExactToken( stream, ")" );
			ReadNextExactToken( stream, ";" );

			oScene.AddObject( texture, true );
		}
		else if ( token == "Box" )
		{
			std::string name = ReadNextToken( stream );
			ReadNextExactToken( stream, "(" );
			Node<real>* box = ReadBox( stream, name );
			ReadNextExactToken( stream, ")" );
			ReadNextExactToken( stream, ";" );

			oScene.AddObject( box, true );
		}
		else if ( token == "Cone" )
		{
			std::string name = ReadNextToken( stream );
			ReadNextExactToken( stream, "(" );
			Node<real>* cone = ReadCone( stream, name );
			ReadNextExactToken( stream, ")" );
			ReadNextExactToken( stream, ";" );

			oScene.AddObject( cone, true );
		}
		else if ( token == "Cylinder" )
		{
			std::string name = ReadNextToken( stream );
			ReadNextExactToken( stream, "(" );
			Node<real>* cylinder = ReadCylinder( stream, name );
			ReadNextExactToken( stream, ")" );
			ReadNextExactToken( stream, ";" );

			oScene.AddObject( cylinder, true );
		}
		else if ( token == "Plane" )
		{
			std::string name = ReadNextToken( stream );
			ReadNextExactToken( stream, "(" );
			Node<real>* plane = ReadPlane( stream, name );
			ReadNextExactToken( stream, ")" );
			ReadNextExactToken( stream, ";" );

			oScene.AddObject( plane, true );
		}
		else if ( token == "Sphere" )
		{
			std::string name = ReadNextToken( stream );
			ReadNextExactToken( stream, "(" );
			Node<real>* sphere = ReadSphere( stream, name );
			ReadNextExactToken( stream, ")" );
			ReadNextExactToken( stream, ";" );

			oScene.AddObject( sphere, true );
		}
		else if ( token == "TriMesh" )
		{
			std::string name = ReadNextToken( stream );
			ReadNextExactToken( stream, "(" );
			Node<real>* triMesh = ReadTriMesh( stream, name );
			ReadNextExactToken( stream, ")" );
			ReadNextExactToken( stream, ";" );

			oScene.AddObject( triMesh, true );
		}
		else if ( token == "Node" )
		{
			std::string name = ReadNextToken( stream );
			ReadNextExactToken( stream, "(" );
			Node<real>* node = ReadNode( stream, name );
			ReadNextExactToken( stream, ")" );
			ReadNextExactToken( stream, ";" );

			oScene.AddObject( node, true );
		}
		else
		{
			throw ( std::string( "Unknown token: " ) + token ).c_str();
		}

		token = ReadNextToken( stream );
	}

	// Read scene ending token
	ReadNextExactToken( stream, ";" );
}