JD2022-TU1/main/extern/Camcam/LIBS/Mixer/SCENE_Medias.cpp

#include "SCENE.h"
//#pragma optimize("",off)
//#define MEDIA_DESTROY_SCENE_VERIFY

int WORLD::GetMediaFromString(char *MediaName, u32 *MediaIndex)
{
	*MediaIndex = MediaDico.IsExist(MediaName);
	if (*MediaIndex == -1) return 0;
	*MediaIndex = MediaDico.mpst_Dico[*MediaIndex].AssociatedValue;
	return *MediaIndex != -1 && ID_MEDIA[*MediaIndex] != NULL && ID_MEDIA[*MediaIndex]->VirtuallyDestroyed == 0;
}


INPUT_IO *WORLD::GetMediaFromImage(MAP *IMG)
{
	if (IMG == NULL)
		return NULL;
	for  (u32 Counter = 0 ; Counter < MAX_INPMED ; Counter++)
	{
		if (ID_MEDIA[Counter] && (&ID_MEDIA[Counter]->Image == IMG))
		{
			return ID_MEDIA[Counter];
		}
	}
	
	return NULL;
}

bool WORLD::MediaToScreen(u32 IDMedia, HDC hdcScreen, int sx, int sy, int x, int y)
{
	if (ID_MEDIA[IDMedia])
	{
		if (ID_MEDIA[IDMedia]->Image.SX < sx || ID_MEDIA[IDMedia]->Image.SY < sy)
			return false;
		if (x < 0 || y < 0)
			return false;

		HBITMAP	_hbmScreen;
		HDC		_hdcCompatible;
		HGDIOBJ _OldHbm;

		_hdcCompatible = CreateCompatibleDC(hdcScreen); 
		
		// Create a compatible bitmap for hdcScreen. 
		_hbmScreen = CreateCompatibleBitmap(hdcScreen, 
						 GetDeviceCaps(hdcScreen, HORZRES), 
						 GetDeviceCaps(hdcScreen, VERTRES)); 
	 
		if (_hbmScreen == 0) 
			return false;	
	 
		// Select the bitmaps into the compatible DC. 
		_OldHbm = SelectObject(_hdcCompatible, _hbmScreen);
		if (!_OldHbm)
			return false; // "Compatible Bitmap Selection"
				 
		////Copy color data for the entire display into a 
		////bitmap that is selected into a compatible DC. 
		if (!BitBlt(_hdcCompatible, 
			   0,0, 
			   sx, sy, 
			   hdcScreen, 
			   x,y, 
			   SRCCOPY)) 
			return false; // "Screen to Compat Blt Failed"
	 //     
		
		BITMAPINFOHEADER bi;
		memset(&bi, 0,sizeof(BITMAPINFOHEADER));
		bi.biSize        = sizeof(BITMAPINFOHEADER);
		bi.biWidth       = sx;
		bi.biHeight      = sy;
		bi.biPlanes      = 1;
		bi.biBitCount    = 32;
		bi.biCompression = BI_RGB;		
		// Get the buffer, and put in the media
		GetDIBits(_hdcCompatible, _hbmScreen, 0, sy, ID_MEDIA[IDMedia]->Image.GetBase(),(BITMAPINFO*) &bi, DIB_RGB_COLORS);

		//GetDIBits(hdcScreen, _hbmScreen, 0, sy, ID_MEDIA[IDMedia]->Image.GetBase(),(BITMAPINFO*) &bi, DIB_RGB_COLORS);

		SelectObject(_hdcCompatible, _OldHbm);
		DeleteDC(_hdcCompatible);
		return true;
	}
	return false;
}


