HEFFECT CALL HGE_Impl::Effect_Load(const char *filename, DWORD size)
{
DWORD _size, length, samples;
void *data;
if(hOpenAL)
{
if(bSilent) return 1;
if(size) { data=(void *)filename; _size=size; }
else
{
data=Resource_Load(filename, &_size);
if(!data) return 0;
}
const BYTE *magic = (const BYTE *) data;
const bool isOgg = ( (_size > 4) &&
(magic[0] == 'O') && (magic[1] == 'g') &&
(magic[2] == 'g') && (magic[3] == 'S') );
// !!! FIXME: we currently expect Ogg Vorbis, since this is all we
// !!! FIXME: need at the moment.
if (!isOgg)
{
if(!size) Resource_Free(data);
return 0;
}
// !!! FIXME: alternately, stream ogg data?
void *allocation_decompressed = NULL;
void *decompressed = NULL;
ALsizei decompressed_size = 0;
ALsizei freq = 0;
ALenum fmt = AL_FORMAT_STEREO16;
if (isOgg)
{
if (alIsExtensionPresent((const ALchar *) "AL_EXT_vorbis"))
{
fmt = alGetEnumValue((const ALchar *) "AL_FORMAT_VORBIS_EXT");
decompressed = data;
decompressed_size = _size;
}
else
{
allocation_decompressed = decompress_vorbis((const BYTE *) data, _size, &decompressed_size, &fmt, &freq);
decompressed = allocation_decompressed;
}
}
ALuint bid = 0;
alGenBuffers(1, &bid);
alBufferData(bid, fmt, decompressed, decompressed_size, freq);
free(allocation_decompressed); // not delete[] !
if(!size) Resource_Free(data);
return (HEFFECT) bid;
}
else return 0;
}
void HGE_Impl::_SoundDone()
{
CStreamList *stmItem=streams, *stmNext;
if(hOpenAL)
{
for (int i = 0; i < sidcount; i++)
alSourceStop(sids[i]);
alDeleteSources(sidcount, sids);
sidcount = 0;
memset(sids, '\0', sizeof (sids));
ALCcontext *ctx = alcGetCurrentContext();
ALCdevice *dev = alcGetContextsDevice(ctx);
alcMakeContextCurrent(NULL);
alcSuspendContext(ctx);
alcDestroyContext(ctx);
alcCloseDevice(dev);
hOpenAL=0;
while(stmItem)
{
stmNext=stmItem->next;
Resource_Free(stmItem->data);
delete stmItem;
stmItem=stmNext;
}
streams=0;
}
}
HTEXTURE CALL HGE_Impl::Texture_Load(const char *filename, DWORD size, bool bMipmap)
{
void *data;
DWORD _size;
HTEXTURE pTex;
CTextureList *texItem;
int w, h, channels;
if(size)
{
data=(void *)filename;
_size=size;
}
else
{
data=pHGE->Resource_Load(filename, &_size);
if(!data) return NULL;
}
pTex = SOIL_load_OGL_texture_and_info_from_memory(
(const unsigned char* const)data,
_size,
SOIL_LOAD_AUTO,
SOIL_CREATE_NEW_ID,
(bMipmap ? SOIL_FLAG_MIPMAPS : 0)
| SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_TEXTURE_REPEATS,
&w, &h, &channels);
if (0 == pTex)
{
_PostError("Can't create texture");
if(!size) Resource_Free(data);
return NULL;
}
if(!size) Resource_Free(data);
texItem=new CTextureList;
texItem->tex=(HTEXTURE)pTex;
texItem->next=textures;
textures=texItem;
return (HTEXTURE)pTex;
}
HEFFECT CALL HGE_Impl::Effect_Load(const char *filename, DWORD size)
{
DWORD _size, length, samples;
HSAMPLE hs;
HSTREAM hstrm;
BASS_CHANNELINFO info;
void *buffer, *data;
if(hBass)
{
if(bSilent) return 1;
if(size) { data=(void *)filename; _size=size; }
else
{
data=Resource_Load(filename, &_size);
if(!data) return NULL;
}
hs=BASS_SampleLoad(TRUE, data, 0, _size, 4, BASS_SAMPLE_OVER_VOL);
if(!hs) {
hstrm=BASS_StreamCreateFile(TRUE, data, 0, _size, BASS_STREAM_DECODE);
if(hstrm) {
length=(DWORD)BASS_ChannelGetLength(hstrm);
BASS_ChannelGetInfo(hstrm, &info);
samples=length;
if(info.chans < 2) samples>>=1;
if((info.flags & BASS_SAMPLE_8BITS) == 0) samples>>=1;
buffer=BASS_SampleCreate(samples, info.freq, 2, 4, info.flags | BASS_SAMPLE_OVER_VOL);
if(!buffer)
{
BASS_StreamFree(hstrm);
_PostError("Can't create sound effect: Not enough memory");
}
else
{
BASS_ChannelGetData(hstrm, buffer, length);
hs=BASS_SampleCreateDone();
BASS_StreamFree(hstrm);
if(!hs) _PostError("Can't create sound effect");
}
}
}
if(!size) Resource_Free(data);
return hs;
}
ResourceSystemMock::ResourceSystemMock()
{
assert(!_reserve && !_free);
_reserve = [this](size_t s){ return Resource_Reserve(s); };
_free = [this](void* p){ Resource_Free(p); };
}
HTEXTURE HGE_CALL HGE_Impl::Texture_Load(const char *filename, hgeU32 size, bool bMipmap)
{
HRESULT hr;
void *data;
hgeU32 _size;
ID3D11Resource* pRes;
ID3D11Resource* pStagingRes;
ID3D11Texture2D* pTex;
ID3D11ShaderResourceView* pSRV;
//D3DXIMAGE_INFO info;
CTextureList *texItem;
//load file to buffer
if (size)
{
//If argument is already the buffer
data = (void *)filename; _size = size;
}
else
{
data = pHGE->Resource_Load(filename, &_size);
if (!data) return NULL;
}
//Get image info
D3DX11_IMAGE_INFO imgInfo;
hr = D3DX11GetImageInfoFromMemory(
(LPCSTR)data,
_size,
NULL,
&imgInfo,
NULL);
if (hr)
{
_PostError("Cannot get image info.\n");
if (!size) Resource_Free(data);
return NULL;
}
D3DX11_IMAGE_LOAD_INFO loadImgInfo;
loadImgInfo.MipLevels = bMipmap ? 0 : 1;
loadImgInfo.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
loadImgInfo.Usage = D3D11_USAGE_STAGING;
loadImgInfo.BindFlags = 0;// (autogen) ? (D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET) : (D3D11_BIND_SHADER_RESOURCE);
loadImgInfo.CpuAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
loadImgInfo.MiscFlags = 0;
//Create Staging texture first
hr = D3DX11CreateTextureFromMemory(
m_pD3DDevice,
(LPCVOID)data,
_size,
&loadImgInfo,
NULL,
&pStagingRes,
0);
if (hr)
{
_PostError("Can't create texture");
if (!size) Resource_Free(data);
return NULL;
}
//shouldn't access the file buffer anymore
if (!size) Resource_Free(data);
//Convert 0xFF00FFFF to transparent color
D3D11_TEXTURE2D_DESC TDesc;
((ID3D11Texture2D*)pStagingRes)->GetDesc(&TDesc);
if (bUseTransparentColor)
{
DWORD* pLockPtr = (DWORD*)Texture_Lock((HTEXTURE)pStagingRes, false);
int end = TDesc.Width * TDesc.Height;
for (int i = 0; i < end; i++)
{
DWORD& currentPixel = pLockPtr[i];
if (GETR(currentPixel) == 0xFF &&
GETG(currentPixel) == 0x00 &&
GETB(currentPixel) == 0xFF)
{
currentPixel = ARGB(0x00, 0x00, 0x00, 0x00);
}
}
//Create default texture with data
//from the staging texture
TDesc.Usage = D3D11_USAGE_DEFAULT;
TDesc.CPUAccessFlags = 0;
TDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
TDesc.MipLevels = bMipmap ? 0 : 1;
D3D11_SUBRESOURCE_DATA sr;
sr.pSysMem = pLockPtr;
sr.SysMemPitch = TDesc.Width * 4;
sr.SysMemSlicePitch = TDesc.Width * TDesc.Height * 4;
hr = m_pD3DDevice->CreateTexture2D(&TDesc, &sr, &pTex);
if (hr)
{
_PostError("Can't create texture");
if (!size) Resource_Free(data);
pStagingRes->Release();
return NULL;
}
Texture_Unlock((HTEXTURE)pStagingRes);
SAFE_RELEASE(pStagingRes);
}
D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;
memset(&SRVDesc, 0, sizeof(SRVDesc));
SRVDesc.Format = TDesc.Format;
SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
SRVDesc.Texture2D.MipLevels = bMipmap ? 0 : 1;
hr = m_pD3DDevice->CreateShaderResourceView(pTex, &SRVDesc, &pSRV);
if (hr)
{
_PostError("Can't create texture");
if (!size) Resource_Free(data);
return NULL;
}
pSRV->GetResource(&pRes);
// hr = CreateWICTextureFromMemory(
// pd3dDevice,
// pd3dImmediateContext,
// (uint8_t*)data,
// _size,
// &pRes,
// &pSRV,
// 0);
texItem = new CTextureList;
texItem->tex = (HTEXTURE)pTex;
texItem->m_pSRV = pSRV;
texItem->width = TDesc.Width;
texItem->height = TDesc.Height;
texItem->next = textures;
textures = texItem;
return (HTEXTURE)texItem;
}
