RomkaZVO/FC1
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

123

Browse Source
This commit is contained in:
romkazvo
2023-08-07 19:29:24 +08:00
commit 34d6c5d489
4832 changed files with 1389451 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2113
Editor/Music/MusicEditorDialog.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

259
Editor/Music/MusicEditorDialog.h Normal file
View File

@@ -0,0 +1,259 @@
////////////////////////////////////////////////////////////////////////////
//
// Crytek Engine Source File.
// Copyright (C), Crytek Studios, 2002.
// -------------------------------------------------------------------------
// File name: MaterialDialog.h
// Version: v1.00
// Created: 22/1/2003 by Timur.
// Compilers: Visual Studio.NET
// Description:
// -------------------------------------------------------------------------
// History:
//
////////////////////////////////////////////////////////////////////////////
#ifndef __musiceditordialog_h__
#define __musiceditordialog_h__
#pragma once
#include "BaseLibraryDialog.h"
#include "Controls\SplitterWndEx.h"
#include "Controls\PropertyCtrl.h"
class CMusicThemeLibItem;
class CMusicManager;
// forward declartions of DynamicMusic structures.
struct SMusicTheme;
struct SMusicPatternSet;
struct SPatternDef;
struct SMusicMood;
struct SMusicData;
struct ISound;
/** Dialog which hosts entity prototype library.
*/
class CMusicEditorDialog : public CBaseLibraryDialog
{
DECLARE_DYNAMIC(CMusicEditorDialog)
public:
CMusicEditorDialog( CWnd *pParent );
~CMusicEditorDialog();
// Called every frame.
void Update();
virtual UINT GetDialogMenuID();
protected:
enum ETreeItemType
{
EITEM_THEME,
EITEM_MOOD,
EITEM_PATTERN_SET,
EITEM_LAYER,
EITEM_PATTERN,
};
enum ELayerType
{
ELAYER_MAIN = 0,
ELAYER_RHYTHMIC = 1,
ELAYER_INCIDENTAL = 2,
};
//! Description of item in tree control.
struct ItemDesc
{
ItemDesc *pParentItem;
ETreeItemType type;
ELayerType layerType;
CMusicThemeLibItem *pItem;
SMusicTheme *m_pTheme;
SMusicMood *m_pMood;
SMusicPatternSet *m_pPatternSet;
SPatternDef *m_pPattern;
//////////////////////////////////////////////////////////////////////////
ItemDesc() : pParentItem(0),type(EITEM_THEME),layerType(ELAYER_MAIN),pItem(0),m_pTheme(0),
m_pMood(0),m_pPatternSet(0),m_pPattern(0) {};
ItemDesc( ItemDesc &item,ELayerType lt ) : pParentItem(&item),type(EITEM_LAYER),layerType(lt),pItem(item.pItem),m_pTheme(item.m_pTheme),
m_pMood(item.m_pMood),m_pPatternSet(item.m_pPatternSet),m_pPattern(item.m_pPattern) {};
ItemDesc( ItemDesc &item ) : pParentItem(&item),type(item.type),layerType(item.layerType),pItem(item.pItem),m_pTheme(item.m_pTheme),
m_pMood(item.m_pMood),m_pPatternSet(item.m_pPatternSet),m_pPattern(item.m_pPattern) {};
};
void DoDataExchange(CDataExchange* pDX);
BOOL OnInitDialog();
afx_msg void OnDestroy();
afx_msg void OnSize(UINT nType, int cx, int cy);
afx_msg void OnMouseMove(UINT nFlags, CPoint point);
afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
afx_msg void OnPlay();
afx_msg void OnUpdatePlay( CCmdUI* pCmdUI );
afx_msg void OnStop();
afx_msg void OnLoadFromLua();
afx_msg void OnBeginDrag(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnNotifyTreeRClick(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnNotifyTreeDblClick(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnBeginLabelEdit(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnEndLabelEdit(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnTreeDeleteItem(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnCopy();
afx_msg void OnPaste();
afx_msg void OnSelChangedItemTree(NMHDR* pNMHDR, LRESULT* pResult);
// File tree
afx_msg void OnNotifyFileTreeClick(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnSelectFileTree(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnFilesBeginDrag(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnFileTreeKillFocus(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnAddItem();
afx_msg void OnAddSubItem();
virtual afx_msg void OnRemoveItem();
virtual afx_msg void OnRenameItem();
virtual afx_msg void OnLoadLibrary();
//////////////////////////////////////////////////////////////////////////
// Some functions can be overriden to modify standart functionality.
//////////////////////////////////////////////////////////////////////////
virtual void InitToolbar();
virtual HTREEITEM InsertItemToTree( CBaseLibraryItem *pItem,HTREEITEM hParent );
virtual void SelectItem( CBaseLibraryItem *item,bool bForceReload=false );
virtual void SetActive( bool bActive );
//////////////////////////////////////////////////////////////////////////
void OnUpdateProperties( IVariable *var );
void DropToItem( HTREEITEM hItem,HTREEITEM hSrcItem );
HTREEITEM InsertItem_Theme( CMusicThemeLibItem *pItem );
HTREEITEM InsertItem_Mood( ItemDesc *pParent,SMusicMood *pMood,HTREEITEM parentItem=0 );
HTREEITEM InsertItem_PatternSet( ItemDesc *pParent,SMusicPatternSet *pPatternSet,HTREEITEM parentItem=0 );
HTREEITEM InsertItem_Pattern( ItemDesc *pParent,SPatternDef *pPattern,HTREEITEM parentItem=0 );
ItemDesc* GetCurrentItem();
virtual void ReloadItems();
void SelectItem( ItemDesc *pItemDesc );
void SetModified();
//////////////////////////////////////////////////////////////////////////
// Adding
//////////////////////////////////////////////////////////////////////////
SMusicTheme* NewTheme( const char *sBaseName=NULL );
SMusicMood* NewMood( SMusicTheme *pTheme,const char *sBaseName=NULL,bool bNewPatternSet=true );
SMusicPatternSet* NewPatternSet( SMusicMood *pMood );
SPatternDef* NewPattern( SMusicPatternSet *pPatternSet,ELayerType layer,const char *sBaseName=NULL,XmlNodeRef &node=XmlNodeRef(0) );
CString MakeUniqPatternName( const CString &baseName );
CString MakeUniqThemeName( const CString &baseName );
CString MakeUniqMoodName( SMusicTheme *pTheme,const CString &baseName );
void CalcProbabilities( SMusicPatternSet *pPatternSet );
void PastePatternSet( SMusicMood *pMood,XmlNodeRef &node );
SMusicMood* PasteMood( SMusicTheme *pTheme,XmlNodeRef &node );
void PasteTheme( XmlNodeRef &node );
//////////////////////////////////////////////////////////////////////////
// Deleting
//////////////////////////////////////////////////////////////////////////
void DeletePattern( ItemDesc *pItemDesc );
void DeletePatternSet( ItemDesc *pItemDesc );
void DeleteMood( ItemDesc *pItemDesc );
void DeleteTheme( ItemDesc *pItemDesc );
//////////////////////////////////////////////////////////////////////////
// IDocListener listener implementation
//////////////////////////////////////////////////////////////////////////
virtual void OnNewDocument();
virtual void OnLoadDocument();
virtual void OnCloseDocument();
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// Music files tree.
//////////////////////////////////////////////////////////////////////////
void OnRealodMusicFiles();
void LoadMusicFiles( std::vector<CString> &musicFiles );
void FillFileTree();
void PlaySound( const CString &filename );
//////////////////////////////////////////////////////////////////////////
DECLARE_MESSAGE_MAP()
//////////////////////////////////////////////////////////////////////////
// Variables.
//////////////////////////////////////////////////////////////////////////
IMusicSystem *m_pMusicSystem;
CSplitterWndEx m_wndVSplitter;
CSplitterWndEx m_wndHSplitter;
CTreeCtrl m_filesTreeCtrl;
CPropertyCtrl m_propsCtrl;
CVarBlockPtr m_vars;
CImageList m_imageList;
CImageList m_filesImageList;
// Material manager.
CMusicManager *m_pMusicManager;
SMusicData *m_pMusicData;
bool m_bPlaying;
bool m_bHandleDeleteItem;
HTREEITEM m_hDropItem;
HTREEITEM m_hDraggedItem;
// All music files.
CString m_musicFilesPath;
std::map<HTREEITEM,CString> m_musicFilesMap;
_smart_ptr<ISound> m_pSound;
//////////////////////////////////////////////////////////////////////////
// Maps to Tree items.
//////////////////////////////////////////////////////////////////////////
std::map<SMusicTheme*,HTREEITEM> m_ThemeToItemMap;
std::map<SMusicMood*,HTREEITEM> m_MoodToItemMap;
std::map<SMusicPatternSet*,HTREEITEM> m_PatternSetToItemMap;
std::map<SPatternDef*,HTREEITEM> m_PatternToItemMap;
typedef std::map<CString,SPatternDef*,stl::less_stricmp<CString> > PatternsMap;
PatternsMap m_PatternsMap;
ETreeItemType m_lastItemType;
};
#endif // __musiceditordialog_h__
/*
[-] Theme files.
[-] Moods { Bridges }
[-] Sneaking
[-] PatternSet0 { MinTimeout=50, MaxTimeout=60 }
[-] MainLayer { Probability = 100 }
-- Pattern0 { File,Volume,FadePos,Probability=50 }
-- Pattern1 { File,Volume,FadePos,Probability=50 }
-- Pattern2 { File,Volume,FadePos,Probability=50 }
-- Pattern3 { File,Volume,FadePos,Probability=50 }
[-] RhythmicLayer { Probability = 100 }
-- Pattern0 { File,Volume,FadePos,Probability=50 }
-- Pattern1 { File,Volume,FadePos,Probability=50 }
-- Pattern2 { File,Volume,FadePos,Probability=50 }
-- Pattern3 { File,Volume,FadePos,Probability=50 }
[-] IncidentalLayer { Probability = 100 }
-- Pattern0 { File,Volume,FadePos,Probability=50 }
-- Pattern1 { File,Volume,FadePos,Probability=50 }
-- Pattern2 { File,Volume,FadePos,Probability=50 }
-- Pattern3 { File,Volume,FadePos,Probability=50 }
[+] PatternSet1 { MinTimeout=50, MaxTimeout=60 }
[+] PatternSet2
[+] Suspense
[+] Nearsuspense
[+] Alert
[+] Victory
*/

296
Editor/Music/MusicEditorUI.h Normal file
View File

@@ -0,0 +1,296 @@
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// File name: MusicEditorUI.h
// Version: v1.00
// Last modified: (21/06/98)
// Compilers: Visual C++.NET
// Description:
// -------------------------------------------------------------------------
// Author: Timur Davidenko (timur@crytek.com)
// -------------------------------------------------------------------------
//
// You are not permitted to distribute, sell or use any part of
// this source for your software without written permision of author.
//
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#ifndef __MusicEditorUI__
#define __MusicEditorUI__
#pragma once
//////////////////////////////////////////////////////////////////////////
// Base class for music UIs
class CMusicEditorUI
{
public:
CVariableArray mainTable;
CVarBlockPtr m_vars;
IVariable::OnSetCallback m_onSetCallback;
virtual CVarBlock* CreateVars() = 0;
protected:
//////////////////////////////////////////////////////////////////////////
void AddVariable( CVariableArray &varArray,CVariableBase &var,const char *varName,unsigned char dataType=IVariable::DT_SIMPLE )
{
var.AddRef(); // Variables are local and must not be released by CVarBlock.
if (varName)
var.SetName(varName);
var.SetDataType(dataType);
if (m_onSetCallback)
var.AddOnSetCallback(m_onSetCallback);
varArray.AddChildVar(&var);
}
//////////////////////////////////////////////////////////////////////////
void AddVariable( CVarBlock *vars,CVariableBase &var,const char *varName,unsigned char dataType=IVariable::DT_SIMPLE )
{
var.AddRef(); // Variables are local and must not be released by CVarBlock.
if (varName)
var.SetName(varName);
var.SetDataType(dataType);
if (m_onSetCallback)
var.AddOnSetCallback(m_onSetCallback);
vars->AddVariable(&var);
}
};
//////////////////////////////////////////////////////////////////////////
class CMusicEditorUI_Theme : public CMusicEditorUI
{
public:
// default mood
CVariableArray bridgesTable;
CVariable<CString> defaultMood;
CVariable<float> defaultMoodTimeout;
CVariable<float> test;
//////////////////////////////////////////////////////////////////////////
CVarBlock* CreateVars()
{
if (m_vars)
return m_vars;
m_vars = new CVarBlock;
AddVariable( m_vars,mainTable,"Theme Properties" );
AddVariable( m_vars,bridgesTable,"Bridges" );
AddVariable( mainTable,defaultMood,"Default Mood" );
AddVariable( mainTable,defaultMoodTimeout,"Default Mood Timeout" );
return m_vars;
}
//////////////////////////////////////////////////////////////////////////
void Set( const SMusicTheme *pTheme )
{
defaultMoodTimeout = pTheme->fDefaultMoodTimeout;
defaultMood = pTheme->sDefaultMood.c_str();
bridgesTable.DeleteAllChilds();
for (TThemeBridgeMap::const_iterator it = pTheme->mapBridges.begin(); it != pTheme->mapBridges.end(); ++it)
{
const char *sTheme = it->first.c_str();
const char *sPattern = it->second.c_str();
CVariable<CString> *pBridgeVar = new CVariable<CString>;
pBridgeVar->SetDataType( IVariable::DT_SIMPLE );
pBridgeVar->SetName( sTheme );
pBridgeVar->Set( sPattern );
bridgesTable.AddChildVar( pBridgeVar );
}
}
//////////////////////////////////////////////////////////////////////////
void Get( SMusicTheme *pTheme )
{
pTheme->fDefaultMoodTimeout = defaultMoodTimeout;
const char *sDefMood = (CString)defaultMood;
pTheme->sDefaultMood = sDefMood;
}
};
//////////////////////////////////////////////////////////////////////////
class CMusicEditorUI_Mood : public CMusicEditorUI
{
public:
CVariable<int> nPriority;
CVariable<float> fFadeOutTime;
CVariable<bool> bPlaySingle;
//////////////////////////////////////////////////////////////////////////
CVarBlock* CreateVars()
{
if (m_vars)
return m_vars;
m_vars = new CVarBlock;
AddVariable( m_vars,mainTable,"Mood Properties" );
AddVariable( mainTable,nPriority,"Priority" );
AddVariable( mainTable,fFadeOutTime,"Fade Out Time" );
AddVariable( mainTable,bPlaySingle,"Play Single" );
return m_vars;
}
//////////////////////////////////////////////////////////////////////////
void Set( const SMusicMood *pMood )
{
nPriority = pMood->nPriority;
fFadeOutTime = pMood->fFadeOutTime;
bPlaySingle = pMood->bPlaySingle;
}
//////////////////////////////////////////////////////////////////////////
void Get( SMusicMood *pMood )
{
pMood->nPriority = nPriority;
pMood->fFadeOutTime = fFadeOutTime;
pMood->bPlaySingle = bPlaySingle;
}
};
//////////////////////////////////////////////////////////////////////////
class CMusicEditorUI_PatternSet : public CMusicEditorUI
{
public:
CVariable<float> fMinTimeout;
CVariable<float> fMaxTimeout;
//////////////////////////////////////////////////////////////////////////
CVarBlock* CreateVars()
{
if (m_vars)
return m_vars;
m_vars = new CVarBlock;
AddVariable( m_vars,mainTable,"Pattern Set Properties" );
AddVariable( mainTable,fMinTimeout,"Min Time Out" );
AddVariable( mainTable,fMaxTimeout,"Max Time Out" );
return m_vars;
}
//////////////////////////////////////////////////////////////////////////
void Set( const SMusicPatternSet *pPatternSet )
{
fMinTimeout = pPatternSet->fMinTimeout;
fMaxTimeout = pPatternSet->fMaxTimeout;
}
//////////////////////////////////////////////////////////////////////////
void Get( SMusicPatternSet *pPatternSet )
{
pPatternSet->fMinTimeout = fMinTimeout;
pPatternSet->fMaxTimeout = fMaxTimeout;
}
};
//////////////////////////////////////////////////////////////////////////
class CMusicEditorUI_Layer : public CMusicEditorUI
{
public:
CVariable<float> fProbability;
CVariable<int> nMaxSimultaneousPatterns;
//////////////////////////////////////////////////////////////////////////
CVarBlock* CreateVars()
{
if (m_vars)
return m_vars;
m_vars = new CVarBlock;
AddVariable( m_vars,mainTable,"Layer Properties" );
AddVariable( mainTable,fProbability,"Probability" );
AddVariable( mainTable,nMaxSimultaneousPatterns,"Max Simultaneous Patterns" );
return m_vars;
}
//////////////////////////////////////////////////////////////////////////
void Set( const SMusicPatternSet *pPatternSet,int layer )
{
switch (layer)
{
case 0:
fProbability = 0;
nMaxSimultaneousPatterns = 1;
break;
case 1:
fProbability = pPatternSet->fRhythmicLayerProbability;
nMaxSimultaneousPatterns = pPatternSet->nMaxSimultaneousRhythmicPatterns;
break;
case 2:
fProbability = pPatternSet->fIncidentalLayerProbability;
nMaxSimultaneousPatterns = pPatternSet->nMaxSimultaneousIncidentalPatterns;
break;
};
}
//////////////////////////////////////////////////////////////////////////
void Get( SMusicPatternSet *pPatternSet,int layer )
{
switch (layer)
{
case 0:
//fProbability = 0;
//nMaxSimultaneousPatterns = 1;
break;
case 1:
pPatternSet->fRhythmicLayerProbability = fProbability;
pPatternSet->nMaxSimultaneousRhythmicPatterns = nMaxSimultaneousPatterns;
break;
case 2:
pPatternSet->fIncidentalLayerProbability = fProbability;
pPatternSet->nMaxSimultaneousIncidentalPatterns = nMaxSimultaneousPatterns;
break;
};
}
};
//////////////////////////////////////////////////////////////////////////
class CMusicEditorUI_Pattern : public CMusicEditorUI
{
public:
CVariable<CString> sFilename;
CVariable<CString> sFadePoints;
CVariable<int> nLayeringVolume;
CVariable<float> fProbability;
//////////////////////////////////////////////////////////////////////////
CVarBlock* CreateVars()
{
if (m_vars)
return m_vars;
m_vars = new CVarBlock;
AddVariable( m_vars,mainTable,"Pattern Properties" );
AddVariable( mainTable,sFilename,"Filename",IVariable::DT_SOUND );
AddVariable( mainTable,sFadePoints,"Fade Points" );
AddVariable( mainTable,nLayeringVolume,"Volume" );
AddVariable( mainTable,fProbability,"Probability" );
return m_vars;
}
//////////////////////////////////////////////////////////////////////////
void Set( const SPatternDef *pPattern )
{
nLayeringVolume = pPattern->nLayeringVolume;
sFilename = pPattern->sFilename.c_str();
fProbability = pPattern->fProbability;
CString str;
for (int i = 0; i < pPattern->vecFadePoints.size(); i++)
{
CString temp;
if (i > 0)
temp.Format( ",%d",(int)pPattern->vecFadePoints[i] );
else
temp.Format( "%d",(int)pPattern->vecFadePoints[i] );
str += temp;
}
sFadePoints = str;
}
//////////////////////////////////////////////////////////////////////////
void Get( SPatternDef *pPattern )
{
CString sfile = sFilename;
pPattern->sFilename = (const char*)sfile;
pPattern->nLayeringVolume = nLayeringVolume;
pPattern->fProbability = fProbability;
CString str = sFadePoints;
int iStart = 0;
pPattern->vecFadePoints.clear();
CString token = TokenizeString( str,",",iStart );
while (!token.IsEmpty())
{
pPattern->vecFadePoints.push_back( atoi(token) );
token = TokenizeString( str,",",iStart );
}
}
};
#endif // __MusicEditorUI__

470
Editor/Music/MusicManager.cpp Normal file
View File

@@ -0,0 +1,470 @@
////////////////////////////////////////////////////////////////////////////
//
// Crytek Engine Source File.
// Copyright (C), Crytek Studios, 2002.
// -------------------------------------------------------------------------
// File name: MusicManager.cpp
// Version: v1.00
// Created: 22/1/2003 by Timur.
// Compilers: Visual Studio.NET
// Description:
// -------------------------------------------------------------------------
// History:
//
////////////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "MusicManager.h"
#include "MusicThemeLibrary.h"
#include "MusicThemeLibItem.h"
#include <ISound.h>
#include <IScriptSystem.h>
#define MUSIC_LIBS_PATH "Editor\\Music\\"
//////////////////////////////////////////////////////////////////////////
// CMusicManager implementation.
//////////////////////////////////////////////////////////////////////////
CMusicManager::CMusicManager()
{
m_pMusicData = new SMusicData();
m_libsPath = MUSIC_LIBS_PATH;
m_pLevelLibrary = (CBaseLibrary*)AddLibrary( "Level" );
m_pLevelLibrary->SetLevelLibrary( true );
}
//////////////////////////////////////////////////////////////////////////
CMusicManager::~CMusicManager()
{
ReleaseMusicData();
delete m_pMusicData;
}
//////////////////////////////////////////////////////////////////////////
void CMusicManager::ClearAll()
{
CBaseLibraryManager::ClearAll();
ReleaseMusicData();
m_pLevelLibrary = (CBaseLibrary*)AddLibrary( "Level" );
m_pLevelLibrary->SetLevelLibrary( true );
}
//////////////////////////////////////////////////////////////////////////
void CMusicManager::Export( XmlNodeRef &node )
{
XmlNodeRef libs = node->newChild( "MusicLibrary" );
for (int i = 0; i < GetLibraryCount(); i++)
{
IDataBaseLibrary* pLib = GetLibrary(i);
// Skip level library.
if (pLib->IsLevelLibrary())
continue;
// Level libraries are saved in in level.
XmlNodeRef libNode = libs->newChild( "Library" );
// Export library.
libNode->setAttr( "Name",pLib->GetName() );
libNode->setAttr( "File",Path::GetFile(pLib->GetFilename()) );
}
}
//////////////////////////////////////////////////////////////////////////
CBaseLibraryItem* CMusicManager::MakeNewItem()
{
return new CMusicThemeLibItem;
}
//////////////////////////////////////////////////////////////////////////
CBaseLibrary* CMusicManager::MakeNewLibrary()
{
return new CMusicThemeLibrary(this);
}
//////////////////////////////////////////////////////////////////////////
CString CMusicManager::GetRootNodeName()
{
return "MusicLibs";
}
//////////////////////////////////////////////////////////////////////////
CString CMusicManager::GetLibsPath()
{
return m_libsPath;
}
#define MUSICLOAD_MODE_BASE 0
#define MUSICLOAD_MODE_PATTERNS 1
#define MUSICLOAD_MODE_THEMES 2
#define MUSICLOAD_MODE_MOODS 3
#define MUSICLOAD_MODE_MOODLAYERS 4
#define MUSICLOAD_MODE_BRIDGES 5
#define MUSICLOAD_MODE_FADEPOS 6
#define MUSICLOAD_MODE_DEFAULTMOOD 7
#define MUSICLOAD_MODE_PATTERNSET 8
class CMusicLoadSinkTemp : public IScriptObjectDumpSink
{
private:
SMusicData *m_pMusicData;
IScriptSystem *m_pScriptSystem;
_SmartScriptObject *m_pObj;
int m_nMode;
SMusicTheme *m_pTheme;
SMusicMood *m_pMood;
SMusicPatternSet *m_pPatternSet;
SPatternDef *m_pPattern;
int m_nLayer;
typedef std::map<string,SPatternDef*,stl::less_stricmp<string> > TPatternsMap;
TPatternsMap m_patternsMap;
public:
CMusicLoadSinkTemp(SMusicData *pMusicData, IScriptSystem *pScriptSystem, _SmartScriptObject *pObj, int nMode=MUSICLOAD_MODE_BASE, SPatternDef *pPattern=NULL, SMusicTheme *pTheme=NULL, SMusicMood *pMood=NULL, SMusicPatternSet *pPatternSet=NULL, int nLayer=MUSICLAYER_MAIN)
{
m_pMusicData=pMusicData;
m_pScriptSystem=pScriptSystem;
m_pObj=pObj;
m_nMode=nMode;
m_pTheme=pTheme;
m_pMood=pMood;
m_pPatternSet=pPatternSet;
m_pPattern=pPattern;
m_nLayer=nLayer;
if (nMode == MUSICLOAD_MODE_MOODLAYERS)
{
// Make map of patterns.
for (int i = 0; i < (int)m_pMusicData->vecPatternDef.size(); i++)
{
SPatternDef *ptrn = m_pMusicData->vecPatternDef[i];
m_patternsMap[ptrn->sName.c_str()] = ptrn;
}
}
}
private:
void OnElementFound(const char *sName, ScriptVarType type)
{
switch (type)
{
case svtObject:
{
_SmartScriptObject pObj(m_pScriptSystem, true);
if (!(*m_pObj)->GetValue(sName, pObj))
break;
switch (m_nMode)
{
case MUSICLOAD_MODE_BASE:
{
if (strcmp("Patterns", sName)==0)
{
CMusicLoadSinkTemp Sink(m_pMusicData, m_pScriptSystem, &pObj, MUSICLOAD_MODE_PATTERNS);
pObj->Dump(&Sink);
}else
if (strcmp("Themes", sName)==0)
{
CMusicLoadSinkTemp Sink(m_pMusicData, m_pScriptSystem, &pObj, MUSICLOAD_MODE_THEMES);
pObj->Dump(&Sink);
}
break;
}
case MUSICLOAD_MODE_PATTERNS:
{
SPatternDef *pPatternDef=new SPatternDef();
const char *pszFilename;
if (!pObj->GetValue("File", pszFilename))
break;
_SmartScriptObject pSubObj(m_pScriptSystem, true);
if (!pObj->GetValue("FadePos", pSubObj))
break;
if (!pObj->GetValue("LayeringVolume", pPatternDef->nLayeringVolume))
pPatternDef->nLayeringVolume=255;
pPatternDef->sName=sName;
pPatternDef->sFilename=pszFilename;
CMusicLoadSinkTemp FadePosSink(m_pMusicData, m_pScriptSystem, &pSubObj, MUSICLOAD_MODE_FADEPOS, pPatternDef);
pSubObj->Dump(&FadePosSink);
m_pMusicData->vecPatternDef.push_back(pPatternDef);
break;
}
case MUSICLOAD_MODE_THEMES:
{
_SmartScriptObject pSubObj(m_pScriptSystem, true);
SMusicTheme *pTheme=new SMusicTheme();
pTheme->sName=sName;
if (pObj->GetValue("DefaultMood", pSubObj))
{
const char *pszDefaultMood;
if (pSubObj->GetValue("Mood", pszDefaultMood))
pTheme->sDefaultMood=pszDefaultMood;
else
pTheme->sDefaultMood="";
pSubObj->GetValue("Timeout", pTheme->fDefaultMoodTimeout);
}
if (pObj->GetValue("Moods", pSubObj))
{
CMusicLoadSinkTemp MoodsSink(m_pMusicData, m_pScriptSystem, &pSubObj, MUSICLOAD_MODE_MOODS, NULL, pTheme);
pSubObj->Dump(&MoodsSink);
}
if (pObj->GetValue("Bridges", pSubObj))
{
CMusicLoadSinkTemp BridgesSink(m_pMusicData, m_pScriptSystem, &pSubObj, MUSICLOAD_MODE_BRIDGES, NULL, pTheme);
pSubObj->Dump(&BridgesSink);
}
m_pMusicData->mapThemes.insert(TThemeMapIt::value_type(sName, pTheme));
break;
}
case MUSICLOAD_MODE_MOODS:
{
if (!m_pTheme)
break;
SMusicMood *pMood=new SMusicMood();
pMood->sName=sName;
if (!pObj->GetValue("Priority", pMood->nPriority))
pMood->nPriority=0; // default priority
if (!pObj->GetValue("FadeOutTime", pMood->fFadeOutTime))
pMood->fFadeOutTime=DEFAULT_CROSSFADE_TIME;
if (!pObj->GetValue("PlaySingle", pMood->bPlaySingle))
pMood->bPlaySingle=false;
_SmartScriptObject pSubObj(m_pScriptSystem, true);
if (pObj->GetValue("PatternSet", pSubObj))
{
CMusicLoadSinkTemp Sink(m_pMusicData, m_pScriptSystem, &pSubObj, MUSICLOAD_MODE_PATTERNSET, NULL, m_pTheme, pMood);
pSubObj->Dump(&Sink);
}
m_pTheme->mapMoods.insert(TMoodMapIt::value_type(sName, pMood));
break;
}
}
break;
}
case svtString:
case svtNumber:
{
switch (m_nMode)
{
case MUSICLOAD_MODE_BRIDGES:
{
if (!m_pTheme)
break;
const char *pszPattern;
if (!(*m_pObj)->GetValue(sName, pszPattern))
break;
m_pTheme->mapBridges.insert(TThemeBridgeMapIt::value_type(sName, pszPattern));
break;
}
}
break;
}
}
}
void OnElementFound(int nIdx, ScriptVarType type)
{
switch (type)
{
case svtObject:
{
switch (m_nMode)
{
case MUSICLOAD_MODE_PATTERNSET:
{
if (!m_pMood)
break;
SMusicPatternSet *pPatternSet=new SMusicPatternSet();
_SmartScriptObject pObj(m_pScriptSystem, true);
if (!(*m_pObj)->GetAt(nIdx, pObj))
break;
if (!pObj->GetValue("MinTimeout", pPatternSet->fMinTimeout))
pPatternSet->fMinTimeout=60.0f;
if (!pObj->GetValue("MaxTimeout", pPatternSet->fMaxTimeout))
pPatternSet->fMaxTimeout=120.0f;
_SmartScriptObject pSubObj(m_pScriptSystem, true);
pPatternSet->fTotalMainPatternProbability=0.0f;
if (pObj->GetValue("MainLayer", pSubObj))
{
_SmartScriptObject pPatternsSubObj(m_pScriptSystem, true);
if (pSubObj->GetValue("Patterns", pPatternsSubObj))
{
CMusicLoadSinkTemp Sink(m_pMusicData, m_pScriptSystem, &pPatternsSubObj, MUSICLOAD_MODE_MOODLAYERS, NULL, m_pTheme, m_pMood, pPatternSet, MUSICLAYER_MAIN);
pPatternsSubObj->Dump(&Sink);
}
}
pPatternSet->fTotalRhythmicPatternProbability=0.0f;
if (pObj->GetValue("RhythmicLayer", pSubObj))
{
if (!pSubObj->GetValue("Probability", pPatternSet->fRhythmicLayerProbability))
pPatternSet->fRhythmicLayerProbability=100.0f;
if (!pSubObj->GetValue("MaxSimultaneousPatterns", pPatternSet->nMaxSimultaneousRhythmicPatterns))
pPatternSet->nMaxSimultaneousRhythmicPatterns=1;
_SmartScriptObject pPatternsSubObj(m_pScriptSystem, true);
if (pSubObj->GetValue("Patterns", pPatternsSubObj))
{
CMusicLoadSinkTemp Sink(m_pMusicData, m_pScriptSystem, &pPatternsSubObj, MUSICLOAD_MODE_MOODLAYERS, NULL, m_pTheme, m_pMood, pPatternSet, MUSICLAYER_RHYTHMIC);
pPatternsSubObj->Dump(&Sink);
}
}
pPatternSet->fTotalIncidentalPatternProbability=0.0f;
if (pObj->GetValue("IncidentalLayer", pSubObj))
{
if (!pSubObj->GetValue("Probability", pPatternSet->fIncidentalLayerProbability))
pPatternSet->fIncidentalLayerProbability=100.0f;
if (!pSubObj->GetValue("MaxSimultaneousPatterns", pPatternSet->nMaxSimultaneousIncidentalPatterns))
pPatternSet->nMaxSimultaneousIncidentalPatterns=1;
_SmartScriptObject pPatternsSubObj(m_pScriptSystem, true);
if (pSubObj->GetValue("Patterns", pPatternsSubObj))
{
CMusicLoadSinkTemp Sink(m_pMusicData, m_pScriptSystem, &pPatternsSubObj, MUSICLOAD_MODE_MOODLAYERS, NULL, m_pTheme, m_pMood, pPatternSet, MUSICLAYER_INCIDENTAL);
pPatternsSubObj->Dump(&Sink);
}
}
m_pMood->vecPatternSets.push_back(pPatternSet);
break;
}
case MUSICLOAD_MODE_MOODLAYERS:
{
if (!m_pPatternSet)
break;
_SmartScriptObject pSubObj(m_pScriptSystem, true);
if (!(*m_pObj)->GetAt(nIdx, pSubObj))
break;
// read attributes
string sPatternName;
float fProbability = 0;
const char *pszPatternName;
if (!pSubObj->GetValue("Pattern", pszPatternName))
break;
sPatternName = pszPatternName;
pSubObj->GetValue("Probability", fProbability);
SPatternDef *pPattern = stl::find_in_map( m_patternsMap,sPatternName,(SPatternDef *)0 );
if (pPattern)
{
pPattern->fProbability = fProbability;
switch (m_nLayer)
{
case MUSICLAYER_MAIN:
m_pPatternSet->vecMainPatterns.push_back(pPattern);
m_pPatternSet->fTotalMainPatternProbability+=fProbability;
break;
case MUSICLAYER_RHYTHMIC:
m_pPatternSet->vecRhythmicPatterns.push_back(pPattern);
m_pPatternSet->fTotalRhythmicPatternProbability+=fProbability;
break;
case MUSICLAYER_INCIDENTAL:
m_pPatternSet->vecIncidentalPatterns.push_back(pPattern);
m_pPatternSet->fTotalIncidentalPatternProbability+=fProbability;
break;
}
}
break;
}
}
break;
}
case svtString:
case svtNumber:
{
switch (m_nMode)
{
case MUSICLOAD_MODE_FADEPOS:
{
if (!m_pPattern)
break;
int nFadePos;
if (!(*m_pObj)->GetAt(nIdx, nFadePos))
break;
m_pPattern->vecFadePoints.push_back(nFadePos);
break;
}
}
break;
}
}
}
};
//////////////////////////////////////////////////////////////////////////
void CMusicManager::LoadFromLua( CBaseLibrary *pLibrary )
{
IScriptSystem *pScriptSystem = GetIEditor()->GetSystem()->GetIScriptSystem();
pScriptSystem->SetGlobalToNull("DynamicMusic");
if (!pScriptSystem->ExecuteFile( "Scripts\\Music\\DynamicMusic.lua", true, true))
return;
_SmartScriptObject pObj(pScriptSystem, true);
if (!pScriptSystem->GetGlobalValue("DynamicMusic", pObj))
return;
CMusicLoadSinkTemp LoadSink(m_pMusicData, pScriptSystem, &pObj);
pObj->Dump(&LoadSink);
pScriptSystem->SetGlobalToNull("DynamicMusic");
// Init library.
for (TThemeMap::iterator it = m_pMusicData->mapThemes.begin(); it != m_pMusicData->mapThemes.end(); ++it)
{
SMusicTheme *pTheme = it->second;
// Make a new item per MusicTheme.
CMusicThemeLibItem *pLibItem = (CMusicThemeLibItem*)CreateItem( pLibrary );
pLibItem->SetName( pTheme->sName.c_str() );
delete pLibItem->GetTheme(); // Delete old theme from item.
pLibItem->SetTheme( pTheme );
}
if (GetIEditor()->GetSystem()->GetIMusicSystem())
GetIEditor()->GetSystem()->GetIMusicSystem()->SetData( m_pMusicData,true );
}
//////////////////////////////////////////////////////////////////////////
void CMusicManager::ReleaseMusicData()
{
// Delete all sub items of music data.
SMusicData *pData = m_pMusicData;
if (!pData)
return;
//////////////////////////////////////////////////////////////////////////
// Stop music system from playing.
if (GetIEditor()->GetSystem()->GetIMusicSystem())
GetIEditor()->GetSystem()->GetIMusicSystem()->SetData( NULL,true ); // Clear music system data.
// release pattern-defs
for (TPatternDefVecIt PatternIt=pData->vecPatternDef.begin();PatternIt!=pData->vecPatternDef.end();++PatternIt)
{
SPatternDef *pPattern=(*PatternIt);
delete pPattern;
}
// release themes/moods
for (TThemeMapIt ThemeIt=pData->mapThemes.begin();ThemeIt!=pData->mapThemes.end();++ThemeIt)
{
SMusicTheme *pTheme=ThemeIt->second;
for (TMoodMapIt MoodIt=pTheme->mapMoods.begin();MoodIt!=pTheme->mapMoods.end();++MoodIt)
{
SMusicMood *pMood=MoodIt->second;
for (TPatternSetVecIt PatternSetIt=pMood->vecPatternSets.begin();PatternSetIt!=pMood->vecPatternSets.end();++PatternSetIt)
{
SMusicPatternSet *pPatternSet=(*PatternSetIt);
delete pPatternSet;
}
delete pMood;
}
delete pTheme;
}
m_pMusicData->mapThemes.clear();
m_pMusicData->vecPatternDef.clear();
}
//////////////////////////////////////////////////////////////////////////
//! Serialize property manager.
void CMusicManager::Serialize( XmlNodeRef &node,bool bLoading )
{
if (bLoading)
{
ReleaseMusicData();
}
CBaseLibraryManager::Serialize( node,bLoading );
if (bLoading)
{
if (GetIEditor()->GetSystem()->GetIMusicSystem())
GetIEditor()->GetSystem()->GetIMusicSystem()->SetData( m_pMusicData,true );
}
}

64
Editor/Music/MusicManager.h Normal file
View File

@@ -0,0 +1,64 @@
////////////////////////////////////////////////////////////////////////////
//
// Crytek Engine Source File.
// Copyright (C), Crytek Studios, 2002.
// -------------------------------------------------------------------------
// File name: MusicManager.h
// Version: v1.00
// Created: 22/1/2003 by Timur.
// Compilers: Visual Studio.NET
// Description:
// -------------------------------------------------------------------------
// History:
//
////////////////////////////////////////////////////////////////////////////
#ifndef __musicmanager_h__
#define __musicmanager_h__
#pragma once
#include "BaseLibraryManager.h"
struct SMusicData;
class CMusicThemeLibrary;
class CMusicThemeLibItem;
/** Manages all entity prototypes and material libraries.
*/
class CRYEDIT_API CMusicManager : public CBaseLibraryManager
{
public:
//! Notification callback.
CMusicManager();
~CMusicManager();
// Clear all prototypes and material libraries.
void ClearAll();
//! Serialize property manager.
virtual void Serialize( XmlNodeRef &node,bool bLoading );
//! Export property manager to game.
void Export( XmlNodeRef &node );
void LoadFromLua( CBaseLibrary *pLibrary );
//! Return Dynamic Music data definition.
SMusicData* GetMusicData() { return m_pMusicData; }
protected:
void ReleaseMusicData();
virtual CBaseLibraryItem* MakeNewItem();
virtual CBaseLibrary* MakeNewLibrary();
//! Root node where this library will be saved.
virtual CString GetRootNodeName();
//! Path to libraries in this manager.
virtual CString GetLibsPath();
CString m_libsPath;
// Stores all music data.
SMusicData *m_pMusicData;
};
#endif // __musicmanager_h__

389
Editor/Music/MusicThemeLibItem.cpp Normal file
View File

@@ -0,0 +1,389 @@
////////////////////////////////////////////////////////////////////////////
//
// Crytek Engine Source File.
// Copyright (C), Crytek Studios, 2002.
// -------------------------------------------------------------------------
// File name: MusicThemeLibItem.cpp
// Version: v1.00
// Created: 3/2/2003 by Timur.
// Compilers: Visual Studio.NET
// Description:
// -------------------------------------------------------------------------
// History:
//
////////////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "MusicThemeLibItem.h"
#include "MusicManager.h"
#include "BaseLibrary.h"
#include "ErrorReport.h"
#include <ISound.h>
//////////////////////////////////////////////////////////////////////////
CMusicThemeLibItem::CMusicThemeLibItem()
{
m_pTheme = new SMusicTheme;
}
//////////////////////////////////////////////////////////////////////////
CMusicThemeLibItem::~CMusicThemeLibItem()
{
}
//////////////////////////////////////////////////////////////////////////
void CMusicThemeLibItem::SerializePattern( SerializeContext &ctx,SPatternDef *pPattern )
{
XmlNodeRef node = ctx.node;
if (ctx.bLoading)
{
// Loading.
if (!ctx.bCopyPaste)
{
pPattern->sName = node->getAttr( "Name" );
}
node->getAttr( "Probability",pPattern->fProbability );
node->getAttr( "LayeringVolume",pPattern->nLayeringVolume );
pPattern->sFilename = node->getAttr( "Filename" );
CString sFadePoints;
if (node->getAttr( "FadePoints",sFadePoints ))
{
int iStart = 0;
pPattern->vecFadePoints.clear();
CString token = TokenizeString( sFadePoints,",",iStart );
while (!token.IsEmpty())
{
pPattern->vecFadePoints.push_back( atoi(token) );
token = TokenizeString( sFadePoints,",",iStart );
}
}
if (!ctx.bCopyPaste)
{
// Add this pattern to music data.
CMusicManager *pManager = GetIEditor()->GetMusicManager();
SMusicData *pMusicData = pManager->GetMusicData();
if (pMusicData)
{
pMusicData->vecPatternDef.push_back(pPattern);
}
}
}
else
{
// Saving.
node->setAttr( "Name",pPattern->sName.c_str() );
node->setAttr( "Probability",pPattern->fProbability );
node->setAttr( "LayeringVolume",pPattern->nLayeringVolume );
node->setAttr( "Filename",pPattern->sFilename.c_str() );
if (!pPattern->vecFadePoints.empty())
{
CString str;
for (int i = 0; i < pPattern->vecFadePoints.size(); i++)
{
CString temp;
if (i > 0)
temp.Format( ",%d",(int)pPattern->vecFadePoints[i] );
else
temp.Format( "%d",(int)pPattern->vecFadePoints[i] );
str += temp;
}
node->setAttr( "FadePoints",str );
}
}
}
//////////////////////////////////////////////////////////////////////////
void CMusicThemeLibItem::SerializePatternSet( SerializeContext &ctx,SMusicPatternSet *pPatternSet )
{
XmlNodeRef nodePtrnSet = ctx.node;
if (ctx.bLoading)
{
// Loading.
nodePtrnSet->getAttr( "MaxTimeout",pPatternSet->fMaxTimeout );
nodePtrnSet->getAttr( "MinTimeout",pPatternSet->fMinTimeout );
nodePtrnSet->getAttr( "IncidentalLayerProbability",pPatternSet->fIncidentalLayerProbability );
nodePtrnSet->getAttr( "RhythmicLayerProbability",pPatternSet->fRhythmicLayerProbability );
nodePtrnSet->getAttr( "MaxSimultaneousIncidentalPatterns",pPatternSet->nMaxSimultaneousIncidentalPatterns );
nodePtrnSet->getAttr( "MaxSimultaneousRhythmicPatterns",pPatternSet->nMaxSimultaneousRhythmicPatterns );
// load patterns.
XmlNodeRef nodeMainLayer = nodePtrnSet->findChild( "MainLayer" );
XmlNodeRef nodeRhythmicLayer = nodePtrnSet->findChild( "RhythmicLayer" );
XmlNodeRef nodeIncidentalLayer = nodePtrnSet->findChild( "IncidentalLayer" );
if (nodeMainLayer)
{
SerializeContext patternCtx(ctx);
for (int j = 0; j < nodeMainLayer->getChildCount(); j++)
{
patternCtx.node = nodeMainLayer->getChild(j);
SPatternDef *pPattern = new SPatternDef;
pPatternSet->vecMainPatterns.push_back(pPattern);
SerializePattern( patternCtx,pPattern );
}
}
if (nodeRhythmicLayer)
{
SerializeContext patternCtx(ctx);
for (int j = 0; j < nodeRhythmicLayer->getChildCount(); j++)
{
patternCtx.node = nodeRhythmicLayer->getChild(j);
SPatternDef *pPattern = new SPatternDef;
pPatternSet->vecRhythmicPatterns.push_back(pPattern);
SerializePattern( patternCtx,pPattern );
}
}
if (nodeIncidentalLayer)
{
SerializeContext patternCtx(ctx);
for (int j = 0; j < nodeIncidentalLayer->getChildCount(); j++)
{
patternCtx.node = nodeIncidentalLayer->getChild(j);
SPatternDef *pPattern = new SPatternDef;
pPatternSet->vecIncidentalPatterns.push_back(pPattern);
SerializePattern( patternCtx,pPattern );
}
}
//////////////////////////////////////////////////////////////////////////
// Calc pattern set probability.
pPatternSet->fTotalMainPatternProbability = 0.0f;
pPatternSet->fTotalRhythmicPatternProbability = 0.0f;
pPatternSet->fTotalIncidentalPatternProbability = 0.0f;
for (int j = 0; j < pPatternSet->vecMainPatterns.size(); j++)
{
pPatternSet->fTotalMainPatternProbability += pPatternSet->vecMainPatterns[j]->fProbability;
}
for (int j = 0; j < pPatternSet->vecRhythmicPatterns.size(); j++)
{
pPatternSet->fTotalRhythmicPatternProbability += pPatternSet->vecRhythmicPatterns[j]->fProbability;
}
for (int j = 0; j < pPatternSet->vecIncidentalPatterns.size(); j++)
{
pPatternSet->fTotalIncidentalPatternProbability += pPatternSet->vecIncidentalPatterns[j]->fProbability;
}
}
else
{
// Saving.
nodePtrnSet->setAttr( "MaxTimeout",pPatternSet->fMaxTimeout );
nodePtrnSet->setAttr( "MinTimeout",pPatternSet->fMinTimeout );
nodePtrnSet->setAttr( "IncidentalLayerProbability",pPatternSet->fIncidentalLayerProbability );
nodePtrnSet->setAttr( "RhythmicLayerProbability",pPatternSet->fRhythmicLayerProbability );
nodePtrnSet->setAttr( "MaxSimultaneousIncidentalPatterns",pPatternSet->nMaxSimultaneousIncidentalPatterns );
nodePtrnSet->setAttr( "MaxSimultaneousRhythmicPatterns",pPatternSet->nMaxSimultaneousRhythmicPatterns );
// Save patterns.
XmlNodeRef nodeMainLayer = nodePtrnSet->newChild( "MainLayer" );
XmlNodeRef nodeRhythmicLayer = nodePtrnSet->newChild( "RhythmicLayer" );
XmlNodeRef nodeIncidentalLayer = nodePtrnSet->newChild( "IncidentalLayer" );
{
SerializeContext patternCtx(ctx);
for (int j = 0; j < pPatternSet->vecMainPatterns.size(); j++)
{
patternCtx.node = nodeMainLayer->newChild("Pattern");
SerializePattern( patternCtx,pPatternSet->vecMainPatterns[j] );
}
}
{
SerializeContext patternCtx(ctx);
for (int j = 0; j < pPatternSet->vecRhythmicPatterns.size(); j++)
{
patternCtx.node = nodeRhythmicLayer->newChild("Pattern");
SerializePattern( patternCtx,pPatternSet->vecRhythmicPatterns[j] );
}
}
{
SerializeContext patternCtx(ctx);
for (int j = 0; j < pPatternSet->vecIncidentalPatterns.size(); j++)
{
patternCtx.node = nodeIncidentalLayer->newChild("Pattern");
SerializePattern( patternCtx,pPatternSet->vecIncidentalPatterns[j] );
}
}
}
}
//////////////////////////////////////////////////////////////////////////
void CMusicThemeLibItem::SerializeMood( SerializeContext &ctx,SMusicMood *pMood )
{
XmlNodeRef node = ctx.node;
if (ctx.bLoading)
{
// Loading.
pMood->sName = node->getAttr( "Name" );
node->getAttr( "PlaySingle",pMood->bPlaySingle );
node->getAttr( "Priority",pMood->nPriority );
node->getAttr( "FadeOutTime",pMood->fFadeOutTime );
if (node->getChildCount() > 0)
{
SerializeContext patternSetCtx(ctx);
// load pattern sets.
for (int i = 0; i < node->getChildCount(); i++)
{
patternSetCtx.node = node->getChild(i);
SMusicPatternSet *pPatternSet = new SMusicPatternSet;
pMood->vecPatternSets.push_back(pPatternSet);
SerializePatternSet( patternSetCtx,pPatternSet );
}
}
}
else
{
// Saving.
node->setAttr( "Name",pMood->sName.c_str() );
node->setAttr( "PlaySingle",pMood->bPlaySingle );
node->setAttr( "Priority",pMood->nPriority );
node->setAttr( "FadeOutTime",pMood->fFadeOutTime );
if (!pMood->vecPatternSets.empty())
{
// Save pattern sets.
SerializeContext patternSetCtx(ctx);
for (int i = 0; i < pMood->vecPatternSets.size(); i++)
{
SMusicPatternSet *pPatternSet = pMood->vecPatternSets[i];
patternSetCtx.node = node->newChild("PatternSet");
SerializePatternSet( patternSetCtx,pPatternSet );
}
}
}
}
//////////////////////////////////////////////////////////////////////////
void CMusicThemeLibItem::Serialize( SerializeContext &ctx )
{
assert(m_pTheme);
CBaseLibraryItem::Serialize( ctx );
XmlNodeRef node = ctx.node;
if (ctx.bLoading)
{
// Loading.
m_pTheme->sName = (const char*)GetName();
m_pTheme->sDefaultMood = node->getAttr( "DefaultMood" );
node->getAttr( "DefaultMoodTimeout",m_pTheme->fDefaultMoodTimeout );
XmlNodeRef nodeMoods = node->findChild("Moods");
if (nodeMoods)
{
SerializeContext moodCtx(ctx);
for (int i = 0; i < nodeMoods->getChildCount(); i++)
{
moodCtx.node = nodeMoods->getChild(i);
SMusicMood *pMood = new SMusicMood;
SerializeMood( moodCtx,pMood );
m_pTheme->mapMoods[pMood->sName.c_str()] = pMood;
}
}
XmlNodeRef nodeBridges = node->findChild( "Bridges" );
if (nodeBridges)
{
for (int i = 0; i < nodeBridges->getChildCount(); i++)
{
XmlNodeRef nodeBridge = nodeBridges->getChild(i);
CString sPattern;
if (nodeBridge->getAttr( "Pattern",sPattern))
{
m_pTheme->mapBridges[nodeBridges->getTag()] = (const char*)sPattern;
}
}
}
// Add this pattern to music data.
CMusicManager *pManager =(CMusicManager*)GetLibrary()->GetManager();
SMusicData *pMusicData = pManager->GetMusicData();
if (pMusicData)
{
pMusicData->mapThemes[m_pTheme->sName.c_str()] = m_pTheme;
}
}
else
{
// Saving.
node->setAttr( "DefaultMood",m_pTheme->sDefaultMood.c_str() );
node->setAttr( "DefaultMoodTimeout",m_pTheme->fDefaultMoodTimeout );
if (!m_pTheme->mapMoods.empty())
{
XmlNodeRef nodeMoods = node->newChild("Moods");
SerializeContext moodCtx(ctx);
for (TMoodMap::iterator it = m_pTheme->mapMoods.begin(); it != m_pTheme->mapMoods.end(); ++it)
{
moodCtx.node = nodeMoods->newChild("Mood");
SerializeMood( moodCtx,it->second );
}
}
if (!m_pTheme->mapBridges.empty())
{
XmlNodeRef nodeBridges = node->newChild( "Bridges" );
for (TThemeBridgeMap::iterator it = m_pTheme->mapBridges.begin(); it != m_pTheme->mapBridges.end(); ++it)
{
const char *sTheme = it->first.c_str();
const char *sPattern = it->second.c_str();
XmlNodeRef nodeBridge = nodeBridges->newChild(sTheme);
nodeBridge->setAttr( "Pattern",sPattern );
}
}
}
}
//////////////////////////////////////////////////////////////////////////
void CMusicThemeLibItem::GatherUsedResources( CUsedResources &resources )
{
// Add all music files.
if (!m_pTheme)
return;
for (TMoodMap::iterator mit = m_pTheme->mapMoods.begin(); mit != m_pTheme->mapMoods.end(); ++mit)
{
SMusicMood *pMood = mit->second;
for (int p = 0; p < pMood->vecPatternSets.size(); p++)
{
SMusicPatternSet *pPatternSet = pMood->vecPatternSets[p];
{
for (int j = 0; j < pPatternSet->vecMainPatterns.size(); j++)
{
AddMusicResourceFile( pPatternSet->vecMainPatterns[j]->sFilename.c_str(),resources );
}
}
{
for (int j = 0; j < pPatternSet->vecRhythmicPatterns.size(); j++)
{
AddMusicResourceFile( pPatternSet->vecRhythmicPatterns[j]->sFilename.c_str(),resources );
}
}
{
for (int j = 0; j < pPatternSet->vecIncidentalPatterns.size(); j++)
{
AddMusicResourceFile( pPatternSet->vecIncidentalPatterns[j]->sFilename.c_str(),resources );
}
}
}
}
}
//////////////////////////////////////////////////////////////////////////
void CMusicThemeLibItem::AddMusicResourceFile( const char *szFilename,CUsedResources &resources )
{
// Try adding both .ogg and .wav versions.
CString ext = Path::GetExt(szFilename);
if (stricmp(ext,"wav") || stricmp(ext,"ogg"))
{
resources.Add( Path::ReplaceExtension(szFilename,"wav") );
resources.Add( Path::ReplaceExtension(szFilename,"ogg") );
}
else
{
resources.Add( szFilename );
}
}

51
Editor/Music/MusicThemeLibItem.h Normal file
View File

@@ -0,0 +1,51 @@
////////////////////////////////////////////////////////////////////////////
//
// Crytek Engine Source File.
// Copyright (C), Crytek Studios, 2002.
// -------------------------------------------------------------------------
// File name: MusicThemeLibItem.h
// Version: v1.00
// Created: 3/2/2003 by Timur.
// Compilers: Visual Studio.NET
// Description:
// -------------------------------------------------------------------------
// History:
//
////////////////////////////////////////////////////////////////////////////
#ifndef __musicthemelibitem_h__
#define __musicthemelibitem_h__
#pragma once
#include "BaseLibraryItem.h"
struct SMusicTheme;
struct SMusicMood;
struct SPatternDef;
struct SMusicPatternSet;
/** CMusicThemeLibItem class holds collection of several dynamic music themes.
*/
class CRYEDIT_API CMusicThemeLibItem : public CBaseLibraryItem
{
public:
CMusicThemeLibItem();
~CMusicThemeLibItem();
//! Serialize material settings to xml.
virtual void Serialize( SerializeContext &ctx );
static void SerializeMood( SerializeContext &ctx,SMusicMood *pMood );
static void SerializePatternSet( SerializeContext &ctx,SMusicPatternSet *pPatternSet );
static void SerializePattern( SerializeContext &ctx,SPatternDef *pPattern );
void SetTheme( SMusicTheme *pTheme ) { m_pTheme = pTheme; };
SMusicTheme* GetTheme() { return m_pTheme; }
virtual void GatherUsedResources( CUsedResources &resources );
private:
void AddMusicResourceFile( const char *szFilename,CUsedResources &resources );
SMusicTheme *m_pTheme;
};
#endif __musicthemelibitem_h__

89
Editor/Music/MusicThemeLibrary.cpp Normal file
View File

@@ -0,0 +1,89 @@
////////////////////////////////////////////////////////////////////////////
//
// Crytek Engine Source File.
// Copyright (C), Crytek Studios, 2002.
// -------------------------------------------------------------------------
// File name: MusicThemeLibrary.cpp
// Version: v1.00
// Created: 22/1/2003 by Timur.
// Compilers: Visual Studio.NET
// Description:
// -------------------------------------------------------------------------
// History:
//
////////////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "MusicThemeLibrary.h"
#include "MusicThemeLibItem.h"
#include "MusicManager.h"
#include <ISound.h>
//////////////////////////////////////////////////////////////////////////
// CMusicThemeLibrary implementation.
//////////////////////////////////////////////////////////////////////////
bool CMusicThemeLibrary::Save()
{
CString filename = GetFilename();
if (filename.IsEmpty())
{
return false;
}
XmlNodeRef root = new CXmlNode( "MusicThemeLibrary" );
Serialize( root,false );
bool bRes = root->saveToFile( GetFilename() );
return bRes;
}
//////////////////////////////////////////////////////////////////////////
bool CMusicThemeLibrary::Load( const CString &filename )
{
if (filename.IsEmpty())
return false;
SetFilename( filename );
XmlParser parser;
XmlNodeRef root = parser.parse( filename );
if (!root)
return false;
Serialize( root,true );
return true;
}
//////////////////////////////////////////////////////////////////////////
void CMusicThemeLibrary::Serialize( XmlNodeRef &root,bool bLoading )
{
if (bLoading)
{
// Loading.
CString name = GetName();
root->getAttr( "Name",name );
SetName( name );
for (int i = 0; i < root->getChildCount(); i++)
{
CMusicThemeLibItem *pItem = new CMusicThemeLibItem;
AddItem( pItem );
XmlNodeRef itemNode = root->getChild(i);
CBaseLibraryItem::SerializeContext ctx( itemNode,bLoading );
pItem->Serialize( ctx );
}
SetModified(false);
}
else
{
// Saving.
root->setAttr( "Name",GetName() );
root->setAttr( "SandboxVersion",(const char*)GetIEditor()->GetFileVersion().ToFullString() );
// Serialize prototypes.
for (int i = 0; i < GetItemCount(); i++)
{
XmlNodeRef itemNode = root->newChild( "Theme" );
CBaseLibraryItem::SerializeContext ctx( itemNode,bLoading );
GetItem(i)->Serialize( ctx );
}
}
}

35
Editor/Music/MusicThemeLibrary.h Normal file
View File

@@ -0,0 +1,35 @@
////////////////////////////////////////////////////////////////////////////
//
// Crytek Engine Source File.
// Copyright (C), Crytek Studios, 2002.
// -------------------------------------------------------------------------
// File name: MusicThemeLibrary.h
// Version: v1.00
// Created: 22/1/2003 by Timur.
// Compilers: Visual Studio.NET
// Description:
// -------------------------------------------------------------------------
// History:
//
////////////////////////////////////////////////////////////////////////////
#ifndef __musicthemelibrary_h__
#define __musicthemelibrary_h__
#pragma once
#include "BaseLibrary.h"
/** Library of prototypes.
*/
class CRYEDIT_API CMusicThemeLibrary : public CBaseLibrary
{
public:
CMusicThemeLibrary( CBaseLibraryManager *pManager ) : CBaseLibrary(pManager) {};
virtual bool Save();
virtual bool Load( const CString &filename );
virtual void Serialize( XmlNodeRef &node,bool bLoading );
private:
};
#endif // __musicthemelibrary_h__