u32 WORLD::CreateMedia(s8 *Name,u32 ColorMode,bool dummy)
{
	u32 ID;
	UnicID mUID;
	if (MediaDico.IsExist(Name) != -1)
	{
		MediaDico.GetUnic(&mUID,Name);
		ID = MediaDico.mpst_Dico[mUID].AssociatedValue;
		if ((ID_MEDIA[ID]) && (ColorMode != ID_MEDIA[ID]->ulColorMode))
			DI->SetTextureColorMode(ID_MEDIA[ID]->ulAssociatedTextureIndex,ColorMode);
		ID_MEDIA[ID]->VirtuallyDestroyed = 0;
		ID_MEDIA[ID]->nbReferences++;
		return (MediaDico.mpst_Dico[mUID].AssociatedValue);
	}
	MediaDico.GetUnic(&mUID,Name);
	while (ID_MEDIA[MediaCreateID]) {MediaCreateID++;};
	ID = MediaCreateID++;
	if (ID > MAX_INPMED)
		return -1;	
	MediaDico.mpst_Dico[mUID].AssociatedValue = ID;
	ID_MEDIA[ID] = CreateIO(this,Name,dummy);
	if (ID_MEDIA[ID]) 
	{
		if (ID_MEDIA[ID]->GetType() != IOtype_LAYER)
			ID_MEDIA[ID]->ulAssociatedTextureIndex = DI->CreateTexture(&ID_MEDIA[ID]->Image,ColorMode);
		ID_MEDIA[ID]->ulColorMode = ColorMode;
		ID_MEDIA[ID]->VirtuallyDestroyed = 0;
	}
	return ID;
}

void WORLD::DestroyMedia(u32 IDMedia, u32 mask)
{
	if (ID_MEDIA[IDMedia])
	{
		ID_MEDIA[IDMedia]->nbReferences--;
		if (ID_MEDIA[IDMedia]->nbReferences <= 0 || (mask & 1))
		{
#ifdef MEDIA_DESTROY_SCENE_VERIFY
			// Begin - Verify if media still used in scene
			if (!(mask & 2))
			{
				for (int i=0; i<MAX_SmallSCenes; i++)
				{
					if (pSmallScenes[i])
					{
						SmallScene *curSmall = pSmallScenes[i];
						for (int j=0; j<curSmall->ulNumberOfMaterials; j++)
						{
							_3D_Material *curMat = curSmall->MaterialsPtrs[j];
							if (!curMat) continue;
							for (int k=0; k<curMat->NumberOfLayers; k++)
							{
								_3D_MaterialLayer *Layer = curMat->Layers + k;
								if (Layer->TextureMediaIndex != -1)
								{
									if (IDMedia == MediaDico.mpst_Dico[Layer->TextureMediaIndex].AssociatedValue)
									{	
										bool YTEST_MediaProblemDetected = true;
									}
								}
							}
						}
					}
				}
			}
			// End - Verify if media still used in scene
#endif			
			MediaDico.DelWord((char *)ID_MEDIA[IDMedia]->MediaName);
			ID_MEDIA[IDMedia]->END();
			if (ID_MEDIA[IDMedia]->ulAssociatedTextureIndex != -1)
			{
				if (ID_MEDIA[IDMedia]->GetType() == IOtype_LAYER)
					DI->DestroyLayerTexture(ID_MEDIA[IDMedia]->ulAssociatedTextureIndex);
				else
					DI->DestroyTexture(ID_MEDIA[IDMedia]->ulAssociatedTextureIndex);
			}

			if (ID_MEDIA[IDMedia]->Tracks)
			{
				FreeTrackPlayer(ID_MEDIA[IDMedia]->Tracks);
				CC_free(ID_MEDIA[IDMedia]->Tracks);
			}

			ID_MEDIA[IDMedia]->ulAssociatedTextureIndex = -1;
			ID_MEDIA[IDMedia]->Tracks = NULL;
			delete ID_MEDIA[IDMedia];
			ID_MEDIA[IDMedia] = NULL;
		}
	}
	MediaCreateID = 0;
}

void WORLD::DestroyAllMedia()
{
	for (u32 Counter = 0 ; Counter < MAX_INPMED; Counter++)
		DestroyMedia(Counter, 1);
	MediaDico.Destroy();
	MediaCreateID = 0;
	MediaToTrack = 0;
}
void WORLD::VirtuallyDestroyAllMedia()
{
	for (u32 Counter = 0 ; Counter < MAX_INPMED; Counter++)
	{
		if (ID_MEDIA[Counter])
		{
			ID_MEDIA[Counter]->VirtuallyDestroyed = 1;
			ID_MEDIA[Counter]->nbReferences = 0;
			ID_MEDIA[Counter]->IsValidForMosaique = 0;
		}
	}
}
void WORLD::TouchMedia(char *Name)
{
	u32 ID;
	UnicID mUID;
	mUID = MediaDico.IsExist(Name);
	if (mUID == -1) return;
	ID = MediaDico.mpst_Dico[mUID].AssociatedValue;
	if (ID > MAX_INPMED) return;
	if (ID_MEDIA[ID])  
		ID_MEDIA[ID]->ulFileAsbeenTouched ++;
}