//
// 创建实体
//
CEntity* CSceneManager::CreateEntity(DWORD dwName, CEntity::TYPE type)
{
CEntity *pEntity = NULL;
switch (type) {
case CEntity::MESH:
if (m_meshs.find(dwName) == m_meshs.end()) {
m_meshs[dwName] = pEntity = SAFE_NEW(MEMTYPE_HEAP) CEntityMesh(dwName, this); ASSERT(pEntity);
}
else {
pEntity = m_meshs[dwName];
}
break;
case CEntity::SKIN:
if (m_skins.find(dwName) == m_skins.end()) {
m_skins[dwName] = pEntity = SAFE_NEW(MEMTYPE_HEAP) CEntitySkin(dwName, this); ASSERT(pEntity);
}
else {
pEntity = m_skins[dwName];
}
break;
case CEntity::EFFECT:
if (m_effects.find(dwName) == m_effects.end()) {
m_effects[dwName] = pEntity = SAFE_NEW(MEMTYPE_HEAP) CEntityEffect(dwName, this); ASSERT(pEntity);
}
else {
pEntity = m_effects[dwName];
}
break;
case CEntity::HALO:
if (m_halos.find(dwName) == m_halos.end()) {
m_halos[dwName] = pEntity = SAFE_NEW(MEMTYPE_HEAP) CEntityHalo(dwName, this); ASSERT(pEntity);
}
else {
pEntity = m_halos[dwName];
}
break;
case CEntity::LIGHT:
if (m_lights.find(dwName) == m_lights.end()) {
m_lights[dwName] = pEntity = SAFE_NEW(MEMTYPE_HEAP) CEntityLight(dwName, this); ASSERT(pEntity);
}
else {
pEntity = m_lights[dwName];
}
break;
}
return pEntity;
}
//-----------------------------------------------------------------------------
//! コンストラクタ
//-----------------------------------------------------------------------------
TaskFilterLensFlare::TaskFilterLensFlare()
: _lensColorTex (nullptr)
, _lensDirtTex (nullptr)
, _lensStarBurstTex (nullptr)
{
SAFE_NEW(_lensColorTex);
SAFE_NEW(_lensDirtTex);
SAFE_NEW(_lensStarBurstTex);
_lensColorTex->loadAndTexImage2D("../Image/LensFlare/lenscolor.png", false, false, GL_TEXTURE_1D);
_lensDirtTex->loadAndTexImage2D("../Image/LensFlare/lensdirt.png", false);
//_lensDirtTex->loadAndTexImage2D("../Image/LensFlare/dust2.jpg", false);
_lensStarBurstTex->loadAndTexImage2D("../Image/LensFlare/lensstar.png", false, true);
}
//
// 加载渲染过程
//
VOID CRenderSolution::LoadFromStream(TiXmlNode *pRenderSolutionNode)
{
ASSERT(pRenderSolutionNode);
if (TiXmlNode *pRenderStageNode = pRenderSolutionNode->FirstChild("RenderStage")) {
do {
//
// 1. 获得渲染过程名
//
const CHAR *szName = pRenderStageNode->ToElement()->AttributeString("name");
if (szName == NULL) throw "No render stage name.";
//
// 2. 检查是否已经加载
//
DWORD dwName = HashValue(szName);
RenderStageMap::const_iterator itRenderStage = m_renderStageMap.find(dwName);
if (itRenderStage != m_renderStageMap.end()) continue;
//
// 3. 加载渲染过程
//
CRenderStage *pRenderStage = SAFE_NEW(MEMTYPE_HEAP) CRenderStage(m_pRenderFlow);
ASSERT(pRenderStage);
m_renderStageSet.push_back(pRenderStage);
m_renderStageMap[dwName] = pRenderStage; // 注意: 先添加到渲染过程集合后再加载渲染过程,
//避免内存泄漏!!!
pRenderStage->LoadFromStream(pRenderStageNode);
} while (pRenderStageNode = pRenderSolutionNode->IterateChildren("RenderStage", pRenderStageNode));
}
}
/**************************************************************************
* name : AddDeclaration
* description: 添加xml文件声明部分
* input : pszVersion 版本
pszEncode 编码方式
pszStdLone 独立属性 yes或no
* output : NA
* return : true - 成功，false - 失败
* remark : NA
**************************************************************************/
bool CXml::AddDeclaration(const char* pszVersion, const char* pszEncode, const char* pszStdLone)
{
if ((NULL == pszVersion) || (NULL == pszEncode) || (NULL == pszStdLone))
{
return false;
}
if (NULL == m_pXMlDoc)
{
SAFE_NEW(m_pXMlDoc, TiXmlDocument);//lint !e774
}
CHECK_POINTER(m_pXMlDoc, false);//lint !e774
TiXmlDeclaration *pXmlDeclaration;
try
{
pXmlDeclaration = new TiXmlDeclaration(pszVersion, pszEncode, pszStdLone);
}
catch (...)
{
pXmlDeclaration = NULL;
return false;//lint !e438
}
CHECK_POINTER(pXmlDeclaration, false);//lint !e774
(void)(m_pXMlDoc->LinkEndChild(pXmlDeclaration));
return true;//lint !e429
}
//
// 加载渲染对象
//
VOID CRenderFlow::LoadRenderTargets(TiXmlNode *pRenderFlowNode)
{
ASSERT(pRenderFlowNode);
if (TiXmlNode *pRenderTargetNode = pRenderFlowNode->FirstChild("RenderTarget")) {
do {
//
// 1. 获得渲染对象名
//
const CHAR *szName = pRenderTargetNode->ToElement()->AttributeString("category");
if (szName == NULL) throw "No render target category.";
//
// 2. 检查是否已经加载
//
DWORD dwName = HashValue(szName);
RenderTargetMap::const_iterator itRenderTarget = m_renderTargets.find(dwName);
if (itRenderTarget != m_renderTargets.end()) continue;
//
// 3. 加载渲染对象
//
CRenderTarget *pRenderTarget = SAFE_NEW(MEMTYPE_HEAP) CRenderTarget(this);
ASSERT(pRenderTarget);
m_renderTargets[dwName] = pRenderTarget; // 注意: 先添加到渲染对象集合后再加载渲染对象,
// 避免内存泄漏!!!
pRenderTarget->LoadFromStream(pRenderTargetNode);
} while (pRenderTargetNode = pRenderFlowNode->IterateChildren("RenderTarget", pRenderTargetNode));
}
}
//
// 加载渲染方案
//
VOID CRenderFlow::LoadRenderSolutions(TiXmlNode *pRenderFlowNode)
{
ASSERT(pRenderFlowNode);
if (TiXmlNode *pRenderSolutionNode = pRenderFlowNode->FirstChild("RenderSolution")) {
do {
//
// 1. 获得渲染方案名
//
const CHAR *szName = pRenderSolutionNode->ToElement()->AttributeString("name");
if (szName == NULL) throw "No render solution name.";
//
// 2. 检查是否已经加载
//
DWORD dwName = HashValue(szName);
RenderSolutionMap::const_iterator itRenderSolution = m_renderSolutions.find(dwName);
if (itRenderSolution != m_renderSolutions.end()) continue;
//
// 3. 加载渲染方案
//
CRenderSolution *pRenderSolution = SAFE_NEW(MEMTYPE_HEAP) CRenderSolution(this);
ASSERT(pRenderSolution);
m_renderSolutions[dwName] = pRenderSolution; // 注意: 先添加到渲染方案集合后再加载渲染方案,
// 避免内存泄漏!!!
pRenderSolution->LoadFromStream(pRenderSolutionNode);
} while (pRenderSolutionNode = pRenderFlowNode->IterateChildren("RenderSolution", pRenderSolutionNode));
}
}
//-----------------------------------------------------------------------------
//! シャドウテクスチャを作成
//-----------------------------------------------------------------------------
bool CascadedShadow::createShadowTexture()
{
SAFE_NEW(_depthTexture);
// 描画ターゲットを作成(複数のシャドウテクスチャを一枚にするのでWIDTHはデプスの横幅×分割数)
if (!_depthTexture->createRenderTarget(DEPTH_SIZE * SPLIT_COUNT, DEPTH_SIZE, GL_RGB, GL_RGB, GL_FLOAT, false, true))
{
MessageBoxA(nullptr, "シャドウテクスチャ作成に失敗しました", "エラー", MB_OK);
}
// タスクモデルでデプステクスチャに書き込むので初回のみデプスハンドルをセットする
TaskModelX::setDepthTexHandle(_depthTexture->getDepthBuffer());
//// テクスチャ作成
//glGenTextures(1, &_depthTexture);
//// ひも付け
//glBindTexture(GL_TEXTURE_2D, _depthTexture);
////---- 転送
//glTexImage2D(GL_TEXTURE_2D,
// 0, // ミップマップ段数
// GL_DEPTH_COMPONENT, // コンポーネント数 3:RGB 4:RGBA
// (GLsizei)_depthTexSize._w, // 幅
// (GLsizei)_depthTexSize._h, // 高さ
// 0, // ボーダーカラー 1:あり 0:なし
// GL_DEPTH_COMPONENT, // [転送元] コンポーネント
// GL_FLOAT, // [転送元] の1要素あたりのサイズ
// NULL); // [転送元] イメージのメモリの先頭
//// テクスチャの品質設定
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
//glBindTexture(GL_TEXTURE_2D, 0);
////---- フレームバッファをテクスチャとデプスバッファと再編成する
//glGenFramebuffers(1, &_depthFrameBuffer);
//// フレームバッファを割り当て(ひも付け)
//glBindFramebuffer(GL_FRAMEBUFFER, _depthFrameBuffer);
//glDrawBuffer(GL_NONE);
//glReadBuffer(GL_NONE);
//// デプステクスチャをFBOに接続
//glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, _depthTexture, 0);
//// フレームバッファが作成できていなければ失敗
//if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
//return false;
//
//// タスクモデルにテクスチャハンドルを渡しておく
//TaskModelX::setDepthTexHandle(_depthTexture);
//
//// バッファバインド開放
//glBindFramebuffer(GL_FRAMEBUFFER, 0);
return true;
}
//-----------------------------------------------------------------------------
//! デストラクタ
//-----------------------------------------------------------------------------
CascadedShadow::~CascadedShadow()
{
for( u32 i=0; i<SPLIT_COUNT; ++i ) {
_pShadow[i] = nullptr;
// シャドウマップ初期化
SAFE_NEW(_pShadow[i]);
}
}
//
// 保存XML
//
VOID CGfxBillboard::SaveXML(TiXmlNode *pGfxNode) const
{
ASSERT(pGfxNode);
TiXmlElement *pOffsetNode = SAFE_NEW(MEMTYPE_HEAP) TiXmlElement("Offset"); ASSERT(pOffsetNode);
{
pOffsetNode->SetAttributeFloat("value", m_offset);
}
pGfxNode->LinkEndChild(pOffsetNode);
TiXmlElement *pDirectionNode = SAFE_NEW(MEMTYPE_HEAP) TiXmlElement("Direction"); ASSERT(pDirectionNode);
{
pDirectionNode->SetAttributeInt("value", m_directionType);
}
pGfxNode->LinkEndChild(pDirectionNode);
CGfxBase::SaveXML(pGfxNode);
}
void ScriptComponent::start() {
Script * meScript = myScript();
if(meScript == nullptr) return;
hasBeenInited = true;
std::string instancename = meScript->getInstanceName(); // gets random string of characters set to this class (runs all this in LUA)
auto context = LUA_INSTANCE.GetGlobalEnvironment().Get<LuaTable>(instancename); // extract table from LUA
context.Set("parent",((LuaUserdata<Entity>)*parent)); // hard set entity parent into extracted table
// access by self.parent.methods(), since this is an actual var set, not a method
SAFE_NEW(privates,ScriptComponentPrivates(context,instancename));
privates->runMethod("start");
}
//
// 保存XML
//
VOID CAffectorKeepLocal::SaveXML(TiXmlNode *pAffectorNode) const
{
ASSERT(pAffectorNode);
TiXmlElement *pKeepLocalNode = SAFE_NEW(MEMTYPE_HEAP) TiXmlElement("KeepLocal"); ASSERT(pKeepLocalNode);
{
pKeepLocalNode->SetAttributeString("enable", cglAttribToString(m_bKeepLocal));
}
pAffectorNode->LinkEndChild(pKeepLocalNode);
CAffectorBase::SaveXML(pAffectorNode);
}
//
// 保存步进时间
//
VOID CAffectorBase::SaveStepTime(TiXmlNode *pAffectorNode, const CAffectorBase *pDefaultAffector) const
{
ASSERT(pAffectorNode);
if (m_step != pDefaultAffector->m_step) {
TiXmlElement *pStepTimeNode = SAFE_NEW(MEMTYPE_HEAP) TiXmlElement("StepTime"); ASSERT(pStepTimeNode);
{
pStepTimeNode->SetAttributeFloat("value", m_step);
}
pAffectorNode->LinkEndChild(pStepTimeNode);
}
}
//-----------------------------------------------------------------------------
//! 初期化
//-----------------------------------------------------------------------------
bool TaskFilterLensFlare::setup()
{
Size<s32> windowSize = GmWindow()->getResolution();
Size<s32> workTexResolution;
workTexResolution._w = windowSize._w * (1.0f/8.0f);
workTexResolution._h = windowSize._h;
// 親クラスの初期化を呼ぶ
TaskFilter::setup(workTexResolution);
//---- テクスチャのメモリ確保
SAFE_NEW(_accumTexture);
if(_accumTexture == nullptr) return false;
SAFE_NEW(_stockTexture);
if(_stockTexture == nullptr) return false;
//---- 空テクスチャの作成
if (!_accumTexture->createRenderTarget(windowSize._w, windowSize._h, GL_RGBA16F_ARB, GL_RGBA, GL_HALF_FLOAT_ARB, true)) {
MessageBox(NULL, "RenderTargetの作成に失敗しました。"__FILE__, "ERROR", MB_OK);
return false;
}
if (!_stockTexture->createRenderTarget(windowSize._w, windowSize._h, GL_RGBA16F_ARB, GL_RGBA, GL_HALF_FLOAT_ARB, true)) {
MessageBox(NULL, "RenderTargetの作成に失敗しました。"__FILE__, "ERROR", MB_OK);
return false;
}
for(u32 i=0; i<2; ++i){
SAFE_NEW(_bilenarExpandTex[i]);
if (_bilenarExpandTex[i] == nullptr) return false;
// ワークテクスチャの2倍の幅のテクスチャ
if (!_bilenarExpandTex[i]->createRenderTarget(workTexResolution._w * 2.0f, workTexResolution._h, GL_RGBA16F_ARB, GL_RGBA, GL_HALF_FLOAT_ARB, true)) {
MessageBox(NULL, "RenderTargetの作成に失敗しました。"__FILE__, "ERROR", MB_OK);
return false;
}
}
return true;
}
//
// 保存结束时间
//
VOID CAffectorBase::SaveEndTime(TiXmlNode *pAffectorNode, const CAffectorBase *pDefaultAffector) const
{
ASSERT(pAffectorNode);
if (m_minEndTime != pDefaultAffector->m_minEndTime || m_maxEndTime != pDefaultAffector->m_maxEndTime) {
TiXmlElement *pEndTimeNode = SAFE_NEW(MEMTYPE_HEAP) TiXmlElement("EndTime"); ASSERT(pEndTimeNode);
{
pEndTimeNode->SetAttributeFloat("min_value", m_minEndTime);
pEndTimeNode->SetAttributeFloat("max_value", m_maxEndTime);
}
pAffectorNode->LinkEndChild(pEndTimeNode);
}
}
//
// 创建节点
//
CSceneNode* CSceneManager::CreateNode(DWORD dwName)
{
CSceneNode *pNode = NULL;
if (m_nodes.find(dwName) == m_nodes.end()) {
m_nodes[dwName] = pNode = SAFE_NEW(MEMTYPE_HEAP) CSceneNode(dwName, this); ASSERT(pNode);
}
else {
pNode = m_nodes[dwName];
}
return pNode;
}
/**************************************************************************
* name : AddElemBeforeCurNode
* description: 在当前节点前添加元素
* input : pszElemName 待添加的元素名
* output : NA
* return : true - 成功，false - 失败
* remark : NA
**************************************************************************/
bool CXml::AddElemBeforeCurNode(const char *pszElemName)
{
CHECK_POINTER(pszElemName, false);
//Tinyxml会管理所有的申请的内存，不需要调用者delete
TiXmlElement *pXmlAddElem = NULL;
try
{
pXmlAddElem = new TiXmlElement(pszElemName);
}
catch (...)
{
pXmlAddElem = NULL;
return false;//lint !e438
}
CHECK_POINTER(pXmlAddElem, false);//lint !e774
if (NULL == m_pXmlNode)
{
if (NULL == m_pXMlDoc)
{
SAFE_NEW(m_pXMlDoc, TiXmlDocument);//lint !e774
}
CHECK_POINTER(m_pXMlDoc, false);//lint !e774
(void)(m_pXMlDoc->LinkEndChild(pXmlAddElem));
GetRootPos();
return true;
}
// 判断指针是否为空
CHECK_POINTER(m_pXmlNode, false); //lint !e774
TiXmlNode *pParent = m_pXmlNode->Parent();
CHECK_POINTER(pParent,false);
TiXmlNode *pXmlNode = pParent->InsertBeforeChild(m_pXmlNode,(*pXmlAddElem));
if (NULL == pXmlNode)
{
return false;
}
m_pXmlNode = pXmlNode;
m_pXmlElem = m_pXmlNode->ToElement();
return true;
}
/**************************************************************************
* name : Load
* description: 加载一个xml文件
* input : NA
* output : NA
* return : true - 成功，false - 失败
* remark : NA
**************************************************************************/
bool CXml::Load(TiXmlEncoding encode)
{
CHECK_POINTER(m_pszFileName, false);
SAFE_NEW(m_pXMlDoc, TiXmlDocument);//lint !e774
// 判断指针是否为空
CHECK_POINTER(m_pXMlDoc, false); //lint !e774
if (m_pXMlDoc->LoadFile(m_pszFileName, encode))
{
GetRootPos();
return true;
}
return false;
}
INT GTextureMgr::Add(ID3D11Device* pDevice, const TCHAR *pFileName)
{
TCHAR szFileName[MAX_PATH];
TCHAR Drive[MAX_PATH];
TCHAR Dir[MAX_PATH];
TCHAR FName[MAX_PATH];
TCHAR Ext[MAX_PATH];
if (pFileName)
{
_tsplitpath(pFileName, Drive, Dir, FName, Ext);
Ext[4] = 0;
memset(szFileName, 0, sizeof(TCHAR) * MAX_PATH);
//D3DX11_IMAGE_FILE_FORMAT
if (_tcsicmp(Ext, _T(".tga")) == 0)
{
_tcscpy(Ext, _T(".bmp"));
}
_stprintf_s(szFileName, _T("%s%s"), FName, Ext);
for (TemplateMapItor itor = TMap.begin(); itor != TMap.end(); itor++)
{
GTexture *pPoint = (GTexture *)(*itor).second;
if (!_tcsicmp(pPoint->m_szName.c_str(), szFileName))
{
return (*itor).first;
}
}
}
GTexture *pPoint = NULL;
SAFE_NEW(pPoint, GTexture);
TCHAR szPath[MAX_PATH] = { 0, };
_stprintf_s(szPath, _T("%s%s"), Drive, Dir);
pPoint->SetPath(szPath);
if (FAILED(pPoint->Load(pDevice, szFileName)))
{
return 0;
}
TMap.insert(make_pair(++m_iCurIndex, pPoint));
return m_iCurIndex;
}
HRESULT PropertyMap::Add(SString *pPropertyName,
SBuffer *pPropertyValue)
{
_ASSERTE(pPropertyName != NULL);
_ASSERTE(pPropertyValue != NULL);
HRESULT hr = S_OK;
NewHolder<PropertyEntry> pPropertyEntry;
SAFE_NEW(pPropertyEntry, PropertyEntry);
pPropertyEntry->SetPropertyName(pPropertyName);
pPropertyEntry->SetPropertyValue(pPropertyValue);
SHash<PropertyHashTraits>::Add(pPropertyEntry);
pPropertyEntry.SuppressRelease();
Exit:
return hr;
}
INT GSpriteMgr::Add(ID3D11Device* pDevice,
TCHAR *pTextureFileName,
TCHAR *pShaderFileName,
ID3D11BlendState* pBlendState,
bool bInstancing)
{
TCHAR szFileName[MAX_PATH];
TCHAR Drive[MAX_PATH];
TCHAR Dir[MAX_PATH];
TCHAR FName[MAX_PATH];
TCHAR Ext[MAX_PATH];
if (pTextureFileName)
{
_tsplitpath_s(pTextureFileName, Drive, Dir, FName, Ext);
Ext[4] = 0;
memset(szFileName, 0, sizeof(TCHAR) * MAX_PATH);
_stprintf_s(szFileName, _T("%s%s"), FName, Ext);
for (TemplateMapItor itor = TMap.begin(); itor != TMap.end(); itor++)
{
GSprite *pPoint = (GSprite *)(*itor).second;
if (!_tcsicmp(pPoint->m_szName.c_str(), szFileName))
{
return (*itor).first;
}
}
}
GSprite *pPoint = NULL;
SAFE_NEW(pPoint, GSprite);
assert(pPoint);
pPoint->m_szPath = Dir;
if (FAILED(pPoint->Load(pDevice, pShaderFileName, pTextureFileName, bInstancing, pBlendState)))
{
SAFE_DEL(pPoint);
return 0;
}
TMap.insert(make_pair(++m_iCurIndex, pPoint));
pPoint->m_iIndex = m_iCurIndex;
return m_iCurIndex;
}
GNode* GQuadTree::CreateNode(GNode* pParentNode, float fTopLeft, float fTopRight, float fBottomLeft, float fBottomRight)
{
GNode* pNode = 0;
SAFE_NEW(pNode, GNode);
assert(pNode);
pNode->m_ChildList.reserve(4);
pNode->m_CornerList.reserve(4);
// AABB
pNode->m_tBox.vMin = D3DXVECTOR3(fTopLeft, 0.0f, fBottomLeft);
pNode->m_tBox.vMax = D3DXVECTOR3(fTopRight, 0.0f, fBottomRight);
pNode->m_tBox.vCenter = (pNode->m_tBox.vMax + pNode->m_tBox.vMin) / 2.0f;
pNode->m_tBox.vAxis[0] = D3DXVECTOR3(1.0f, 0.0f, 0.0f);
pNode->m_tBox.vAxis[1] = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
pNode->m_tBox.vAxis[2] = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
pNode->m_tBox.fExtent[0] = pNode->m_tBox.vMax.x - pNode->m_tBox.vCenter.x;
pNode->m_tBox.fExtent[1] = pNode->m_tBox.vMax.y - pNode->m_tBox.vCenter.y;
pNode->m_tBox.fExtent[2] = pNode->m_tBox.vMax.z - pNode->m_tBox.vCenter.z;
pNode->m_tBox.fRadius[0] = pNode->m_tBox.vMax.x - pNode->m_tBox.vCenter.x;
pNode->m_tBox.fRadius[1] = pNode->m_tBox.vMax.y - pNode->m_tBox.vCenter.y;
pNode->m_tBox.fRadius[2] = pNode->m_tBox.vMax.z - pNode->m_tBox.vCenter.z;
pNode->m_CornerList.push_back(D3DXVECTOR3(pNode->m_tBox.vMin.x, 0.0f, pNode->m_tBox.vMax.z));
pNode->m_CornerList.push_back(pNode->m_tBox.vMax);
pNode->m_CornerList.push_back(pNode->m_tBox.vMin);
pNode->m_CornerList.push_back(D3DXVECTOR3(pNode->m_tBox.vMax.x, 0.0f, pNode->m_tBox.vMin.z));
if (pParentNode)
{
pNode->m_iDepth = pParentNode->m_iDepth + 1;
if (m_iMaxDepth < pNode->m_iDepth)
{
m_iMaxDepth = pNode->m_iDepth;
}
}
return pNode;
}
/**************************************************************************
* name : Parse
* description: 解析一个xml流到xml文件
* input : pszStream xml流
* output : NA
* return : true - 成功，false - 失败
* remark : NA
**************************************************************************/
bool CXml::Parse(const char *pszStream, TiXmlEncoding encode)
{
CHECK_POINTER(pszStream, false);
//songyiqun
SAFE_DELETE(m_pXMlDoc);
SAFE_NEW(m_pXMlDoc, TiXmlDocument);//lint !e774
CHECK_POINTER(m_pXMlDoc, false);//lint !e774
//TIXML_ENCODING_LEGACY为Tinyxml使用的编码方式
(void)(m_pXMlDoc->Parse(pszStream, NULL, encode));
if (0 != m_pXMlDoc->Error())
{
return false;
}
GetRootPos();
return true;
}
/**************************************************************************
* name : GetXMLStream
* description: 获取xml流
* input : NA
* output : nXMLStreamLength
* return : const char* xml流
* remark : NA
**************************************************************************/
const char* CXml::GetXMLStream(unsigned int &uiXMLStreamLength)
{
TiXmlPrinter xmlPrinter;
xmlPrinter.SetStreamPrinting();
if (NULL == m_pXMlDoc)
{
SAFE_NEW(m_pXMlDoc, TiXmlDocument);//lint !e774
}
CHECK_POINTER(m_pXMlDoc, NULL);//lint !e774
if (!m_pXMlDoc->Accept(&xmlPrinter))
{
return NULL;
}
uiXMLStreamLength = xmlPrinter.Size();
m_strStream = xmlPrinter.CStr();
return m_strStream.c_str();
}
//-----------------------------------------------------------------------------
//! コンストラクタ
//-----------------------------------------------------------------------------
CascadedShadow::CascadedShadow()
: _currentShadowNum (0)
, _split_weight (0.75f)
, _modelMatrix (Matrix::IDENTITY)
, _depthTexture (nullptr)
{
for( u32 i=0; i<6; ++i ) {
_MinMax[i] = 0.0f;
}
// シャドウマップ初期化とプロジェクション行列初期化
for( u32 i=0; i<SPLIT_COUNT; ++i ) {
_pShadow[i] = nullptr;
// シャドウマップ初期化
SAFE_NEW(_pShadow[i]);
// 視錐台初期化
/*f[i]._fov = TO_RADIAN(120.0f);
f[i]._ratio = (f32)WIDTH/(f32)HEIGHT;*/
// プロジェクション行列初期化
_depthProj[i] = Matrix::IDENTITY;
}
// テクスチャの横幅は分割数分取る
_depthTexSize = Size<s32>(DEPTH_SIZE * SPLIT_COUNT, DEPTH_SIZE);
// シャドウテクスチャを作成
if( !createShadowTexture() ) {
MessageBoxA(NULL, "シャドウテクスチャ作成に失敗しました", "エラー", MB_OK);
}
// 分割数をシェーダに渡しておく
GmShader()->changeShader(SystemShader::SHADER_TEXTURE);
GmShader()->setUniform1f("gSplitCount", (GLfloat)SPLIT_COUNT);
GmShader()->beginPrevShader();
TaskModelX::setBiasMatrix(_biasMatrix);
_isSetRender = false;
}
D3D::D3D()
{
SAFE_NEW( screenViewPort , D3D11_VIEWPORT );
}
/* static */
HRESULT Compatibility::Retarget(AssemblyName *pAssemblyName,
AssemblyName **ppRetargetedAssemblyName,
BOOL *pfIsRetargeted)
{
HRESULT hr = S_OK;
BINDER_LOG_ENTER(W("Compatibility::Retarget"));
IF_FALSE_GO(pAssemblyName != NULL);
IF_FALSE_GO(ppRetargetedAssemblyName != NULL);
BINDER_LOG_ASSEMBLY_NAME(W("source"), pAssemblyName);
if (pfIsRetargeted)
{
*pfIsRetargeted = FALSE;
}
#ifdef FEATURE_CORESYSTEM
// Apply retargeting only for strong-named culture neutral assemblies
if (pAssemblyName->IsStronglyNamed() &&
pAssemblyName->GetDeNormalizedCulture().IsEmpty())
{
ReleaseHolder<AssemblyName> pRetargetedAssemblyName;
SString &simpleName = pAssemblyName->GetSimpleName();
AssemblyVersion *pAssemblyVersion = pAssemblyName->GetVersion();
SString publicKeyToken;
TextualIdentityParser::BlobToHex(pAssemblyName->GetPublicKeyTokenBLOB(),
publicKeyToken);
// Perform linear search for matching assembly. Legacy Fusion also does that
for (unsigned int i = 0; i < LENGTH_OF(arRetargetConfig); i++)
{
#ifdef FEATURE_LEGACYNETCF
if (!RuntimeIsLegacyNetCF(0) && arRetargetConfig[i].fMangoOnly == TRUE)
continue;
#endif
if (IsMatchingString(simpleName, arRetargetConfig[i].pwzSimpleName) &&
IsMatchingVersion(pAssemblyVersion, arRetargetConfig[i].pwzVersion) &&
IsMatchingString(publicKeyToken, arRetargetConfig[i].pwzPublicKeyToken))
{
AssemblyVersion newAssemblyVersion;
IF_FALSE_GO(newAssemblyVersion.SetVersion(arRetargetConfig[i].pwzNewVersion));
SAFE_NEW(pRetargetedAssemblyName, AssemblyName);
if (arRetargetConfig[i].pwzNewSimpleName != NULL)
{
pRetargetedAssemblyName->
GetSimpleName().Set(arRetargetConfig[i].pwzNewSimpleName);
}
else
{
pRetargetedAssemblyName->GetSimpleName().Set(simpleName);
}
pRetargetedAssemblyName->SetVersion(&newAssemblyVersion);
SBuffer newPublicKeyTokenBlob;
SmallStackSString newPublicKeyToken(arRetargetConfig[i].pwzNewPublicKeyToken);
TextualIdentityParser::HexToBlob(newPublicKeyToken,
FALSE /* fValidateHex */,
TRUE /* fIsToken */,
newPublicKeyTokenBlob);
pRetargetedAssemblyName->GetPublicKeyTokenBLOB().Set(newPublicKeyTokenBlob);
BINDER_LOG_ASSEMBLY_NAME(W("retargeted"), pRetargetedAssemblyName);
*ppRetargetedAssemblyName = pRetargetedAssemblyName.Extract();
if (pfIsRetargeted)
{
*pfIsRetargeted = TRUE;
}
GO_WITH_HRESULT(S_OK);
}
}
// Create a clone without retargetable flag
if (pAssemblyName->GetIsRetargetable())
{
IF_FAIL_GO(pAssemblyName->Clone(&pRetargetedAssemblyName));
pRetargetedAssemblyName->SetIsRetargetable(FALSE);
*ppRetargetedAssemblyName = pRetargetedAssemblyName.Extract();
} else
{
pAssemblyName->AddRef();
*ppRetargetedAssemblyName = pAssemblyName;
}
}
else
#endif // FEATURE_CORESYSTEM
{
pAssemblyName->AddRef();
*ppRetargetedAssemblyName = pAssemblyName;
}
Exit:
BINDER_LOG_LEAVE_HR(W("Compatibility::Retarget"), hr);
return hr;
}
bool TAcceptor::Run()
{
int iRet;
SOCKADDR_IN clientaddr;
int addrlen;
SOCKET client_sock;
while(m_bStarted)
{
addrlen = sizeof( clientaddr );
client_sock = accept( m_ListenSock, (SOCKADDR*)&clientaddr, &addrlen );
if( client_sock == INVALID_SOCKET )
{
continue;
}
I_DebugStr.DisplayText("[IP:%s,PORT:%d]\r\n", inet_ntoa(clientaddr.sin_addr),
ntohs(clientaddr.sin_port) );
//WaitForSingleObject( pServer->m_Mutex, INFINITE );
{
TSynchronize sync(this);
TUser* pUser = NULL;
SAFE_NEW( pUser, TUser );
pUser->m_Socket = client_sock;
I_ServerIOCP.AddhandleToIOCP( (HANDLE)client_sock,
(DWORD)pUser);
WSAEVENT hEvent = WSACreateEvent();
ZeroMemory(&(pUser->m_ov), sizeof(pUser->m_ov));
pUser->m_ov.m_iFlags = OVERLAPPED2::MODE_SEND;
pUser->m_ov.hEvent = hEvent;
pUser->m_iEvent = pUser->m_Socket;
I_Server.m_iClientNumber++;
I_Server.m_UserList.push_back(pUser);
// 환영메세지
UPACKET sendmsg;
ZeroMemory( &sendmsg, sizeof(sendmsg) );
sprintf( sendmsg.msg, "[서버]환영합니다. 대화명을 입력해 주세여");
sendmsg.ph.type = PACKET_CHAT_NAME_REQ;
sendmsg.ph.len = sizeof(PACKET_HEADER) + strlen(sendmsg.msg);
ZeroMemory( &pUser->m_strBuffer, sizeof(char)*2048 );
pUser->m_wsaBuffer.buf = (char*)&sendmsg;
pUser->m_wsaBuffer.len = sendmsg.ph.len;
DWORD dwSendByte = sendmsg.ph.len;
iRet = WSASend( client_sock,
&(pUser->m_wsaBuffer),
1,
&dwSendByte,
0,
(LPOVERLAPPED)&pUser->m_ov,
NULL );
if( iRet == SOCKET_ERROR )
{
I_DebugStr.T_ERROR();
}
/*if( WSASetEvent(I_Server.m_EventArray[0])== FALSE )
{
break;
}*/
}
Sleep(1);
}
m_bStarted = false;
// 스레드 시작 함수가 리턴되면 스레드는 소멸됨.
return 0;
}
