Shader::~Shader()
{
ES_SAFE_RELEASE(vertexShader_);
ES_SAFE_RELEASE(pixelShader_);
ES_SAFE_DELETE_ARRAY(m_vertexConstantBuffer);
ES_SAFE_DELETE_ARRAY(m_pixelConstantBuffer);
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void Renderer::GenerateRenderTargets(int32_t width, int32_t height)
{
ES_SAFE_RELEASE(m_renderTarget);
ES_SAFE_RELEASE(m_renderTargetTexture);
ES_SAFE_RELEASE(m_renderTargetDepth);
ES_SAFE_RELEASE(m_renderEffectBackTarget);
ES_SAFE_RELEASE(m_renderEffectBackTargetTexture);
if (width == 0 || height == 0) return;
HRESULT hr;
hr = GetDevice()->CreateTexture(width, height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_renderTargetTexture, NULL);
if (FAILED(hr)) return;
m_renderTargetTexture->GetSurfaceLevel(0, &m_renderTarget);
GetDevice()->CreateDepthStencilSurface(width, height, D3DFMT_D16, D3DMULTISAMPLE_NONE, 0, TRUE, &m_renderTargetDepth, NULL);
hr = GetDevice()->CreateTexture(width, height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_renderEffectBackTargetTexture, NULL);
if (FAILED(hr)) return;
m_renderEffectBackTargetTexture->GetSurfaceLevel(0, &m_renderEffectBackTarget);
}
void Effkseer_End()
{
// サーバーを停止する
if (g_server != NULL)
{
g_server->Stop();
ES_SAFE_DELETE(g_server);
}
// 読み込まれたエフェクトを削除する。
for (auto e : effectHandleToEffect)
{
auto effect = e.second;
ES_SAFE_RELEASE(effect);
}
effectHandleToEffect.clear();
// エフェクト管理用インスタンスを破棄する。
g_manager2d->Destroy();
g_manager3d->Destroy();
// 描画用インスタンスを破棄する。
g_renderer2d->Destroy();
g_renderer3d->Destroy();
ES_SAFE_DELETE(g_effectFile);
ES_SAFE_RELEASE(g_dx9_backgroundTexture);
ES_SAFE_RELEASE(g_dx9_backgroundSurface);
ES_SAFE_RELEASE(g_dx11_backGroundTexture);
ES_SAFE_RELEASE(g_dx11_backGroundTextureSRV);
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
EffectImplemented::~EffectImplemented()
{
Reset();
ES_SAFE_RELEASE( m_setting );
ES_SAFE_RELEASE( m_pManager );
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
IDirect3DTexture9* Renderer::ExportBackground()
{
IDirect3DSurface9* tempRender = nullptr;
IDirect3DSurface9* tempDepth = nullptr;
GetDevice()->GetRenderTarget(0, &tempRender);
GetDevice()->GetDepthStencilSurface(&tempDepth);
GetDevice()->SetRenderTarget(0, m_renderEffectBackTarget);
GetDevice()->SetDepthStencilSurface(nullptr);
m_d3d_device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0);
if (m_recording)
{
m_background->Rendering(m_recordingTargetTexture, m_width, m_height);
}
else
{
m_background->Rendering(m_renderTargetTexture, m_width, m_height);
}
GetDevice()->SetRenderTarget(0, tempRender);
GetDevice()->SetDepthStencilSurface(tempDepth);
ES_SAFE_RELEASE(tempRender);
ES_SAFE_RELEASE(tempDepth);
return m_renderEffectBackTargetTexture;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void TermGraphics()
{
g_renderer->Destory();
ES_SAFE_RELEASE( g_d3d_device );
ES_SAFE_RELEASE( g_d3d );
ExitWindow();
}
//-----------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------
Shader::~Shader()
{
ES_SAFE_RELEASE( m_vertexShader );
ES_SAFE_RELEASE( m_pixelShader );
ES_SAFE_RELEASE( m_vertexDeclaration );
ES_SAFE_RELEASE( m_constantBufferToVS );
ES_SAFE_RELEASE( m_constantBufferToPS );
ES_SAFE_DELETE_ARRAY(m_vertexConstantBuffer);
ES_SAFE_DELETE_ARRAY(m_pixelConstantBuffer);
}
bool PrepareTexture_DX11(uint32_t width, uint32_t height, DXGI_FORMAT format)
{
ID3D11Device* dx11_device = (ID3D11Device*)GetUseDirect3D11Device();
if (dx11_device == nullptr) return false;
ES_SAFE_RELEASE(g_dx11_backGroundTextureSRV);
ES_SAFE_RELEASE(g_dx11_backGroundTexture);
ZeroMemory(&g_dx11_backGroundTextureDesc, sizeof(g_dx11_backGroundTextureDesc));
g_dx11_backGroundTextureDesc.Usage = D3D11_USAGE_DEFAULT;
g_dx11_backGroundTextureDesc.Format = format;
g_dx11_backGroundTextureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
g_dx11_backGroundTextureDesc.Width = width;
g_dx11_backGroundTextureDesc.Height = height;
g_dx11_backGroundTextureDesc.CPUAccessFlags = 0;
g_dx11_backGroundTextureDesc.MipLevels = 1;
g_dx11_backGroundTextureDesc.ArraySize = 1;
g_dx11_backGroundTextureDesc.SampleDesc.Count = 1;
g_dx11_backGroundTextureDesc.SampleDesc.Quality = 0;
HRESULT hr = S_OK;
hr = dx11_device->CreateTexture2D(&g_dx11_backGroundTextureDesc, nullptr, &g_dx11_backGroundTexture);
if (FAILED(hr))
{
return false;
}
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
ZeroMemory(&srvDesc, sizeof(srvDesc));
switch (format)
{
case DXGI_FORMAT_R8G8B8A8_TYPELESS:
srvDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
break;
case DXGI_FORMAT_R16G16B16A16_TYPELESS:
srvDesc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
break;
default:
srvDesc.Format = format;
break;
}
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MipLevels = 1;
hr = dx11_device->CreateShaderResourceView(g_dx11_backGroundTexture, &srvDesc, &g_dx11_backGroundTextureSRV);
if (FAILED(hr))
{
return false;
}
return true;
}
virtual void OnDistorting()
{
IDirect3DSurface9* targetSurface = nullptr;
IDirect3DSurface9* texSurface = nullptr;
HRESULT hr = S_OK;
// レンダーターゲットを取得
hr = g_D3d9Device->GetRenderTarget( 0, &targetSurface );
if( FAILED( hr ) ){
return;
}
// レンダーターゲットの情報を取得
D3DSURFACE_DESC targetSurfaceDesc;
targetSurface->GetDesc( &targetSurfaceDesc );
// シザリング範囲を取得
RECT scissorRect;
g_D3d9Device->GetScissorRect( &scissorRect );
// 描画範囲を計算
uint32_t width = scissorRect.right - scissorRect.left;
uint32_t height = scissorRect.bottom - scissorRect.top;
// 保持テクスチャとフォーマットが異なればテクスチャを作り直す
if( backGroundTexture == nullptr ||
backGroundTextureWidth != width ||
backGroundTextureHeight != height ||
backGroundTextureFormat != targetSurfaceDesc.Format )
{
PrepareTexture( width, height, targetSurfaceDesc.Format );
}
// コピーするためのサーフェスを取得
hr = backGroundTexture->GetSurfaceLevel( 0, &texSurface );
if( FAILED( hr ) ){
return;
}
// サーフェス間コピー
hr = g_D3d9Device->StretchRect( targetSurface, &scissorRect, texSurface, NULL, D3DTEXF_NONE);
if( FAILED( hr ) ){
return;
}
// 取得したサーフェスの参照カウンタを下げる
ES_SAFE_RELEASE( texSurface );
ES_SAFE_RELEASE( targetSurface );
renderer->SetBackground( backGroundTexture );
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
Renderer::~Renderer()
{
assert( !m_recording );
ES_SAFE_RELEASE( m_backGroundTexture );
ES_SAFE_RELEASE(m_renderTarget);
ES_SAFE_RELEASE(m_renderTargetTexture);
ES_SAFE_RELEASE(m_renderTargetDepth);
ES_SAFE_RELEASE(m_renderEffectBackTarget);
ES_SAFE_RELEASE(m_renderEffectBackTargetTexture);
ES_SAFE_DELETE( m_guide );
ES_SAFE_DELETE( m_grid );
ES_SAFE_DELETE( m_culling );
ES_SAFE_DELETE( m_background );
if( m_renderer != NULL )
{
m_renderer->Destory();
m_renderer = NULL;
}
ES_SAFE_RELEASE( m_d3d_device );
ES_SAFE_RELEASE( m_d3d );
}
int Effekseer_InitDistortion(float scale)
{
int sizeX, sizeY, colorBitDepth;
if (GetScreenState(&sizeX, &sizeY, &colorBitDepth) != 0) return -1;
sizeX = static_cast<int32_t>(sizeX * scale);
sizeY = static_cast<int32_t>(sizeY * scale);
LPDIRECT3DDEVICE9 dx9_device = (LPDIRECT3DDEVICE9) GetUseDirect3DDevice9();
ID3D11Device* dx11_device = (ID3D11Device*)GetUseDirect3D11Device();
ID3D11DeviceContext* dx11_device_context = (ID3D11DeviceContext*)GetUseDirect3D11DeviceContext();
if (dx9_device != NULL)
{
ES_SAFE_RELEASE(g_dx9_backgroundTexture);
ES_SAFE_RELEASE(g_dx9_backgroundSurface);
HRESULT hr;
hr = dx9_device->CreateTexture(
sizeX,
sizeY,
1,
D3DUSAGE_RENDERTARGET,
D3DFMT_A8R8G8B8,
D3DPOOL_DEFAULT,
&g_dx9_backgroundTexture,
NULL
);
if (FAILED(hr))
{
return -1;
}
g_backgroundWidth = sizeX;
g_backgroundHeight = sizeY;
g_dx9_backgroundTexture->GetSurfaceLevel(0, &g_dx9_backgroundSurface);
}
else if(dx11_device != NULL)
{
g_backgroundWidth = sizeX;
g_backgroundHeight = sizeY;
PrepareTexture_DX11(g_backgroundWidth, g_backgroundHeight, DXGI_FORMAT_R8G8B8A8_UNORM);
}
g_isDistortionEnabled = true;
return 0;
}
static bool CopyRenderTargetToBackground()
{
bool ret = false;
LPDIRECT3DDEVICE9 device = (LPDIRECT3DDEVICE9)GetUseDirect3DDevice9();
if (device == NULL) return nullptr;
HRESULT hr;
IDirect3DSurface9* tempRender = nullptr;
IDirect3DSurface9* tempDepth = nullptr;
hr = device->GetRenderTarget(0, &tempRender);
if (FAILED(hr))
{
goto Exit;
}
hr = device->GetDepthStencilSurface(&tempDepth);
if (FAILED(hr))
{
goto Exit;
}
device->SetRenderTarget(0, g_dx9_backgroundSurface);
device->SetDepthStencilSurface(nullptr);
D3DSURFACE_DESC desc;
tempRender->GetDesc(&desc);
const bool isSame = (desc.Width == g_backgroundWidth && desc.Height == g_backgroundHeight);
device->StretchRect(
tempRender,
nullptr,
g_dx9_backgroundSurface,
nullptr,
(isSame ? D3DTEXF_POINT : D3DTEXF_LINEAR)
);
device->SetRenderTarget(0, tempRender);
device->SetDepthStencilSurface(tempDepth);
ret = true;
Exit:;
ES_SAFE_RELEASE(tempRender);
ES_SAFE_RELEASE(tempDepth);
return ret;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void TermGraphics()
{
g_renderer->Destory();
ES_SAFE_RELEASE( g_renderTargetView );
ES_SAFE_RELEASE( g_backBuffer );
ES_SAFE_RELEASE( g_depthStencilView );
ES_SAFE_RELEASE( g_depthBuffer );
ES_SAFE_RELEASE( g_swapChain );
ES_SAFE_RELEASE( g_dxgiFactory );
ES_SAFE_RELEASE( g_adapter );
ES_SAFE_RELEASE( g_dxgiDevice );
ES_SAFE_RELEASE( g_context );
ES_SAFE_RELEASE( g_device );
ExitWindow();
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
ManagerImplemented::~ManagerImplemented()
{
StopAllEffects();
ExecuteEvents();
for( int i = 0; i < 5; i++ )
{
GCDrawSet( true );
}
assert( m_reserved_instances.size() == m_instance_max );
ES_SAFE_DELETE_ARRAY( m_reserved_instances_buffer );
Culling3D::SafeRelease(m_cullingWorld);
ES_SAFE_DELETE(m_spriteRenderer);
ES_SAFE_DELETE(m_ribbonRenderer);
ES_SAFE_DELETE(m_modelRenderer);
ES_SAFE_DELETE(m_trackRenderer);
ES_SAFE_DELETE(m_ringRenderer);
ES_SAFE_DELETE(m_soundPlayer);
ES_SAFE_RELEASE( m_setting );
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
RendererImplemented::~RendererImplemented()
{
#ifdef __EFFEKSEER_RENDERER_INTERNAL_LOADER__
EffekseerRenderer::PngTextureLoader::Finalize();
#endif
assert( m_reference == 0 );
ES_SAFE_DELETE(m_distortingCallback);
ES_SAFE_RELEASE(m_background);
ES_SAFE_DELETE(m_standardRenderer);
ES_SAFE_DELETE(m_shader);
ES_SAFE_DELETE(m_shader_no_texture);
ES_SAFE_DELETE(m_shader_distortion);
ES_SAFE_DELETE(m_shader_no_texture_distortion);
ES_SAFE_DELETE( m_state );
ES_SAFE_DELETE( m_renderState );
ES_SAFE_DELETE( m_vertexBuffer );
ES_SAFE_DELETE( m_indexBuffer );
assert( m_reference == -6 );
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void Renderer::EndRecord( const wchar_t* outputPath )
{
assert( m_recording );
GetDevice()->SetRenderTarget( 0, m_recordingTempTarget );
GetDevice()->SetDepthStencilSurface( m_recordingTempDepth );
ES_SAFE_RELEASE( m_recordingTempTarget );
ES_SAFE_RELEASE( m_recordingTempDepth );
D3DXSaveSurfaceToFileW( outputPath, D3DXIFF_PNG, m_recordingTarget, NULL, NULL );
ES_SAFE_RELEASE( m_recordingTarget );
ES_SAFE_RELEASE( m_recordingTargetTexture );
ES_SAFE_RELEASE( m_recordingDepth );
m_recording = false;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
static bool CopyRenderTargetToBackground()
{
bool ret = false;
HRESULT hr;
IDirect3DSurface9* tempRender = nullptr;
IDirect3DSurface9* tempDepth = nullptr;
hr = g_d3d_device->GetRenderTarget(0, &tempRender);
if (FAILED(hr))
{
goto Exit;
}
hr = g_d3d_device->GetDepthStencilSurface(&tempDepth);
if (FAILED(hr))
{
goto Exit;
}
g_d3d_device->SetRenderTarget(0, g_backgroundSurface);
g_d3d_device->SetDepthStencilSurface(nullptr);
D3DSURFACE_DESC desc;
tempRender->GetDesc(&desc);
g_d3d_device->StretchRect(
tempRender,
nullptr,
g_backgroundSurface,
nullptr,
D3DTEXF_POINT
);
g_d3d_device->SetRenderTarget(0, tempRender);
g_d3d_device->SetDepthStencilSurface(tempDepth);
ret = true;
Exit:;
ES_SAFE_RELEASE(tempRender);
ES_SAFE_RELEASE(tempDepth);
return ret;
}
virtual void OnDistorting()
{
IDirect3DSurface9* targetSurface = nullptr;
IDirect3DSurface9* texSurface = nullptr;
HRESULT hr = S_OK;
hr = texture->GetSurfaceLevel( 0, &texSurface );
assert(SUCCEEDED(hr));
hr = device->GetRenderTarget( 0, &targetSurface );
assert(SUCCEEDED(hr));
hr = device->StretchRect( targetSurface, NULL, texSurface, NULL, D3DTEXF_NONE);
assert(SUCCEEDED(hr));
ES_SAFE_RELEASE( texSurface );
ES_SAFE_RELEASE( targetSurface );
renderer->SetBackground( texture );
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void Renderer::LoadBackgroundImage( void* data, int32_t size )
{
ES_SAFE_RELEASE( m_backGroundTexture );
if( data != NULL )
{
D3DXCreateTextureFromFileInMemory( m_renderer->GetDevice(), data, size, &m_backGroundTexture );
}
else
{
}
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
bool Renderer::EndRendering()
{
assert( m_d3d != NULL );
assert( m_d3d_device != NULL );
m_renderer->EndRendering();
if (m_isSRGBMode)
{
GetDevice()->SetSamplerState(0, D3DSAMP_SRGBTEXTURE, FALSE);
}
if( RendersGuide && !m_recording )
{
m_guide->Rendering( m_width, m_height, GuideWidth, GuideHeight );
}
if (!m_recording)
{
GetDevice()->SetRenderTarget(0, m_renderDefaultTarget);
GetDevice()->SetDepthStencilSurface(m_renderDefaultDepth);
ES_SAFE_RELEASE(m_renderDefaultTarget);
ES_SAFE_RELEASE(m_renderDefaultDepth);
m_d3d_device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(0, 0, 0, 0), 1.0f, 0);
m_background->Rendering(m_renderTargetTexture, m_width, m_height);
m_renderer->SetBackground(nullptr);
}
if (m_recording)
{
m_renderer->SetCameraMatrix(m_cameraMatTemp);
m_renderer->SetProjectionMatrix(m_projMatTemp);
}
m_d3d_device->EndScene();
return true;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
bool Renderer::BeginRecord( int32_t width, int32_t height )
{
assert( !m_recording );
assert( m_recordingTempTarget == NULL );
assert( m_recordingTempDepth == NULL );
m_recordingWidth = width;
m_recordingHeight = height;
HRESULT hr;
hr = GetDevice()->CreateTexture( width, height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_recordingTargetTexture, NULL );
if( FAILED( hr ) ) return false;
m_recordingTargetTexture->GetSurfaceLevel( 0, &m_recordingTarget );
GetDevice()->CreateDepthStencilSurface( width, height, D3DFMT_D16, D3DMULTISAMPLE_NONE, 0, TRUE, &m_recordingDepth, NULL );
if( m_recordingTarget == NULL || m_recordingDepth == NULL )
{
ES_SAFE_RELEASE( m_recordingTarget );
ES_SAFE_RELEASE( m_recordingTargetTexture );
ES_SAFE_RELEASE( m_recordingDepth );
return false;
}
GetDevice()->GetRenderTarget( 0, &m_recordingTempTarget );
GetDevice()->GetDepthStencilSurface( &m_recordingTempDepth );
GetDevice()->SetRenderTarget( 0, m_recordingTarget );
GetDevice()->SetDepthStencilSurface( m_recordingDepth );
m_recording = true;
return true;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
bool Renderer::Present()
{
HRESULT hr;
// ガンマ
if (m_isSRGBMode)
{
IDirect3DSwapChain9* swapChain = nullptr;
m_d3d_device->GetSwapChain(0, &swapChain);
hr = swapChain->Present(nullptr, nullptr, nullptr, nullptr, D3DPRESENT_LINEAR_CONTENT);
ES_SAFE_RELEASE(swapChain);
}
else
{
hr = m_d3d_device->Present(NULL, NULL, NULL, NULL);
}
switch ( hr )
{
// ドライバ内部の意味不明なエラー
case D3DERR_DRIVERINTERNALERROR:
return false;
// デバイスロスト
case D3DERR_DEVICELOST:
while ( FAILED( hr = m_d3d_device->TestCooperativeLevel() ) )
{
switch ( hr )
{
// デバイスロスト
case D3DERR_DEVICELOST:
::SleepEx( 1000, true );
break;
// デバイスロスト：リセット可
case D3DERR_DEVICENOTRESET:
ResetDevice();
break;
}
}
break;
}
return true;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void Renderer::EndRecord(std::vector<Effekseer::Color>& pixels)
{
assert(m_recording);
pixels.resize(m_recordingWidth * m_recordingHeight);
GetDevice()->SetRenderTarget(0, m_recordingTempTarget);
GetDevice()->SetDepthStencilSurface(m_recordingTempDepth);
ES_SAFE_RELEASE(m_recordingTempTarget);
ES_SAFE_RELEASE(m_recordingTempDepth);
IDirect3DSurface9* temp_sur = nullptr;
//IDirect3DTexture9* temp_tex = nullptr;
GetDevice()->CreateOffscreenPlainSurface(
m_recordingWidth, m_recordingHeight, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &temp_sur, NULL);
//temp_tex->GetSurfaceLevel(0, &temp_sur);
GetDevice()->GetRenderTargetData(m_recordingTarget, temp_sur);
D3DLOCKED_RECT drect;
RECT rect;
rect.top = 0;
rect.left = 0;
rect.right = m_recordingWidth;
rect.bottom = m_recordingHeight;
auto hr = temp_sur->LockRect(&drect, &rect, D3DLOCK_READONLY);
if (SUCCEEDED(hr))
{
for (int32_t y = 0; y < m_recordingHeight; y++)
{
for (int32_t x = 0; x < m_recordingWidth; x++)
{
auto src = &(((uint8_t*) drect.pBits)[x * 4 + drect.Pitch * y]);
pixels[x + m_recordingWidth * y].R = src[2];
pixels[x + m_recordingWidth * y].G = src[1];
pixels[x + m_recordingWidth * y].B = src[0];
}
}
temp_sur->UnlockRect();
}
ES_SAFE_RELEASE(temp_sur);
//ES_SAFE_RELEASE(temp_tex);
ES_SAFE_RELEASE(m_recordingTarget);
ES_SAFE_RELEASE(m_recordingTargetTexture);
ES_SAFE_RELEASE(m_recordingDepth);
m_recording = false;
}
int DeleteEffekseerEffect(int effectResourceHandle)
{
if (effectHandleToEffectFileName.count(effectResourceHandle) > 0)
{
auto fileName = effectHandleToEffectFileName[effectResourceHandle];
auto effect = effectHandleToEffect[effectResourceHandle];
effectFileNameToEffectHandle.erase(fileName);
effectHandleToEffect.erase(effectResourceHandle);
effectHandleToEffectFileName.erase(effectResourceHandle);
if (g_server != nullptr)
{
g_server->Unregister(effect);
}
ES_SAFE_RELEASE(effect);
}
return -1;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void Rendering()
{
g_d3d_device->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0,0,0), 1.0f, 0 );
LPDIRECT3DSURFACE9 targetSurface = NULL;
g_d3d_device->GetRenderTarget( 0, &targetSurface );
g_d3d_device->UpdateSurface( g_d3d_clearing_image, NULL, targetSurface, NULL );
ES_SAFE_RELEASE( targetSurface );
g_d3d_device->BeginScene();
g_renderer->SetLightDirection(::Effekseer::Vector3D(1.0f, 1.0f, 1.0f));
g_renderer->SetLightAmbientColor(::Effekseer::Color(40, 40, 40, 255));
g_renderer->BeginRendering();
g_manager->Draw();
g_renderer->EndRendering();
g_d3d_device->EndScene();
g_d3d_device->Present( NULL, NULL, NULL, NULL );
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
int main()
{
g_manager = ::Effekseer::Manager::Create( 2000 );
#if __CULLING_TEST
g_manager->CreateCullingWorld(200, 200, 200, 4);
#endif
#if _WIN32
InitGraphics(g_window_width, g_window_height);
InitSound();
#else
InitGraphics( g_window_width, g_window_height);
InitSound();
#endif
Init();
while(DoEvent())
{
Loop();
g_manager->Update();
Rendering();
}
g_manager->Destroy();
for (size_t i = 0; i < g_effects.size(); i++)
{
ES_SAFE_RELEASE(g_effects[i]);
}
TermSound();
TermGraphics();
return 0;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
int main(int argc, char **argv)
{
#if _WIN32
char current_path[MAX_PATH + 1];
GetDirectoryName(current_path, argv[0]);
SetCurrentDirectoryA(current_path);
#endif
InitWindow();
// 描画用インスタンスの生成
g_renderer = ::EffekseerRendererDX9::Renderer::Create( g_d3d_device, 2000 );
// Specify a distortion function
// 歪み機能を設定
// If you'd like to distort background and particles by rendering, it need to specify it.
// It is a bit heavy
// もし、描画するごとに背景とパーティクルを歪ませたい場合、設定する必要がある
// やや重い
g_renderer->SetDistortingCallback(new DistortingCallback());
// 背景バッファの生成
g_d3d_device->CreateTexture(
640,
480,
1,
D3DUSAGE_RENDERTARGET,
D3DFMT_A8R8G8B8,
D3DPOOL_DEFAULT,
&g_backgroundTexture,
NULL
);
g_backgroundTexture->GetSurfaceLevel(0, &g_backgroundSurface);
// エフェクト管理用インスタンスの生成
g_manager = ::Effekseer::Manager::Create( 2000 );
// 描画用インスタンスから描画機能を設定
g_manager->SetSpriteRenderer( g_renderer->CreateSpriteRenderer() );
g_manager->SetRibbonRenderer( g_renderer->CreateRibbonRenderer() );
g_manager->SetRingRenderer( g_renderer->CreateRingRenderer() );
g_manager->SetTrackRenderer(g_renderer->CreateTrackRenderer());
g_manager->SetModelRenderer( g_renderer->CreateModelRenderer() );
// 描画用インスタンスからテクスチャの読込機能を設定
// 独自拡張可能、現在はファイルから読み込んでいる。
g_manager->SetTextureLoader( g_renderer->CreateTextureLoader() );
g_manager->SetModelLoader( g_renderer->CreateModelLoader() );
// 音再生用インスタンスの生成
g_sound = ::EffekseerSound::Sound::Create( g_xa2, 16, 16 );
// 音再生用インスタンスから再生機能を指定
g_manager->SetSoundPlayer( g_sound->CreateSoundPlayer() );
// 音再生用インスタンスからサウンドデータの読込機能を設定
// 独自拡張可能、現在はファイルから読み込んでいる。
g_manager->SetSoundLoader( g_sound->CreateSoundLoader() );
// 視点位置を確定
g_position = ::Effekseer::Vector3D(10.0f, 5.0f, 20.0f) * 0.25;
// 投影行列を設定
g_renderer->SetProjectionMatrix(
::Effekseer::Matrix44().PerspectiveFovRH(90.0f / 180.0f * 3.14f, (float)g_window_width / (float)g_window_height, 1.0f, 50.0f));
// カメラ行列を設定
g_renderer->SetCameraMatrix(
::Effekseer::Matrix44().LookAtRH(g_position, ::Effekseer::Vector3D(0.0f, 0.0f, 0.0f), ::Effekseer::Vector3D(0.0f, 1.0f, 0.0f)));
// エフェクトの読込
g_effect = Effekseer::Effect::Create(g_manager, (const EFK_CHAR*)L"distortion.efk");
// エフェクトの再生
g_handle = g_manager->Play(g_effect, 0, 0, 0);
MainLoop();
// エフェクトの停止
g_manager->StopEffect(g_handle);
// エフェクトの破棄
ES_SAFE_RELEASE(g_effect);
// 先にエフェクト管理用インスタンスを破棄
g_manager->Destroy();
// 次に音再生用インスタンスを破棄
g_sound->Destroy();
// 次に描画用インスタンスを破棄
g_renderer->Destroy();
// XAudio2の解放
if( g_xa2_master != NULL )
{
g_xa2_master->DestroyVoice();
g_xa2_master = NULL;
}
ES_SAFE_RELEASE( g_xa2 );
// バックバッファの破棄
ES_SAFE_RELEASE( g_backgroundTexture );
ES_SAFE_RELEASE( g_backgroundSurface );
// DirectXの解放
ES_SAFE_RELEASE( g_d3d_device );
ES_SAFE_RELEASE( g_d3d );
// COMの終了処理
CoUninitialize();
return 0;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
bool PngTextureLoader::Load(void* data, int32_t size, bool rev)
{
#if __PNG_DDI
auto global = GlobalAlloc(GMEM_MOVEABLE,size);
auto buf = GlobalLock(global);
CopyMemory(buf, data, size);
GlobalUnlock(global);
LPSTREAM stream = NULL;
CreateStreamOnHGlobal( global, false, &stream);
Gdiplus::Bitmap* bmp = Gdiplus::Bitmap::FromStream(stream);
ES_SAFE_RELEASE(stream);
GlobalFree(global);
if( bmp != NULL && bmp->GetLastStatus() == Gdiplus::Ok )
{
textureWidth = bmp->GetWidth();
textureHeight = bmp->GetHeight();
textureData.resize(textureWidth * textureHeight * 4);
if(rev)
{
for(auto y = 0; y < textureHeight; y++ )
{
for(auto x = 0; x < textureWidth; x++ )
{
Gdiplus::Color color;
bmp->GetPixel(x, textureHeight - y - 1, &color);
textureData[(x + y * textureWidth) * 4 + 0] = color.GetR();
textureData[(x + y * textureWidth) * 4 + 1] = color.GetG();
textureData[(x + y * textureWidth) * 4 + 2] = color.GetB();
textureData[(x + y * textureWidth) * 4 + 3] = color.GetA();
}
}
}
else
{
for(auto y = 0; y < textureHeight; y++ )
{
for(auto x = 0; x < textureWidth; x++ )
{
Gdiplus::Color color;
bmp->GetPixel(x, y, &color);
textureData[(x + y * textureWidth) * 4 + 0] = color.GetR();
textureData[(x + y * textureWidth) * 4 + 1] = color.GetG();
textureData[(x + y * textureWidth) * 4 + 2] = color.GetB();
textureData[(x + y * textureWidth) * 4 + 3] = color.GetA();
}
}
}
return true;
}
else
{
ES_SAFE_DELETE(bmp);
return false;
}
#else
uint8_t* data_ = (uint8_t*) data;
/* pngアクセス構造体を作成 */
png_structp png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
/* リードコールバック関数指定 */
png_set_read_fn(png, &data_, &PngReadData);
/* png画像情報構造体を作成 */
png_infop png_info = png_create_info_struct(png);
/* エラーハンドリング */
if (setjmp(png_jmpbuf(png)))
{
png_destroy_read_struct(&png, &png_info, NULL);
return false;
}
/* IHDRチャンク情報を取得 */
png_read_info(png, png_info);
png_uint_32 width, height;
int bit_depth, color_type, interlace_type, comp_type, filter_type;
png_get_IHDR(png, png_info, &width, &height, &bit_depth, &color_type, &interlace_type,
&comp_type, &filter_type);
/* RGBA8888フォーマットに変換する */
if (bit_depth < 8)
{
png_set_packing(png);
}
else if (bit_depth == 16)
{
png_set_strip_16(png);
}
uint32_t pixelBytes = 4;
switch (color_type)
{
case PNG_COLOR_TYPE_PALETTE:
png_set_palette_to_rgb(png);
pixelBytes = 4;
break;
case PNG_COLOR_TYPE_GRAY:
png_set_expand_gray_1_2_4_to_8(png);
pixelBytes = 3;
break;
case PNG_COLOR_TYPE_RGB:
pixelBytes = 3;
break;
case PNG_COLOR_TYPE_RGBA:
break;
}
uint8_t* image = new uint8_t[width * height * pixelBytes];
uint32_t pitch = width * pixelBytes;
/* イメージデータを読み込む */
textureWidth = width;
textureHeight = height;
textureData.resize(textureWidth * textureHeight * 4);
if (rev)
{
for (uint32_t i = 0; i < height; i++)
{
png_read_row(png, &image[(height - 1 - i) * pitch], NULL);
}
}
else
{
for (uint32_t i = 0; i < height; i++)
{
png_read_row(png, &image[i * pitch], NULL);
}
}
if (pixelBytes == 4)
{
memcpy(textureData.data(), image, width * height * pixelBytes);
}
else
{
for (int32_t y = 0; y < height; y++)
{
for (int32_t x = 0; x < width; x++)
{
int32_t src = (x + y * width) * 3;
int32_t dst = (x + y * width) * 4;
textureData[dst + 0] = image[src + 0];
textureData[dst + 1] = image[src + 1];
textureData[dst + 2] = image[src + 2];
textureData[dst + 3] = 255;
}
}
}
delete [] image;
png_destroy_read_struct(&png, &png_info, NULL);
return true;
#endif
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void ManagerImplemented::SetSetting(Setting* setting)
{
ES_SAFE_RELEASE(m_setting);
m_setting = setting;
ES_SAFE_ADDREF(m_setting);
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void ManagerImplemented::GCDrawSet( bool isRemovingManager )
{
// インスタンスグループ自体の削除処理
{
std::map<Handle,DrawSet>::iterator it = m_RemovingDrawSets[1].begin();
while( it != m_RemovingDrawSets[1].end() )
{
DrawSet& drawset = (*it).second;
// 全破棄処理
drawset.InstanceContainerPointer->RemoveForcibly( true );
drawset.InstanceContainerPointer->~InstanceContainer();
InstanceContainer::operator delete( drawset.InstanceContainerPointer, this );
ES_SAFE_RELEASE( drawset.ParameterPointer );
ES_SAFE_DELETE( drawset.GlobalPointer );
if(m_cullingWorld != NULL)
{
m_cullingWorld->RemoveObject(drawset.CullingObjectPointer);
Culling3D::SafeRelease(drawset.CullingObjectPointer);
}
m_RemovingDrawSets[1].erase( it++ );
}
m_RemovingDrawSets[1].clear();
}
{
std::map<Handle,DrawSet>::iterator it = m_RemovingDrawSets[0].begin();
while( it != m_RemovingDrawSets[0].end() )
{
DrawSet& drawset = (*it).second;
m_RemovingDrawSets[1][ (*it).first ] = (*it).second;
m_RemovingDrawSets[0].erase( it++ );
}
m_RemovingDrawSets[0].clear();
}
{
std::map<Handle,DrawSet>::iterator it = m_DrawSets.begin();
while( it != m_DrawSets.end() )
{
DrawSet& draw_set = (*it).second;
// 削除フラグが立っている時
bool isRemoving = draw_set.IsRemoving;
// 何も存在しない時
if( !isRemoving && draw_set.GlobalPointer->GetInstanceCount() == 0 )
{
isRemoving = true;
}
// ルートのみ存在し、既に新しく生成する見込みがないとき
if( !isRemoving && draw_set.GlobalPointer->GetInstanceCount() == 1 )
{
InstanceContainer* pRootContainer = draw_set.InstanceContainerPointer;
InstanceGroup* group = pRootContainer->GetFirstGroup();
if( group )
{
Instance* pRootInstance = group->GetFirst();
if( pRootInstance && pRootInstance->GetState() == INSTANCE_STATE_ACTIVE )
{
int maxcreate_count = 0;
for( int i = 0; i < Min(pRootInstance->m_pEffectNode->GetChildrenCount(), Instance::ChildrenMax); i++ )
{
auto child = (EffectNodeImplemented*) pRootInstance->m_pEffectNode->GetChild(i);
float last_generation_time =
child->CommonValues.GenerationTime.max *
(child->CommonValues.MaxGeneration - 1) +
child->CommonValues.GenerationTimeOffset.max +
1.0f;
if( pRootInstance->m_LivingTime >= last_generation_time )
{
maxcreate_count++;
}
else
{
break;
}
}
if( maxcreate_count == pRootInstance->m_pEffectNode->GetChildrenCount() )
{
// 音が再生中でないとき
if (!GetSoundPlayer() || !GetSoundPlayer()->CheckPlayingTag(draw_set.GlobalPointer))
{
isRemoving = true;
}
}
}
}
}
if( isRemoving )
{
// 消去処理
StopEffect( (*it).first );
if( (*it).second.RemovingCallback != NULL )
{
(*it).second.RemovingCallback( this, (*it).first, isRemovingManager );
}
m_RemovingDrawSets[0][ (*it).first ] = (*it).second;
m_DrawSets.erase( it++ );
}
else
{
++it;
}
}
}
}
