// ******************************************************************
// Aus Speicherbereich initialisieren
age_Result ageD_D3DEffect::Init(void* pMemory,
int iMemorySize)
{
ageD_VFile* pVFile;
// Parameter prüfen
if(pMemory == NULL) AGE_ERROR_NULL_POINTER("pMemory", AGE_ERROR);
if(iMemorySize <= 0) AGE_ERROR_INVALID_VALUE("iMemorySize", AGE_ERROR);
// Virtuelle Datei erstellen
pVFile = new ageD_VFile;
if(pVFile == NULL) AGE_ERROR_OUT_OF_MEMORY(AGE_ERROR);
// Aus Speicher laden
if(pVFile->Init(pMemory, iMemorySize))
{
// Fehler!
AGE_ERROR("Fehler beim Erstellen der virtuellen Datei!", AGE_ERROR);
}
// Die andere Methode aufrufen
if(Init(pVFile, pVFile->GetSize()))
{
// Fehler!
AGE_SAFE_DELETE(pVFile);
AGE_ERROR("Fehler beim Erstellen des Effekts!", AGE_ERROR);
}
// Die virtuelle Datei wieder freigeben
AGE_SAFE_DELETE(pVFile);
return AGE_OK;
}
// ******************************************************************
// Erstellen aus einer echten Datei
age_Result ageD_D3DEffect::Init(char* pcFilename)
{
ageD_VFile* pVFile;
// Parameter prüfen
if(pcFilename == NULL) AGE_ERROR_NULL_POINTER("pcFilename", AGE_ERROR);
// Virtuelle Datei erstellen
pVFile = new ageD_VFile;
if(pVFile == NULL) AGE_ERROR_OUT_OF_MEMORY(AGE_ERROR);
// Aus Datei laden
if(pVFile->Init(pcFilename))
{
// Fehler!
AGE_ERROR("Fehler beim Erstellen der virtuellen Datei!", AGE_ERROR);
}
// Die andere Methode aufrufen
if(Init(pVFile, pVFile->GetSize()))
{
// Fehler!
AGE_ERROR("Fehler beim Erstellen des Effekts!", AGE_ERROR);
}
// Die virtuelle Datei wieder freigeben
AGE_SAFE_DELETE(pVFile);
return AGE_OK;
}
// ******************************************************************
// Interne Funktion zum Hinzufügen eines Speicherbereichs zur Liste
Result MemAddToList(void* pMemory,
int iSize)
{
MemListEntry NewEntry; // Neuer Listeneintrag
ListEntry<MemListEntry>* pNewMemoryListEntry; // Neuer Speicherlisteneintrag
// Parameter prüfen
if(pMemory == NULL) AGE_ERROR_NULL_POINTER("pMemory", AGE_ERROR);
if(iSize < 0) AGE_ERROR_INVALID_VALUE("iSize", AGE_ERROR);
// Neuen Listeneintrag ausfüllen
NewEntry.pMemory = pMemory;
NewEntry.pUserMemory = (BYTE*)(pMemory) + sizeof(ListEntry<MemListEntry>*);
NewEntry.iSize = iSize;
strcpy(NewEntry.acCheck, "TriBase");
// Eintrag zur Speicherliste hinzufügen
pNewMemoryListEntry = g_pMemoryList->AddEntry(&NewEntry);
if(pNewMemoryListEntry == NULL) AGE_ERROR("Fehler beim Erzeugen des neuen Listeneintrags!", AGE_ERROR);
// Zeiger auf den Speicherlisteneintrag in den Speicher schreiben
*((ListEntry<MemListEntry>**)(pMemory)) = pNewMemoryListEntry;
return AGE_OK;
}
// ******************************************************************
// Erstellen aus einem String
age_Result ageD_D3DEffect::Init(char* pcCode,
int iSize)
{
HRESULT hResult;
// Parameter prüfen und sicherstellen, dass Direct3D initialisiert wurde
if(pcCode == NULL) AGE_ERROR_NULL_POINTER("pcCode", AGE_ERROR);
if(iSize == 0 || iSize < -1) AGE_ERROR_INVALID_VALUE("iSize", AGE_ERROR);
if(!ageG_Direct3D::IsInitialized()) AGE_ERROR("Direct3D wurde noch nicht initialisiert!", AGE_ERROR);
// Länge anpassen
if(iSize == -1) iSize = strlen(pcCode);
// Jetzt den Effekt erstellen
if(FAILED(hResult = D3DXCreateEffect(ageG_Direct3D::GetDevice(),
pcCode, iSize, NULL, NULL, 0,
age_g_pEffectPool, &m_pEffect, NULL)))
{
// Fehler!
AGE_ERROR_DIRECTX("D3DXCreateEffect", hResult, AGE_ERROR);
}
// Effektbeschreibung abfragen
m_pEffect->GetDesc(&m_Desc);
// Die erste gültige Technik setzen
SetTechnique(-1);
return AGE_OK;
}
// ******************************************************************
// Abfragen der Größe eines Speicherbereichs
TRIBASE_API int MemGetSize(void* pMemory)
{
ListEntry<MemListEntry>* pMemoryListEntry;
// Parameter prüfen
if(pMemory == NULL) return -1;
// Listeneintrag abfragen
if(MemGetEntry(pMemory, &pMemoryListEntry))
{
AGE_ERROR("FEHLER in MemGetSize: Ungültiger Speicherbereich angegeben!", -1);
}
// Größe liefern
return pMemoryListEntry->Data.iSize;
}
bool Library::load(const std::string &name)
{
AGE_ASSERT(handle == nullptr && "Library is not closed");
std::string libraryName = Library::GenerateName(name);
if (libraryName.empty())
{
#if defined(AGE_PLATFORM_WINDOWS)
handle = GetModuleHandle(nullptr);
#else
handle = dlopen(nullptr, 0);
#endif
}
else
{
#if defined(AGE_PLATFORM_WINDOWS)
handle = LoadLibrary(libraryName.c_str());
#else
handle = dlopen(libraryName.c_str(), RTLD_LAZY);
#endif
if (!handle)
{
libraryName = name;
#if defined(AGE_PLATFORM_WINDOWS)
handle = LoadLibrary(libraryName.c_str());
#else
handle = dlopen(libraryName.c_str(), RTLD_LAZY);
#endif
}
}
if (handle != nullptr)
{
if (libraryName.empty())
{
pluginName = "CurrentProcess";
}
else
{
pluginName = libraryName;
}
return true;
}
else
{
AGE_ERROR("Impossible to load \"", libraryName, "\" library");
return false;
}
}
// ******************************************************************
// Erstellen aus einer virtuellen Datei
age_Result ageD_D3DEffect::Init(ageD_VFile* pVFile,
int iSize)
{
// Parameter prüfen und sicherstellen, dass Direct3D initialisiert wurde
if(pVFile == NULL) AGE_ERROR_NULL_POINTER("pVFile", AGE_ERROR);
if(iSize == 0 || iSize < -1) AGE_ERROR_INVALID_VALUE("iSize", AGE_ERROR);
// Länge anpassen
if(iSize == -1) iSize = pVFile->GetSize();
// Die andere Methode aufrufen
if(Init((char*)(pVFile->GetBuffer()) + pVFile->GetCursor(), iSize))
{
// Fehler!
AGE_ERROR("Fehler beim Erstellen des Effekts!", AGE_ERROR);
}
return AGE_OK;
}
// ******************************************************************
// Starten eines Effekts
int ageD_D3DEffect::Begin(BOOL bSaveState, // = TRUE
BOOL bCaptureOnFinish) // = TRUE
{
HRESULT hResult;
unsigned int uiNumPasses;
// Die Begin-Methode aufrufen
if(FAILED(hResult = m_pEffect->Begin(&uiNumPasses,
bSaveState ? 0 : D3DXFX_DONOTSAVESTATE)))
{
// Fehler!
AGE_ERROR("Fehler beim Starten des Effekts!", -1);
}
// Angaben kopieren
m_bStateSaved = bSaveState;
m_bCaptureOnFinish = bCaptureOnFinish;
// Anzahl der Durchgänge zurückliefern
return uiNumPasses;
}
// ******************************************************************
// Funktion zum Reservieren von Speicher
TRIBASE_API void* MemAlloc(int iSize)
{
void* pMemory;
// Parameter prüfen
if(iSize < 0) AGE_ERROR_INVALID_VALUE("iSize", NULL);
// Speicher reservieren und leeren. Beim Reservieren werden ein
// paar Bytes mehr gebraucht, damit der Zeiger auf den Listeneintrag
// mitgespeichert werden kann.
pMemory = ::operator new(iSize + sizeof(ListEntry<MemListEntry>*));
if(pMemory == NULL) return NULL;
g_iByteCounter += iSize + sizeof(ListEntry<MemListEntry>*);
ZeroMemory(pMemory, iSize + sizeof(ListEntry<MemListEntry>*));
// Zur Liste hinzufügen
if(MemAddToList(pMemory, iSize)) AGE_ERROR("Hinzufügen zur Liste fehlgeschlagen!", NULL);
// Zeiger zurückliefern
return (BYTE*)(pMemory) + sizeof(ListEntry<MemListEntry>*);
}
// ******************************************************************
// Freigeben eines Speicherbereichs
TRIBASE_API Result MemFree(void* pMemory)
{
ListEntry<MemListEntry>* pMemoryListEntry;
MemListEntry Entry;
// Parameter prüfen
if(pMemory == NULL) AGE_ERROR_NULL_POINTER("pMemory", AGE_ERROR);
// Listeneintrag abfragen
if(MemGetEntry(pMemory, &pMemoryListEntry))
{
AGE_ERROR("Ungültiger Speicherbereich angegeben!", AGE_ERROR);
}
// Speicher und Listeneintrag löschen
Entry = pMemoryListEntry->Data;
g_iByteCounter -= Entry.iSize + sizeof(ListEntry<MemListEntry>*);
::operator delete(Entry.pMemory);
g_pMemoryList->DeleteEntry(pMemoryListEntry);
return AGE_OK;
}
