//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
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 );
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
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 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);
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
EffectNodeImplemented::~EffectNodeImplemented()
{
for( size_t i = 0; i < m_Nodes.size(); i++ )
{
ES_SAFE_DELETE( m_Nodes[i] );
}
ES_SAFE_DELETE( TranslationFCurve );
ES_SAFE_DELETE( RotationFCurve );
ES_SAFE_DELETE( ScalingFCurve );
}
int Effkseer_InitServer(int port)
{
if (g_server != NULL) return -1;
g_server = Effekseer::Server::Create();
if (!g_server->Start(port))
{
ES_SAFE_DELETE(g_server);
return -1;
}
return 0;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
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 );
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
TrackRenderer* TrackRenderer::Create(RendererImplemented* renderer)
{
assert(renderer != NULL);
Shader* shader = Shader::Create(renderer, g_ribbon_vs_src, strlen(g_ribbon_vs_src), g_ribbon_fs_src, strlen(g_ribbon_fs_src), "TrackRenderer");
if (shader == NULL) return NULL;
Shader* shader_no_texture = Shader::Create(renderer, g_ribbon_vs_src, strlen(g_ribbon_vs_src), g_ribbon_fs_no_texture_src, strlen(g_ribbon_fs_no_texture_src), "TrackRenderer");
if (shader_no_texture == NULL)
{
ES_SAFE_DELETE(shader);
return NULL;
}
return new TrackRenderer(renderer, shader, shader_no_texture);
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void ManagerImplemented::SetSpriteRenderer(SpriteRenderer* renderer)
{
ES_SAFE_DELETE(m_spriteRenderer);
m_spriteRenderer = renderer;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
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;
}
}
}
}
Renderer::~Renderer()
{
ES_SAFE_DELETE(impl);
}
void RendererImplemented::SetDistortingCallback(EffekseerRenderer::DistortingCallback* callback)
{
ES_SAFE_DELETE(m_distortingCallback);
m_distortingCallback = callback;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
int main()
{
InitWindow();
// 描画用インスタンスの生成
g_renderer = ::EffekseerRendererDX9::Renderer::Create( g_d3d_device, 2000 );
// エフェクト管理用インスタンスの生成
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->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_server = Effekseer::Server::Create();
// サーバーをポート60000で開始
g_server->Start( 60000 );
// 視点位置を確定
g_position = ::Effekseer::Vector3D( 10.0f, 5.0f, 20.0f );
// 投影行列を設定
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"test.efk" );
// 編集元のファイルがtest.efkprojであるとし、エフェクトをtestという名称で登録
g_server->Regist( (const EFK_CHAR*)L"test", g_effect );
MainLoop();
// エフェクトの破棄
ES_SAFE_RELEASE( g_effect );
// サーバーの破棄
ES_SAFE_DELETE( g_server );
// 先にエフェクト管理用インスタンスを破棄
g_manager->Destroy();
// 次に音再生用インスタンスを破棄
g_sound->Destory();
// 次に描画用インスタンスを破棄
g_renderer->Destory();
// XAudio2の解放
if( g_xa2_master != NULL )
{
g_xa2_master->DestroyVoice();
g_xa2_master = NULL;
}
ES_SAFE_RELEASE( g_xa2 );
// DirectXの解放
ES_SAFE_RELEASE( g_d3d_device );
ES_SAFE_RELEASE( g_d3d );
// COMの終了処理
CoUninitialize();
return 0;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void ManagerImplemented::SetTrackRenderer(TrackRenderer* renderer)
{
ES_SAFE_DELETE(m_trackRenderer);
m_trackRenderer = renderer;
}
virtual ~CachedTextureLoader()
{
ES_SAFE_DELETE(textureLoader);
}
virtual ~CachedModelLoader()
{
ES_SAFE_DELETE(modelLoader);
}
void* ModelLoader::Load(const void* data, int32_t size)
{
Model* model = new Model((uint8_t*)data, size);
model->ModelCount = Effekseer::Min(Effekseer::Max(model->GetModelCount(), 1), 40);
model->InternalModels = new Model::InternalModel[model->GetFrameCount()];
for (int32_t f = 0; f < model->GetFrameCount(); f++)
{
model->InternalModels[f].VertexCount = model->GetVertexCount(f);
{
std::vector<Effekseer::Model::VertexWithIndex> vs;
for (int32_t m = 0; m < model->ModelCount; m++)
{
for (int32_t i = 0; i < model->GetVertexCount(f); i++)
{
Effekseer::Model::VertexWithIndex v;
v.Position = model->GetVertexes(f)[i].Position;
v.Normal = model->GetVertexes(f)[i].Normal;
v.Binormal = model->GetVertexes(f)[i].Binormal;
v.Tangent = model->GetVertexes(f)[i].Tangent;
v.UV = model->GetVertexes(f)[i].UV;
v.VColor = model->GetVertexes(f)[i].VColor;
v.Index[0] = m;
vs.push_back(v);
}
}
ID3D11Buffer* vb = NULL;
D3D11_BUFFER_DESC hBufferDesc;
hBufferDesc.ByteWidth = sizeof(Effekseer::Model::VertexWithIndex) * model->GetVertexCount(f) * model->ModelCount;
hBufferDesc.Usage = D3D11_USAGE_DEFAULT;
hBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
hBufferDesc.CPUAccessFlags = 0;
hBufferDesc.MiscFlags = 0;
hBufferDesc.StructureByteStride = sizeof(float);
D3D11_SUBRESOURCE_DATA hSubResourceData;
hSubResourceData.pSysMem = &(vs[0]);
hSubResourceData.SysMemPitch = 0;
hSubResourceData.SysMemSlicePitch = 0;
if (FAILED(device->CreateBuffer(&hBufferDesc, &hSubResourceData, &vb)))
{
return NULL;
}
model->InternalModels[f].VertexBuffer = vb;
}
model->InternalModels[f].FaceCount = model->GetFaceCount(f);
model->InternalModels[f].IndexCount = model->InternalModels[f].FaceCount * 3;
{
std::vector<Effekseer::Model::Face> fs;
for (int32_t m = 0; m < model->ModelCount; m++)
{
for (int32_t i = 0; i < model->InternalModels[f].FaceCount; i++)
{
Effekseer::Model::Face face;
face.Indexes[0] = model->GetFaces(f)[i].Indexes[0] + model->GetVertexCount(f) * m;
face.Indexes[1] = model->GetFaces(f)[i].Indexes[1] + model->GetVertexCount(f) * m;
face.Indexes[2] = model->GetFaces(f)[i].Indexes[2] + model->GetVertexCount(f) * m;
fs.push_back(face);
}
}
ID3D11Buffer* ib = NULL;
D3D11_BUFFER_DESC hBufferDesc;
hBufferDesc.Usage = D3D11_USAGE_DEFAULT;
hBufferDesc.ByteWidth = sizeof(int32_t) * 3 * model->InternalModels[f].FaceCount * model->ModelCount;
hBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
hBufferDesc.CPUAccessFlags = 0;
hBufferDesc.MiscFlags = 0;
hBufferDesc.StructureByteStride = sizeof(int32_t);
D3D11_SUBRESOURCE_DATA hSubResourceData;
hSubResourceData.pSysMem = &(fs[0]);
hSubResourceData.SysMemPitch = 0;
hSubResourceData.SysMemSlicePitch = 0;
if (FAILED(device->CreateBuffer(&hBufferDesc, &hSubResourceData, &ib)))
{
ES_SAFE_DELETE(model);
return nullptr;
}
model->InternalModels[f].IndexBuffer = ib;
}
}
return model;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void ManagerImplemented::SetRingRenderer(RingRenderer* renderer)
{
ES_SAFE_DELETE(m_ringRenderer);
m_ringRenderer = renderer;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void ManagerImplemented::SetModelRenderer(ModelRenderer* renderer)
{
ES_SAFE_DELETE(m_modelRenderer);
m_modelRenderer = renderer;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void EffectImplemented::Reset()
{
UnloadResources();
Setting* loader = GetSetting();
TextureLoader* textureLoader = loader->GetTextureLoader();
for( int i = 0; i < m_ImageCount; i++ )
{
if( m_ImagePaths[i] != NULL ) delete [] m_ImagePaths[i];
}
m_ImageCount = 0;
ES_SAFE_DELETE_ARRAY( m_ImagePaths );
ES_SAFE_DELETE_ARRAY(m_pImages);
{
for (int i = 0; i < m_normalImageCount; i++)
{
if (m_normalImagePaths[i] != NULL) delete [] m_normalImagePaths[i];
}
m_normalImageCount = 0;
ES_SAFE_DELETE_ARRAY(m_normalImagePaths);
ES_SAFE_DELETE_ARRAY(m_normalImages);
}
{
for (int i = 0; i < m_distortionImageCount; i++)
{
if (m_distortionImagePaths[i] != NULL) delete [] m_distortionImagePaths[i];
}
m_distortionImageCount = 0;
ES_SAFE_DELETE_ARRAY(m_distortionImagePaths);
ES_SAFE_DELETE_ARRAY(m_distortionImages);
}
for( int i = 0; i < m_WaveCount; i++ )
{
if( m_WavePaths[i] != NULL ) delete [] m_WavePaths[i];
}
m_WaveCount = 0;
ES_SAFE_DELETE_ARRAY( m_WavePaths );
ES_SAFE_DELETE_ARRAY( m_pWaves );
for( int i = 0; i < m_modelCount; i++ )
{
if( m_modelPaths[i] != NULL ) delete [] m_modelPaths[i];
}
m_modelCount = 0;
ES_SAFE_DELETE_ARRAY( m_modelPaths );
ES_SAFE_DELETE_ARRAY( m_pModels );
ES_SAFE_DELETE( m_pRoot );
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void ManagerImplemented::SetSoundPlayer(SoundPlayer* soundPlayer)
{
ES_SAFE_DELETE(m_soundPlayer);
m_soundPlayer = soundPlayer;
}
Culling::~Culling()
{
ES_SAFE_DELETE(lineRenderer);
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
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
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
TrackRenderer::~TrackRenderer()
{
ES_SAFE_DELETE(m_shader);
ES_SAFE_DELETE(m_shader_no_texture);
}
