diff --git a/source/geom/green.cpp b/source/geom/green.cpp index 295f38180d7d608e13ff8e0081b9a68ea11016e1..ddf5720563f72f2e6ffc3ca1d7723cb9619045e7 100644 --- a/source/geom/green.cpp +++ b/source/geom/green.cpp @@ -6,7 +6,7 @@ See the license in LICENSE #include "green.h" -Green::Green() +CGreen::CGreen() { //для растиетльности (с хардварным инстансингом) //{ @@ -21,191 +21,197 @@ Green::Green() D3DDECL_END() }; - Green::DXDevice->CreateVertexDeclaration(InstanceGreen, &VertexDeclarationGreen); + CGreen::m_pDXDevice->CreateVertexDeclaration(InstanceGreen, &m_pVertexDeclarationGreen); - Green::DXDevice->CreateVertexBuffer( - GREEN_MAX_ELEM_IN_DIP * sizeof(GreenDataVertex), + CGreen::m_pDXDevice->CreateVertexBuffer( + GREEN_MAX_ELEM_IN_DIP * sizeof(CGreenDataVertex), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, - &TransVertBuf, + &m_pTransVertBuf, 0); - IRSData* tmparr = new IRSData(); - ArrComFor.push_back(tmparr); - IRSData* tmparr2 = new IRSData(); - ArrComFor.push_back(tmparr2); + CIRSData* tmparr = new CIRSData(); + m_aArrComFor.push_back(tmparr); + CIRSData* tmparr2 = new CIRSData(); + m_aArrComFor.push_back(tmparr2); + + m_iCurrCountDrawObj = 0; } -Green::~Green() +CGreen::~CGreen() { - for (long i = 0; i < ArrModels.size(); ++i) + for (int i = 0; i < m_aGreens.size(); ++i) { - mem_delete(ArrModels[i]); + mem_delete(m_aGreens[i]); } - ArrModels.clear(); + m_aGreens.clear(); - mem_release(TransVertBuf); - mem_release(VertexDeclarationGreen); + mem_release(m_pTransVertBuf); + mem_release(m_pVertexDeclarationGreen); - while (ArrComFor.size() > 0) + while (m_aArrComFor.size() > 0) { - mem_delete(ArrComFor[0]); - ArrComFor.erase(0); + mem_delete(m_aArrComFor[0]); + m_aArrComFor.erase(0); } } -Green::Model::Model() +CGreen::CModel::CModel() { - ArrLod[0] = ArrLod[1] = ArrLod[2] = 0; - AllCountGreen = 0; - SplitsIDs = 0; - SplitsTree = 0; - AllTrans = 0; - ArrLod[0] = ArrLod[1] = ArrLod[2] = 0; - NavigateMesh = 0; + m_aLods[0] = m_aLods[1] = m_aLods[2] = 0; + m_uiCountObj = 0; + m_idCountSplits = 0; + m_pSplitsTree = 0; + m_pAllTrans = 0; + m_pPhysMesh = 0; + m_szName[0] = 0; + + m_vMax = float3(0,0,0); + m_vMin = float3(0, 0, 0); } -Green::Model::NavMesh::NavMesh() +CGreen::CModel::CPhysMesh::CPhysMesh() { - arr_vertex = 0; - arr_index = 0; - count_vertex = 0; - count_index = 0; - arr_mtl = 0; - pathname = ""; + m_pArrVertex = 0; + m_pArrIndex = 0; + m_iCountVertex = 0; + m_iCountIndex = 0; + m_pArrMtl = 0; + m_sPathName = ""; } -Green::Model::NavMesh::~NavMesh() +CGreen::CModel::CPhysMesh::~CPhysMesh() { - mem_delete_a(arr_vertex); - count_vertex = 0; - mem_delete_a(arr_index); - mem_delete_a(arr_mtl); - count_index = 0; + mem_delete_a(m_pArrVertex); + m_iCountVertex = 0; + mem_delete_a(m_pArrIndex); + mem_delete_a(m_pArrMtl); + m_iCountIndex = 0; } -Green::Model::~Model() +CGreen::CModel::~CModel() { - mem_delete(SplitsTree); - mem_delete(AllTrans); - mem_delete(NavigateMesh); + mem_delete(m_pSplitsTree); + mem_delete(m_pAllTrans); + mem_delete(m_pPhysMesh); - mem_del(ArrLod[0]); - if (ArrLod[0] != ArrLod[1]) - mem_del(ArrLod[1]); + mem_del(m_aLods[0]); + if (m_aLods[0] != m_aLods[1]) + mem_del(m_aLods[1]); - if (ArrLod[0] != ArrLod[2] && ArrLod[1] != ArrLod[2]) - mem_del(ArrLod[2]); + if (m_aLods[0] != m_aLods[2] && m_aLods[1] != m_aLods[2]) + mem_del(m_aLods[2]); } -Green::Segment::Segment() +CGreen::CSegment::CSegment() { for (int i = 0; i < GREEN_COUNT_TYPE_SEGMENTATION; ++i) - Splits[i] = 0; + m_aSplits[i] = 0; - Data = 0; - CountAllGreen = 0; - BoundVolumeSys = 0; - BoundVolumeP = 0; - Id = -1; - BFNonEnd = false; + m_pObjData = 0; + m_iCountObj = 0; + m_pBoundVolumeSys = 0; + m_pBoundVolumeP = 0; + m_fDistForCamera = 0; + m_id = -1; + m_idNonEnd = false; } -Green::Segment::~Segment() +CGreen::CSegment::~CSegment() { for (int i = 0; i<GREEN_COUNT_TYPE_SEGMENTATION; i++) - mem_delete(Splits[i]); - mem_delete_a(Data); + mem_delete(m_aSplits[i]); + mem_delete_a(m_pObjData); - mem_release_del(BoundVolumeSys); - mem_release_del(BoundVolumeP); + mem_release_del(m_pBoundVolumeSys); + mem_release_del(m_pBoundVolumeP); } -Green::Lod::Lod() +CGreen::CLod::CLod() { - model = 0; + m_pModel = 0; } -Green::Lod::~Lod() +CGreen::CLod::~CLod() { - idstex.clear(); - mem_release_del(model); + m_aIDsTextures.clear(); + mem_release_del(m_pModel); } -Green::InfoRenderSegments::InfoRenderSegments() +CGreen::CInfoRenderSegments::CInfoRenderSegments() { - Arr = 0; Count = 0; CountCom = 0; + m_ppSegments = 0; m_iCount = 0; m_iCountCom = 0; } -Green::InfoRenderSegments::~InfoRenderSegments() +CGreen::CInfoRenderSegments::~CInfoRenderSegments() { - mem_delete_a(Arr); + mem_delete_a(m_ppSegments); } -Green::IRSData::IRSData() +CGreen::CIRSData::CIRSData() { } -Green::IRSData::~IRSData() +CGreen::CIRSData::~CIRSData() { - queue.clear(); + m_aQueue.clear(); - for (int i = 0; i < arr.size(); ++i) + for (int i = 0; i < m_aIRS.size(); ++i) { - mem_delete(arr[i]); + mem_delete(m_aIRS[i]); } - arr.clear(); + m_aIRS.clear(); } -void Green::OnLostDevice() +void CGreen::onLostDevice() { - mem_release_del(TransVertBuf); + mem_release_del(m_pTransVertBuf); } -void Green::OnResetDevice() +void CGreen::onResetDevice() { - Green::DXDevice->CreateVertexBuffer( - GREEN_MAX_ELEM_IN_DIP * sizeof(GreenDataVertex), + CGreen::m_pDXDevice->CreateVertexBuffer( + GREEN_MAX_ELEM_IN_DIP * sizeof(CGreenDataVertex), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, - &TransVertBuf, + &m_pTransVertBuf, 0); } -void Green::PreSegmentation(Model* model, float3* min_level, float3* max_level) +void CGreen::preSegmentation(CModel* model, float3* min_level, float3* max_level) { - model->SplitsTree = new Segment(); + model->m_pSplitsTree = new CSegment(); float3 tmpMin, tmpMax; float3 tmpMin2, tmpMax2; - model->SplitsTree->BoundVolumeSys = SGCore_CrBound(); - SGCore_FCompBoundBox(model->ArrLod[0]->model->m_pVertexBuffer, &(model->SplitsTree->BoundVolumeSys), model->ArrLod[0]->model->m_uiAllVertexCount, sizeof(vertex_static)); + model->m_pSplitsTree->m_pBoundVolumeSys = SGCore_CrBound(); + SGCore_FCompBoundBox(model->m_aLods[0]->m_pModel->m_pVertexBuffer, &(model->m_pSplitsTree->m_pBoundVolumeSys), model->m_aLods[0]->m_pModel->m_uiAllVertexCount, sizeof(vertex_static)); - model->SplitsTree->BoundVolumeSys->getMinMax(&tmpMin2, &tmpMax2); - model->BBMax = tmpMax2 * (1.f + GREEN_GEN_RAND_SCALE); - model->BBMin = tmpMin2 * (1.f + GREEN_GEN_RAND_SCALE); + model->m_pSplitsTree->m_pBoundVolumeSys->getMinMax(&tmpMin2, &tmpMax2); + model->m_vMax = tmpMax2 * (1.f + GREEN_GEN_RAND_SCALE); + model->m_vMin = tmpMin2 * (1.f + GREEN_GEN_RAND_SCALE); tmpMin = *min_level; tmpMax = *max_level; - tmpMax.x += model->BBMax.x; - tmpMax.y += model->BBMax.y; - tmpMax.z += model->BBMax.z; + tmpMax.x += model->m_vMax.x; + tmpMax.y += model->m_vMax.y; + tmpMax.z += model->m_vMax.z; - tmpMin.x += model->BBMin.x; - tmpMin.y += model->BBMin.y; - tmpMin.z += model->BBMin.z; + tmpMin.x += model->m_vMin.x; + tmpMin.y += model->m_vMin.y; + tmpMin.z += model->m_vMin.z; float tmpX = tmpMax.x - tmpMin.x; float tmpY = tmpMax.y - tmpMin.y; float tmpZ = tmpMax.z - tmpMin.z; - model->SplitsTree->BoundVolumeP = SGCore_CrBound(); - model->SplitsTree->BoundVolumeP->setMinMax(&tmpMin, &tmpMax); + model->m_pSplitsTree->m_pBoundVolumeP = SGCore_CrBound(); + model->m_pSplitsTree->m_pBoundVolumeP->setMinMax(&tmpMin, &tmpMax); //выравниваем по квадрату if (tmpX > tmpZ) @@ -223,27 +229,27 @@ void Green::PreSegmentation(Model* model, float3* min_level, float3* max_level) tmpMin.x -= tmpX; } - model->SplitsTree->BoundVolumeSys->setMinMax(&tmpMin, &tmpMax); + model->m_pSplitsTree->m_pBoundVolumeSys->setMinMax(&tmpMin, &tmpMax); - model->SplitsTree->CountAllGreen = model->AllCountGreen; - if (model->AllCountGreen > 0) + model->m_pSplitsTree->m_iCountObj = model->m_uiCountObj; + if (model->m_uiCountObj > 0) { - model->SplitsTree->Data = new GreenDataVertex[model->AllCountGreen]; - memcpy(model->SplitsTree->Data, model->AllTrans, sizeof(GreenDataVertex)* model->AllCountGreen); + model->m_pSplitsTree->m_pObjData = new CGreenDataVertex[model->m_uiCountObj]; + memcpy(model->m_pSplitsTree->m_pObjData, model->m_pAllTrans, sizeof(CGreenDataVertex)* model->m_uiCountObj); } - if (model->SplitsTree->CountAllGreen > 0) - model->SplitsTree->BFNonEnd = true; + if (model->m_pSplitsTree->m_iCountObj > 0) + model->m_pSplitsTree->m_idNonEnd = true; else - model->SplitsTree->BFNonEnd = false; + model->m_pSplitsTree->m_idNonEnd = false; - CycleSegmentation(model->SplitsTree, model); + cycleSegmentation(model->m_pSplitsTree, model); } -void Green::CycleSegmentation(Segment* Split, Model* mesh) +void CGreen::cycleSegmentation(CSegment* Split, CModel* mesh) { - Array<Segment*> queue; - long tmpcount = 0; + Array<CSegment*> queue; + int tmpcount = 0; queue.push_back(Split); float width = 0; float depth = 0; @@ -251,51 +257,51 @@ void Green::CycleSegmentation(Segment* Split, Model* mesh) while (queue.size()) { - queue[0]->BoundVolumeSys->getMinMax(&min, &max); + queue[0]->m_pBoundVolumeSys->getMinMax(&min, &max); if ((max.x - min.x)*0.5f > GREEN_BB_MIN_X && (max.z - min.z)*0.5f > GREEN_BB_MIN_Z) { - Segmentation(queue[0], mesh); + segmentation(queue[0], mesh); for (int i = 0; i < GREEN_COUNT_TYPE_SEGMENTATION; i++) { - if (queue[0]->Splits[i]) - queue.push_back(queue[0]->Splits[i]); + if (queue[0]->m_aSplits[i]) + queue.push_back(queue[0]->m_aSplits[i]); } } else - queue[0]->BFNonEnd = false; + queue[0]->m_idNonEnd = false; queue.erase(0); ++tmpcount; } } -void Green::Segmentation(Segment* Split, Model* mesh) +void CGreen::segmentation(CSegment* Split, CModel* mesh) { Array<DWORD> ArrPoly[4]; for (int i = 0; i<4; i++) - Split->Splits[i] = new Segment(); + Split->m_aSplits[i] = new CSegment(); ISXBound* ArrBound[4]; for (int i = 0; i < 4; ++i) ArrBound[i] = SGCore_CrBound(); - SGCore_0ComBoundBoxArr4(Split->BoundVolumeSys, (ArrBound)); + SGCore_0ComBoundBoxArr4(Split->m_pBoundVolumeSys, (ArrBound)); float3 tmpmin, tmpmax; for (int i = 0; i<4; ++i) { - Split->Splits[i]->BoundVolumeSys = ArrBound[i]; - Split->Splits[i]->BoundVolumeSys->getMinMax(&tmpmin, &tmpmax); - Split->Splits[i]->BoundVolumeP = SGCore_CrBound(); - Split->Splits[i]->BoundVolumeP->setMinMax(&tmpmin, &tmpmax); + Split->m_aSplits[i]->m_pBoundVolumeSys = ArrBound[i]; + Split->m_aSplits[i]->m_pBoundVolumeSys->getMinMax(&tmpmin, &tmpmax); + Split->m_aSplits[i]->m_pBoundVolumeP = SGCore_CrBound(); + Split->m_aSplits[i]->m_pBoundVolumeP->setMinMax(&tmpmin, &tmpmax); } bool *tmp_arr_mesh_poly = 0; - if (Split->CountAllGreen) + if (Split->m_iCountObj) { - tmp_arr_mesh_poly = new bool[Split->CountAllGreen]; - for (int i = 0; i < Split->CountAllGreen; i++) + tmp_arr_mesh_poly = new bool[Split->m_iCountObj]; + for (int i = 0; i < Split->m_iCountObj; i++) tmp_arr_mesh_poly[i] = true; } @@ -303,16 +309,16 @@ void Green::Segmentation(Segment* Split, Model* mesh) float3 tmpMin, tmpMax; for (WORD i = 0; i<4; ++i) { - Split->Splits[i]->BoundVolumeSys->getMinMax(&tmpMin, &tmpMax); - //SGCore_FCreateBoundingBoxMesh(&tmpMin, &tmpMax, &(Split->Splits[i]->BoundBox)); + Split->m_aSplits[i]->m_pBoundVolumeSys->getMinMax(&tmpMin, &tmpMax); + //SGCore_FCreateBoundingBoxMesh(&tmpMin, &tmpMax, &(Split->m_aSplits[i]->BoundBox)); - for (DWORD j = 0; j<Split->CountAllGreen; ++j) + for (DWORD j = 0; j<Split->m_iCountObj; ++j) { //если позици¤ провер¤емого полигона находитьс¤ в пределах ограничивающего паралелепипеда if ( - (long(tmpMax.x * 1000) >= long(Split->Data[j].m_vPosition.x * 1000) && long(tmpMin.x * 1000) <= long(Split->Data[j].m_vPosition.x * 1000)) + (int(tmpMax.x * 1000) >= int(Split->m_pObjData[j].m_vPosition.x * 1000) && int(tmpMin.x * 1000) <= int(Split->m_pObjData[j].m_vPosition.x * 1000)) && - (long(tmpMax.z * 1000) >= long(Split->Data[j].m_vPosition.z * 1000) && long(tmpMin.z * 1000) <= long(Split->Data[j].m_vPosition.z * 1000)) + (int(tmpMax.z * 1000) >= int(Split->m_pObjData[j].m_vPosition.z * 1000) && int(tmpMin.z * 1000) <= int(Split->m_pObjData[j].m_vPosition.z * 1000)) && tmp_arr_mesh_poly[j] ) @@ -328,137 +334,137 @@ void Green::Segmentation(Segment* Split, Model* mesh) for (int i = 0; i<4; i++) { - Split->Splits[i]->CountAllGreen = ArrPoly[i].size(); + Split->m_aSplits[i]->m_iCountObj = ArrPoly[i].size(); - if (Split->Splits[i]->CountAllGreen > 0) + if (Split->m_aSplits[i]->m_iCountObj > 0) { - Split->Splits[i]->Data = new GreenDataVertex[Split->Splits[i]->CountAllGreen]; + Split->m_aSplits[i]->m_pObjData = new CGreenDataVertex[Split->m_aSplits[i]->m_iCountObj]; for (DWORD k = 0; k < ArrPoly[i].size(); k++) { - Split->Splits[i]->Data[k] = Split->Data[ArrPoly[i][k]]; + Split->m_aSplits[i]->m_pObjData[k] = Split->m_pObjData[ArrPoly[i][k]]; } - AlignBound(mesh, Split->Splits[i]); + alignBound(mesh, Split->m_aSplits[i]); ArrPoly[i].clear(); } - if (Split->Splits[i]->CountAllGreen > 0) - Split->Splits[i]->BFNonEnd = true; + if (Split->m_aSplits[i]->m_iCountObj > 0) + Split->m_aSplits[i]->m_idNonEnd = true; else { - Split->Splits[i]->BFNonEnd = false; + Split->m_aSplits[i]->m_idNonEnd = false; } } - mem_delete_a(Split->Data); + mem_delete_a(Split->m_pObjData); mem_delete_a(tmp_arr_mesh_poly); } -void Green::AlignBound(Model* model, Segment* split) +void CGreen::alignBound(CModel* model, CSegment* split) { - if (split->CountAllGreen > 0) + if (split->m_iCountObj > 0) { - float3 comMax = split->Data[0].m_vPosition; - float3 comMin = split->Data[0].m_vPosition; + float3 comMax = split->m_pObjData[0].m_vPosition; + float3 comMin = split->m_pObjData[0].m_vPosition; - for (int k = 0; k<split->CountAllGreen; ++k) + for (int k = 0; k<split->m_iCountObj; ++k) { - if (split->Data[k].m_vPosition.y > comMax.y) - comMax.y = split->Data[k].m_vPosition.y; + if (split->m_pObjData[k].m_vPosition.y > comMax.y) + comMax.y = split->m_pObjData[k].m_vPosition.y; - if (split->Data[k].m_vPosition.y < comMin.y) - comMin.y = split->Data[k].m_vPosition.y; + if (split->m_pObjData[k].m_vPosition.y < comMin.y) + comMin.y = split->m_pObjData[k].m_vPosition.y; - if (split->Data[k].m_vPosition.x > comMax.x) - comMax.x = split->Data[k].m_vPosition.x; + if (split->m_pObjData[k].m_vPosition.x > comMax.x) + comMax.x = split->m_pObjData[k].m_vPosition.x; - if (split->Data[k].m_vPosition.x < comMin.x) - comMin.x = split->Data[k].m_vPosition.x; + if (split->m_pObjData[k].m_vPosition.x < comMin.x) + comMin.x = split->m_pObjData[k].m_vPosition.x; - if (split->Data[k].m_vPosition.z > comMax.z) - comMax.z = split->Data[k].m_vPosition.z; + if (split->m_pObjData[k].m_vPosition.z > comMax.z) + comMax.z = split->m_pObjData[k].m_vPosition.z; - if (split->Data[k].m_vPosition.z < comMin.z) - comMin.z = split->Data[k].m_vPosition.z; + if (split->m_pObjData[k].m_vPosition.z < comMin.z) + comMin.z = split->m_pObjData[k].m_vPosition.z; } float3 tmpMin, tmpMax; float scalecoef = 1.f + GREEN_GEN_RAND_SCALE; - split->BoundVolumeSys->getMinMax(&tmpMin, &tmpMax); - tmpMax.y = comMax.y + model->BBMax.y * scalecoef; - tmpMin.y = comMin.y + model->BBMin.y * scalecoef; + split->m_pBoundVolumeSys->getMinMax(&tmpMin, &tmpMax); + tmpMax.y = comMax.y + model->m_vMax.y * scalecoef; + tmpMin.y = comMin.y + model->m_vMin.y * scalecoef; - split->BoundVolumeSys->setMinMax(&tmpMin, &tmpMax); + split->m_pBoundVolumeSys->setMinMax(&tmpMin, &tmpMax); - tmpMax.x = comMax.x + model->BBMax.x * scalecoef; - tmpMax.y = comMax.y + model->BBMax.y * scalecoef; - tmpMax.z = comMax.z + model->BBMax.z * scalecoef; + tmpMax.x = comMax.x + model->m_vMax.x * scalecoef; + tmpMax.y = comMax.y + model->m_vMax.y * scalecoef; + tmpMax.z = comMax.z + model->m_vMax.z * scalecoef; - tmpMin.x = comMin.x + model->BBMin.x * scalecoef; - tmpMin.y = comMin.y + model->BBMin.y * scalecoef; - tmpMin.z = comMin.z + model->BBMin.z * scalecoef; + tmpMin.x = comMin.x + model->m_vMin.x * scalecoef; + tmpMin.y = comMin.y + model->m_vMin.y * scalecoef; + tmpMin.z = comMin.z + model->m_vMin.z * scalecoef; - split->BoundVolumeP->setMinMax(&tmpMin, &tmpMax); + split->m_pBoundVolumeP->setMinMax(&tmpMin, &tmpMax); } } -void Green::SetSplitID(Model* model) +void CGreen::setSplitID(CModel* model) { - Array<Segment*, GREEN_DEFAULT_RESERVE_COM> queue; - long tmpcount = 0; - queue.push_back(model->SplitsTree); + Array<CSegment*, GREEN_DEFAULT_RESERVE_COM> queue; + int tmpcount = 0; + queue.push_back(model->m_pSplitsTree); while (queue.size()) { - SetSplitID2(model, queue[0], &queue); + setSplitID2(model, queue[0], &queue); queue.erase(0); ++tmpcount; } } -void Green::SetSplitID2(Model* model, Segment* Split, Array<Segment*, GREEN_DEFAULT_RESERVE_COM>* queue) +void CGreen::setSplitID2(CModel* model, CSegment* Split, Array<CSegment*, GREEN_DEFAULT_RESERVE_COM>* queue) { if (Split) { - Split->Id = model->SplitsIDs; - model->SplitsArr[Split->Id] = Split; - ++(model->SplitsIDs); + Split->m_id = model->m_idCountSplits; + model->m_aSplitsArr[Split->m_id] = Split; + ++(model->m_idCountSplits); for (int i = 0; i < 4; i++) { - if (Split->Splits[i]) - queue->push_back(Split->Splits[i]); + if (Split->m_aSplits[i]) + queue->push_back(Split->m_aSplits[i]); } } } -void Green::CPUFillingArrIndeces(const ISXFrustum* frustum, float3* viewpos, ID id_arr) +void CGreen::comArrIndeces(const ISXFrustum* frustum, const float3* viewpos, ID id_arr) { GREEN_PRECOND_ARRCOMFOR_ERR_ID(id_arr); - DWORD tmpcount = 0; - DWORD* tmpcountcom = 0; - Segment** tmpsegments = 0; - for (int i = 0; i < ArrModels.size(); ++i) + int tmpcount = 0; + int* tmpcountcom = 0; + CSegment** tmpsegments = 0; + for (int i = 0; i < m_aGreens.size(); ++i) { - tmpcount = ArrComFor[id_arr]->arr[i]->Count; - ArrComFor[id_arr]->arr[i]->CountCom = 0; - tmpcountcom = &(ArrComFor[id_arr]->arr[i]->CountCom); - tmpsegments = ArrComFor[id_arr]->arr[i]->Arr; + tmpcount = m_aArrComFor[id_arr]->m_aIRS[i]->m_iCount; + m_aArrComFor[id_arr]->m_aIRS[i]->m_iCountCom = 0; + tmpcountcom = &(m_aArrComFor[id_arr]->m_aIRS[i]->m_iCountCom); + tmpsegments = m_aArrComFor[id_arr]->m_aIRS[i]->m_ppSegments; - ArrComFor[id_arr]->queue.clearFast(); - //long tmpcount = 0; - ArrComFor[id_arr]->queue.push_back(ArrModels[i]->SplitsTree); + m_aArrComFor[id_arr]->m_aQueue.clearFast(); + //int tmpcount = 0; + m_aArrComFor[id_arr]->m_aQueue.push_back(m_aGreens[i]->m_pSplitsTree); - while (ArrComFor[id_arr]->queue.size()) + while (m_aArrComFor[id_arr]->m_aQueue.size()) { - ComRecArrIndeces(frustum, tmpsegments, tmpcountcom, ArrComFor[id_arr]->queue[0], viewpos, &ArrComFor[id_arr]->queue, tmpcount); + comRecArrIndeces(frustum, tmpsegments, tmpcountcom, m_aArrComFor[id_arr]->m_aQueue[0], viewpos, &m_aArrComFor[id_arr]->m_aQueue, tmpcount); - ArrComFor[id_arr]->queue.erase(0); + m_aArrComFor[id_arr]->m_aQueue.erase(0); //++tmpcount; } } @@ -466,26 +472,26 @@ void Green::CPUFillingArrIndeces(const ISXFrustum* frustum, float3* viewpos, ID int qwert = 0; } -void Green::ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits, DWORD *count, Segment* comsegment, float3* viewpos, Array<Segment*, GREEN_DEFAULT_RESERVE_COM>* queue, ID curr_splits_ids_render) +void CGreen::comRecArrIndeces(const ISXFrustum* frustum, CSegment** arrsplits, int *count, CSegment* comsegment, const float3* viewpos, Array<CSegment*, GREEN_DEFAULT_RESERVE_COM>* queue, ID curr_splits_ids_render) { float3 jcenter; float jradius; ID SortId[GREEN_COUNT_TYPE_SEGMENTATION]; - comsegment->BoundVolumeP->getSphere(&jcenter, &jradius); + comsegment->m_pBoundVolumeP->getSphere(&jcenter, &jradius); - if (comsegment->CountAllGreen > 0 && frustum->sphereInFrustum(&jcenter, jradius)) + if (comsegment->m_iCountObj > 0 && frustum->sphereInFrustum(&jcenter, jradius)) { - if (comsegment->BFNonEnd) + if (comsegment->m_idNonEnd) { - if (Green::UseSortFrontToBackSplits) + if (CGreen::m_isUseSortFrontToBackSplits) { for (int q = 0; q<GREEN_COUNT_TYPE_SEGMENTATION; ++q) { SortId[q] = -1; - if (comsegment->Splits[q]) + if (comsegment->m_aSplits[q]) { - comsegment->Splits[q]->BoundVolumeP->getSphere(&jcenter, &jradius); - comsegment->Splits[q]->DistForCamera = SMVector3Length2((jcenter - (*viewpos))) - jradius*jradius; + comsegment->m_aSplits[q]->m_pBoundVolumeP->getSphere(&jcenter, &jradius); + comsegment->m_aSplits[q]->m_fDistForCamera = SMVector3Length2((jcenter - (*viewpos))) - jradius*jradius; } } @@ -493,16 +499,16 @@ void Green::ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits, DWO int tmpCountGreater = 0; for (int i = 0; i<GREEN_COUNT_TYPE_SEGMENTATION; ++i) { - if (comsegment->Splits[i]) + if (comsegment->m_aSplits[i]) { tmpCountGreater = 0; - pl1 = comsegment->Splits[i]->DistForCamera; + pl1 = comsegment->m_aSplits[i]->m_fDistForCamera; for (int k = 0; k<GREEN_COUNT_TYPE_SEGMENTATION; ++k) { - if (comsegment->Splits[k]) + if (comsegment->m_aSplits[k]) { - pl2 = comsegment->Splits[k]->DistForCamera; + pl2 = comsegment->m_aSplits[k]->m_fDistForCamera; if (i != k && pl2 >= pl1) ++tmpCountGreater; @@ -525,149 +531,149 @@ void Green::ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits, DWO for (int j = 0; j<GREEN_COUNT_TYPE_SEGMENTATION; ++j) { - if (SortId[(GREEN_COUNT_TYPE_SEGMENTATION - 1) - j] != -1 && comsegment->Splits[SortId[(GREEN_COUNT_TYPE_SEGMENTATION-1) - j]]) - queue->push_back(comsegment->Splits[SortId[(GREEN_COUNT_TYPE_SEGMENTATION-1) - j]]); + if (SortId[(GREEN_COUNT_TYPE_SEGMENTATION - 1) - j] != -1 && comsegment->m_aSplits[SortId[(GREEN_COUNT_TYPE_SEGMENTATION-1) - j]]) + queue->push_back(comsegment->m_aSplits[SortId[(GREEN_COUNT_TYPE_SEGMENTATION-1) - j]]); } } else { for (int j = 0; j < GREEN_COUNT_TYPE_SEGMENTATION; ++j) { - if (comsegment->Splits[j]) - queue->push_back(comsegment->Splits[j]); + if (comsegment->m_aSplits[j]) + queue->push_back(comsegment->m_aSplits[j]); } } } else { - if ((*count) < curr_splits_ids_render && comsegment->Data) + if ((*count) < curr_splits_ids_render && comsegment->m_pObjData) { arrsplits[(*count)] = comsegment; - comsegment->DistForCamera = 0;// SMVector3Length((jcenter - (*viewpos))) - jradius; + comsegment->m_fDistForCamera = 0;// SMVector3Length((jcenter - (*viewpos))) - jradius; (*count)++; } } } } -void Green::GPURender2(DWORD timeDelta, float3* viewpos, ID nm, int lod, ID id_tex) +void CGreen::render2(DWORD timeDelta, const float3* viewpos, ID nm, int lod, ID id_tex) { //если есть что к отрисовке - if (RTCountDrawObj) + if (m_iCurrCountDrawObj) { - Green::DXDevice->SetStreamSourceFreq(0, (D3DSTREAMSOURCE_INDEXEDDATA | RTCountDrawObj)); + CGreen::m_pDXDevice->SetStreamSourceFreq(0, (D3DSTREAMSOURCE_INDEXEDDATA | m_iCurrCountDrawObj)); - Green::DXDevice->SetStreamSourceFreq(1, (D3DSTREAMSOURCE_INSTANCEDATA | 1)); - Green::DXDevice->SetStreamSource(1, TransVertBuf, 0, sizeof(GreenDataVertex)); + CGreen::m_pDXDevice->SetStreamSourceFreq(1, (D3DSTREAMSOURCE_INSTANCEDATA | 1)); + CGreen::m_pDXDevice->SetStreamSource(1, m_pTransVertBuf, 0, sizeof(CGreenDataVertex)); - Green::DXDevice->SetStreamSource(0, ArrModels[nm]->ArrLod[lod]->model->m_pVertexBuffer, 0, sizeof(vertex_static)); - Green::DXDevice->SetIndices(ArrModels[nm]->ArrLod[lod]->model->m_pIndexBuffer); - Green::DXDevice->SetVertexDeclaration(VertexDeclarationGreen); + CGreen::m_pDXDevice->SetStreamSource(0, m_aGreens[nm]->m_aLods[lod]->m_pModel->m_pVertexBuffer, 0, sizeof(vertex_static)); + CGreen::m_pDXDevice->SetIndices(m_aGreens[nm]->m_aLods[lod]->m_pModel->m_pIndexBuffer); + CGreen::m_pDXDevice->SetVertexDeclaration(m_pVertexDeclarationGreen); - jCountIndex = 0; - for (DWORD i = 0; i < ArrModels[nm]->ArrLod[lod]->model->m_uiSubsetCount; i++) + int iCountIndex = 0; + for (DWORD i = 0; i < m_aGreens[nm]->m_aLods[lod]->m_pModel->m_uiSubsetCount; i++) { - SGCore_MtlSet((id_tex > 0 ? id_tex : ArrModels[nm]->ArrLod[lod]->idstex[i]), 0); + SGCore_MtlSet((id_tex > 0 ? id_tex : m_aGreens[nm]->m_aLods[lod]->m_aIDsTextures[i]), 0); - if (ArrModels[nm]->TypeGreen == GREEN_TYPE_GRASS) - Green::DXDevice->SetVertexShaderConstantF(59, (float*)&float2_t(Green::BeginEndLessening, Green::DistLods.x), 1); - else - Green::DXDevice->SetVertexShaderConstantF(59, (float*)&float2_t(0,0), 1); + if (m_aGreens[nm]->m_typeGreen == GREEN_TYPE_GRASS) + CGreen::m_pDXDevice->SetVertexShaderConstantF(59, (float*)&float2_t(CGreen::m_fDistGrassLessening, CGreen::m_vDistLods.x), 1); + else + CGreen::m_pDXDevice->SetVertexShaderConstantF(59, (float*)&float2_t(0,0), 1); - Green::DXDevice->SetVertexShaderConstantF(60, (float*)viewpos, 1); - Green::DXDevice->SetVertexShaderConstantF(61, (float*)&(ArrModels[nm]->ArrLod[lod]->model->m_vBSphere), 1); - Green::DXDevice->SetVertexShaderConstantF(62, (float*)&(ArrModels[nm]->ArrLod[lod]->model->m_vBBMax), 1); - Green::DXDevice->SetVertexShaderConstantF(63, (float*)&(ArrModels[nm]->ArrLod[lod]->model->m_vBBMin), 1); + CGreen::m_pDXDevice->SetVertexShaderConstantF(60, (float*)viewpos, 1); + CGreen::m_pDXDevice->SetVertexShaderConstantF(61, (float*)&(m_aGreens[nm]->m_aLods[lod]->m_pModel->m_vBSphere), 1); + CGreen::m_pDXDevice->SetVertexShaderConstantF(62, (float*)&(m_aGreens[nm]->m_aLods[lod]->m_pModel->m_vBBMax), 1); + CGreen::m_pDXDevice->SetVertexShaderConstantF(63, (float*)&(m_aGreens[nm]->m_aLods[lod]->m_pModel->m_vBBMin), 1); - SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, ArrModels[nm]->ArrLod[lod]->model->m_pVertexCount[i], jCountIndex, ArrModels[nm]->ArrLod[lod]->model->m_pIndexCount[i] / 3); - Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + ((ArrModels[nm]->ArrLod[lod]->model->m_pIndexCount[i] / 3) * RTCountDrawObj)); - jCountIndex += ArrModels[nm]->ArrLod[lod]->model->m_pIndexCount[i]; + SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, m_aGreens[nm]->m_aLods[lod]->m_pModel->m_pVertexCount[i], iCountIndex, m_aGreens[nm]->m_aLods[lod]->m_pModel->m_pIndexCount[i] / 3); + Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + ((m_aGreens[nm]->m_aLods[lod]->m_pModel->m_pIndexCount[i] / 3) * m_iCurrCountDrawObj)); + iCountIndex += m_aGreens[nm]->m_aLods[lod]->m_pModel->m_pIndexCount[i]; } - Green::DXDevice->SetStreamSourceFreq(0, 1); - Green::DXDevice->SetStreamSourceFreq(1, 1); + CGreen::m_pDXDevice->SetStreamSourceFreq(0, 1); + CGreen::m_pDXDevice->SetStreamSourceFreq(1, 1); } } -void Green::GPURender(DWORD timeDelta, float3* viewpos, GREEN_TYPE type, ID id_arr) +void CGreen::render(DWORD timeDelta, const float3* viewpos, GREEN_TYPE type, ID id_arr) { GREEN_PRECOND_ARRCOMFOR_ERR_ID(id_arr); float3 jcenter; float jradius; - for (int nm = 0; nm < ArrModels.size(); ++nm) + for (int nm = 0; nm < m_aGreens.size(); ++nm) { //если тип не указан - if (type != GREEN_TYPE_ALL && type != ArrModels[nm]->TypeGreen) + if (type != GREEN_TYPE_ALL && type != m_aGreens[nm]->m_typeGreen) continue; - jarrsplits = ArrComFor[id_arr]->arr[nm]->Arr; - jcount = ArrComFor[id_arr]->arr[nm]->CountCom; + CSegment **ppArrSplits = m_aArrComFor[id_arr]->m_aIRS[nm]->m_ppSegments; + int iCount = m_aArrComFor[id_arr]->m_aIRS[nm]->m_iCountCom; for (int lod = 0; lod < GREEN_COUNT_LOD; ++lod) { - if (ArrModels[nm]->ArrLod[lod]) + if (m_aGreens[nm]->m_aLods[lod]) { - RTGPUArrVerteces = 0; - TransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD); - RTCountDrawObj = 0; + CGreenDataVertex* RTGPUArrVerteces = 0; + m_pTransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD); + m_iCurrCountDrawObj = 0; - for (DWORD i = 0; i < jcount; i++) + for (DWORD i = 0; i < iCount; i++) { - if (RTCountDrawObj + jarrsplits[i]->CountAllGreen >= GREEN_MAX_ELEM_IN_DIP) + if (m_iCurrCountDrawObj + ppArrSplits[i]->m_iCountObj >= GREEN_MAX_ELEM_IN_DIP) { - TransVertBuf->Unlock(); - GPURender2(timeDelta, viewpos, nm, lod, -1); - TransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD); - RTCountDrawObj = 0; + m_pTransVertBuf->Unlock(); + render2(timeDelta, viewpos, nm, lod, -1); + m_pTransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD); + m_iCurrCountDrawObj = 0; } - jarrsplits[i]->BoundVolumeP->getSphere(&jcenter, &jradius); - jarrsplits[i]->DistForCamera = SMVector3Length((jcenter - (*viewpos))) - jradius; + ppArrSplits[i]->m_pBoundVolumeP->getSphere(&jcenter, &jradius); + ppArrSplits[i]->m_fDistForCamera = SMVector3Length((jcenter - (*viewpos))) - jradius; if ( //распределение по дистанции есесно и по лодам ( - (lod == 0 && jarrsplits[i]->DistForCamera <= Green::DistLods.x) || - (lod == 1 && jarrsplits[i]->DistForCamera <= Green::DistLods.y && jarrsplits[i]->DistForCamera > Green::DistLods.x) || - (lod == 2 && jarrsplits[i]->DistForCamera > Green::DistLods.y) + (lod == 0 && ppArrSplits[i]->m_fDistForCamera <= CGreen::m_vDistLods.x) || + (lod == 1 && ppArrSplits[i]->m_fDistForCamera <= CGreen::m_vDistLods.y && ppArrSplits[i]->m_fDistForCamera > CGreen::m_vDistLods.x) || + (lod == 2 && ppArrSplits[i]->m_fDistForCamera > CGreen::m_vDistLods.y) ) ) { //если это не трава - if (!(lod == 0 && ArrModels[nm]->TypeGreen == GREEN_TYPE_GRASS)) + if (!(lod == 0 && m_aGreens[nm]->m_typeGreen == GREEN_TYPE_GRASS)) { - memcpy(RTGPUArrVerteces + (RTCountDrawObj), - jarrsplits[i]->Data, - jarrsplits[i]->CountAllGreen * sizeof(GreenDataVertex)); + memcpy(RTGPUArrVerteces + (m_iCurrCountDrawObj), + ppArrSplits[i]->m_pObjData, + ppArrSplits[i]->m_iCountObj * sizeof(CGreenDataVertex)); - RTCountDrawObj += jarrsplits[i]->CountAllGreen; + m_iCurrCountDrawObj += ppArrSplits[i]->m_iCountObj; } //иначе это трава, а ее по особенному рисуем - else if (lod == 0 && ArrModels[nm]->TypeGreen == GREEN_TYPE_GRASS) + else if (lod == 0 && m_aGreens[nm]->m_typeGreen == GREEN_TYPE_GRASS) { - if (Green::CurrentFreqGrass >= 100) + if (CGreen::m_iRenderFreqGrass >= 100) { - memcpy(RTGPUArrVerteces + (RTCountDrawObj), - jarrsplits[i]->Data, - jarrsplits[i]->CountAllGreen * sizeof(GreenDataVertex)); + memcpy(RTGPUArrVerteces + (m_iCurrCountDrawObj), + ppArrSplits[i]->m_pObjData, + ppArrSplits[i]->m_iCountObj * sizeof(CGreenDataVertex)); - RTCountDrawObj += jarrsplits[i]->CountAllGreen; + m_iCurrCountDrawObj += ppArrSplits[i]->m_iCountObj; } else { - float percent = float(Green::CurrentFreqGrass) / 100.f; - float newCount = ((float)jarrsplits[i]->CountAllGreen * percent); - float step = float(jarrsplits[i]->CountAllGreen) / newCount; + float percent = float(CGreen::m_iRenderFreqGrass) / 100.f; + float newCount = ((float)ppArrSplits[i]->m_iCountObj * percent); + float step = float(ppArrSplits[i]->m_iCountObj) / newCount; UINT lastCP = 0; - for (float k = 0; k < jarrsplits[i]->CountAllGreen; k += step) + for (float k = 0; k < ppArrSplits[i]->m_iCountObj; k += step) { UINT curCP = (int)floor(k + 0.5);; if (curCP > lastCP) { - memcpy(RTGPUArrVerteces + RTCountDrawObj, jarrsplits[i]->Data + curCP, sizeof(GreenDataVertex)); - RTCountDrawObj += 1; + memcpy(RTGPUArrVerteces + m_iCurrCountDrawObj, ppArrSplits[i]->m_pObjData + curCP, sizeof(CGreenDataVertex)); + m_iCurrCountDrawObj += 1; lastCP = curCP; } } @@ -676,77 +682,77 @@ void Green::GPURender(DWORD timeDelta, float3* viewpos, GREEN_TYPE type, ID id_a } } - TransVertBuf->Unlock(); + m_pTransVertBuf->Unlock(); - GPURender2(timeDelta, viewpos, nm, lod, -1); + render2(timeDelta, viewpos, nm, lod, -1); } } } } -void Green::GPURenderSingly(DWORD timeDelta, float3* viewpos, ID id, ID id_tex) +void CGreen::renderSingly(DWORD timeDelta, const float3* viewpos, ID id, ID id_tex) { - if (ArrModels.size() <= id) + if (m_aGreens.size() <= id) return; float3 jcenter; float jradius; ID id_arr = 0; - jarrsplits = ArrComFor[id_arr]->arr[id]->Arr; - jcount = ArrComFor[id_arr]->arr[id]->CountCom; + CSegment **ppArrSplits = m_aArrComFor[id_arr]->m_aIRS[id]->m_ppSegments; + int iCount = m_aArrComFor[id_arr]->m_aIRS[id]->m_iCountCom; for (int lod = 0; lod < GREEN_COUNT_LOD; ++lod) { - if (ArrModels[id]->ArrLod[lod]) + if (m_aGreens[id]->m_aLods[lod]) { - RTGPUArrVerteces = 0; - TransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD); - RTCountDrawObj = 0; + CGreenDataVertex* RTGPUArrVerteces = 0; + m_pTransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD); + m_iCurrCountDrawObj = 0; - for (DWORD i = 0; i < jcount; i++) + for (int i = 0; i < iCount; i++) { - if (RTCountDrawObj + jarrsplits[i]->CountAllGreen >= GREEN_MAX_ELEM_IN_DIP) + if (m_iCurrCountDrawObj + ppArrSplits[i]->m_iCountObj >= GREEN_MAX_ELEM_IN_DIP) { - TransVertBuf->Unlock(); - GPURender2(timeDelta, viewpos, id, lod, id_tex); - TransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD); - RTCountDrawObj = 0; + m_pTransVertBuf->Unlock(); + render2(timeDelta, viewpos, id, lod, id_tex); + m_pTransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD); + m_iCurrCountDrawObj = 0; } - jarrsplits[i]->BoundVolumeP->getSphere(&jcenter, &jradius); - jarrsplits[i]->DistForCamera = SMVector3Length((jcenter - (*viewpos))) - jradius; + ppArrSplits[i]->m_pBoundVolumeP->getSphere(&jcenter, &jradius); + ppArrSplits[i]->m_fDistForCamera = SMVector3Length((jcenter - (*viewpos))) - jradius; if ( //распределение по дистанции есесно и по лодам ( - (lod == 0 && jarrsplits[i]->DistForCamera <= Green::DistLods.x) || - (lod == 1 && jarrsplits[i]->DistForCamera <= Green::DistLods.y && jarrsplits[i]->DistForCamera > Green::DistLods.x) || - (lod == 2 && jarrsplits[i]->DistForCamera > Green::DistLods.y) || !(ArrModels[id]->ArrLod[1]) + (lod == 0 && ppArrSplits[i]->m_fDistForCamera <= CGreen::m_vDistLods.x) || + (lod == 1 && ppArrSplits[i]->m_fDistForCamera <= CGreen::m_vDistLods.y && ppArrSplits[i]->m_fDistForCamera > CGreen::m_vDistLods.x) || + (lod == 2 && ppArrSplits[i]->m_fDistForCamera > CGreen::m_vDistLods.y) || !(m_aGreens[id]->m_aLods[1]) ) ) { - if (!(lod == 0 && ArrModels[id]->TypeGreen == GREEN_TYPE_GRASS)) + if (!(lod == 0 && m_aGreens[id]->m_typeGreen == GREEN_TYPE_GRASS)) { - memcpy(RTGPUArrVerteces + (RTCountDrawObj), - jarrsplits[i]->Data, - jarrsplits[i]->CountAllGreen * sizeof(GreenDataVertex)); + memcpy(RTGPUArrVerteces + (m_iCurrCountDrawObj), + ppArrSplits[i]->m_pObjData, + ppArrSplits[i]->m_iCountObj * sizeof(CGreenDataVertex)); - RTCountDrawObj += jarrsplits[i]->CountAllGreen; + m_iCurrCountDrawObj += ppArrSplits[i]->m_iCountObj; } else { float percent = 0.1f; - float newCount = ((float)jarrsplits[i]->CountAllGreen * percent); - float step = float(jarrsplits[i]->CountAllGreen) / newCount; + float newCount = ((float)ppArrSplits[i]->m_iCountObj * percent); + float step = float(ppArrSplits[i]->m_iCountObj) / newCount; UINT lastCP = 0; - for (float k = 0; k < jarrsplits[i]->CountAllGreen; k += step) + for (float k = 0; k < ppArrSplits[i]->m_iCountObj; k += step) { UINT curCP = (int)floor(k + 0.5);; if (curCP > lastCP) { - memcpy(RTGPUArrVerteces + RTCountDrawObj, jarrsplits[i]->Data + curCP, sizeof(GreenDataVertex)); - RTCountDrawObj += 1; + memcpy(RTGPUArrVerteces + m_iCurrCountDrawObj, ppArrSplits[i]->m_pObjData + curCP, sizeof(CGreenDataVertex)); + m_iCurrCountDrawObj += 1; lastCP = curCP; } } @@ -754,74 +760,74 @@ void Green::GPURenderSingly(DWORD timeDelta, float3* viewpos, ID id, ID id_tex) } } - TransVertBuf->Unlock(); + m_pTransVertBuf->Unlock(); - GPURender2(timeDelta, viewpos, id, lod, id_tex); + render2(timeDelta, viewpos, id, lod, id_tex); } } } -void Green::GPURenderObject(DWORD timeDelta, float3* viewpos, ID id, ID split, ID idobj, ID id_tex) +void CGreen::renderObject(DWORD timeDelta, const float3* viewpos, ID id, ID split, ID idobj, ID id_tex) { - if (id < 0 || ArrModels.size() <= id || split < 0 || ArrModels[id]->SplitsArr.size() <= split || idobj < 0 || ArrModels[id]->SplitsArr[split]->CountAllGreen <= idobj) + if (id < 0 || m_aGreens.size() <= id || split < 0 || m_aGreens[id]->m_aSplitsArr.size() <= split || idobj < 0 || m_aGreens[id]->m_aSplitsArr[split]->m_iCountObj <= idobj) return; - RTGPUArrVerteces = 0; - TransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD); - memcpy(RTGPUArrVerteces, &(ArrModels[id]->SplitsArr[split]->Data[idobj]), sizeof(GreenDataVertex)); - TransVertBuf->Unlock(); - RTCountDrawObj = 1; + CGreenDataVertex* RTGPUArrVerteces = 0; + m_pTransVertBuf->Lock(0, 0, (void**)&RTGPUArrVerteces, D3DLOCK_DISCARD); + memcpy(RTGPUArrVerteces, &(m_aGreens[id]->m_aSplitsArr[split]->m_pObjData[idobj]), sizeof(CGreenDataVertex)); + m_pTransVertBuf->Unlock(); + m_iCurrCountDrawObj = 1; - GPURender2(timeDelta, viewpos, id, 0, id_tex); + render2(timeDelta, viewpos, id, 0, id_tex); } -ID Green::Init(StaticGeom* geom, const char* name, +ID CGreen::init(CStaticGeom* geom, const char* name, const char* path_mask, float count_max, const char* path, const char* lod1, const char* lod2, const char* navmesh) { - if (geom->GetCountModel() > 0 && def_str_validate(path)) + if (geom->getCountModel() > 0 && def_str_validate(path)) { - Model* tmpnewmpdel = new Model(); - sprintf(tmpnewmpdel->Name, name); - tmpnewmpdel->MaskName = path_mask; - tmpnewmpdel->ArrLod[0] = new Lod(); - tmpnewmpdel->ArrLod[1] = 0; - tmpnewmpdel->ArrLod[2] = 0; + CModel* tmpnewmpdel = new CModel(); + sprintf(tmpnewmpdel->m_szName, name); + tmpnewmpdel->m_szMaskName = path_mask; + tmpnewmpdel->m_aLods[0] = new CLod(); + tmpnewmpdel->m_aLods[1] = 0; + tmpnewmpdel->m_aLods[2] = 0; if (!lod1 && !lod2) - tmpnewmpdel->TypeGreen = GREEN_TYPE_GRASS; + tmpnewmpdel->m_typeGreen = GREEN_TYPE_GRASS; else - tmpnewmpdel->TypeGreen = GREEN_TYPE_TREE; + tmpnewmpdel->m_typeGreen = GREEN_TYPE_TREE; char tmppath[1024]; sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), path); - SGCore_StaticModelLoad(tmppath, &tmpnewmpdel->ArrLod[0]->model); - tmpnewmpdel->ArrLod[0]->path = path; + SGCore_StaticModelLoad(tmppath, &tmpnewmpdel->m_aLods[0]->m_pModel); + tmpnewmpdel->m_aLods[0]->m_sPath = path; char tmppathtex[1024]; - for (int i = 0; i < tmpnewmpdel->ArrLod[0]->model->m_uiSubsetCount; ++i) + for (int i = 0; i < tmpnewmpdel->m_aLods[0]->m_pModel->m_uiSubsetCount; ++i) { - sprintf(tmppathtex, "%s.dds", tmpnewmpdel->ArrLod[0]->model->m_ppTextures[i]); - tmpnewmpdel->ArrLod[0]->idstex[i] = SGCore_MtlLoad(tmppathtex, (tmpnewmpdel->TypeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS)); + sprintf(tmppathtex, "%s.dds", tmpnewmpdel->m_aLods[0]->m_pModel->m_ppTextures[i]); + tmpnewmpdel->m_aLods[0]->m_aIDsTextures[i] = SGCore_MtlLoad(tmppathtex, (tmpnewmpdel->m_typeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS)); } if (def_str_validate(lod1)) { if (stricmp(path, lod1) == 0) - tmpnewmpdel->ArrLod[1] = tmpnewmpdel->ArrLod[0]; + tmpnewmpdel->m_aLods[1] = tmpnewmpdel->m_aLods[0]; else { - tmpnewmpdel->ArrLod[1] = new Lod(); + tmpnewmpdel->m_aLods[1] = new CLod(); sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), lod1); - tmpnewmpdel->ArrLod[1]->path = lod1; - SGCore_StaticModelLoad(tmppath, &tmpnewmpdel->ArrLod[1]->model); + tmpnewmpdel->m_aLods[1]->m_sPath = lod1; + SGCore_StaticModelLoad(tmppath, &tmpnewmpdel->m_aLods[1]->m_pModel); - for (int i = 0; i < tmpnewmpdel->ArrLod[1]->model->m_uiSubsetCount; ++i) + for (int i = 0; i < tmpnewmpdel->m_aLods[1]->m_pModel->m_uiSubsetCount; ++i) { - sprintf(tmppathtex, "%s.dds", tmpnewmpdel->ArrLod[1]->model->m_ppTextures[i]); - tmpnewmpdel->ArrLod[1]->idstex[i] = SGCore_MtlLoad(tmppathtex, (tmpnewmpdel->TypeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS)); + sprintf(tmppathtex, "%s.dds", tmpnewmpdel->m_aLods[1]->m_pModel->m_ppTextures[i]); + tmpnewmpdel->m_aLods[1]->m_aIDsTextures[i] = SGCore_MtlLoad(tmppathtex, (tmpnewmpdel->m_typeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS)); } } } @@ -829,54 +835,54 @@ ID Green::Init(StaticGeom* geom, const char* name, if (def_str_validate(lod2)) { if (stricmp(path, lod2) == 0) - tmpnewmpdel->ArrLod[2] = tmpnewmpdel->ArrLod[0]; + tmpnewmpdel->m_aLods[2] = tmpnewmpdel->m_aLods[0]; else if (stricmp(lod1, lod2) == 0) - tmpnewmpdel->ArrLod[2] = tmpnewmpdel->ArrLod[1]; + tmpnewmpdel->m_aLods[2] = tmpnewmpdel->m_aLods[1]; else { - tmpnewmpdel->ArrLod[2] = new Lod(); + tmpnewmpdel->m_aLods[2] = new CLod(); sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), lod2); - tmpnewmpdel->ArrLod[2]->path = lod2; - SGCore_StaticModelLoad(tmppath, &tmpnewmpdel->ArrLod[2]->model); + tmpnewmpdel->m_aLods[2]->m_sPath = lod2; + SGCore_StaticModelLoad(tmppath, &tmpnewmpdel->m_aLods[2]->m_pModel); - for (int i = 0; i < tmpnewmpdel->ArrLod[2]->model->m_uiSubsetCount; ++i) + for (int i = 0; i < tmpnewmpdel->m_aLods[2]->m_pModel->m_uiSubsetCount; ++i) { - sprintf(tmppathtex, "%s.dds", tmpnewmpdel->ArrLod[1]->model->m_ppTextures[i]); - tmpnewmpdel->ArrLod[2]->idstex[i] = SGCore_MtlLoad(tmppathtex, (tmpnewmpdel->TypeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS)); + sprintf(tmppathtex, "%s.dds", tmpnewmpdel->m_aLods[1]->m_pModel->m_ppTextures[i]); + tmpnewmpdel->m_aLods[2]->m_aIDsTextures[i] = SGCore_MtlLoad(tmppathtex, (tmpnewmpdel->m_typeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS)); } } } ISXBound* tmpbb = SGCore_CrBound(); - SGCore_FCompBoundBox(tmpnewmpdel->ArrLod[0]->model->m_pVertexBuffer, &tmpbb, tmpnewmpdel->ArrLod[0]->model->m_uiAllVertexCount, sizeof(vertex_static)); + SGCore_FCompBoundBox(tmpnewmpdel->m_aLods[0]->m_pModel->m_pVertexBuffer, &tmpbb, tmpnewmpdel->m_aLods[0]->m_pModel->m_uiAllVertexCount, sizeof(vertex_static)); float3 mmax, mmin; tmpbb->getMinMax(&mmin, &mmax); mem_release(tmpbb); float3 tmpmin, tmpmax; - geom->GetMinMax(&tmpmin, &tmpmax); + geom->getMinMax(&tmpmin, &tmpmax); if (def_str_validate(path_mask)) { ID IDTexMask = SGCore_LoadTexAddName(path_mask, LOAD_TEXTURE_TYPE_LOAD); SGCore_LoadTexAllLoad(); - GenByTex(geom, tmpnewmpdel, IDTexMask, &mmin, &mmax, count_max); + genByTex(geom, tmpnewmpdel, IDTexMask, &mmin, &mmax, count_max); } - PreSegmentation(tmpnewmpdel, &tmpmin, &tmpmax); - mem_delete_a(tmpnewmpdel->AllTrans); + preSegmentation(tmpnewmpdel, &tmpmin, &tmpmax); + mem_delete_a(tmpnewmpdel->m_pAllTrans); - SetSplitID(tmpnewmpdel); + setSplitID(tmpnewmpdel); - ArrModels.push_back(tmpnewmpdel); + m_aGreens.push_back(tmpnewmpdel); if (def_str_validate(navmesh)) { - SetGreenNav(ArrModels.size() - 1, navmesh); + setGreenNav(m_aGreens.size() - 1, navmesh); } - AddModelInArrCom(ArrModels.size() - 1); - return ArrModels.size() - 1; + addModelInArrCom(m_aGreens.size() - 1); + return m_aGreens.size() - 1; } else { @@ -886,12 +892,12 @@ ID Green::Init(StaticGeom* geom, const char* name, return -1; } -void Green::GenByTex(StaticGeom* geom, Model* model, ID idmask, float3* min, float3* max, float count_max) +void CGreen::genByTex(CStaticGeom* geom, CModel* model, ID idmask, float3* min, float3* max, float count_max) { float CountMaxInPixel = count_max; float3 tmpmin, tmpmax; - geom->GetMinMax(&tmpmin, &tmpmax); + geom->getMinMax(&tmpmin, &tmpmax); float r2d = 0; @@ -955,7 +961,7 @@ void Green::GenByTex(StaticGeom* geom, Model* model, ID idmask, float3* min, flo tmppos2.x = (tmp2.x - OneEdX*0.5f) + randf(0.0, OneEdX); tmppos2.z = (tmp2.z - OneEdY*0.5f) + randf(0.0, OneEdY); - if (model->TypeGreen == GREEN_TYPE_TREE) + if (model->m_typeGreen == GREEN_TYPE_TREE) { for (int k = 0; k < arrpos.size(); ++k) { @@ -969,16 +975,16 @@ void Green::GenByTex(StaticGeom* geom, Model* model, ID idmask, float3* min, flo } if (isintersect) - isintersect = geom->GetIntersectedRayY(&tmppos2); + isintersect = geom->getIntersectedRayY(&tmppos2); if (isintersect) { arrpos.push_back(tmppos2); - ++model->AllCountGreen; + ++model->m_uiCountObj; //если тип дерево, то на пиксель генерируем только одно дерево - if (model->TypeGreen == GREEN_TYPE_TREE) + if (model->m_typeGreen == GREEN_TYPE_TREE) break; } else @@ -992,31 +998,31 @@ void Green::GenByTex(StaticGeom* geom, Model* model, ID idmask, float3* min, flo SGCore_LoadTexGetTex(idmask)->UnlockRect(0); - if (model->AllCountGreen <= 0) + if (model->m_uiCountObj <= 0) return; - model->AllTrans = new GreenDataVertex[model->AllCountGreen]; + model->m_pAllTrans = new CGreenDataVertex[model->m_uiCountObj]; - for (DWORD i = 0; i<model->AllCountGreen; i++) + for (DWORD i = 0; i<model->m_uiCountObj; i++) { - model->AllTrans[i].m_vPosition = arrpos[i]; - model->AllTrans[i].m_vTexCoord.x = 1.f + randf(0.f, GREEN_GEN_RAND_SCALE); - model->AllTrans[i].m_vTexCoord.y = randf(0.f, GREEN_GEN_RAND_ROTATE_Y); - model->AllTrans[i].m_vTexCoord.z = 0;// (float(rand() % 200) / 100.f) - 1.f; - model->AllTrans[i].m_vSinCosRot.x = sinf(model->AllTrans[i].m_vTexCoord.y); - model->AllTrans[i].m_vSinCosRot.y = cosf(model->AllTrans[i].m_vTexCoord.y); + model->m_pAllTrans[i].m_vPosition = arrpos[i]; + model->m_pAllTrans[i].m_vTexCoord.x = 1.f + randf(0.f, GREEN_GEN_RAND_SCALE); + model->m_pAllTrans[i].m_vTexCoord.y = randf(0.f, GREEN_GEN_RAND_ROTATE_Y); + model->m_pAllTrans[i].m_vTexCoord.z = 0;// (float(rand() % 200) / 100.f) - 1.f; + model->m_pAllTrans[i].m_vSinCosRot.x = sinf(model->m_pAllTrans[i].m_vTexCoord.y); + model->m_pAllTrans[i].m_vSinCosRot.y = cosf(model->m_pAllTrans[i].m_vTexCoord.y); } arrpos.clear(); } -ID Green::GetIDSplit(ID id, float3* pos) +ID CGreen::getIDSplit(ID id, float3* pos) { - if (id < 0 || ArrModels.size() <= id) + if (id < 0 || m_aGreens.size() <= id) return -1; - Array<Segment*> queue; - long tmpcount = 0; - queue.push_back(ArrModels[id]->SplitsTree); + Array<CSegment*> queue; + int tmpcount = 0; + queue.push_back(m_aGreens[id]->m_pSplitsTree); float width = 0; float depth = 0; float3 min, max; @@ -1024,47 +1030,47 @@ ID Green::GetIDSplit(ID id, float3* pos) while (queue.size()) { - queue[0]->BoundVolumeSys->getMinMax(&min, &max); + queue[0]->m_pBoundVolumeSys->getMinMax(&min, &max); if (max.x >= pos->x && max.z >= pos->z && min.x <= pos->x && min.z <= pos->z) { - if (!(queue[0]->Splits[0])) - tmpidsplit = queue[0]->Id; + if (!(queue[0]->m_aSplits[0])) + tmpidsplit = queue[0]->m_id; else { - queue[0]->BFNonEnd = true; - ++(queue[0]->CountAllGreen); + queue[0]->m_idNonEnd = true; + ++(queue[0]->m_iCountObj); float3 tmpMin, tmpMax; float scalecoef = 1.f + GREEN_GEN_RAND_SCALE; - queue[0]->BoundVolumeSys->getMinMax(&tmpMin, &tmpMax); - if (tmpMax.y < (pos->y + ArrModels[id]->BBMax.y * scalecoef)) - tmpMax.y = tmpMax.y + ArrModels[id]->BBMax.y * scalecoef; + queue[0]->m_pBoundVolumeSys->getMinMax(&tmpMin, &tmpMax); + if (tmpMax.y < (pos->y + m_aGreens[id]->m_vMax.y * scalecoef)) + tmpMax.y = tmpMax.y + m_aGreens[id]->m_vMax.y * scalecoef; - if (tmpMin.y >(pos->y + ArrModels[id]->BBMin.y * scalecoef)) - tmpMin.y = tmpMin.y + ArrModels[id]->BBMin.y * scalecoef; + if (tmpMin.y >(pos->y + m_aGreens[id]->m_vMin.y * scalecoef)) + tmpMin.y = tmpMin.y + m_aGreens[id]->m_vMin.y * scalecoef; - queue[0]->BoundVolumeSys->setMinMax(&tmpMin, &tmpMax); + queue[0]->m_pBoundVolumeSys->setMinMax(&tmpMin, &tmpMax); - if (tmpMax.x < (pos->x + ArrModels[id]->BBMax.x * scalecoef)) - tmpMax.x = tmpMax.x + ArrModels[id]->BBMax.x * scalecoef; + if (tmpMax.x < (pos->x + m_aGreens[id]->m_vMax.x * scalecoef)) + tmpMax.x = tmpMax.x + m_aGreens[id]->m_vMax.x * scalecoef; - if (tmpMax.z < (pos->z + ArrModels[id]->BBMax.z * scalecoef)) - tmpMax.z = tmpMax.z + ArrModels[id]->BBMax.z * scalecoef; + if (tmpMax.z < (pos->z + m_aGreens[id]->m_vMax.z * scalecoef)) + tmpMax.z = tmpMax.z + m_aGreens[id]->m_vMax.z * scalecoef; - if (tmpMin.x >(pos->x + ArrModels[id]->BBMin.x * scalecoef)) - tmpMin.x = tmpMin.x + ArrModels[id]->BBMin.x * scalecoef; + if (tmpMin.x >(pos->x + m_aGreens[id]->m_vMin.x * scalecoef)) + tmpMin.x = tmpMin.x + m_aGreens[id]->m_vMin.x * scalecoef; - if (tmpMin.z >(pos->z + ArrModels[id]->BBMin.z * scalecoef)) - tmpMin.z = tmpMin.z + ArrModels[id]->BBMin.z * scalecoef; + if (tmpMin.z >(pos->z + m_aGreens[id]->m_vMin.z * scalecoef)) + tmpMin.z = tmpMin.z + m_aGreens[id]->m_vMin.z * scalecoef; - queue[0]->BoundVolumeP->setMinMax(&tmpMin, &tmpMax); + queue[0]->m_pBoundVolumeP->setMinMax(&tmpMin, &tmpMax); } for (int i = 0; i < GREEN_COUNT_TYPE_SEGMENTATION; i++) { - if (queue[0]->Splits[i]) - queue.push_back(queue[0]->Splits[i]); + if (queue[0]->m_aSplits[i]) + queue.push_back(queue[0]->m_aSplits[i]); } } @@ -1075,22 +1081,22 @@ ID Green::GetIDSplit(ID id, float3* pos) return tmpidsplit; } -ID Green::AddObject(ID id, float3* pos, GreenDataVertex* data, ID* idsplit) +ID CGreen::addObject(ID id, float3* pos, CGreenDataVertex* data, ID* idsplit) { - if (id < 0 || ArrModels.size() <= id) + if (id < 0 || m_aGreens.size() <= id) return -1; - ID tmpidsplit = GetIDSplit(id, pos); + ID tmpidsplit = getIDSplit(id, pos); if (tmpidsplit < 0) return -1; - int oldlen = ArrModels[id]->SplitsArr[tmpidsplit]->CountAllGreen; - GreenDataVertex* tmpdv = new GreenDataVertex[oldlen + 1]; + int oldlen = m_aGreens[id]->m_aSplitsArr[tmpidsplit]->m_iCountObj; + CGreenDataVertex* tmpdv = new CGreenDataVertex[oldlen + 1]; if (oldlen > 0) - memcpy(tmpdv, ArrModels[id]->SplitsArr[tmpidsplit]->Data, oldlen * sizeof(GreenDataVertex)); + memcpy(tmpdv, m_aGreens[id]->m_aSplitsArr[tmpidsplit]->m_pObjData, oldlen * sizeof(CGreenDataVertex)); - GreenDataVertex tmpdvobj; + CGreenDataVertex tmpdvobj; if (!data) { tmpdvobj.m_vPosition = *pos; @@ -1106,13 +1112,13 @@ ID Green::AddObject(ID id, float3* pos, GreenDataVertex* data, ID* idsplit) tmpdvobj.m_vPosition = *pos; } - memcpy(tmpdv + oldlen, &tmpdvobj, sizeof(GreenDataVertex)); - mem_delete_a(ArrModels[id]->SplitsArr[tmpidsplit]->Data); - ArrModels[id]->SplitsArr[tmpidsplit]->Data = tmpdv; - ++(ArrModels[id]->SplitsArr[tmpidsplit]->CountAllGreen); - ++(ArrModels[id]->AllCountGreen); - int currlen = ArrModels[id]->SplitsArr[tmpidsplit]->CountAllGreen; - AlignBound(ArrModels[id], ArrModels[id]->SplitsArr[tmpidsplit]); + memcpy(tmpdv + oldlen, &tmpdvobj, sizeof(CGreenDataVertex)); + mem_delete_a(m_aGreens[id]->m_aSplitsArr[tmpidsplit]->m_pObjData); + m_aGreens[id]->m_aSplitsArr[tmpidsplit]->m_pObjData = tmpdv; + ++(m_aGreens[id]->m_aSplitsArr[tmpidsplit]->m_iCountObj); + ++(m_aGreens[id]->m_uiCountObj); + int currlen = m_aGreens[id]->m_aSplitsArr[tmpidsplit]->m_iCountObj; + alignBound(m_aGreens[id], m_aGreens[id]->m_aSplitsArr[tmpidsplit]); if (idsplit) *idsplit = tmpidsplit; @@ -1120,69 +1126,69 @@ ID Green::AddObject(ID id, float3* pos, GreenDataVertex* data, ID* idsplit) return oldlen; } -void Green::DelObject(ID id, ID idsplit, ID idobj) +void CGreen::deleteObject(ID id, ID idsplit, ID idobj) { - if (id < 0 || ArrModels.size() <= id || idsplit < 0 || ArrModels[id]->SplitsArr.size() <= idsplit || idobj < 0 || ArrModels[id]->SplitsArr[idsplit]->CountAllGreen <= idobj) + if (id < 0 || m_aGreens.size() <= id || idsplit < 0 || m_aGreens[id]->m_aSplitsArr.size() <= idsplit || idobj < 0 || m_aGreens[id]->m_aSplitsArr[idsplit]->m_iCountObj <= idobj) return; - int oldlen = ArrModels[id]->SplitsArr[idsplit]->CountAllGreen; - GreenDataVertex* tmpdv = new GreenDataVertex[oldlen - 1]; - memcpy(tmpdv, ArrModels[id]->SplitsArr[idsplit]->Data, idobj * sizeof(GreenDataVertex)); - memcpy(tmpdv + idobj, ArrModels[id]->SplitsArr[idsplit]->Data + idobj + 1, ((oldlen - idobj) - 1)* sizeof(GreenDataVertex)); - mem_delete_a(ArrModels[id]->SplitsArr[idsplit]->Data); - ArrModels[id]->SplitsArr[idsplit]->Data = tmpdv; - --(ArrModels[id]->SplitsArr[idsplit]->CountAllGreen); - --(ArrModels[id]->AllCountGreen); - AlignBound(ArrModels[id], ArrModels[id]->SplitsArr[idsplit]); + int oldlen = m_aGreens[id]->m_aSplitsArr[idsplit]->m_iCountObj; + CGreenDataVertex* tmpdv = new CGreenDataVertex[oldlen - 1]; + memcpy(tmpdv, m_aGreens[id]->m_aSplitsArr[idsplit]->m_pObjData, idobj * sizeof(CGreenDataVertex)); + memcpy(tmpdv + idobj, m_aGreens[id]->m_aSplitsArr[idsplit]->m_pObjData + idobj + 1, ((oldlen - idobj) - 1)* sizeof(CGreenDataVertex)); + mem_delete_a(m_aGreens[id]->m_aSplitsArr[idsplit]->m_pObjData); + m_aGreens[id]->m_aSplitsArr[idsplit]->m_pObjData = tmpdv; + --(m_aGreens[id]->m_aSplitsArr[idsplit]->m_iCountObj); + --(m_aGreens[id]->m_uiCountObj); + alignBound(m_aGreens[id], m_aGreens[id]->m_aSplitsArr[idsplit]); } -void Green::GetPosObject(ID id, ID idsplit, ID idobj, float3_t* pos) +void CGreen::getPosObject(ID id, ID idsplit, ID idobj, float3_t* pos) { - if (!pos || id < 0 || ArrModels.size() <= id || idsplit < 0 || ArrModels[id]->SplitsArr.size() <= idsplit || idobj < 0 || ArrModels[id]->SplitsArr[idsplit]->CountAllGreen <= idobj) + if (!pos || id < 0 || m_aGreens.size() <= id || idsplit < 0 || m_aGreens[id]->m_aSplitsArr.size() <= idsplit || idobj < 0 || m_aGreens[id]->m_aSplitsArr[idsplit]->m_iCountObj <= idobj) return; - *pos = ArrModels[id]->SplitsArr[idsplit]->Data[idobj].m_vPosition; + *pos = m_aGreens[id]->m_aSplitsArr[idsplit]->m_pObjData[idobj].m_vPosition; } -void Green::SetPosObject(ID id, ID* idsplit, ID* idobj, float3_t* pos) +void CGreen::setPosObject(ID id, ID* idsplit, ID* idobj, const float3_t* pos) { - if (!pos || !idsplit || !idobj || id < 0 || ArrModels.size() <= id || (*idsplit) < 0 || ArrModels[id]->SplitsArr.size() <= (*idsplit) || (*idobj) < 0 || ArrModels[id]->SplitsArr[(*idsplit)]->CountAllGreen <= (*idobj)) + if (!pos || !idsplit || !idobj || id < 0 || m_aGreens.size() <= id || (*idsplit) < 0 || m_aGreens[id]->m_aSplitsArr.size() <= (*idsplit) || (*idobj) < 0 || m_aGreens[id]->m_aSplitsArr[(*idsplit)]->m_iCountObj <= (*idobj)) return; - if (GetIDSplit(id, &float3(*pos)) == (*idsplit)) - ArrModels[id]->SplitsArr[(*idsplit)]->Data[(*idobj)].m_vPosition = *pos; + if (getIDSplit(id, &float3(*pos)) == (*idsplit)) + m_aGreens[id]->m_aSplitsArr[(*idsplit)]->m_pObjData[(*idobj)].m_vPosition = *pos; else { - GreenDataVertex tmpdv = ArrModels[id]->SplitsArr[(*idsplit)]->Data[(*idobj)]; - DelObject(id, (*idsplit), (*idobj)); - (*idobj) = AddObject(id, &float3(*pos), &tmpdv, idsplit); + CGreenDataVertex tmpdv = m_aGreens[id]->m_aSplitsArr[(*idsplit)]->m_pObjData[(*idobj)]; + deleteObject(id, (*idsplit), (*idobj)); + (*idobj) = addObject(id, &float3(*pos), &tmpdv, idsplit); } } -void Green::Save(const char* path) +void CGreen::save(const char* path) { FILE* file = fopen(path, "wb"); - int32_t countmodel = ArrModels.size(); + int32_t countmodel = m_aGreens.size(); fwrite(&countmodel, sizeof(int32_t), 1, file); - for (long i = 0; i < ArrModels.size(); ++i) + for (int i = 0; i < m_aGreens.size(); ++i) { - fwrite(&ArrModels[i]->TypeGreen, sizeof(int32_t), 1, file); + fwrite(&m_aGreens[i]->m_typeGreen, sizeof(int32_t), 1, file); - int32_t tmpstrlen = strlen(ArrModels[i]->Name); + int32_t tmpstrlen = strlen(m_aGreens[i]->m_szName); fwrite(&tmpstrlen, sizeof(int32_t), 1, file); - fwrite(ArrModels[i]->Name, sizeof(char), tmpstrlen, file); + fwrite(m_aGreens[i]->m_szName, sizeof(char), tmpstrlen, file); - tmpstrlen = ArrModels[i]->MaskName.length(); + tmpstrlen = m_aGreens[i]->m_szMaskName.length(); fwrite(&tmpstrlen, sizeof(int32_t), 1, file); - fwrite(ArrModels[i]->MaskName.c_str(), sizeof(char), tmpstrlen, file); + fwrite(m_aGreens[i]->m_szMaskName.c_str(), sizeof(char), tmpstrlen, file); - if (ArrModels[i]->NavigateMesh) + if (m_aGreens[i]->m_pPhysMesh) { - tmpstrlen = strlen(ArrModels[i]->NavigateMesh->pathname.c_str()); + tmpstrlen = strlen(m_aGreens[i]->m_pPhysMesh->m_sPathName.c_str()); fwrite(&tmpstrlen, sizeof(int32_t), 1, file); - fwrite(ArrModels[i]->NavigateMesh->pathname.c_str(), sizeof(char), tmpstrlen, file); + fwrite(m_aGreens[i]->m_pPhysMesh->m_sPathName.c_str(), sizeof(char), tmpstrlen, file); } else { @@ -1190,39 +1196,39 @@ void Green::Save(const char* path) fwrite(&tmpstrlen, sizeof(int32_t), 1, file); } - if (ArrModels[i]->TypeGreen == GREEN_TYPE_GRASS) + if (m_aGreens[i]->m_typeGreen == GREEN_TYPE_GRASS) { - tmpstrlen = strlen(ArrModels[i]->ArrLod[0]->path.c_str()); + tmpstrlen = strlen(m_aGreens[i]->m_aLods[0]->m_sPath.c_str()); fwrite(&tmpstrlen, sizeof(int32_t), 1, file); - fwrite(ArrModels[i]->ArrLod[0]->path.c_str(), sizeof(char), tmpstrlen, file); + fwrite(m_aGreens[i]->m_aLods[0]->m_sPath.c_str(), sizeof(char), tmpstrlen, file); } else { for (int k = 0; k < GREEN_COUNT_LOD; ++k) { - tmpstrlen = ArrModels[i]->ArrLod[k]->path.length(); + tmpstrlen = m_aGreens[i]->m_aLods[k]->m_sPath.length(); fwrite(&tmpstrlen, sizeof(int32_t), 1, file); - fwrite(ArrModels[i]->ArrLod[k]->path.c_str(), sizeof(char), tmpstrlen, file); + fwrite(m_aGreens[i]->m_aLods[k]->m_sPath.c_str(), sizeof(char), tmpstrlen, file); } } - fwrite(&ArrModels[i]->BBMin.x, sizeof(float), 1, file); - fwrite(&ArrModels[i]->BBMin.y, sizeof(float), 1, file); - fwrite(&ArrModels[i]->BBMin.z, sizeof(float), 1, file); + fwrite(&m_aGreens[i]->m_vMin.x, sizeof(float), 1, file); + fwrite(&m_aGreens[i]->m_vMin.y, sizeof(float), 1, file); + fwrite(&m_aGreens[i]->m_vMin.z, sizeof(float), 1, file); - fwrite(&ArrModels[i]->BBMax.x, sizeof(float), 1, file); - fwrite(&ArrModels[i]->BBMax.y, sizeof(float), 1, file); - fwrite(&ArrModels[i]->BBMax.z, sizeof(float), 1, file); + fwrite(&m_aGreens[i]->m_vMax.x, sizeof(float), 1, file); + fwrite(&m_aGreens[i]->m_vMax.y, sizeof(float), 1, file); + fwrite(&m_aGreens[i]->m_vMax.z, sizeof(float), 1, file); - fwrite(&ArrModels[i]->AllCountGreen, sizeof(uint32_t), 1, file); + fwrite(&m_aGreens[i]->m_uiCountObj, sizeof(uint32_t), 1, file); - Array<Segment*> queue; - long tmpcount = 0; - queue.push_back(ArrModels[i]->SplitsTree); + Array<CSegment*> queue; + int tmpcount = 0; + queue.push_back(m_aGreens[i]->m_pSplitsTree); while (queue.size()) { - SaveSplit(queue[0], file, &queue); + saveSplit(queue[0], file, &queue); queue.erase(0); ++tmpcount; @@ -1232,10 +1238,10 @@ void Green::Save(const char* path) fclose(file); } -void Green::SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue) +void CGreen::saveSplit(CSegment* Split, FILE* file, Array<CSegment*> * queue) { float3 jmin, jmax; - Split->BoundVolumeSys->getMinMax(&jmin, &jmax); + Split->m_pBoundVolumeSys->getMinMax(&jmin, &jmax); fwrite(&jmin.x, sizeof(float), 1, file); fwrite(&jmin.y, sizeof(float), 1, file); fwrite(&jmin.z, sizeof(float), 1, file); @@ -1244,7 +1250,7 @@ void Green::SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue) fwrite(&jmax.y, sizeof(float), 1, file); fwrite(&jmax.z, sizeof(float), 1, file); - Split->BoundVolumeP->getMinMax(&jmin, &jmax); + Split->m_pBoundVolumeP->getMinMax(&jmin, &jmax); fwrite(&jmin.x, sizeof(float), 1, file); fwrite(&jmin.y, sizeof(float), 1, file); fwrite(&jmin.z, sizeof(float), 1, file); @@ -1253,34 +1259,34 @@ void Green::SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue) fwrite(&jmax.y, sizeof(float), 1, file); fwrite(&jmax.z, sizeof(float), 1, file); - fwrite(&Split->CountAllGreen, sizeof(uint32_t), 1, file); + fwrite(&Split->m_iCountObj, sizeof(uint32_t), 1, file); - if (Split->CountAllGreen > 0) + if (Split->m_iCountObj > 0) int qwerty = 0; - fwrite(&Split->BFNonEnd, sizeof(int8_t), 1, file); + fwrite(&Split->m_idNonEnd, sizeof(int8_t), 1, file); bool isexists = true; - if (Split->Splits[0]/*!Split->Data && Split->CountAllGreen > 0*/) + if (Split->m_aSplits[0]/*!Split->m_pObjData && Split->m_iCountObj > 0*/) { fwrite(&isexists, sizeof(int8_t), 1, file); for (int i = 0; i<GREEN_COUNT_TYPE_SEGMENTATION; i++) { - if (Split->Splits[i]) - queue->push_back(Split->Splits[i]); + if (Split->m_aSplits[i]) + queue->push_back(Split->m_aSplits[i]); } } else { isexists = false; fwrite(&isexists, sizeof(int8_t), 1, file); - if (Split->CountAllGreen > 0) - fwrite(Split->Data, sizeof(GreenDataVertex), Split->CountAllGreen, file); + if (Split->m_iCountObj > 0) + fwrite(Split->m_pObjData, sizeof(CGreenDataVertex), Split->m_iCountObj, file); } } -void Green::Load(const char* path) +void CGreen::load(const char* path) { FILE* file = fopen(path, "rb"); @@ -1294,34 +1300,34 @@ void Green::Load(const char* path) int32_t countmodel; fread(&countmodel, sizeof(int32_t), 1, file); - for (long i = 0; i < countmodel; ++i) + for (int i = 0; i < countmodel; ++i) { tmpstr[0][0] = tmpstr[1][0] = tmpstr[2][0] = 0; - Model* tmpmodel = new Model(); - fread(&tmpmodel->TypeGreen, sizeof(int32_t), 1, file); + CModel* tmpmodel = new CModel(); + fread(&tmpmodel->m_typeGreen, sizeof(int32_t), 1, file); - int32_t tmpstrlen;// = strlen(ArrModels[i]->Name); + int32_t tmpstrlen;// = strlen(m_aGreens[i]->Name); fread(&tmpstrlen, sizeof(int32_t), 1, file); fread(tmpNameMask, sizeof(char), tmpstrlen, file); tmpNameMask[tmpstrlen] = 0; - sprintf(tmpmodel->Name,"%s",tmpNameMask); + sprintf(tmpmodel->m_szName, "%s", tmpNameMask); - //tmpstrlen = ArrModels[i]->MaskName.length(); + //tmpstrlen = m_aGreens[i]->m_szMaskName.length(); fread(&tmpstrlen, sizeof(int32_t), 1, file); fread(tmpNameMask, sizeof(char), tmpstrlen, file); tmpNameMask[tmpstrlen] = 0; - tmpmodel->MaskName = tmpNameMask; + tmpmodel->m_szMaskName = tmpNameMask; fread(&tmpstrlen, sizeof(int32_t), 1, file); if (tmpstrlen > 0) { fread(tmpNameMask, sizeof(char), tmpstrlen, file); tmpNameMask[tmpstrlen] = 0; - tmpmodel->NavigateMesh = new Model::NavMesh(); - tmpmodel->NavigateMesh->pathname = tmpNameMask; + tmpmodel->m_pPhysMesh = new CModel::CPhysMesh(); + tmpmodel->m_pPhysMesh->m_sPathName = tmpNameMask; } - if (tmpmodel->TypeGreen == GREEN_TYPE_GRASS) + if (tmpmodel->m_typeGreen == GREEN_TYPE_GRASS) { fread(&tmpstrlen, sizeof(int32_t), 1, file); fread(tmpstr[0], sizeof(char), tmpstrlen, file); @@ -1338,35 +1344,35 @@ void Green::Load(const char* path) } - tmpmodel->ArrLod[0] = new Lod(); - tmpmodel->ArrLod[1] = 0; - tmpmodel->ArrLod[2] = 0; + tmpmodel->m_aLods[0] = new CLod(); + tmpmodel->m_aLods[1] = 0; + tmpmodel->m_aLods[2] = 0; sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), tmpstr[0]); - SGCore_StaticModelLoad(tmppath, &tmpmodel->ArrLod[0]->model); - tmpmodel->ArrLod[0]->path = tmpstr[0]; + SGCore_StaticModelLoad(tmppath, &tmpmodel->m_aLods[0]->m_pModel); + tmpmodel->m_aLods[0]->m_sPath = tmpstr[0]; char tmppathtex[1024]; - for (int k = 0; k < tmpmodel->ArrLod[0]->model->m_uiSubsetCount; ++k) + for (int k = 0; k < tmpmodel->m_aLods[0]->m_pModel->m_uiSubsetCount; ++k) { - sprintf(tmppathtex, "%s.dds", tmpmodel->ArrLod[0]->model->m_ppTextures[k]); - tmpmodel->ArrLod[0]->idstex[k] = SGCore_MtlLoad(tmppathtex, (tmpmodel->TypeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS)); + sprintf(tmppathtex, "%s.dds", tmpmodel->m_aLods[0]->m_pModel->m_ppTextures[k]); + tmpmodel->m_aLods[0]->m_aIDsTextures[k] = SGCore_MtlLoad(tmppathtex, (tmpmodel->m_typeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS)); } if (tmpstr[1][0]) { if (stricmp(tmpstr[0], tmpstr[1]) == 0) - tmpmodel->ArrLod[1] = tmpmodel->ArrLod[0]; + tmpmodel->m_aLods[1] = tmpmodel->m_aLods[0]; else { - tmpmodel->ArrLod[1] = new Lod(); - tmpmodel->ArrLod[1]->path = tmpstr[1]; + tmpmodel->m_aLods[1] = new CLod(); + tmpmodel->m_aLods[1]->m_sPath = tmpstr[1]; sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), tmpstr[1]); - SGCore_StaticModelLoad(tmppath, &tmpmodel->ArrLod[1]->model); + SGCore_StaticModelLoad(tmppath, &tmpmodel->m_aLods[1]->m_pModel); - for (int k = 0; k < tmpmodel->ArrLod[1]->model->m_uiSubsetCount; ++k) + for (int k = 0; k < tmpmodel->m_aLods[1]->m_pModel->m_uiSubsetCount; ++k) { - sprintf(tmppathtex, "%s.dds", tmpmodel->ArrLod[1]->model->m_ppTextures[k]); - tmpmodel->ArrLod[1]->idstex[k] = SGCore_MtlLoad(tmppathtex, (tmpmodel->TypeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS)); + sprintf(tmppathtex, "%s.dds", tmpmodel->m_aLods[1]->m_pModel->m_ppTextures[k]); + tmpmodel->m_aLods[1]->m_aIDsTextures[k] = SGCore_MtlLoad(tmppathtex, (tmpmodel->m_typeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS)); } } } @@ -1374,63 +1380,63 @@ void Green::Load(const char* path) if (tmpstr[2][0]) { if (stricmp(tmpstr[0], tmpstr[2]) == 0) - tmpmodel->ArrLod[2] = tmpmodel->ArrLod[0]; + tmpmodel->m_aLods[2] = tmpmodel->m_aLods[0]; else if (stricmp(tmpstr[1], tmpstr[2]) == 0) - tmpmodel->ArrLod[2] = tmpmodel->ArrLod[1]; + tmpmodel->m_aLods[2] = tmpmodel->m_aLods[1]; else { - tmpmodel->ArrLod[2] = new Lod(); - tmpmodel->ArrLod[2]->path = tmpstr[2]; + tmpmodel->m_aLods[2] = new CLod(); + tmpmodel->m_aLods[2]->m_sPath = tmpstr[2]; sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), tmpstr[2]); - SGCore_StaticModelLoad(tmppath, &tmpmodel->ArrLod[2]->model); + SGCore_StaticModelLoad(tmppath, &tmpmodel->m_aLods[2]->m_pModel); - for (int k = 0; k < tmpmodel->ArrLod[2]->model->m_uiSubsetCount; ++k) + for (int k = 0; k < tmpmodel->m_aLods[2]->m_pModel->m_uiSubsetCount; ++k) { - sprintf(tmppathtex, "%s.dds", tmpmodel->ArrLod[1]->model->m_ppTextures[k]); - tmpmodel->ArrLod[2]->idstex[k] = SGCore_MtlLoad(tmppathtex, (tmpmodel->TypeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS)); + sprintf(tmppathtex, "%s.dds", tmpmodel->m_aLods[1]->m_pModel->m_ppTextures[k]); + tmpmodel->m_aLods[2]->m_aIDsTextures[k] = SGCore_MtlLoad(tmppathtex, (tmpmodel->m_typeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS)); } } } - fread(&tmpmodel->BBMin.x, sizeof(float), 1, file); - fread(&tmpmodel->BBMin.y, sizeof(float), 1, file); - fread(&tmpmodel->BBMin.z, sizeof(float), 1, file); + fread(&tmpmodel->m_vMin.x, sizeof(float), 1, file); + fread(&tmpmodel->m_vMin.y, sizeof(float), 1, file); + fread(&tmpmodel->m_vMin.z, sizeof(float), 1, file); - fread(&tmpmodel->BBMax.x, sizeof(float), 1, file); - fread(&tmpmodel->BBMax.y, sizeof(float), 1, file); - fread(&tmpmodel->BBMax.z, sizeof(float), 1, file); + fread(&tmpmodel->m_vMax.x, sizeof(float), 1, file); + fread(&tmpmodel->m_vMax.y, sizeof(float), 1, file); + fread(&tmpmodel->m_vMax.z, sizeof(float), 1, file); - fread(&tmpmodel->AllCountGreen, sizeof(uint32_t), 1, file); + fread(&tmpmodel->m_uiCountObj, sizeof(uint32_t), 1, file); - Array<Segment**> queue; - long tmpcount = 0; - queue.push_back(&(tmpmodel->SplitsTree)); + Array<CSegment**> queue; + int tmpcount = 0; + queue.push_back(&(tmpmodel->m_pSplitsTree)); while (queue.size()) { - LoadSplit(queue[0], file, &queue); + loadSplit(queue[0], file, &queue); - if ((*queue[0])->Data) - tmpmodel->AllCountGreen += (*queue[0])->CountAllGreen; + if ((*queue[0])->m_pObjData) + tmpmodel->m_uiCountObj += (*queue[0])->m_iCountObj; queue.erase(0); ++tmpcount; } - SetSplitID(tmpmodel); + setSplitID(tmpmodel); - ArrModels.push_back(tmpmodel); - AddModelInArrCom(ArrModels.size() - 1); + m_aGreens.push_back(tmpmodel); + addModelInArrCom(m_aGreens.size() - 1); - if (tmpmodel->NavigateMesh) - SetGreenNav(ArrModels.size() - 1, tmpmodel->NavigateMesh->pathname.c_str()); + if (tmpmodel->m_pPhysMesh) + setGreenNav(m_aGreens.size() - 1, tmpmodel->m_pPhysMesh->m_sPathName.c_str()); } fclose(file); } -void Green::LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue) +void CGreen::loadSplit(CSegment** Split, FILE* file, Array<CSegment**> * queue) { - (*Split) = new Segment(); + (*Split) = new CSegment(); float3 jmin, jmax; fread(&jmin.x, sizeof(float), 1, file); fread(&jmin.y, sizeof(float), 1, file); @@ -1440,8 +1446,8 @@ void Green::LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue) fread(&jmax.y, sizeof(float), 1, file); fread(&jmax.z, sizeof(float), 1, file); - (*Split)->BoundVolumeSys = SGCore_CrBound(); - (*Split)->BoundVolumeSys->setMinMax(&jmin, &jmax); + (*Split)->m_pBoundVolumeSys = SGCore_CrBound(); + (*Split)->m_pBoundVolumeSys->setMinMax(&jmin, &jmax); fread(&jmin.x, sizeof(float), 1, file); @@ -1452,12 +1458,12 @@ void Green::LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue) fread(&jmax.y, sizeof(float), 1, file); fread(&jmax.z, sizeof(float), 1, file); - (*Split)->BoundVolumeP = SGCore_CrBound(); - (*Split)->BoundVolumeP->setMinMax(&jmin, &jmax); + (*Split)->m_pBoundVolumeP = SGCore_CrBound(); + (*Split)->m_pBoundVolumeP->setMinMax(&jmin, &jmax); - fread(&(*Split)->CountAllGreen, sizeof(uint32_t), 1, file); + fread(&(*Split)->m_iCountObj, sizeof(uint32_t), 1, file); - fread(&(*Split)->BFNonEnd, sizeof(int8_t), 1, file); + fread(&(*Split)->m_idNonEnd, sizeof(int8_t), 1, file); bool isexists = false; fread(&isexists, sizeof(int8_t), 1, file); @@ -1466,38 +1472,38 @@ void Green::LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue) { for (int i = 0; i<GREEN_COUNT_TYPE_SEGMENTATION; i++) { - queue->push_back(&((*Split)->Splits[i])); + queue->push_back(&((*Split)->m_aSplits[i])); } } else { - if ((*Split)->CountAllGreen > 0) + if ((*Split)->m_iCountObj > 0) { - (*Split)->Data = new GreenDataVertex[(*Split)->CountAllGreen]; + (*Split)->m_pObjData = new CGreenDataVertex[(*Split)->m_iCountObj]; - fread((*Split)->Data, sizeof(GreenDataVertex)*(*Split)->CountAllGreen, 1, file); + fread((*Split)->m_pObjData, sizeof(CGreenDataVertex)*(*Split)->m_iCountObj, 1, file); } } } -ID Green::AddArrForCom() +ID CGreen::addArrForCom() { - IRSData* ttmpdata = new IRSData(); - for (long i = 0; i < ArrModels.size(); ++i) + CIRSData* ttmpdata = new CIRSData(); + for (int i = 0; i < m_aGreens.size(); ++i) { - InfoRenderSegments* tmpirs = new InfoRenderSegments(); - tmpirs->Count = ArrModels[i]->SplitsIDs; - tmpirs->Arr = new Segment*[ArrModels[i]->SplitsIDs]; - tmpirs->CountCom = 0; - ttmpdata->arr.push_back(tmpirs); + CInfoRenderSegments* tmpirs = new CInfoRenderSegments(); + tmpirs->m_iCount = m_aGreens[i]->m_idCountSplits; + tmpirs->m_ppSegments = new CSegment*[m_aGreens[i]->m_idCountSplits]; + tmpirs->m_iCountCom = 0; + ttmpdata->m_aIRS.push_back(tmpirs); } ID id_arr = -1; - for (long i = 0; i < ArrComFor.size(); ++i) + for (int i = 0; i < m_aArrComFor.size(); ++i) { - if (ArrComFor[i] == 0) + if (m_aArrComFor[i] == 0) { - ArrComFor[i] = ttmpdata; + m_aArrComFor[i] = ttmpdata; id_arr = i; break; } @@ -1505,219 +1511,219 @@ ID Green::AddArrForCom() if (id_arr == -1) { - ArrComFor.push_back(ttmpdata); - id_arr = ArrComFor.size() - 1; + m_aArrComFor.push_back(ttmpdata); + id_arr = m_aArrComFor.size() - 1; } return id_arr; } -bool Green::existsArrForCom(ID id) +bool CGreen::existsArrForCom(ID id) { - return (ArrComFor.size() > id); + return (m_aArrComFor.size() > id); } -void Green::DelArrForCom(ID id_arr) +void CGreen::deleteArrForCom(ID id_arr) { GREEN_PRECOND_ARRCOMFOR_ERR_ID(id_arr); - mem_delete(ArrComFor[id_arr]); + mem_delete(m_aArrComFor[id_arr]); } -void Green::AddModelInArrCom(ID id_model) +void CGreen::addModelInArrCom(ID id_model) { GREEN_PRECOND_ARRCOMFOR_ERR_ID_MODEL(id_model); - for (long i = 0; i < ArrComFor.size(); ++i) + for (int i = 0; i < m_aArrComFor.size(); ++i) { - InfoRenderSegments* tmpirs = new InfoRenderSegments(); - tmpirs->Count = ArrModels[id_model]->SplitsIDs; - tmpirs->Arr = new Segment*[ArrModels[id_model]->SplitsIDs]; - tmpirs->CountCom = 0; - ArrComFor[i]->arr.push_back(tmpirs); + CInfoRenderSegments* tmpirs = new CInfoRenderSegments(); + tmpirs->m_iCount = m_aGreens[id_model]->m_idCountSplits; + tmpirs->m_ppSegments = new CSegment*[m_aGreens[id_model]->m_idCountSplits]; + tmpirs->m_iCountCom = 0; + m_aArrComFor[i]->m_aIRS.push_back(tmpirs); } } -void Green::DelModelInArrCom(ID id_model) +void CGreen::deleteModelInArrCom(ID id_model) { GREEN_PRECOND_ARRCOMFOR_ERR_ID_MODEL(id_model); - for (int i = 0; i < ArrComFor.size(); ++i) + for (int i = 0; i < m_aArrComFor.size(); ++i) { - if (!(ArrComFor[i])) + if (!(m_aArrComFor[i])) continue; - mem_delete(ArrComFor[i]->arr[id_model]); - ArrComFor[i]->arr.erase(id_model); + mem_delete(m_aArrComFor[i]->m_aIRS[id_model]); + m_aArrComFor[i]->m_aIRS.erase(id_model); } } -ID Green::GetCountGreen() +ID CGreen::getCountGreen() { - return ArrModels.size(); + return m_aGreens.size(); } -char* Green::GetGreenName(ID id) +char* CGreen::getGreenName(ID id) { - if (id < ArrModels.size()) - return ArrModels[id]->Name; + if (id < m_aGreens.size()) + return m_aGreens[id]->m_szName; return 0; } -long Green::GetGreenCountGen(ID id) +int CGreen::getGreenCountGen(ID id) { - if (id < ArrModels.size()) - return ArrModels[id]->AllCountGreen; + if (id < m_aGreens.size()) + return m_aGreens[id]->m_uiCountObj; return -1; } -long Green::GetGreenCountPoly(ID id) +int CGreen::getGreenCountPoly(ID id) { - if (id < ArrModels.size() && ArrModels[id]->ArrLod[0]) - return ArrModels[id]->ArrLod[0]->model->m_uiAllIndexCount / 3; + if (id < m_aGreens.size() && m_aGreens[id]->m_aLods[0]) + return m_aGreens[id]->m_aLods[0]->m_pModel->m_uiAllIndexCount / 3; return -1; } -int Green::GetGreenTypeCountGen(ID id) +int CGreen::getGreenTypeCountGen(ID id) { - if (id < ArrModels.size()) - return ArrModels[id]->TypeGreen; + if (id < m_aGreens.size()) + return m_aGreens[id]->m_typeGreen; return -1; } -const char* Green::GetGreenModel(ID id) +const char* CGreen::getGreenModel(ID id) { - if (id < ArrModels.size()) - return ArrModels[id]->ArrLod[0]->path.c_str(); + if (id < m_aGreens.size()) + return m_aGreens[id]->m_aLods[0]->m_sPath.c_str(); return 0; } -const char* Green::GetGreenLod1(ID id) +const char* CGreen::getGreenLod1(ID id) { - if (id < ArrModels.size() && ArrModels[id]->ArrLod[1]) - return ArrModels[id]->ArrLod[1]->path.c_str(); + if (id < m_aGreens.size() && m_aGreens[id]->m_aLods[1]) + return m_aGreens[id]->m_aLods[1]->m_sPath.c_str(); return 0; } -const char* Green::GetGreenLod2(ID id) +const char* CGreen::getGreenLod2(ID id) { - if (id < ArrModels.size() && ArrModels[id]->ArrLod[2]) - return ArrModels[id]->ArrLod[2]->path.c_str(); + if (id < m_aGreens.size() && m_aGreens[id]->m_aLods[2]) + return m_aGreens[id]->m_aLods[2]->m_sPath.c_str(); return 0; } -const char* Green::GetGreenMask(ID id) +const char* CGreen::getGreenMask(ID id) { - if (id < ArrModels.size()) - return ArrModels[id]->MaskName.c_str(); + if (id < m_aGreens.size()) + return m_aGreens[id]->m_szMaskName.c_str(); return 0; } -const char* Green::GetGreenNav(ID id) +const char* CGreen::getGreenNav(ID id) { - if (id < ArrModels.size() && ArrModels[id]->NavigateMesh) - return ArrModels[id]->NavigateMesh->pathname.c_str(); + if (id < m_aGreens.size() && m_aGreens[id]->m_pPhysMesh) + return m_aGreens[id]->m_pPhysMesh->m_sPathName.c_str(); return 0; } -void Green::DelGreen(ID id) +void CGreen::deleteGreen(ID id) { - if (id >= 0 && id < ArrModels.size()) + if (id >= 0 && id < m_aGreens.size()) { - DelModelInArrCom(id); - mem_delete(ArrModels[id]); - ArrModels.erase(id); + deleteModelInArrCom(id); + mem_delete(m_aGreens[id]); + m_aGreens.erase(id); } } -void Green::Clear() +void CGreen::clear() { - while(ArrModels.size() > 0) + while(m_aGreens.size() > 0) { - DelModelInArrCom(0); - mem_delete(ArrModels[0]); - ArrModels.erase(0); + deleteModelInArrCom(0); + mem_delete(m_aGreens[0]); + m_aGreens.erase(0); } - while (ArrComFor.size() > 2) + while (m_aArrComFor.size() > 2) { - mem_delete(ArrComFor[2]); - ArrComFor.erase(2); + mem_delete(m_aArrComFor[2]); + m_aArrComFor.erase(2); } } -void Green::SetGreenLod(ID id, int lod, const char* pathname) +void CGreen::setGreenLod(ID id, int lod, const char* pathname) { - if (!(lod >= 0 && lod < GREEN_COUNT_LOD && id >= 0 && id < ArrModels.size())) + if (!(lod >= 0 && lod < GREEN_COUNT_LOD && id >= 0 && id < m_aGreens.size())) return; bool isunic = true; for (int i = 0; i < GREEN_COUNT_LOD; ++i) { - if (ArrModels[id]->ArrLod[i] == ArrModels[id]->ArrLod[lod]) + if (m_aGreens[id]->m_aLods[i] == m_aGreens[id]->m_aLods[lod]) isunic = false; } if (isunic) - mem_delete(ArrModels[id]->ArrLod[lod]); + mem_delete(m_aGreens[id]->m_aLods[lod]); char tmppath[1024]; - ArrModels[id]->ArrLod[lod] = new Lod(); - ArrModels[id]->ArrLod[lod]->path = pathname; + m_aGreens[id]->m_aLods[lod] = new CLod(); + m_aGreens[id]->m_aLods[lod]->m_sPath = pathname; sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), pathname); - SGCore_StaticModelLoad(tmppath, &ArrModels[id]->ArrLod[lod]->model); + SGCore_StaticModelLoad(tmppath, &m_aGreens[id]->m_aLods[lod]->m_pModel); - for (int k = 0; k < ArrModels[id]->ArrLod[lod]->model->m_uiSubsetCount; ++k) + for (int k = 0; k < m_aGreens[id]->m_aLods[lod]->m_pModel->m_uiSubsetCount; ++k) { - sprintf(tmppath, "%s.dds", ArrModels[id]->ArrLod[lod]->model->m_ppTextures[k]); - ArrModels[id]->ArrLod[lod]->idstex[k] = SGCore_MtlLoad(tmppath, (ArrModels[id]->TypeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS)); + sprintf(tmppath, "%s.dds", m_aGreens[id]->m_aLods[lod]->m_pModel->m_ppTextures[k]); + m_aGreens[id]->m_aLods[lod]->m_aIDsTextures[k] = SGCore_MtlLoad(tmppath, (m_aGreens[id]->m_typeGreen == GREEN_TYPE_TREE ? MTL_TYPE_TREE : MTL_TYPE_GRASS)); } } -void Green::SetGreenNav(ID id, const char* pathname) +void CGreen::setGreenNav(ID id, const char* pathname) { - if (!(id >= 0 && id < ArrModels.size())) + if (!(id >= 0 && id < m_aGreens.size())) return; char tmpstr[1024]; sprintf(tmpstr, "%s", pathname); - mem_delete(ArrModels[id]->NavigateMesh); - ArrModels[id]->NavigateMesh = new Model::NavMesh(); + mem_delete(m_aGreens[id]->m_pPhysMesh); + m_aGreens[id]->m_pPhysMesh = new CModel::CPhysMesh(); char tmppath[1024]; sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), tmpstr); - ArrModels[id]->NavigateMesh->pathname = tmpstr; + m_aGreens[id]->m_pPhysMesh->m_sPathName = tmpstr; ISXDataStaticModel* nmesh; SGCore_StaticModelLoad(tmppath, &nmesh); - ArrModels[id]->NavigateMesh->count_vertex = nmesh->m_uiAllVertexCount; - ArrModels[id]->NavigateMesh->count_index = nmesh->m_uiAllIndexCount; - ArrModels[id]->NavigateMesh->arr_vertex = new float3_t[nmesh->m_uiAllVertexCount]; + m_aGreens[id]->m_pPhysMesh->m_iCountVertex = nmesh->m_uiAllVertexCount; + m_aGreens[id]->m_pPhysMesh->m_iCountIndex = nmesh->m_uiAllIndexCount; + m_aGreens[id]->m_pPhysMesh->m_pArrVertex = new float3_t[nmesh->m_uiAllVertexCount]; vertex_static *pVert; nmesh->m_pVertexBuffer->Lock(0, 0, (void **)&pVert, 0); - for (long i = 0; i < nmesh->m_uiAllVertexCount; ++i) + for (int i = 0; i < nmesh->m_uiAllVertexCount; ++i) { - ArrModels[id]->NavigateMesh->arr_vertex[i] = pVert[i].Pos; + m_aGreens[id]->m_pPhysMesh->m_pArrVertex[i] = pVert[i].Pos; } nmesh->m_pVertexBuffer->Unlock(); - ArrModels[id]->NavigateMesh->arr_index = new uint32_t[nmesh->m_uiAllIndexCount]; - ArrModels[id]->NavigateMesh->arr_mtl = new ID[nmesh->m_uiAllIndexCount]; + m_aGreens[id]->m_pPhysMesh->m_pArrIndex = new uint32_t[nmesh->m_uiAllIndexCount]; + m_aGreens[id]->m_pPhysMesh->m_pArrMtl = new ID[nmesh->m_uiAllIndexCount]; UINT* pInd; nmesh->m_pIndexBuffer->Lock(0, 0, (void **)&pInd, 0); DWORD prebias = 0; - long tmp_countindex = 0; + int tmp_countindex = 0; char tmpnametex[SXGC_LOADTEX_MAX_SIZE_DIRNAME]; for (int i = 0; i < nmesh->m_uiSubsetCount; ++i) { @@ -1725,8 +1731,8 @@ void Green::SetGreenNav(ID id, const char* pathname) ID tmpidmtl = SGCore_MtlLoad(tmpnametex, MTL_TYPE_TREE); for (int k = 0; k < nmesh->m_pIndexCount[i]; ++k) { - ArrModels[id]->NavigateMesh->arr_index[tmp_countindex] = pInd[nmesh->m_pStartIndex[i] + k] /*+ prebias*/; - ArrModels[id]->NavigateMesh->arr_mtl[tmp_countindex] = tmpidmtl; + m_aGreens[id]->m_pPhysMesh->m_pArrIndex[tmp_countindex] = pInd[nmesh->m_pStartIndex[i] + k] /*+ prebias*/; + m_aGreens[id]->m_pPhysMesh->m_pArrMtl[tmp_countindex] = tmpidmtl; ++tmp_countindex; } prebias += nmesh->m_pIndexCount[i]; @@ -1735,50 +1741,50 @@ void Green::SetGreenNav(ID id, const char* pathname) mem_release_del(nmesh); } -void Green::GetNavMeshAndTransform(float3_t*** arr_vertex, int32_t** arr_count_vertex, uint32_t*** arr_index, ID*** arr_mtl, int32_t** arr_count_index, GreenDataVertex*** arr_transform, int32_t** arr_count_transform, int32_t* arr_count_green) +void CGreen::getNavMeshAndTransform(float3_t*** arr_vertex, int32_t** arr_count_vertex, uint32_t*** arr_index, ID*** arr_mtl, int32_t** arr_count_index, CGreenDataVertex*** arr_transform, int32_t** arr_count_transform, int32_t* arr_count_green) { - if (ArrModels.size() <= 0) + if (m_aGreens.size() <= 0) return; int count_green = 0; - for (int id = 0; id < ArrModels.size(); ++id) + for (int id = 0; id < m_aGreens.size(); ++id) { - if (!(ArrModels[id]->NavigateMesh)) + if (!(m_aGreens[id]->m_pPhysMesh)) continue; - Array<Segment*> queue; - long tmpcount = 0; - queue.push_back(ArrModels[id]->SplitsTree); + Array<CSegment*> queue; + int tmpcount = 0; + queue.push_back(m_aGreens[id]->m_pSplitsTree); - ArrModels[id]->AllCountGreen = 0; + m_aGreens[id]->m_uiCountObj = 0; while (queue.size()) { - if (!(queue[0]->Splits[0]) && queue[0]->Data && queue[0]->CountAllGreen > 0) + if (!(queue[0]->m_aSplits[0]) && queue[0]->m_pObjData && queue[0]->m_iCountObj > 0) { - int AllCountGreen = ArrModels[id]->AllCountGreen; - int CountAllGreen = queue[0]->CountAllGreen; - GreenDataVertex* tmpdv = new GreenDataVertex[ArrModels[id]->AllCountGreen + queue[0]->CountAllGreen]; - if (ArrModels[id]->AllTrans) - memcpy(tmpdv, ArrModels[id]->AllTrans, sizeof(GreenDataVertex)* ArrModels[id]->AllCountGreen); - memcpy(tmpdv + ArrModels[id]->AllCountGreen, queue[0]->Data, sizeof(GreenDataVertex)* queue[0]->CountAllGreen); - mem_delete_a(ArrModels[id]->AllTrans); - ArrModels[id]->AllTrans = tmpdv; - ArrModels[id]->AllCountGreen += queue[0]->CountAllGreen; + int m_uiCountObj = m_aGreens[id]->m_uiCountObj; + int CountAllGreen = queue[0]->m_iCountObj; + CGreenDataVertex* tmpdv = new CGreenDataVertex[m_aGreens[id]->m_uiCountObj + queue[0]->m_iCountObj]; + if (m_aGreens[id]->m_pAllTrans) + memcpy(tmpdv, m_aGreens[id]->m_pAllTrans, sizeof(CGreenDataVertex)* m_aGreens[id]->m_uiCountObj); + memcpy(tmpdv + m_aGreens[id]->m_uiCountObj, queue[0]->m_pObjData, sizeof(CGreenDataVertex)* queue[0]->m_iCountObj); + mem_delete_a(m_aGreens[id]->m_pAllTrans); + m_aGreens[id]->m_pAllTrans = tmpdv; + m_aGreens[id]->m_uiCountObj += queue[0]->m_iCountObj; } for (int i = 0; i < GREEN_COUNT_TYPE_SEGMENTATION; ++i) { - if (queue[0]->Splits[i]) - queue.push_back(queue[0]->Splits[i]); + if (queue[0]->m_aSplits[i]) + queue.push_back(queue[0]->m_aSplits[i]); } queue.erase(0); ++tmpcount; } - if (ArrModels[id]->AllTrans) + if (m_aGreens[id]->m_pAllTrans) ++count_green; } @@ -1794,57 +1800,57 @@ void Green::GetNavMeshAndTransform(float3_t*** arr_vertex, int32_t** arr_count_v (*arr_mtl) = new ID*[count_green]; (*arr_count_index) = new int32_t[count_green]; - (*arr_transform) = new GreenDataVertex*[count_green]; + (*arr_transform) = new CGreenDataVertex*[count_green]; (*arr_count_transform) = new int32_t[count_green]; int curr_model = 0; - for (int i = 0; i < ArrModels.size(); ++i) + for (int i = 0; i < m_aGreens.size(); ++i) { - if (!(ArrModels[i]->NavigateMesh)) + if (!(m_aGreens[i]->m_pPhysMesh)) continue; - (*arr_vertex)[curr_model] = new float3_t[ArrModels[i]->NavigateMesh->count_vertex]; - memcpy((*arr_vertex)[curr_model], ArrModels[i]->NavigateMesh->arr_vertex, sizeof(float3_t)* ArrModels[i]->NavigateMesh->count_vertex); - (*arr_count_vertex)[curr_model] = ArrModels[i]->NavigateMesh->count_vertex; + (*arr_vertex)[curr_model] = new float3_t[m_aGreens[i]->m_pPhysMesh->m_iCountVertex]; + memcpy((*arr_vertex)[curr_model], m_aGreens[i]->m_pPhysMesh->m_pArrVertex, sizeof(float3_t)* m_aGreens[i]->m_pPhysMesh->m_iCountVertex); + (*arr_count_vertex)[curr_model] = m_aGreens[i]->m_pPhysMesh->m_iCountVertex; - (*arr_index)[curr_model] = new uint32_t[ArrModels[i]->NavigateMesh->count_index]; - memcpy((*arr_index)[curr_model], ArrModels[i]->NavigateMesh->arr_index, sizeof(uint32_t)* ArrModels[i]->NavigateMesh->count_index); - (*arr_mtl)[curr_model] = new ID[ArrModels[i]->NavigateMesh->count_index]; - memcpy((*arr_mtl)[curr_model], ArrModels[i]->NavigateMesh->arr_mtl, sizeof(ID)* ArrModels[i]->NavigateMesh->count_index); - (*arr_count_index)[curr_model] = ArrModels[i]->NavigateMesh->count_index; + (*arr_index)[curr_model] = new uint32_t[m_aGreens[i]->m_pPhysMesh->m_iCountIndex]; + memcpy((*arr_index)[curr_model], m_aGreens[i]->m_pPhysMesh->m_pArrIndex, sizeof(uint32_t)* m_aGreens[i]->m_pPhysMesh->m_iCountIndex); + (*arr_mtl)[curr_model] = new ID[m_aGreens[i]->m_pPhysMesh->m_iCountIndex]; + memcpy((*arr_mtl)[curr_model], m_aGreens[i]->m_pPhysMesh->m_pArrMtl, sizeof(ID)* m_aGreens[i]->m_pPhysMesh->m_iCountIndex); + (*arr_count_index)[curr_model] = m_aGreens[i]->m_pPhysMesh->m_iCountIndex; - (*arr_transform)[curr_model] = new GreenDataVertex[ArrModels[i]->AllCountGreen]; - (*arr_count_transform)[curr_model] = ArrModels[i]->AllCountGreen; - for (long k = 0; k < ArrModels[i]->AllCountGreen; ++k) + (*arr_transform)[curr_model] = new CGreenDataVertex[m_aGreens[i]->m_uiCountObj]; + (*arr_count_transform)[curr_model] = m_aGreens[i]->m_uiCountObj; + for (int k = 0; k < m_aGreens[i]->m_uiCountObj; ++k) { - (*arr_transform)[curr_model][k] = ArrModels[i]->AllTrans[k];// SMMatrixScaling(float3(ArrModels[i]->AllTrans[k].TexCoord.x, ArrModels[i]->AllTrans[k].TexCoord.x, ArrModels[i]->AllTrans[k].TexCoord.x)) * SMMatrixRotationY(ArrModels[i]->AllTrans[k].TexCoord.y) * SMMatrixTranslation(ArrModels[i]->AllTrans[k].Position); + (*arr_transform)[curr_model][k] = m_aGreens[i]->m_pAllTrans[k];// SMMatrixScaling(float3(m_aGreens[i]->m_pAllTrans[k].TexCoord.x, m_aGreens[i]->m_pAllTrans[k].TexCoord.x, m_aGreens[i]->m_pAllTrans[k].TexCoord.x)) * SMMatrixRotationY(m_aGreens[i]->m_pAllTrans[k].TexCoord.y) * SMMatrixTranslation(m_aGreens[i]->m_pAllTrans[k].Position); } ++curr_model; } - for (int id = 0; id < ArrModels.size(); ++id) + for (int id = 0; id < m_aGreens.size(); ++id) { - mem_delete_a(ArrModels[id]->AllTrans); + mem_delete_a(m_aGreens[id]->m_pAllTrans); } } -void Green::GetPartBeam(float3* pos, float3 * dir, Segment** arrsplits, DWORD *count, Segment* comsegment, ID curr_splits_ids_render) +void CGreen::getPartBeam(const float3* pos, const float3 * dir, CSegment** arrsplits, int *count, CSegment* comsegment, ID curr_splits_ids_render) { float3 center; float radius; - comsegment->BoundVolumeP->getSphere(¢er, &radius); + comsegment->m_pBoundVolumeP->getSphere(¢er, &radius); float distsqr = SGCore_0DistancePointBeam2(center, *pos, *dir); - if (comsegment->CountAllGreen > 0 && distsqr <= radius*radius) + if (comsegment->m_iCountObj > 0 && distsqr <= radius*radius) { - if (comsegment->BFNonEnd) + if (comsegment->m_idNonEnd) { for (int j = 0; j<GREEN_COUNT_TYPE_SEGMENTATION; ++j) { - if (comsegment->Splits[j]) - GetPartBeam(pos, dir, arrsplits, count, comsegment->Splits[j], curr_splits_ids_render); + if (comsegment->m_aSplits[j]) + getPartBeam(pos, dir, arrsplits, count, comsegment->m_aSplits[j], curr_splits_ids_render); } } else @@ -1859,9 +1865,9 @@ void Green::GetPartBeam(float3* pos, float3 * dir, Segment** arrsplits, DWORD *c } } -bool Green::TraceBeam(float3* start, float3* dir, float3* _res, ID* idgreen, ID* idsplits, ID* idobj, ID* idmtl) +bool CGreen::traceBeam(const float3* start, const float3* dir, float3* _res, ID* idgreen, ID* idsplits, ID* idobj, ID* idmtl) { - if (ArrModels.size() <= 0) + if (m_aGreens.size() <= 0) return false; SXTriangle tmptri; @@ -1873,37 +1879,37 @@ bool Green::TraceBeam(float3* start, float3* dir, float3* _res, ID* idgreen, ID* res = (*start) + float3(10000.0f, 10000.0f, 10000.0f); il = (*dir) * 10000.0f; bool found = false; - InfoRenderSegments* irs = 0; - Model* model = 0; + CInfoRenderSegments* irs = 0; + CModel* model = 0; float4x4 mat; - for (int id = 0; id < ArrModels.size(); ++id) + for (int id = 0; id < m_aGreens.size(); ++id) { - model = ArrModels[id]; - irs = ArrComFor[1]->arr[id]; - irs->CountCom = 0; + model = m_aGreens[id]; + irs = m_aArrComFor[1]->m_aIRS[id]; + irs->m_iCountCom = 0; - GetPartBeam(start, dir, irs->Arr, &(irs->CountCom), model->SplitsTree, irs->Count); + getPartBeam(start, dir, irs->m_ppSegments, &(irs->m_iCountCom), model->m_pSplitsTree, irs->m_iCount); vertex_static* pVertData = 0; - if (FAILED(model->ArrLod[0]->model->m_pVertexBuffer->Lock(0, 0, (void**)&pVertData, 0))) + if (FAILED(model->m_aLods[0]->m_pModel->m_pVertexBuffer->Lock(0, 0, (void**)&pVertData, 0))) continue; DWORD* pIndData = 0; - if (FAILED(model->ArrLod[0]->model->m_pIndexBuffer->Lock(0, 0, (void**)&pIndData, 0))) + if (FAILED(model->m_aLods[0]->m_pModel->m_pIndexBuffer->Lock(0, 0, (void**)&pIndData, 0))) continue; - for (int k = 0; k < irs->CountCom; ++k) + for (int k = 0; k < irs->m_iCountCom; ++k) { - for (int key = 0; key < irs->Arr[k]->CountAllGreen; ++key) + for (int key = 0; key < irs->m_ppSegments[k]->m_iCountObj; ++key) { UINT tmpcountind = 0; - for (int g = 0; g < model->ArrLod[0]->model->m_uiSubsetCount; ++g) + for (int g = 0; g < model->m_aLods[0]->m_pModel->m_uiSubsetCount; ++g) { - for (int poly = 0; poly < model->ArrLod[0]->model->m_pIndexCount[g] / 3; ++poly) + for (int poly = 0; poly < model->m_aLods[0]->m_pModel->m_pIndexCount[g] / 3; ++poly) { - float tmpscale = irs->Arr[k]->Data[key].m_vTexCoord.x; - mat = SMMatrixScaling(tmpscale, tmpscale, tmpscale) * SMMatrixRotationY(irs->Arr[k]->Data[key].m_vTexCoord.y) * SMMatrixTranslation(irs->Arr[k]->Data[key].m_vPosition); + float tmpscale = irs->m_ppSegments[k]->m_pObjData[key].m_vTexCoord.x; + mat = SMMatrixScaling(tmpscale, tmpscale, tmpscale) * SMMatrixRotationY(irs->m_ppSegments[k]->m_pObjData[key].m_vTexCoord.y) * SMMatrixTranslation(irs->m_ppSegments[k]->m_pObjData[key].m_vPosition); tmptri.a = SMVector3Transform(pVertData[pIndData[poly]].Pos, mat); tmptri.b = SMVector3Transform(pVertData[pIndData[poly + 1]].Pos, mat); @@ -1920,24 +1926,24 @@ bool Green::TraceBeam(float3* start, float3* dir, float3* _res, ID* idgreen, ID* *idgreen = id; if (idsplits) - *idsplits = irs->Arr[k]->Id; + *idsplits = irs->m_ppSegments[k]->m_id; if (idobj) *idobj = key; if (idmtl) - *idmtl = model->ArrLod[0]->idstex[g]; + *idmtl = model->m_aLods[0]->m_aIDsTextures[g]; } } } - tmpcountind += model->ArrLod[0]->model->m_uiSubsetCount; + tmpcountind += model->m_aLods[0]->m_pModel->m_uiSubsetCount; } } } - model->ArrLod[0]->model->m_pVertexBuffer->Unlock(); - model->ArrLod[0]->model->m_pIndexBuffer->Unlock(); + model->m_aLods[0]->m_pModel->m_pVertexBuffer->Unlock(); + model->m_aLods[0]->m_pModel->m_pIndexBuffer->Unlock(); } if (found && _res) @@ -1946,20 +1952,20 @@ bool Green::TraceBeam(float3* start, float3* dir, float3* _res, ID* idgreen, ID* return found; } -void Green::GetPartBB(float3* bbmin, float3 * bbmax, Segment** arrsplits, DWORD *count, Segment* comsegment, ID curr_splits_ids_render) +void CGreen::getPartBB(float3* bbmin, float3 * bbmax, CSegment** arrsplits, int *count, CSegment* comsegment, ID curr_splits_ids_render) { float3 min,max; float radius; - comsegment->BoundVolumeP->getMinMax(&min, &max); + comsegment->m_pBoundVolumeP->getMinMax(&min, &max); - if (comsegment->CountAllGreen > 0 && SGCore_0InretsectBox(bbmin, bbmax, &min, &max)) + if (comsegment->m_iCountObj > 0 && SGCore_0InretsectBox(bbmin, bbmax, &min, &max)) { - if (comsegment->BFNonEnd) + if (comsegment->m_idNonEnd) { for (int j = 0; j<GREEN_COUNT_TYPE_SEGMENTATION; ++j) { - if (comsegment->Splits[j]) - GetPartBB(bbmin, bbmax, arrsplits, count, comsegment->Splits[j], curr_splits_ids_render); + if (comsegment->m_aSplits[j]) + getPartBB(bbmin, bbmax, arrsplits, count, comsegment->m_aSplits[j], curr_splits_ids_render); } } else @@ -1974,49 +1980,49 @@ void Green::GetPartBB(float3* bbmin, float3 * bbmax, Segment** arrsplits, DWORD } } -bool Green::GetOccurencessLeafGrass(float3* bbmin, float3* bbmax, int physic_mtl) +bool CGreen::getOccurencessLeafGrass(float3* bbmin, float3* bbmax, int physic_mtl) { - if (ArrModels.size() <= 0) + if (m_aGreens.size() <= 0) return false; bool isfound = false; - InfoRenderSegments* irs = 0; - Model* model = 0; + CInfoRenderSegments* irs = 0; + CModel* model = 0; float3 p1, p2, p3, min, max; float4x4 mat; - for (int id = 0; id < ArrModels.size() && !isfound; ++id) + for (int id = 0; id < m_aGreens.size() && !isfound; ++id) { - model = ArrModels[id]; - irs = ArrComFor[1]->arr[id]; - irs->CountCom = 0; + model = m_aGreens[id]; + irs = m_aArrComFor[1]->m_aIRS[id]; + irs->m_iCountCom = 0; - GetPartBB(bbmin, bbmax, irs->Arr, &(irs->CountCom), model->SplitsTree, irs->Count); + getPartBB(bbmin, bbmax, irs->m_ppSegments, &(irs->m_iCountCom), model->m_pSplitsTree, irs->m_iCount); vertex_static* pVertData = 0; - if (FAILED(model->ArrLod[0]->model->m_pVertexBuffer->Lock(0, 0, (void**)&pVertData, 0))) + if (FAILED(model->m_aLods[0]->m_pModel->m_pVertexBuffer->Lock(0, 0, (void**)&pVertData, 0))) continue; DWORD* pIndData = 0; - if (FAILED(model->ArrLod[0]->model->m_pIndexBuffer->Lock(0, 0, (void**)&pIndData, 0))) + if (FAILED(model->m_aLods[0]->m_pModel->m_pIndexBuffer->Lock(0, 0, (void**)&pIndData, 0))) continue; - for (int g = 0; g < model->ArrLod[0]->model->m_uiSubsetCount && !isfound; ++g) + for (int g = 0; g < model->m_aLods[0]->m_pModel->m_uiSubsetCount && !isfound; ++g) { - int pt = SGCore_MtlGetPhysicType(model->ArrLod[0]->idstex[g]); - if (SGCore_MtlGetPhysicType(model->ArrLod[0]->idstex[g]) != physic_mtl) + int pt = SGCore_MtlGetPhysicType(model->m_aLods[0]->m_aIDsTextures[g]); + if (SGCore_MtlGetPhysicType(model->m_aLods[0]->m_aIDsTextures[g]) != physic_mtl) continue; - for (int k = 0; k < irs->CountCom && !isfound; ++k) + for (int k = 0; k < irs->m_iCountCom && !isfound; ++k) { - for (int key = 0; key < irs->Arr[k]->CountAllGreen && !isfound; ++key) + for (int key = 0; key < irs->m_ppSegments[k]->m_iCountObj && !isfound; ++key) { - for (int poly = 0; poly < model->ArrLod[0]->model->m_pIndexCount[g] / 3 && !isfound; ++poly) + for (int poly = 0; poly < model->m_aLods[0]->m_pModel->m_pIndexCount[g] / 3 && !isfound; ++poly) { - float tmpscale = irs->Arr[k]->Data[key].m_vTexCoord.x; - mat = SMMatrixScaling(tmpscale, tmpscale, tmpscale) * SMMatrixRotationY(irs->Arr[k]->Data[key].m_vTexCoord.y) * SMMatrixTranslation(irs->Arr[k]->Data[key].m_vPosition); + float tmpscale = irs->m_ppSegments[k]->m_pObjData[key].m_vTexCoord.x; + mat = SMMatrixScaling(tmpscale, tmpscale, tmpscale) * SMMatrixRotationY(irs->m_ppSegments[k]->m_pObjData[key].m_vTexCoord.y) * SMMatrixTranslation(irs->m_ppSegments[k]->m_pObjData[key].m_vPosition); p1 = SMVector3Transform(pVertData[pIndData[poly]].Pos, mat); p2 = SMVector3Transform(pVertData[pIndData[poly + 1]].Pos, mat); @@ -2063,8 +2069,8 @@ bool Green::GetOccurencessLeafGrass(float3* bbmin, float3* bbmax, int physic_mtl } } - model->ArrLod[0]->model->m_pVertexBuffer->Unlock(); - model->ArrLod[0]->model->m_pIndexBuffer->Unlock(); + model->m_aLods[0]->m_pModel->m_pVertexBuffer->Unlock(); + model->m_aLods[0]->m_pModel->m_pIndexBuffer->Unlock(); } return isfound; diff --git a/source/geom/green.h b/source/geom/green.h index 5bc914a6b6b18ebb061833261f4bdc5798126bed..3d006558e0b593e4db0e07242d70be74e7b25735 100644 --- a/source/geom/green.h +++ b/source/geom/green.h @@ -17,204 +17,306 @@ See the license in LICENSE #include "static_geom.h" #include "sxgeom.h" -#define GREEN_COUNT_TYPE_SEGMENTATION 4 -#define GREEN_COUNT_LOD 3 - -#define GREEN_DEFAULT_RESERVE_GEN 1024 -#define GREEN_DEFAULT_RESERVE_COM 1024 +//########################################################################## #define GREEN_PRECOND_ARRCOMFOR_ERR_ID(id_arr) \ -if (!(id_arr < ArrComFor.size()))\ +if (!(id_arr < m_aArrComFor.size()))\ {\ LibReport(REPORT_MSG_LEVEL_ERROR, "%s - green: unresolved id '%d' for array of compute visible", GEN_MSG_LOCATION, id_arr); \ } #define GREEN_PRECOND_ARRCOMFOR_ERR_ID_MODEL(id_model) \ -if (!(id_model < ArrModels.size() && ArrModels[id_model]))\ +if (!(id_model < m_aGreens.size() && m_aGreens[id_model]))\ {\ LibReport(REPORT_MSG_LEVEL_ERROR, "%s - green: unresolved id '%d' for array of models", GEN_MSG_LOCATION, id_model); \ } -class Green +//########################################################################## + +//! тип деления пространства для рендера растительности +#define GREEN_COUNT_TYPE_SEGMENTATION 4 + +//! количество лодов растительноси +#define GREEN_COUNT_LOD 3 + +#define GREEN_DEFAULT_RESERVE_GEN 1024 +#define GREEN_DEFAULT_RESERVE_COM 1024 + +//########################################################################## + +//! класс растительности +class CGreen { public: - static int CurrentFreqGrass; - static float2_t DistLods; - static float BeginEndLessening; - static bool UseSortFrontToBackSplits; - static IDirect3DDevice9* DXDevice; + //! плотность растительности при рендере (0,100] + static int m_iRenderFreqGrass; + + //! дистанция лодов x - где заканчивается первый лод и начинается второй, y - где заканчивается второй и начинается третий лод + static float2_t m_vDistLods; + + //! дистанция с которой начнет уменьшаться трава, пределы [0, m_vDistLods.x) + static float m_fDistGrassLessening; + + //! использовать ли сортировку от ближнего к дальнему для сплитов + static bool m_isUseSortFrontToBackSplits; + + //! direct3d device + static IDirect3DDevice9* m_pDXDevice; + + //###################################################################### SX_ALIGNED_OP_MEM - Green(); - ~Green(); + CGreen(); + ~CGreen(); - ID Init(StaticGeom* geom, const char* name, - const char* path_mask, - float count_max, - const char* path, const char* lod1, const char* lod2, - const char* navmesh); + //********************************************************************** - ID GetIDSplit(ID id, float3* pos); - ID AddObject(ID id, float3* pos, GreenDataVertex* data, ID* idsplit); - void DelObject(ID id, ID idsplit, ID idobj); - void GetPosObject(ID id, ID idsplit, ID idobj, float3_t* pos); - void SetPosObject(ID id, ID* idsplit, ID* idobj, float3_t* pos); + ID init( + CStaticGeom *pGeom, const char *szName, + const char *szPathMask, + float fCountMax, + const char *szPath, const char *szLod1, const char *szLod2, + const char *szPhysMesh + ); - void DelGreen(ID id); + ID getIDSplit(ID idGreen, float3 *pPos); + ID addObject(ID idGreen, float3 *pPos, CGreenDataVertex *pData, ID *pIDsplit); + void deleteObject(ID idGreen, ID idSplit, ID idObj); + void getPosObject(ID idGreen, ID idSplit, ID idObj, float3_t *pPos); + void setPosObject(ID idGreen, ID *pIDsplit, ID *pIDobj, const float3_t *pPos); + + void deleteGreen(ID idGreen); - void OnLostDevice(); - void OnResetDevice(); + void onLostDevice(); + void onResetDevice(); - ID AddArrForCom(); - bool existsArrForCom(ID id); - void DelArrForCom(ID id_arr); + ID addArrForCom(); + bool existsArrForCom(ID idGreen); + void deleteArrForCom(ID idArr); - void Save(const char* path); - void Load(const char* path); - void Clear(); - void CPUFillingArrIndeces(const ISXFrustum* frustum, float3* viewpos, ID id_arr = 0); - void GPURender(DWORD timeDelta, float3* viewpos, GREEN_TYPE type, ID id_arr = 0); - void GPURenderSingly(DWORD timeDelta, float3* viewpos, ID id, ID id_tex); - void GPURenderObject(DWORD timeDelta, float3* viewpos, ID id, ID split, ID idobj, ID id_tex); - - ID GetCountGreen(); - char* GetGreenName(ID id); - long GetGreenCountGen(ID id); - long GetGreenCountPoly(ID id); - int GetGreenTypeCountGen(ID id); - const char* GetGreenModel(ID id); - const char* GetGreenLod1(ID id); - const char* GetGreenLod2(ID id); - const char* GetGreenMask(ID id); - const char* GetGreenNav(ID id); - void SetGreenLod(ID id, int lod, const char* pathname); - void SetGreenNav(ID id, const char* pathname); - - void GetNavMeshAndTransform(float3_t*** arr_vertex, int32_t** arr_count_vertex, uint32_t*** arr_index, ID*** arr_mtl, int32_t** arr_count_index, GreenDataVertex*** arr_transform, int32_t** arr_count_transform, int32_t* arr_count_green); - bool GetOccurencessLeafGrass(float3* bbmin, float3* bbmax, int physic_mtl); + void save(const char *szPath); + void load(const char *szPath); + void clear(); + void comArrIndeces(const ISXFrustum *pFrustum, const float3 *pViewPos, ID idArr = 0); + void render(DWORD timeDelta, const float3 *pViewPos, GREEN_TYPE type, ID idArr = 0); + void renderSingly(DWORD timeDelta, const float3 *pViewPos, ID id, ID idTexture); + void renderObject(DWORD timeDelta, const float3 *pViewPos, ID id, ID idSplit, ID idObj, ID idTexture); + + ID getCountGreen(); + char* getGreenName(ID idGreen); + int getGreenCountGen(ID idGreen); + int getGreenCountPoly(ID idGreen); + int getGreenTypeCountGen(ID idGreen); + const char* getGreenModel(ID idGreen); + const char* getGreenLod1(ID idGreen); + const char* getGreenLod2(ID idGreen); + const char* getGreenMask(ID idGreen); + const char* getGreenNav(ID idGreen); + void setGreenLod(ID idGreen, int iLod, const char *szPathName); + void setGreenNav(ID idGreen, const char *szPathName); + + void getNavMeshAndTransform(float3_t ***pppArrVertex, int32_t **ppArrCountVertex, uint32_t ***pppArrIndex, ID ***pppArrMtl, int32_t **ppArrCountIndex, CGreenDataVertex ***pppArrTransform, int32_t **ppArrCountTransform, int32_t *pArrCountGreen); + bool getOccurencessLeafGrass(float3 *pMin, float3 *pMax, int iPhysicMtl); - bool TraceBeam(float3* start, float3* dir, float3* _res, ID* idgreen, ID* idsplits, ID* idobj, ID* idmtl); + bool traceBeam(const float3 *pStart, const float3 *pDir, float3 *pResult, ID *pIDgreen, ID *pIDsplits, ID *pIDobj, ID *pIDmtl); + + //###################################################################### - // - struct Segment + //! сегмент пространства с растительностью + struct CSegment { SX_ALIGNED_OP_MEM - Segment(); - ~Segment(); + CSegment(); + ~CSegment(); - Segment* Splits[GREEN_COUNT_TYPE_SEGMENTATION]; //массив из 4 частей данного участка + //! массив из 4 частей данного участка + CSegment *m_aSplits[GREEN_COUNT_TYPE_SEGMENTATION]; - GreenDataVertex* Data; - DWORD CountAllGreen; //количество элементов + //! массив данных трансформаций каждого элемента данного куска + CGreenDataVertex *m_pObjData; - ISXBound* BoundVolumeSys; //выравненный ограничивающий объем для равномерного деления - ISXBound* BoundVolumeP; //облегающий ограничивающий объем + //! количество элементов + int m_iCountObj; - float DistForCamera; + //! выравненный ограничивающий объем для равномерного деления + ISXBound *m_pBoundVolumeSys; + + //! облегающий ограничивающий объем + ISXBound *m_pBoundVolumeP; + + //! дистация от камеры + float m_fDistForCamera; + + //! идентификатор куска + ID m_id; + + //! имеет ли кусок куски внутри себя? + bool m_idNonEnd; - ID Id; //идентификатор куска - //ID3DXMesh* BoundBox; //ограничивающий параллелепипед (меш) - bool BFNonEnd;//имеет ли кусок куски внутри себя? }; - struct Lod + //********************************************************************** + + //! лод растительности + struct CLod { - Lod(); - ~Lod(); - String path; - Array<ID> idstex; - ISXDataStaticModel* model; + CLod(); + ~CLod(); + + //! путь до лода + String m_sPath; + + //! массив текстур лода + Array<ID> m_aIDsTextures; + + //! статическая модель + ISXDataStaticModel *m_pModel; }; - struct Model + //********************************************************************** + + //! модель растительности, в том числе лоды и навигационные оболочки + struct CModel { SX_ALIGNED_OP_MEM - Model(); - ~Model(); + CModel(); + ~CModel(); - struct NavMesh + //! класс физической модели для растительности, формат модели стандартный + struct CPhysMesh { - NavMesh(); - ~NavMesh(); - float3_t* arr_vertex; - int32_t count_vertex; - uint32_t* arr_index; - ID* arr_mtl; - int32_t count_index; - String pathname; + CPhysMesh(); + ~CPhysMesh(); + + //! массив вершин + float3_t *m_pArrVertex; + + //! количество вершин в массиве m_pArrVertex + int32_t m_iCountVertex; + + //! массив индексов + uint32_t *m_pArrIndex; + + //! количество индексов в массиве m_pArrIndex + int32_t m_iCountIndex; + + //! массив id материалов последовательно для каждого индекса их m_pArrIndex + ID *m_pArrMtl; + + //! путь до статической модели + String m_sPathName; }; - GREEN_TYPE TypeGreen; // - String MaskName; - uint32_t AllCountGreen; //сколько всего сгенерировано объектов - char Name[OBJECT_NAME_MAX_LEN]; - NavMesh* NavigateMesh; - - Segment* SplitsTree; - Array<Segment*> SplitsArr; - float3 BBMax, BBMin; - GreenDataVertex* AllTrans;// - Lod* ArrLod[GREEN_COUNT_LOD]; - ID SplitsIDs; //общее количество сегментов/спилтов + //! тип растительности + GREEN_TYPE m_typeGreen; + + //! имя текстуры маски + String m_szMaskName; + + //! сколько всего сгенерировано объектов + uint32_t m_uiCountObj; + + //! имя объекта растительности + char m_szName[OBJECT_NAME_MAX_LEN]; + + //! физическая модель + CPhysMesh *m_pPhysMesh; + + //! начальный/главный сплит пространства + CSegment *m_pSplitsTree; + + //! массив всех конечных сплитов пространтва + Array<CSegment*> m_aSplitsArr; + + //! экстремумы пространства занимаемого этой растительностью + float3 m_vMax, m_vMin; + + //! массив трансформаций всех объектов растительности + CGreenDataVertex *m_pAllTrans; + + //! массив лодов + CLod *m_aLods[GREEN_COUNT_LOD]; + + //! общее количество сегментов/сплитов + ID m_idCountSplits; }; - //структура содержащая минимальную необходимую информацию о сегменте модели - struct InfoRenderSegments + //********************************************************************** + + //! структура содержащая минимальную необходимую информацию о сегменте модели для рендера + struct CInfoRenderSegments { - InfoRenderSegments(); - ~InfoRenderSegments(); - Segment** Arr; //массив хранящий в себе указатели на сегменты REALTIME - DWORD Count; //размер Arr - DWORD CountCom; //сколько сегментов записано в Arr REALTIME + CInfoRenderSegments(); + ~CInfoRenderSegments(); + + //!массив хранящий в себе указатели на сегменты REALTIME + CSegment **m_ppSegments; + + //! размер Arr + int m_iCount; + + //! сколько сегментов записано в Arr REALTIME + int m_iCountCom; }; - struct IRSData + //********************************************************************** + + //! данные для просчетов видимости + struct CIRSData { - IRSData(); - ~IRSData(); - Array<Segment*, GREEN_DEFAULT_RESERVE_COM> queue; - Array<InfoRenderSegments*> arr; + CIRSData(); + ~CIRSData(); + + //! очередь обработки просчетов видимости для каждого сегмента + Array<CSegment*, GREEN_DEFAULT_RESERVE_COM> m_aQueue; + + //! массив информации для рендера сегментов + Array<CInfoRenderSegments*> m_aIRS; }; protected: - Array<IRSData*> ArrComFor; //информация о сегментах для рендера - void SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue); - void LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue); - void GPURender2(DWORD timeDelta, float3* viewpos, ID nm, int lod, ID id_tex); - void AlignBound(Model* model, Segment* split); - void GenByTex(StaticGeom* geom, Model* model, ID idmask, float3* min, float3* max, float count_max); - - void GetPartBeam(float3* pos, float3 * dir, Segment** arrsplits, DWORD *count, Segment* comsegment, ID curr_splits_ids_render); - void GetPartBB(float3* bbmin, float3 * bbmax, Segment** arrsplits, DWORD *count, Segment* comsegment, ID curr_splits_ids_render); + + void saveSplit(CSegment *pSplit, FILE *pFile, Array<CSegment*> *pQueue); + void loadSplit(CSegment **ppSplit, FILE * file, Array<CSegment**> *pQueue); + void render2(DWORD timeDelta, const float3 *pViewPos, ID nm, int iLod, ID idTexture); + void alignBound(CModel *pModel, CSegment *pSplit); + void genByTex(CStaticGeom *pGeom, CModel *pModel, ID idMask, float3 *pMin, float3 *pMax, float fCountMax); - void ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits, DWORD *count, Segment* comsegment, float3* viewpos, Array<Segment*, GREEN_DEFAULT_RESERVE_COM>* queue, ID curr_splits_ids_render); + void getPartBeam(const float3 *pPos, const float3 *pDir, CSegment **ppArrSplits, int *pCount, CSegment *pSegment, ID idCurrSplitRender); + void getPartBB(float3 *pMin, float3 *pMax, CSegment **ppArrSplits, int *pCount, CSegment *pSegment, ID idCurrSplitRender); - void AddModelInArrCom(ID id_model); - void DelModelInArrCom(ID id_model); + void comRecArrIndeces(const ISXFrustum *pFrustum, CSegment **ppArrSplits, int *pCount, CSegment *pSegment, const float3 *pViewPos, Array<CSegment*, GREEN_DEFAULT_RESERVE_COM> *pQueue, ID idCurrSplitRender); - Array<Model*> ArrModels; - IDirect3DVertexBuffer9* TransVertBuf; //буфер вершин с трансформациями растительности - IDirect3DVertexDeclaration9* VertexDeclarationGreen; + void addModelInArrCom(ID idModel); + void deleteModelInArrCom(ID idModel); - void PreSegmentation(Model* model, float3* min_level, float3* max_level); - void CycleSegmentation(Segment* Split, Model* mesh); - void Segmentation(Segment* Split, Model* mesh); - void SetSplitID(Model* model); - void SetSplitID2(Model* model, Segment* Split, Array<Segment*, GREEN_DEFAULT_RESERVE_COM>* queue); + void preSegmentation(CModel *pModel, float3 *pMinLevel, float3 *pMaxLevel); + void cycleSegmentation(CSegment *pSplit, CModel *pMesh); + void segmentation(CSegment *pSplit, CModel *pMesh); + void setSplitID(CModel *pModel); + void setSplitID2(CModel *pModel, CSegment *pSplit, Array<CSegment*, GREEN_DEFAULT_RESERVE_COM> *pQueue); + + //********************************************************************** + + //! информация о сегментах для рендера + Array<CIRSData*> m_aArrComFor; + + //! количество элементов текущей растительности для отрисовки + int m_iCurrCountDrawObj; - long RTCountDrawObj; - GreenDataVertex* RTGPUArrVerteces; - D3DXMATRIX mat; + //! массив всех green + Array<CModel*> m_aGreens; - Segment** jarrsplits; - DWORD jcount; + //! буфер вершин с трансформациями растительности + IDirect3DVertexBuffer9 *m_pTransVertBuf; - DWORD jCountIndex; + //! декларация вершин + IDirect3DVertexDeclaration9 *m_pVertexDeclarationGreen; }; diff --git a/source/geom/static_geom.cpp b/source/geom/static_geom.cpp index a29726b9ca7d1e90046ac09317f7aaf6c918f3f1..42b1ee3d74c7dab91c64a2bc8185ff7f3b7f8bbe 100644 --- a/source/geom/static_geom.cpp +++ b/source/geom/static_geom.cpp @@ -6,162 +6,164 @@ See the license in LICENSE #include "static_geom.h" -StaticGeom::Segment::Segment() +CStaticGeom::CSegment::CSegment() { for (int i = 0; i < GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++i) { - Splits[i] = 0; + m_aSplits[i] = 0; } - ArrPoly = 0; - CountPoly = 0; - NumberGroup = 0; - NumberGroupModel = 0; - CountSubSet = 0; - CountAllPoly = 0; - BoundVolumeSys = 0; - BoundVolumeP = 0; - ID = -1; - SID = -1; - BFNonEnd = false; + m_ppArrPoly = 0; + m_pCountPoly = 0; + m_pNumberGroup = 0; + m_pNumberGroupModel = 0; + m_uiCountSubSet = 0; + m_uiCountAllPoly = 0; + m_pBoundVolumeSys = 0; + m_pBoundVolumeP = 0; + m_ID = -1; + m_SID = -1; + m_isNonEnd = false; } -StaticGeom::Segment::~Segment() +CStaticGeom::CSegment::~CSegment() { for (int i = 0; i < GEOM_COUNT_TYPE_SEGMENTATION_OCTO; i++) { - mem_delete(Splits[i]); + mem_delete(m_aSplits[i]); } - mem_delete_a(NumberGroup); - mem_delete_a(NumberGroupModel); - mem_delete_a(CountPoly); + mem_delete_a(m_pNumberGroup); + mem_delete_a(m_pNumberGroupModel); + mem_delete_a(m_pCountPoly); - if (ArrPoly) + if (m_ppArrPoly) { - for (DWORD i = 0; i < CountSubSet; i++) + for (DWORD i = 0; i < m_uiCountSubSet; i++) { - mem_delete_a(ArrPoly[i]); + mem_delete_a(m_ppArrPoly[i]); } } - mem_delete_a(ArrPoly); - mem_release_del(BoundVolumeSys); - mem_release_del(BoundVolumeP); + mem_delete_a(m_ppArrPoly); + mem_release_del(m_pBoundVolumeSys); + mem_release_del(m_pBoundVolumeP); //ndx_release(BoundBox); } -StaticGeom::Group::Group() +CStaticGeom::CGroup::CGroup() { - name = ""; - idtex = -1; - SortGroup = 0; - AllCountVertex = AllCountIndex = 0; + m_sName = ""; + m_idTexture = -1; + m_iSortGroup = 0; + m_iCountVertex = m_iCountIndex = 0; } -/*StaticGeom::Group::VertexBuff::VertexBuff() +/*CStaticGeom::Group::VertexBuff::VertexBuff() { arr = 0; count = 0; } -StaticGeom::Group::VertexBuff::~VertexBuff() +CStaticGeom::Group::VertexBuff::~VertexBuff() { mem_delete_a(arr); count = 0; }*/ -StaticGeom::Group::~Group() +CStaticGeom::CGroup::~CGroup() { - idtex = -1; - AllCountVertex = AllCountIndex = 0; - CountVertex.clear(); - CountIndex.clear(); + m_idTexture = -1; + m_iCountVertex = m_iCountIndex = 0; + m_aCountVertex.clear(); + m_aCountIndex.clear(); - for (long i = 0; i < VertexBuffer.size(); ++i) + for (int i = 0; i < m_aVertexBuffers.size(); ++i) { - mem_release_del(VertexBuffer[i]); + mem_release_del(m_aVertexBuffers[i]); //mem_delete(VertexBufferOrigin[i]); } } -StaticGeom::Model::Lod::Lod() +CStaticGeom::CModel::CLod::CLod() { - PathName[0] = 0; - model = 0; - BoundVolume = SGCore_CrBound(); + m_szPathName[0] = 0; + m_pModel = 0; + m_pBoundVolume = SGCore_CrBound(); } -StaticGeom::Model::Lod::~Lod() +CStaticGeom::CModel::CLod::~CLod() { - mem_release_del(model); - mem_release_del(BoundVolume); + mem_release_del(m_pModel); + mem_release_del(m_pBoundVolume); } -StaticGeom::Model::Model() +CStaticGeom::CModel::CModel() { - SplitsIDs = SplitsIDsRender = 0; - ArrSplits = 0; - Position = float3(0,0,0); - Rotation = float3(0,0,0); - Scale = float3(1,1,1); + m_idCountSplits = m_idCountSplitsRender = 0; + m_pArrSplits = 0; + m_vPosition = float3(0, 0, 0); + m_vRotation = float3(0, 0, 0); + m_vScale = float3(1, 1, 1); - OldPosition = Position; - OldRotation = Rotation; - OldScale = Scale; + m_vOldPosition = m_vPosition; + m_vOldRotation = m_vRotation; + m_vOldScale = m_vScale; - CountPoly = 0; + m_uiCountPoly = 0; - Name[0] = 0; - PathName[0] = 0; - IsRenderLod = false; + m_szName[0] = 0; + m_szPathName[0] = 0; + m_isRenderLod = false; } -StaticGeom::Model::~Model() +CStaticGeom::CModel::~CModel() { - SplitsIDs = SplitsIDsRender = 0; - SubSet.clear(); - mem_delete(ArrSplits); + m_idCountSplits = m_idCountSplitsRender = 0; + m_aSubSets.clear(); + mem_delete(m_pArrSplits); } -StaticGeom::InfoRenderSegments::InfoRenderSegments() +CStaticGeom::CInfoRenderSegments::CInfoRenderSegments() { - Arr = 0; Count = 0; CountCom = 0; + m_ppSegments = 0; m_iCount = 0; m_iCountCom = 0; } -StaticGeom::InfoRenderSegments::~InfoRenderSegments() +CStaticGeom::CInfoRenderSegments::~CInfoRenderSegments() { - mem_delete_a(Arr); + mem_delete_a(m_ppSegments); } -StaticGeom::IRSData::IRSData() +CStaticGeom::CIRSData::CIRSData() { } -StaticGeom::IRSData::~IRSData() +CStaticGeom::CIRSData::~CIRSData() { - queue.clear(); - for (int i = 0; i < arr.size(); ++i) + m_aQueue.clear(); + for (int i = 0; i < m_aIRS.size(); ++i) { - mem_delete(arr[i]); + mem_delete(m_aIRS[i]); } - arr.clear(); + m_aIRS.clear(); } -StaticGeom::StaticGeom() +CStaticGeom::CStaticGeom() { - SizeRenderIndexBuffer = 0; - RenderIndexBuffer = 0; - RTCPUArrIndicesPtrs = 0; + m_iSizeRenderIndexBuffer = 0; + m_pRenderIndexBuffer = 0; + + m_pppRTArrIndices = 0; + m_ppRTCountDrawPoly = 0; + m_pppRTCountDrawPolyModel = 0; + m_pppRTBeginIndexModel = 0; - WorldMat = SMMatrixIdentity(); + m_mWorld = SMMatrixIdentity(); - ArrMeshVertex = 0; - ArrMeshIndex = 0; - jvevyn = D3DXVECTOR3(0.0f, -1000.0f, 0.0f); - jvevyp = D3DXVECTOR3(0.0f, 1000.0f, 0.0f); + m_pCurrArrMeshVertex = 0; + m_pCurrArrMeshIndex = 0; - BoundVolume = SGCore_CrBound(); + m_pBoundVolume = SGCore_CrBound(); /*D3DVERTEXELEMENT9 layoutstatic[] = { @@ -171,62 +173,62 @@ StaticGeom::StaticGeom() D3DDECL_END() }; - StaticGeom::DXDevice->CreateVertexDeclaration(layoutstatic, &VertexDeclarationStatic);*/ + CStaticGeom::m_pDXDevice->CreateVertexDeclaration(layoutstatic, &VertexDeclarationStatic);*/ - IRSData* tmparr = new IRSData(); - ArrComFor.push_back(tmparr); - IRSData* tmparr2 = new IRSData(); - ArrComFor.push_back(tmparr2); + CIRSData* tmparr = new CIRSData(); + m_aArrComFor.push_back(tmparr); + CIRSData* tmparr2 = new CIRSData(); + m_aArrComFor.push_back(tmparr2); } -StaticGeom::~StaticGeom() +CStaticGeom::~CStaticGeom() { - for (long i = 0; i < ArrComFor.size(); ++i) + for (int i = 0; i < m_aArrComFor.size(); ++i) { - mem_delete(ArrComFor[i]); + mem_delete(m_aArrComFor[i]); } - ArrComFor.clear(); - mem_delete_a(ArrMeshVertex); - mem_delete_a(ArrMeshIndex); - mem_release(RenderIndexBuffer); + m_aArrComFor.clear(); + mem_delete_a(m_pCurrArrMeshVertex); + mem_delete_a(m_pCurrArrMeshIndex); + mem_release(m_pRenderIndexBuffer); //mem_release(VertexDeclarationStatic); - mem_release(BoundVolume); + mem_release(m_pBoundVolume); - DelArrIndexPtr(); + deleteArrIndexPtr(); - for (long i = 0; i < AllModels.size(); ++i) + for (int i = 0; i < m_aAllModels.size(); ++i) { - mem_delete(AllModels[i]); + mem_delete(m_aAllModels[i]); } - AllModels.clear(); + m_aAllModels.clear(); - for (long i = 0; i < AllGroups.size(); ++i) + for (int i = 0; i < m_aAllGroups.size(); ++i) { - mem_delete(AllGroups[i]); + mem_delete(m_aAllGroups[i]); } - AllGroups.clear(); + m_aAllGroups.clear(); } -void StaticGeom::OnLostDevice() +void CStaticGeom::onLostDevice() { - mem_release_del(RenderIndexBuffer); + mem_release_del(m_pRenderIndexBuffer); } -void StaticGeom::OnResetDevice() +void CStaticGeom::onResetDevice() { - StaticGeom::DXDevice->CreateIndexBuffer(sizeof(uint32_t)* SizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &RenderIndexBuffer, 0); + CStaticGeom::m_pDXDevice->CreateIndexBuffer(sizeof(uint32_t)* m_iSizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &m_pRenderIndexBuffer, 0); } -long StaticGeom::GetCountModel() +int CStaticGeom::getCountModel() { - return AllModels.size(); + return m_aAllModels.size(); } -ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name) +ID CStaticGeom::addModel(const char* path, const char* lod1, const char* name) { LibReport(0, "load geometry: '%s'.. ", path); - DelArrIndexPtr(); + deleteArrIndexPtr(); ISXDataStaticModel* model = 0; @@ -234,14 +236,14 @@ ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name) sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), path); SGCore_StaticModelLoad(tmppath, &model); - Model* tmpmodel = new Model(); - ID tmpidmodel = AllModels.size() - 1; + CModel* tmpmodel = new CModel(); + ID tmpidmodel = m_aAllModels.size() - 1; if (!def_str_validate(name)) - sprintf(tmpmodel->Name, ""); + sprintf(tmpmodel->m_szName, ""); else - sprintf(tmpmodel->Name, "%s", name); + sprintf(tmpmodel->m_szName, "%s", name); - sprintf(tmpmodel->PathName, "%s", path); + sprintf(tmpmodel->m_szPathName, "%s", path); bool isunictex = true; //уникальна ли подгруппа в модели? (то есть, нет ли данной подгруппы в списке уже загруженных) @@ -256,11 +258,11 @@ ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name) for (int i = 0; i < model->m_uiSubsetCount; ++i) { - tmpmodel->CountPoly += model->m_pIndexCount[i] / 3; + tmpmodel->m_uiCountPoly += model->m_pIndexCount[i] / 3; char tmptex[1024]; sprintf(tmptex, "%s.dds", model->m_ppTextures[i]); - tmpmodel->IDTex[i] = SGCore_MtlLoad(tmptex, MTL_TYPE_GEOM); + tmpmodel->m_aIDsTexures[i] = SGCore_MtlLoad(tmptex, MTL_TYPE_GEOM); @@ -273,16 +275,16 @@ ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name) isunictex = true; - for (int k = 0; k < AllGroups.size(); ++k) + for (int k = 0; k < m_aAllGroups.size(); ++k) { //сравниваем подгруппы только по имени, если имена одинаковые значит это одна и та же подгруппа - if (stricmp(AllGroups[k]->name.c_str(), model->m_ppTextures[i]) == 0) + if (stricmp(m_aAllGroups[k]->m_sName.c_str(), model->m_ppTextures[i]) == 0) { isunictex = false; - Model::GDataBuff gdb; + CModel::CSubSet gdb; - gdb.idgroup = k; + gdb.m_idGroup = k; IDirect3DVertexBuffer9* vb; @@ -290,25 +292,25 @@ ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name) vertex_static * pData2; //если последний незаполненный буфер не вмещает в себ¤ - if (AllGroups[k]->CountIndex[AllGroups[k]->CountIndex.size() - 1] / 3 + model->m_pIndexCount[i] / 3 > GEOM_MAX_POLY_IN_GROUP) + if (m_aAllGroups[k]->m_aCountIndex[m_aAllGroups[k]->m_aCountIndex.size() - 1] / 3 + model->m_pIndexCount[i] / 3 > GEOM_MAX_POLY_IN_GROUP) { //создаем новый - gdb.VertexStart = 0; - gdb.VertexCount = model->m_pVertexCount[i]; + gdb.m_idVertexStart = 0; + gdb.m_uiVertexCount = model->m_pVertexCount[i]; - StaticGeom::DXDevice->CreateVertexBuffer(sizeof(vertex_static)* model->m_pVertexCount[i], NULL, NULL, D3DPOOL_MANAGED, &vb, 0); + CStaticGeom::m_pDXDevice->CreateVertexBuffer(sizeof(vertex_static)* model->m_pVertexCount[i], NULL, NULL, D3DPOOL_MANAGED, &vb, 0); /*Group::VertexBuff* vborigin = new Group::VertexBuff(); vborigin->count = model->VertexCount[i]; vborigin->arr = new float3_t[vborigin->count]; - for (long j = 0; j < model->VertexCount[i]; ++j) + for (int j = 0; j < model->VertexCount[i]; ++j) { vborigin->arr[j] = (model->ArrVertBuf + model->StartVertex[i] + j)->Pos; } - AllGroups[k]->VertexBufferOrigin.push_back(vborigin);*/ + m_aAllGroups[k]->VertexBufferOrigin.push_back(vborigin);*/ - AllGroups[k]->AllCountVertex += model->m_pVertexCount[i]; - AllGroups[k]->CountVertex.push_back(model->m_pVertexCount[i]); + m_aAllGroups[k]->m_iCountVertex += model->m_pVertexCount[i]; + m_aAllGroups[k]->m_aCountVertex.push_back(model->m_pVertexCount[i]); //копируем данные в новый вершинный буфер if (!FAILED(vb->Lock(0, 0, (void**)&pData, 0))) { @@ -316,115 +318,115 @@ ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name) vb->Unlock(); } - AllGroups[k]->VertexBuffer.push_back(vb); + m_aAllGroups[k]->m_aVertexBuffers.push_back(vb); - gdb.IndexStart = 0; - gdb.IndexCount = model->m_pIndexCount[i]; - AllGroups[k]->AllCountIndex += model->m_pIndexCount[i]; - AllGroups[k]->CountIndex.push_back(model->m_pIndexCount[i]); + gdb.m_idIndexStart = 0; + gdb.m_uiIndexCount = model->m_pIndexCount[i]; + m_aAllGroups[k]->m_iCountIndex += model->m_pIndexCount[i]; + m_aAllGroups[k]->m_aCountIndex.push_back(model->m_pIndexCount[i]); - gdb.idbuff = AllGroups[k]->VertexBuffer.size()-1; + gdb.m_idBuff = m_aAllGroups[k]->m_aVertexBuffers.size() - 1; - AllGroups[k]->ArrModels[gdb.idbuff].push_back(tmpmodel); + m_aAllGroups[k]->m_aModels[gdb.m_idBuff].push_back(tmpmodel); - if (SizeRenderIndexBuffer < model->m_pIndexCount[i]) + if (m_iSizeRenderIndexBuffer < model->m_pIndexCount[i]) { - mem_release(RenderIndexBuffer); - SizeRenderIndexBuffer = model->m_pIndexCount[i]; - StaticGeom::DXDevice->CreateIndexBuffer(sizeof(uint32_t)* SizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &RenderIndexBuffer, 0); + mem_release(m_pRenderIndexBuffer); + m_iSizeRenderIndexBuffer = model->m_pIndexCount[i]; + CStaticGeom::m_pDXDevice->CreateIndexBuffer(sizeof(uint32_t)* m_iSizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &m_pRenderIndexBuffer, 0); } } //иначе если влезет в буфер else { //впихиваем в буфер - gdb.idbuff = AllGroups[k]->VertexBuffer.size() - 1; - Array<Model*>& tmparrmodel = AllGroups[k]->ArrModels[gdb.idbuff]; - AllGroups[k]->ArrModels[gdb.idbuff].push_back(tmpmodel); - long lastvbnum = AllGroups[k]->VertexBuffer.size() - 1; + gdb.m_idBuff = m_aAllGroups[k]->m_aVertexBuffers.size() - 1; + Array<CModel*>& tmparrmodel = m_aAllGroups[k]->m_aModels[gdb.m_idBuff]; + m_aAllGroups[k]->m_aModels[gdb.m_idBuff].push_back(tmpmodel); + int lastvbnum = m_aAllGroups[k]->m_aVertexBuffers.size() - 1; - StaticGeom::DXDevice->CreateVertexBuffer(sizeof(vertex_static)* (AllGroups[k]->CountVertex[lastvbnum] + model->m_pVertexCount[i]), NULL, NULL, D3DPOOL_MANAGED, &vb, 0); + CStaticGeom::m_pDXDevice->CreateVertexBuffer(sizeof(vertex_static)* (m_aAllGroups[k]->m_aCountVertex[lastvbnum] + model->m_pVertexCount[i]), NULL, NULL, D3DPOOL_MANAGED, &vb, 0); /*Group::VertexBuff* vborigin = new Group::VertexBuff(); - vborigin->count = (AllGroups[k]->CountVertex[lastvbnum] + model->VertexCount[i]); + vborigin->count = (m_aAllGroups[k]->CountVertex[lastvbnum] + model->VertexCount[i]); vborigin->arr = new float3_t[vborigin->count]; - memcpy(vborigin->arr, AllGroups[k]->VertexBufferOrigin[lastvbnum]->arr, sizeof(float3_t) * AllGroups[k]->CountVertex[lastvbnum]); - for (long j = 0; j < model->VertexCount[i]; ++j) + memcpy(vborigin->arr, m_aAllGroups[k]->VertexBufferOrigin[lastvbnum]->arr, sizeof(float3_t) * m_aAllGroups[k]->CountVertex[lastvbnum]); + for (int j = 0; j < model->VertexCount[i]; ++j) { - vborigin->arr[AllGroups[k]->CountVertex[lastvbnum]+j] = (model->ArrVertBuf + model->StartVertex[i] + j)->Pos; + vborigin->arr[m_aAllGroups[k]->CountVertex[lastvbnum]+j] = (model->ArrVertBuf + model->StartVertex[i] + j)->Pos; } - mem_delete(AllGroups[k]->VertexBufferOrigin[lastvbnum]); - AllGroups[k]->VertexBufferOrigin[lastvbnum] = vborigin;*/ + mem_delete(m_aAllGroups[k]->VertexBufferOrigin[lastvbnum]); + m_aAllGroups[k]->VertexBufferOrigin[lastvbnum] = vborigin;*/ - gdb.VertexStart = AllGroups[k]->CountVertex[lastvbnum]; - gdb.VertexCount = model->m_pVertexCount[i]; + gdb.m_idVertexStart = m_aAllGroups[k]->m_aCountVertex[lastvbnum]; + gdb.m_uiVertexCount = model->m_pVertexCount[i]; if (!FAILED(vb->Lock(0, 0, (void**)&pData, 0))) { - if (!FAILED(AllGroups[k]->VertexBuffer[lastvbnum]->Lock(0, 0, (void**)&pData2, 0))) + if (!FAILED(m_aAllGroups[k]->m_aVertexBuffers[lastvbnum]->Lock(0, 0, (void**)&pData2, 0))) { - memcpy(pData, pData2, sizeof(vertex_static)* AllGroups[k]->CountVertex[lastvbnum]); - AllGroups[k]->VertexBuffer[lastvbnum]->Unlock(); + memcpy(pData, pData2, sizeof(vertex_static)* m_aAllGroups[k]->m_aCountVertex[lastvbnum]); + m_aAllGroups[k]->m_aVertexBuffers[lastvbnum]->Unlock(); } - memcpy(pData + AllGroups[k]->CountVertex[lastvbnum], pVert + model->m_pStartVertex[i], sizeof(vertex_static)* (model->m_pVertexCount[i])); + memcpy(pData + m_aAllGroups[k]->m_aCountVertex[lastvbnum], pVert + model->m_pStartVertex[i], sizeof(vertex_static)* (model->m_pVertexCount[i])); vb->Unlock(); } - AllGroups[k]->AllCountVertex += model->m_pVertexCount[i]; - AllGroups[k]->CountVertex[lastvbnum] += model->m_pVertexCount[i]; - mem_release(AllGroups[k]->VertexBuffer[lastvbnum]); - AllGroups[k]->VertexBuffer[lastvbnum] = vb; + m_aAllGroups[k]->m_iCountVertex += model->m_pVertexCount[i]; + m_aAllGroups[k]->m_aCountVertex[lastvbnum] += model->m_pVertexCount[i]; + mem_release(m_aAllGroups[k]->m_aVertexBuffers[lastvbnum]); + m_aAllGroups[k]->m_aVertexBuffers[lastvbnum] = vb; - gdb.IndexStart = AllGroups[k]->CountIndex[lastvbnum]; - gdb.IndexCount = model->m_pIndexCount[i]; + gdb.m_idIndexStart = m_aAllGroups[k]->m_aCountIndex[lastvbnum]; + gdb.m_uiIndexCount = model->m_pIndexCount[i]; - AllGroups[k]->AllCountIndex += model->m_pIndexCount[i]; - AllGroups[k]->CountIndex[lastvbnum] += model->m_pIndexCount[i]; + m_aAllGroups[k]->m_iCountIndex += model->m_pIndexCount[i]; + m_aAllGroups[k]->m_aCountIndex[lastvbnum] += model->m_pIndexCount[i]; - if (SizeRenderIndexBuffer < (AllGroups[k]->CountIndex[lastvbnum] + model->m_pIndexCount[i])) + if (m_iSizeRenderIndexBuffer < (m_aAllGroups[k]->m_aCountIndex[lastvbnum] + model->m_pIndexCount[i])) { - mem_release(RenderIndexBuffer); - SizeRenderIndexBuffer = (AllGroups[k]->CountIndex[lastvbnum] + model->m_pIndexCount[i]); - StaticGeom::DXDevice->CreateIndexBuffer(sizeof(uint32_t)* SizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &RenderIndexBuffer, 0); + mem_release(m_pRenderIndexBuffer); + m_iSizeRenderIndexBuffer = (m_aAllGroups[k]->m_aCountIndex[lastvbnum] + model->m_pIndexCount[i]); + CStaticGeom::m_pDXDevice->CreateIndexBuffer(sizeof(uint32_t)* m_iSizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &m_pRenderIndexBuffer, 0); } } - tmpmodel->SubSet.push_back(gdb); + tmpmodel->m_aSubSets.push_back(gdb); } } if (isunictex) { - Group* ngroup = new Group(); - Model::GDataBuff gdb; + CGroup* ngroup = new CGroup(); + CModel::CSubSet gdb; - ngroup->ArrModels[0].push_back(tmpmodel); + ngroup->m_aModels[0].push_back(tmpmodel); - gdb.idbuff = 0; - gdb.idgroup = AllGroups.size(); - gdb.VertexStart = 0; - gdb.VertexCount = model->m_pVertexCount[i]; - gdb.IndexStart = 0; - gdb.IndexCount = model->m_pIndexCount[i]; + gdb.m_idBuff = 0; + gdb.m_idGroup = m_aAllGroups.size(); + gdb.m_idVertexStart = 0; + gdb.m_uiVertexCount = model->m_pVertexCount[i]; + gdb.m_idIndexStart = 0; + gdb.m_uiIndexCount = model->m_pIndexCount[i]; - tmpmodel->SubSet.push_back(gdb); + tmpmodel->m_aSubSets.push_back(gdb); IDirect3DVertexBuffer9* vb; - StaticGeom::DXDevice->CreateVertexBuffer(sizeof(vertex_static)* model->m_pVertexCount[i], NULL, NULL, D3DPOOL_MANAGED, &vb, 0); + CStaticGeom::m_pDXDevice->CreateVertexBuffer(sizeof(vertex_static)* model->m_pVertexCount[i], NULL, NULL, D3DPOOL_MANAGED, &vb, 0); /*Group::VertexBuff* vborigin = new Group::VertexBuff(); vborigin->count = model->VertexCount[i]; vborigin->arr = new float3_t[vborigin->count]; - for (long k = 0; k < model->VertexCount[i]; ++k) + for (int k = 0; k < model->VertexCount[i]; ++k) { vborigin->arr[k] = (model->ArrVertBuf + model->StartVertex[i] + k)->Pos; }*/ - ngroup->AllCountVertex = model->m_pVertexCount[i]; - ngroup->CountVertex.push_back(model->m_pVertexCount[i]); + ngroup->m_iCountVertex = model->m_pVertexCount[i]; + ngroup->m_aCountVertex.push_back(model->m_pVertexCount[i]); vertex_static * pData; if (!FAILED(vb->Lock(0, 0, (void**)&pData, 0))) { @@ -432,27 +434,27 @@ ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name) vb->Unlock(); } - ngroup->AllCountIndex = model->m_pIndexCount[i]; - ngroup->CountIndex.push_back(model->m_pIndexCount[i]); + ngroup->m_iCountIndex = model->m_pIndexCount[i]; + ngroup->m_aCountIndex.push_back(model->m_pIndexCount[i]); - ngroup->VertexBuffer.push_back(vb); + ngroup->m_aVertexBuffers.push_back(vb); //ngroup->VertexBufferOrigin.push_back(vborigin); - if (SizeRenderIndexBuffer < model->m_pIndexCount[i]) + if (m_iSizeRenderIndexBuffer < model->m_pIndexCount[i]) { - mem_release(RenderIndexBuffer); - SizeRenderIndexBuffer = model->m_pIndexCount[i]; - StaticGeom::DXDevice->CreateIndexBuffer(sizeof(uint32_t)* SizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &RenderIndexBuffer, 0); + mem_release(m_pRenderIndexBuffer); + m_iSizeRenderIndexBuffer = model->m_pIndexCount[i]; + CStaticGeom::m_pDXDevice->CreateIndexBuffer(sizeof(uint32_t)* m_iSizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &m_pRenderIndexBuffer, 0); } //char tmptex[1024]; //sprintf(tmptex, "%s.dds", model->ArrTextures[i]); - ngroup->idtex = tmpmodel->IDTex[i];// SGCore_LoadMtl(tmptex, MTL_GEOM); - ngroup->SortGroup = SGCore_MtlGetSort(ngroup->idtex); - ngroup->IsRenderSingly = SGCore_MtlGroupRenderIsSingly(ngroup->idtex); - ngroup->name = model->m_ppTextures[i]; - AllGroups.push_back(ngroup); + ngroup->m_idTexture = tmpmodel->m_aIDsTexures[i];// SGCore_LoadMtl(tmptex, MTL_GEOM); + ngroup->m_iSortGroup = SGCore_MtlGetSort(ngroup->m_idTexture); + ngroup->m_isRenderSingly = SGCore_MtlGroupRenderIsSingly(ngroup->m_idTexture); + ngroup->m_sName = model->m_ppTextures[i]; + m_aAllGroups.push_back(ngroup); } @@ -491,37 +493,37 @@ ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name) float3 tmpMM = SMVectorLerp(tmpMax, tmpMin, 0.5f); - D3DXPlaneFromPoints(&tmpmodel->SubSet[i].Plane, + D3DXPlaneFromPoints(&tmpmodel->m_aSubSets[i].m_oPlane, &D3DXVECTOR3(pData[indeces[model->m_pStartIndex[i] + 0]].Pos.x, pData[indeces[model->m_pStartIndex[i] + 0]].Pos.y, pData[indeces[model->m_pStartIndex[i] + 0]].Pos.z), &D3DXVECTOR3(pData[indeces[model->m_pStartIndex[i] + 1]].Pos.x, pData[indeces[model->m_pStartIndex[i] + 1]].Pos.y, pData[indeces[model->m_pStartIndex[i] + 1]].Pos.z), &D3DXVECTOR3(pData[indeces[model->m_pStartIndex[i] + 2]].Pos.x, pData[indeces[model->m_pStartIndex[i] + 2]].Pos.y, pData[indeces[model->m_pStartIndex[i] + 2]].Pos.z)); model->m_pVertexBuffer->Unlock(); model->m_pIndexBuffer->Unlock(); - tmpmodel->SubSet[i].Center = (float3_t)((tmpMax + tmpMin) * 0.5); - tmpmodel->SubSet[i].Min = tmpMin; - tmpmodel->SubSet[i].Max = tmpMax; + tmpmodel->m_aSubSets[i].m_vCenter = (float3_t)((tmpMax + tmpMin) * 0.5); + tmpmodel->m_aSubSets[i].m_vMin = tmpMin; + tmpmodel->m_aSubSets[i].m_vMax = tmpMax; } model->m_pVertexBuffer->Unlock(); model->m_pIndexBuffer->Unlock(); - AllModels.push_back(tmpmodel); + m_aAllModels.push_back(tmpmodel); - SetModelLodPath(AllModels.size() - 1, lod1); + setModelLodPath(m_aAllModels.size() - 1, lod1); - PreSegmentation(tmpmodel, model); + preSegmentation(tmpmodel, model); - SetSplitID(tmpmodel->ArrSplits, &tmpmodel->SplitsIDs, &tmpmodel->SplitsIDsRender); + setSplitID(tmpmodel->m_pArrSplits, &tmpmodel->m_idCountSplits, &tmpmodel->m_idCountSplitsRender); - AddModelInArrCom(AllModels.size() - 1); + addModelInArrCom(m_aAllModels.size() - 1); - InitArrIndexPtr(); + initArrIndexPtr(); float3 jmin, jmax, jmin2, jmax2; - AllModels[AllModels.size()-1]->ArrSplits->BoundVolumeP->getMinMax(&jmin, &jmax); - BoundVolume->getMinMax(&jmin2, &jmax2); + m_aAllModels[m_aAllModels.size()-1]->m_pArrSplits->m_pBoundVolumeP->getMinMax(&jmin, &jmax); + m_pBoundVolume->getMinMax(&jmin2, &jmax2); if (jmin2.x > jmin.x) jmin2.x = jmin.x; @@ -537,89 +539,89 @@ ID StaticGeom::AddModel(const char* path, const char* lod1, const char* name) if (jmax2.z < jmax.z) jmax2.z = jmax.z; - BoundVolume->setMinMax(&jmin2, &jmax2); + m_pBoundVolume->setMinMax(&jmin2, &jmax2); mem_release_del(model); - mem_delete_a(ArrMeshVertex); - mem_delete_a(ArrMeshIndex); + mem_delete_a(m_pCurrArrMeshVertex); + mem_delete_a(m_pCurrArrMeshIndex); LibReport(0, " completed\n", path); - return AllModels.size() - 1; + return m_aAllModels.size() - 1; } -void StaticGeom::DelModel(ID id) +void CStaticGeom::deleteModel(ID id) { - if (id >= AllModels.size()) + if (id >= m_aAllModels.size()) return; - Model* tmpmodel = AllModels[id]; + CModel* tmpmodel = m_aAllModels[id]; //ПРЕЖДЕ НАДО ОЧИСТИТЬ БУФЕРЫ КОТОРЫЕ ЗАПОЛНЯЮТСЯ ИНДЕКСНЫМИ ДАННЫМИ, ИБО ПОСЛЕ УДАЛЕНИЯ МОДЕЛИ ДАННЫЕ ДЛЯ ОЧИТСКИ БУДУТ УЖЕ НЕКОРРЕТНЫЕ - DelArrIndexPtr(); + deleteArrIndexPtr(); vertex_static* pData, *pData2, *pData3; ID idgroup; ID idbuff; - for (long i = 0; i < tmpmodel->SubSet.size(); ++i) + for (int i = 0; i < tmpmodel->m_aSubSets.size(); ++i) { - idgroup = tmpmodel->SubSet[i].idgroup; - idbuff = tmpmodel->SubSet[i].idbuff; + idgroup = tmpmodel->m_aSubSets[i].m_idGroup; + idbuff = tmpmodel->m_aSubSets[i].m_idBuff; - long tmpcountvertexi = AllGroups[idgroup]->CountVertex[idbuff]; - long tmpcountvertex = tmpmodel->SubSet[i].VertexCount; - long tmpcountstartvertex = tmpmodel->SubSet[i].VertexStart; + int tmpcountvertexi = m_aAllGroups[idgroup]->m_aCountVertex[idbuff]; + int tmpcountvertex = tmpmodel->m_aSubSets[i].m_uiVertexCount; + int tmpcountstartvertex = tmpmodel->m_aSubSets[i].m_idVertexStart; //если количество удаляемых вершин меньше чем общее количество вершин в буфере подгруппы - if (AllGroups[idgroup]->CountVertex[idbuff] > tmpmodel->SubSet[i].VertexCount) + if (m_aAllGroups[idgroup]->m_aCountVertex[idbuff] > tmpmodel->m_aSubSets[i].m_uiVertexCount) { //производим удаление, путем пересоздания есесно IDirect3DVertexBuffer9* vb; - StaticGeom::DXDevice->CreateVertexBuffer(sizeof(vertex_static)* (AllGroups[idgroup]->CountVertex[idbuff] - tmpmodel->SubSet[i].VertexCount), NULL, NULL, D3DPOOL_MANAGED, &vb, 0); + CStaticGeom::m_pDXDevice->CreateVertexBuffer(sizeof(vertex_static)* (m_aAllGroups[idgroup]->m_aCountVertex[idbuff] - tmpmodel->m_aSubSets[i].m_uiVertexCount), NULL, NULL, D3DPOOL_MANAGED, &vb, 0); /*Group::VertexBuff* vborigin = new Group::VertexBuff(); - vborigin->count = (AllGroups[idgroup]->CountVertex[idbuff] - tmpmodel->SubSet[i].VertexCount); + vborigin->count = (m_aAllGroups[idgroup]->CountVertex[idbuff] - tmpmodel->m_aSubSets[i].VertexCount); vborigin->arr = new float3_t[vborigin->count];*/ vb->Lock(0, 0, (void**)&pData, 0); - AllGroups[idgroup]->VertexBuffer[idbuff]->Lock(0, 0, (void**)&pData2, 0); - long tmpvertexstart = tmpmodel->SubSet[i].VertexStart; - memcpy(pData, pData2, sizeof(vertex_static)* tmpmodel->SubSet[i].VertexStart); - //memcpy(vborigin->arr, AllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr, sizeof(float3_t)* tmpmodel->SubSet[i].VertexStart); - if (AllGroups[idgroup]->CountVertex[idbuff] - (tmpmodel->SubSet[i].VertexStart + tmpmodel->SubSet[i].VertexCount) > 0) + m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Lock(0, 0, (void**)&pData2, 0); + int tmpvertexstart = tmpmodel->m_aSubSets[i].m_idVertexStart; + memcpy(pData, pData2, sizeof(vertex_static)* tmpmodel->m_aSubSets[i].m_idVertexStart); + //memcpy(vborigin->arr, m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr, sizeof(float3_t)* tmpmodel->m_aSubSets[i].VertexStart); + if (m_aAllGroups[idgroup]->m_aCountVertex[idbuff] - (tmpmodel->m_aSubSets[i].m_idVertexStart + tmpmodel->m_aSubSets[i].m_uiVertexCount) > 0) { - memcpy(pData + tmpmodel->SubSet[i].VertexStart, pData2 + tmpmodel->SubSet[i].VertexStart + tmpmodel->SubSet[i].VertexCount, sizeof(vertex_static)* (AllGroups[idgroup]->CountVertex[idbuff] - (tmpmodel->SubSet[i].VertexStart + tmpmodel->SubSet[i].VertexCount))); - //memcpy(vborigin->arr + tmpmodel->SubSet[i].VertexStart, AllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr + tmpmodel->SubSet[i].VertexStart + tmpmodel->SubSet[i].VertexCount, sizeof(float3_t)* (AllGroups[idgroup]->CountVertex[idbuff] - (tmpmodel->SubSet[i].VertexStart + tmpmodel->SubSet[i].VertexCount))); + memcpy(pData + tmpmodel->m_aSubSets[i].m_idVertexStart, pData2 + tmpmodel->m_aSubSets[i].m_idVertexStart + tmpmodel->m_aSubSets[i].m_uiVertexCount, sizeof(vertex_static)* (m_aAllGroups[idgroup]->m_aCountVertex[idbuff] - (tmpmodel->m_aSubSets[i].m_idVertexStart + tmpmodel->m_aSubSets[i].m_uiVertexCount))); + //memcpy(vborigin->arr + tmpmodel->m_aSubSets[i].VertexStart, m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr + tmpmodel->m_aSubSets[i].VertexStart + tmpmodel->m_aSubSets[i].VertexCount, sizeof(float3_t)* (m_aAllGroups[idgroup]->CountVertex[idbuff] - (tmpmodel->m_aSubSets[i].VertexStart + tmpmodel->m_aSubSets[i].VertexCount))); } vb->Unlock(); - AllGroups[idgroup]->VertexBuffer[idbuff]->Unlock(); + m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Unlock(); //обновляем данные и производим замену - AllGroups[idgroup]->AllCountVertex -= tmpmodel->SubSet[i].VertexCount; - AllGroups[idgroup]->CountVertex[idbuff] -= tmpmodel->SubSet[i].VertexCount; + m_aAllGroups[idgroup]->m_iCountVertex -= tmpmodel->m_aSubSets[i].m_uiVertexCount; + m_aAllGroups[idgroup]->m_aCountVertex[idbuff] -= tmpmodel->m_aSubSets[i].m_uiVertexCount; - AllGroups[idgroup]->AllCountIndex -= tmpmodel->SubSet[i].IndexCount; - AllGroups[idgroup]->CountIndex[idbuff] -= tmpmodel->SubSet[i].IndexCount; + m_aAllGroups[idgroup]->m_iCountIndex -= tmpmodel->m_aSubSets[i].m_uiIndexCount; + m_aAllGroups[idgroup]->m_aCountIndex[idbuff] -= tmpmodel->m_aSubSets[i].m_uiIndexCount; - mem_release(AllGroups[idgroup]->VertexBuffer[idbuff]); - AllGroups[idgroup]->VertexBuffer[idbuff] = vb; + mem_release(m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]); + m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff] = vb; - /*mem_delete(AllGroups[idgroup]->VertexBufferOrigin[idbuff]); - AllGroups[idgroup]->VertexBufferOrigin[idbuff] = vborigin;*/ + /*mem_delete(m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]); + m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff] = vborigin;*/ } //если количество моделей в массиве больше одной - if (AllGroups[idgroup]->ArrModels[idbuff].size() > 1) + if (m_aAllGroups[idgroup]->m_aModels[idbuff].size() > 1) { //находим удаляемую модель в массиве моделей в буфере данной подгруппы - long tmpidingroup = -1; //id модели в текущем массиве, в подгруппе - for (int k = 0; k < AllGroups[idgroup]->ArrModels[idbuff].size(); ++k) + int tmpidingroup = -1; //id модели в текущем массиве, в подгруппе + for (int k = 0; k < m_aAllGroups[idgroup]->m_aModels[idbuff].size(); ++k) { - Model* tmptmpmodel = AllGroups[idgroup]->ArrModels[idbuff][k]; - if (AllGroups[idgroup]->ArrModels[idbuff][k] == tmpmodel) + CModel* tmptmpmodel = m_aAllGroups[idgroup]->m_aModels[idbuff][k]; + if (m_aAllGroups[idgroup]->m_aModels[idbuff][k] == tmpmodel) { tmpidingroup = k; break; @@ -634,43 +636,43 @@ void StaticGeom::DelModel(ID id) } //обновляем данные в подгруппе модели о стартовых позициях - for (int k = tmpidingroup + 1; k < AllGroups[idgroup]->ArrModels[idbuff].size(); ++k) + for (int k = tmpidingroup + 1; k < m_aAllGroups[idgroup]->m_aModels[idbuff].size(); ++k) { - Model* tmptmpmodel = AllGroups[idgroup]->ArrModels[idbuff][k]; - for (int j = 0; j < AllGroups[idgroup]->ArrModels[idbuff][k]->SubSet.size(); ++j) + CModel* tmptmpmodel = m_aAllGroups[idgroup]->m_aModels[idbuff][k]; + for (int j = 0; j < m_aAllGroups[idgroup]->m_aModels[idbuff][k]->m_aSubSets.size(); ++j) { - if (tmptmpmodel->SubSet[j].idgroup == idgroup) + if (tmptmpmodel->m_aSubSets[j].m_idGroup == idgroup) { - tmptmpmodel->SubSet[j].IndexStart -= tmpmodel->SubSet[i].IndexCount; - tmptmpmodel->SubSet[j].VertexStart -= tmpmodel->SubSet[i].VertexCount; + tmptmpmodel->m_aSubSets[j].m_idIndexStart -= tmpmodel->m_aSubSets[i].m_uiIndexCount; + tmptmpmodel->m_aSubSets[j].m_idVertexStart -= tmpmodel->m_aSubSets[i].m_uiVertexCount; break; } } //обновляем также все индексы во всех сплитах - Array<Segment*, GEOM_DEFAULT_RESERVE_COM> queue; - queue.push_back(AllGroups[idgroup]->ArrModels[idbuff][k]->ArrSplits); + Array<CSegment*, GEOM_DEFAULT_RESERVE_COM> queue; + queue.push_back(m_aAllGroups[idgroup]->m_aModels[idbuff][k]->m_pArrSplits); while (queue.size()) { - if (queue[0]->BFNonEnd) + if (queue[0]->m_isNonEnd) { for (int j = 0; j < GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++j) { - if (queue[0]->Splits[j]) - queue.push_back(queue[0]->Splits[j]); + if (queue[0]->m_aSplits[j]) + queue.push_back(queue[0]->m_aSplits[j]); } } else { - for (int j = 0; j < queue[0]->CountSubSet; ++j) + for (int j = 0; j < queue[0]->m_uiCountSubSet; ++j) { - if (queue[0]->NumberGroup[j] == idgroup ) + if (queue[0]->m_pNumberGroup[j] == idgroup ) { - for (int q = 0; q < queue[0]->CountPoly[j]*3; ++q) + for (int q = 0; q < queue[0]->m_pCountPoly[j]*3; ++q) { - queue[0]->ArrPoly[j][q] -= tmpmodel->SubSet[i].VertexCount; + queue[0]->m_ppArrPoly[j][q] -= tmpmodel->m_aSubSets[i].m_uiVertexCount; } } } @@ -681,67 +683,67 @@ void StaticGeom::DelModel(ID id) } //удал¤ем текущую удал¤емую модель из массива моделей буфера текущей подгруппы - AllGroups[idgroup]->ArrModels[idbuff].erase(tmpidingroup); + m_aAllGroups[idgroup]->m_aModels[idbuff].erase(tmpidingroup); } //если в буфере подгруппы всего одна модель, то значит эта та модель которую удаляем - else if (AllGroups[idgroup]->ArrModels[idbuff].size() == 1) - AllGroups[idgroup]->ArrModels[idbuff].erase(0); + else if (m_aAllGroups[idgroup]->m_aModels[idbuff].size() == 1) + m_aAllGroups[idgroup]->m_aModels[idbuff].erase(0); //если количество удалемых вершин больше либо равно количеству имеющихся в буфере подгруппы if (tmpcountvertexi <= tmpcountvertex) { //то теряется смысл данного буфера, и надо его удалить - Group* tmpgroup = AllGroups[idgroup]; + CGroup* tmpgroup = m_aAllGroups[idgroup]; - tmpgroup->CountVertex.erase(idbuff); - tmpgroup->CountIndex.erase(idbuff); - mem_release(tmpgroup->VertexBuffer[idbuff]); - //IDirect3DVertexBuffer9* vb = AllGroups[idgroup]->VertexBuffer[idbuff]; - tmpgroup->VertexBuffer.erase(idbuff); - tmpgroup->ArrModels.erase(idbuff); - //Group::VertexBuff* tmpduff = AllGroups[idgroup]->VertexBufferOrigin[idbuff]; + tmpgroup->m_aCountVertex.erase(idbuff); + tmpgroup->m_aCountIndex.erase(idbuff); + mem_release(tmpgroup->m_aVertexBuffers[idbuff]); + //IDirect3DVertexBuffer9* vb = m_aAllGroups[idgroup]->VertexBuffer[idbuff]; + tmpgroup->m_aVertexBuffers.erase(idbuff); + tmpgroup->m_aModels.erase(idbuff); + //Group::VertexBuff* tmpduff = m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]; /*mem_delete(tmpgroup->VertexBufferOrigin[idbuff]); tmpgroup->VertexBufferOrigin.erase(idbuff);*/ } //если подгруппа пустая, то обрабатываем все значения что больше идентификатора группы - if (AllGroups[idgroup]->CountVertex.size() <= 0) + if (m_aAllGroups[idgroup]->m_aCountVertex.size() <= 0) { - //Group* tmpgroup = AllGroups[idgroup]; + //Group* tmpgroup = m_aAllGroups[idgroup]; //то есть декрементируем все идентфиикаторы подгрупп которые больше чем текущая удаляемая подгруппа //декремент произодим и у текущей удаляемой модели, ибо все будет смещено, а значит и в этой моделе должно быть все смещенно для корретных просчетов - for (int k = 0; k < AllModels.size(); ++k) + for (int k = 0; k < m_aAllModels.size(); ++k) { - Model* tmptmpmodel = AllModels[k]; + CModel* tmptmpmodel = m_aAllModels[k]; - for (long j = 0; j < tmptmpmodel->SubSet.size(); ++j) + for (int j = 0; j < tmptmpmodel->m_aSubSets.size(); ++j) { - if (tmptmpmodel->SubSet[j].idgroup > idgroup) - --(tmptmpmodel->SubSet[j].idgroup); + if (tmptmpmodel->m_aSubSets[j].m_idGroup > idgroup) + --(tmptmpmodel->m_aSubSets[j].m_idGroup); } //также проходимся и по всем сплитам чтобы и там произвести декремент - Array<Segment*, GEOM_DEFAULT_RESERVE_COM> queue; - queue.push_back(tmptmpmodel->ArrSplits); + Array<CSegment*, GEOM_DEFAULT_RESERVE_COM> queue; + queue.push_back(tmptmpmodel->m_pArrSplits); while (queue.size()) { - if (queue[0]->BFNonEnd) + if (queue[0]->m_isNonEnd) { for (int j = 0; j < GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++j) { - if (queue[0]->Splits[j]) - queue.push_back(queue[0]->Splits[j]); + if (queue[0]->m_aSplits[j]) + queue.push_back(queue[0]->m_aSplits[j]); } } else { - for (int j = 0; j < queue[0]->CountSubSet; ++j) + for (int j = 0; j < queue[0]->m_uiCountSubSet; ++j) { - if (queue[0]->NumberGroup[j] > idgroup) - --(queue[0]->NumberGroup[j]); + if (queue[0]->m_pNumberGroup[j] > idgroup) + --(queue[0]->m_pNumberGroup[j]); } } @@ -750,16 +752,16 @@ void StaticGeom::DelModel(ID id) } //удаляем подгруппу, за ненадобностью - mem_delete(AllGroups[idgroup]); - AllGroups.erase(idgroup); + mem_delete(m_aAllGroups[idgroup]); + m_aAllGroups.erase(idgroup); } //если подгруппа не пустая то может быть тогда можно где-то совместить буферы? else { - for (long k = 0; k < AllGroups[idgroup]->VertexBuffer.size(); ++k) + for (int k = 0; k < m_aAllGroups[idgroup]->m_aVertexBuffers.size(); ++k) { //можно ли совместить буферы - if (idbuff != k && AllGroups[idgroup]->CountIndex[idbuff] / 3 + AllGroups[idgroup]->CountIndex[k] / 3 <= GEOM_MAX_POLY_IN_GROUP) + if (idbuff != k && m_aAllGroups[idgroup]->m_aCountIndex[idbuff] / 3 + m_aAllGroups[idgroup]->m_aCountIndex[k] / 3 <= GEOM_MAX_POLY_IN_GROUP) { //СОВМЕЩАЕМ ТЕКУЩИЙ ОБРАБАТЫВАЕМЫЙ БУФЕР (idbuff) (ИЗ КОТОРОГО МОДЕЛЬ БЫЛА УДАЛЕНА С БУФЕРОМ В КОТОРЙ ОН ВМЕЩАЕТСЯ (k) //idbuff => k @@ -767,74 +769,74 @@ void StaticGeom::DelModel(ID id) //производим совмещение данных в буферах //{ IDirect3DVertexBuffer9* vb; - StaticGeom::DXDevice->CreateVertexBuffer(sizeof(vertex_static)* (AllGroups[idgroup]->CountVertex[idbuff] + AllGroups[idgroup]->CountVertex[k]), NULL, NULL, D3DPOOL_MANAGED, &vb, 0); + CStaticGeom::m_pDXDevice->CreateVertexBuffer(sizeof(vertex_static)* (m_aAllGroups[idgroup]->m_aCountVertex[idbuff] + m_aAllGroups[idgroup]->m_aCountVertex[k]), NULL, NULL, D3DPOOL_MANAGED, &vb, 0); /*Group::VertexBuff* vborigin = new Group::VertexBuff(); - vborigin->count = (AllGroups[idgroup]->CountVertex[idbuff] + AllGroups[idgroup]->CountVertex[k]); + vborigin->count = (m_aAllGroups[idgroup]->CountVertex[idbuff] + m_aAllGroups[idgroup]->CountVertex[k]); vborigin->arr = new float3_t[vborigin->count];*/ vb->Lock(0, 0, (void**)&pData, 0); - AllGroups[idgroup]->VertexBuffer[idbuff]->Lock(0, 0, (void**)&pData2, 0); - AllGroups[idgroup]->VertexBuffer[k]->Lock(0, 0, (void**)&pData3, 0); + m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Lock(0, 0, (void**)&pData2, 0); + m_aAllGroups[idgroup]->m_aVertexBuffers[k]->Lock(0, 0, (void**)&pData3, 0); - memcpy(pData, pData3, sizeof(vertex_static)* AllGroups[idgroup]->CountVertex[k]); - //memcpy(vborigin->arr, AllGroups[idgroup]->VertexBufferOrigin[k]->arr, sizeof(float3_t)* AllGroups[idgroup]->CountVertex[k]); + memcpy(pData, pData3, sizeof(vertex_static)* m_aAllGroups[idgroup]->m_aCountVertex[k]); + //memcpy(vborigin->arr, m_aAllGroups[idgroup]->VertexBufferOrigin[k]->arr, sizeof(float3_t)* m_aAllGroups[idgroup]->CountVertex[k]); - memcpy(pData + AllGroups[idgroup]->CountVertex[k], pData2, sizeof(vertex_static)* AllGroups[idgroup]->CountVertex[idbuff]); - //memcpy(vborigin->arr + AllGroups[idgroup]->CountVertex[k], AllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr, sizeof(float3_t)* AllGroups[idgroup]->CountVertex[idbuff]); + memcpy(pData + m_aAllGroups[idgroup]->m_aCountVertex[k], pData2, sizeof(vertex_static)* m_aAllGroups[idgroup]->m_aCountVertex[idbuff]); + //memcpy(vborigin->arr + m_aAllGroups[idgroup]->CountVertex[k], m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr, sizeof(float3_t)* m_aAllGroups[idgroup]->CountVertex[idbuff]); vb->Unlock(); - AllGroups[idgroup]->VertexBuffer[idbuff]->Unlock(); - AllGroups[idgroup]->VertexBuffer[k]->Unlock(); + m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Unlock(); + m_aAllGroups[idgroup]->m_aVertexBuffers[k]->Unlock(); //} //обновляем данные во всех моделях которые есть в текущем буфере - for (long m = 0; m < AllGroups[idgroup]->ArrModels[idbuff].size(); ++m) + for (int m = 0; m < m_aAllGroups[idgroup]->m_aModels[idbuff].size(); ++m) { - long tmpsizearrmodls = AllGroups[idgroup]->ArrModels[idbuff].size(); - Model* tmptmpmodel = AllGroups[idgroup]->ArrModels[idbuff][m]; + int tmpsizearrmodls = m_aAllGroups[idgroup]->m_aModels[idbuff].size(); + CModel* tmptmpmodel = m_aAllGroups[idgroup]->m_aModels[idbuff][m]; //обновляем данные в структуре инфе о перемещенном буфере - for (long j = 0; j < tmptmpmodel->SubSet.size(); ++j) + for (int j = 0; j < tmptmpmodel->m_aSubSets.size(); ++j) { - if (tmptmpmodel->SubSet[j].idgroup == idgroup) + if (tmptmpmodel->m_aSubSets[j].m_idGroup == idgroup) { //а именно, текущий буфер if (idbuff > k) - tmptmpmodel->SubSet[j].idbuff = k; + tmptmpmodel->m_aSubSets[j].m_idBuff = k; else - tmptmpmodel->SubSet[j].idbuff = k - 1; + tmptmpmodel->m_aSubSets[j].m_idBuff = k - 1; //и стартовые позиции - tmptmpmodel->SubSet[j].IndexStart += AllGroups[idgroup]->CountIndex[k]; - tmptmpmodel->SubSet[j].VertexStart += AllGroups[idgroup]->CountVertex[k]; + tmptmpmodel->m_aSubSets[j].m_idIndexStart += m_aAllGroups[idgroup]->m_aCountIndex[k]; + tmptmpmodel->m_aSubSets[j].m_idVertexStart += m_aAllGroups[idgroup]->m_aCountVertex[k]; break; } } //обновляем все индексы модели текущей подгруппы перемещенного буфера //{ - Array<Segment*, GEOM_DEFAULT_RESERVE_COM> queue; - queue.push_back(tmptmpmodel->ArrSplits); + Array<CSegment*, GEOM_DEFAULT_RESERVE_COM> queue; + queue.push_back(tmptmpmodel->m_pArrSplits); while (queue.size()) { - if (queue[0]->BFNonEnd) + if (queue[0]->m_isNonEnd) { for (int j = 0; j < GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++j) { - if (queue[0]->Splits[j]) - queue.push_back(queue[0]->Splits[j]); + if (queue[0]->m_aSplits[j]) + queue.push_back(queue[0]->m_aSplits[j]); } } else { - for (int j = 0; j < queue[0]->CountSubSet; ++j) + for (int j = 0; j < queue[0]->m_uiCountSubSet; ++j) { - if (queue[0]->NumberGroup[j] == idgroup) + if (queue[0]->m_pNumberGroup[j] == idgroup) { - for (int q = 0; q < queue[0]->CountPoly[j] * 3; ++q) + for (int q = 0; q < queue[0]->m_pCountPoly[j] * 3; ++q) { - queue[0]->ArrPoly[j][q] += AllGroups[idgroup]->CountVertex[k]; + queue[0]->m_ppArrPoly[j][q] += m_aAllGroups[idgroup]->m_aCountVertex[k]; } } } @@ -848,15 +850,15 @@ void StaticGeom::DelModel(ID id) //обновляем информацию во всех моделях у которых такая же подгруппа, но которые находились в буферах "выше" //сообщаем что они стали ниже на единицу //{ - for (long j = idbuff+1; j < AllGroups[idgroup]->ArrModels.size(); ++j) + for (int j = idbuff+1; j < m_aAllGroups[idgroup]->m_aModels.size(); ++j) { - for (long q = 0; q < AllGroups[idgroup]->ArrModels[j].size(); ++q) + for (int q = 0; q < m_aAllGroups[idgroup]->m_aModels[j].size(); ++q) { - for (long g = 0; g < AllGroups[idgroup]->ArrModels[j][q]->SubSet.size(); ++g) + for (int g = 0; g < m_aAllGroups[idgroup]->m_aModels[j][q]->m_aSubSets.size(); ++g) { - if (AllGroups[idgroup]->ArrModels[j][q]->SubSet[g].idgroup == idgroup && AllGroups[idgroup]->ArrModels[j][q]->SubSet[g].idbuff > idbuff) + if (m_aAllGroups[idgroup]->m_aModels[j][q]->m_aSubSets[g].m_idGroup == idgroup && m_aAllGroups[idgroup]->m_aModels[j][q]->m_aSubSets[g].m_idBuff > idbuff) { - --(AllGroups[idgroup]->ArrModels[j][q]->SubSet[g].idbuff); + --(m_aAllGroups[idgroup]->m_aModels[j][q]->m_aSubSets[g].m_idBuff); } } } @@ -865,28 +867,28 @@ void StaticGeom::DelModel(ID id) //обновляем информацию в k буфере, по ходу удаляем информацию в idbuff буфере //{ - AllGroups[idgroup]->CountVertex[k] += AllGroups[idgroup]->CountVertex[idbuff]; - AllGroups[idgroup]->CountIndex[k] += AllGroups[idgroup]->CountIndex[idbuff]; + m_aAllGroups[idgroup]->m_aCountVertex[k] += m_aAllGroups[idgroup]->m_aCountVertex[idbuff]; + m_aAllGroups[idgroup]->m_aCountIndex[k] += m_aAllGroups[idgroup]->m_aCountIndex[idbuff]; - mem_release(AllGroups[idgroup]->VertexBuffer[k]); - mem_release(AllGroups[idgroup]->VertexBuffer[idbuff]); - AllGroups[idgroup]->VertexBuffer[k] = vb; + mem_release(m_aAllGroups[idgroup]->m_aVertexBuffers[k]); + mem_release(m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]); + m_aAllGroups[idgroup]->m_aVertexBuffers[k] = vb; - /*mem_delete(AllGroups[idgroup]->VertexBufferOrigin[k]); - mem_delete(AllGroups[idgroup]->VertexBufferOrigin[idbuff]); - AllGroups[idgroup]->VertexBufferOrigin[k] = vborigin;*/ + /*mem_delete(m_aAllGroups[idgroup]->VertexBufferOrigin[k]); + mem_delete(m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]); + m_aAllGroups[idgroup]->VertexBufferOrigin[k] = vborigin;*/ //перемещаем все модели из idbuff буфера в тот с которым совмещаем - for (long m = 0; m < AllGroups[idgroup]->ArrModels[idbuff].size(); ++m) - AllGroups[idgroup]->ArrModels[k].push_back(AllGroups[idgroup]->ArrModels[idbuff][m]); + for (int m = 0; m < m_aAllGroups[idgroup]->m_aModels[idbuff].size(); ++m) + m_aAllGroups[idgroup]->m_aModels[k].push_back(m_aAllGroups[idgroup]->m_aModels[idbuff][m]); - AllGroups[idgroup]->CountVertex.erase(idbuff); - AllGroups[idgroup]->CountIndex.erase(idbuff); + m_aAllGroups[idgroup]->m_aCountVertex.erase(idbuff); + m_aAllGroups[idgroup]->m_aCountIndex.erase(idbuff); - AllGroups[idgroup]->ArrModels.erase(idbuff); + m_aAllGroups[idgroup]->m_aModels.erase(idbuff); - AllGroups[idgroup]->VertexBuffer.erase(idbuff); - //AllGroups[idgroup]->VertexBufferOrigin.erase(idbuff); + m_aAllGroups[idgroup]->m_aVertexBuffers.erase(idbuff); + //m_aAllGroups[idgroup]->VertexBufferOrigin.erase(idbuff); //} //ПРЕРЫВАЕМ ЦИКЛ, ТАК КАК УЖЕ ОБЪЕДИНИЛИ И ЭТОГО ХВАТИТ @@ -897,33 +899,33 @@ void StaticGeom::DelModel(ID id) } //удаляем модель из просчетов, как объект, и из массива тоже - DelModelInArrCom(id); - mem_delete(AllModels[id]); - AllModels.erase(id); + deleteModelInArrCom(id); + mem_delete(m_aAllModels[id]); + m_aAllModels.erase(id); //реинициализируем буферы для индексных данных рендера - InitArrIndexPtr(); + initArrIndexPtr(); } -void StaticGeom::SetSplitID(Segment* Split, ID* SplitsIDs, ID* SplitsIDsRender) +void CStaticGeom::setSplitID(CSegment* Split, ID* SplitsIDs, ID* SplitsIDsRender) { - Array<Segment*> queue; - long tmpcount = 0; + Array<CSegment*> queue; + int tmpcount = 0; queue.push_back(Split); while (queue.size()) { - if (queue[0] && queue[0]->BFNonEnd) + if (queue[0] && queue[0]->m_isNonEnd) { - queue[0]->ID = (*SplitsIDs); + queue[0]->m_ID = (*SplitsIDs); ++(*SplitsIDs); for (int i = 0; i<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; i++) - queue.push_back(queue[0]->Splits[i]); + queue.push_back(queue[0]->m_aSplits[i]); } else if (queue[0]) { - queue[0]->ID = (*SplitsIDs); - queue[0]->SID = (*SplitsIDsRender); + queue[0]->m_ID = (*SplitsIDs); + queue[0]->m_SID = (*SplitsIDsRender); ++(*SplitsIDs); ++(*SplitsIDsRender); } @@ -933,119 +935,121 @@ void StaticGeom::SetSplitID(Segment* Split, ID* SplitsIDs, ID* SplitsIDsRender) } } -void StaticGeom::DelArrIndexPtr() +void CStaticGeom::deleteArrIndexPtr() { - if (RTCPUArrIndicesPtrs) + if (m_pppRTArrIndices) { - for (long i = 0; i<AllGroups.size(); i++) + for (int i = 0; i < m_aAllGroups.size(); ++i) { - for (long k = 0; k < AllGroups[i]->VertexBuffer.size(); ++k) + for (int k = 0; k < m_aAllGroups[i]->m_aVertexBuffers.size(); ++k) { - mem_delete_a(RTCPUArrIndicesPtrs[i][k]); - mem_delete_a(RTCountDrawPolyModel[i][k]); - mem_delete_a(RTBeginIndexModel[i][k]); + mem_delete_a(m_pppRTArrIndices[i][k]); + mem_delete_a(m_pppRTCountDrawPolyModel[i][k]); + mem_delete_a(m_pppRTBeginIndexModel[i][k]); } - mem_delete_a(RTCountDrawPoly[i]); - mem_delete_a(RTCountDrawPolyModel[i]); - mem_delete_a(RTBeginIndexModel[i]); - mem_delete_a(RTCPUArrIndicesPtrs[i]); + mem_delete_a(m_ppRTCountDrawPoly[i]); + mem_delete_a(m_pppRTCountDrawPolyModel[i]); + mem_delete_a(m_pppRTBeginIndexModel[i]); + mem_delete_a(m_pppRTArrIndices[i]); } - mem_delete_a(RTCountDrawPoly); - mem_delete_a(RTCountDrawPolyModel); - mem_delete_a(RTBeginIndexModel); - mem_delete_a(RTCPUArrIndicesPtrs); + mem_delete_a(m_ppRTCountDrawPoly); + mem_delete_a(m_pppRTCountDrawPolyModel); + mem_delete_a(m_pppRTBeginIndexModel); + mem_delete_a(m_pppRTArrIndices); } } -void StaticGeom::InitArrIndexPtr() +void CStaticGeom::initArrIndexPtr() { - RTCPUArrIndicesPtrs = new uint32_t**[AllGroups.size()]; - RTCountDrawPoly = new uint32_t*[AllGroups.size()]; - RTCountDrawPolyModel = new uint32_t**[AllGroups.size()]; - RTBeginIndexModel = new uint32_t**[AllGroups.size()]; + m_pppRTArrIndices = new uint32_t**[m_aAllGroups.size()]; + m_ppRTCountDrawPoly = new uint32_t*[m_aAllGroups.size()]; + m_pppRTCountDrawPolyModel = new uint32_t**[m_aAllGroups.size()]; + m_pppRTBeginIndexModel = new uint32_t**[m_aAllGroups.size()]; - for (DWORD i = 0; i<AllGroups.size(); i++) + for (int i = 0; i<m_aAllGroups.size(); i++) { - RTCountDrawPoly[i] = new uint32_t[AllGroups[i]->VertexBuffer.size()]; - RTCPUArrIndicesPtrs[i] = new uint32_t*[AllGroups[i]->VertexBuffer.size()]; - RTCountDrawPolyModel[i] = new uint32_t*[AllGroups[i]->VertexBuffer.size()]; - RTBeginIndexModel[i] = new uint32_t*[AllGroups[i]->VertexBuffer.size()]; + m_ppRTCountDrawPoly[i] = new uint32_t[m_aAllGroups[i]->m_aVertexBuffers.size()]; + m_pppRTArrIndices[i] = new uint32_t*[m_aAllGroups[i]->m_aVertexBuffers.size()]; + m_pppRTCountDrawPolyModel[i] = new uint32_t*[m_aAllGroups[i]->m_aVertexBuffers.size()]; + m_pppRTBeginIndexModel[i] = new uint32_t*[m_aAllGroups[i]->m_aVertexBuffers.size()]; - for (long k = 0; k < AllGroups[i]->VertexBuffer.size(); ++k) - { - RTCPUArrIndicesPtrs[i][k] = new uint32_t[AllGroups[i]->CountIndex[k]]; - RTCountDrawPolyModel[i][k] = new uint32_t[AllGroups[i]->ArrModels[k].size()]; - RTBeginIndexModel[i][k] = new uint32_t[AllGroups[i]->ArrModels[k].size()]; - } + for (int k = 0; k < m_aAllGroups[i]->m_aVertexBuffers.size(); ++k) + { + m_pppRTArrIndices[i][k] = new uint32_t[m_aAllGroups[i]->m_aCountIndex[k]]; + m_pppRTCountDrawPolyModel[i][k] = new uint32_t[m_aAllGroups[i]->m_aModels[k].size()]; + m_pppRTBeginIndexModel[i][k] = new uint32_t[m_aAllGroups[i]->m_aModels[k].size()]; + } } } -void StaticGeom::CPUFillingArrIndeces(const ISXFrustum* frustum, float3* viewpos, ID id_arr) +void CStaticGeom::comArrIndeces(const ISXFrustum* frustum, const float3* viewpos, ID id_arr) { STATIC_PRECOND_ARRCOMFOR_ERR_ID(id_arr); - DWORD tmpcount = 0; - DWORD* tmpcountcom = 0; - Segment** tmpsegments = 0; + int tmpcount = 0; + int* tmpcountcom = 0; + CSegment** tmpsegments = 0; float jradius; float3 jcenter; - for(int i = 0, l = AllModels.size(); i < l; ++i) + for(int i = 0, l = m_aAllModels.size(); i < l; ++i) { if (id_arr == 0) { - AllModels[i]->ArrSplits->BoundVolumeP->getSphere(&jcenter, &jradius); - AllModels[i]->ArrSplits->DistForCamera = SMVector3Length((jcenter - (*viewpos))) - jradius; + m_aAllModels[i]->m_pArrSplits->m_pBoundVolumeP->getSphere(&jcenter, &jradius); + m_aAllModels[i]->m_pArrSplits->m_fDistForCamera = SMVector3Length((jcenter - (*viewpos))) - jradius; } - if (AllModels[i]->ArrSplits->DistForCamera >= StaticGeom::DistForLod && AllModels[i]->Lod0.model) - AllModels[i]->IsRenderLod = true; + if (m_aAllModels[i]->m_pArrSplits->m_fDistForCamera >= CStaticGeom::m_fDistForLod && m_aAllModels[i]->m_oLod0.m_pModel) + m_aAllModels[i]->m_isRenderLod = true; else { - AllModels[i]->IsRenderLod = false; - tmpcount = ArrComFor[id_arr]->arr[i]->Count; - ArrComFor[id_arr]->arr[i]->CountCom = 0; - tmpcountcom = &(ArrComFor[id_arr]->arr[i]->CountCom); - tmpsegments = ArrComFor[id_arr]->arr[i]->Arr; + m_aAllModels[i]->m_isRenderLod = false; + tmpcount = m_aArrComFor[id_arr]->m_aIRS[i]->m_iCount; + m_aArrComFor[id_arr]->m_aIRS[i]->m_iCountCom = 0; + tmpcountcom = &(m_aArrComFor[id_arr]->m_aIRS[i]->m_iCountCom); + tmpsegments = m_aArrComFor[id_arr]->m_aIRS[i]->m_ppSegments; - ArrComFor[id_arr]->queue.push_back(AllModels[i]->ArrSplits); + m_aArrComFor[id_arr]->m_aQueue.push_back(m_aAllModels[i]->m_pArrSplits); - while (ArrComFor[id_arr]->queue.size()) + while (m_aArrComFor[id_arr]->m_aQueue.size()) { - ComRecArrIndeces(frustum, tmpsegments, tmpcountcom, ArrComFor[id_arr]->queue[0], viewpos, &ArrComFor[id_arr]->queue, tmpcount); + comRecArrIndeces(frustum, tmpsegments, tmpcountcom, m_aArrComFor[id_arr]->m_aQueue[0], viewpos, &m_aArrComFor[id_arr]->m_aQueue, tmpcount); - ArrComFor[id_arr]->queue.erase(0); + m_aArrComFor[id_arr]->m_aQueue.erase(0); ++tmpcount; } + + m_aArrComFor[id_arr]->m_aQueue.clear(); } int qwert = 0; } } -void StaticGeom::ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits, DWORD *count, Segment* comsegment, float3* viewpos, Array<Segment*, GEOM_DEFAULT_RESERVE_COM>* queue, ID curr_splits_ids_render) +void CStaticGeom::comRecArrIndeces(const ISXFrustum* frustum, CSegment** arrsplits, int *count, CSegment* comsegment, const float3* viewpos, Array<CSegment*, GEOM_DEFAULT_RESERVE_COM>* queue, ID curr_splits_ids_render) { float jradius; float3 jcenter; - comsegment->BoundVolumeP->getSphere(&jcenter, &jradius); + comsegment->m_pBoundVolumeP->getSphere(&jcenter, &jradius); - if (comsegment->CountAllPoly > 0 && (frustum->sphereInFrustum(&jcenter, jradius))) + if (comsegment->m_uiCountAllPoly > 0 && (frustum->sphereInFrustum(&jcenter, jradius))) { - if (comsegment->BFNonEnd ) + if (comsegment->m_isNonEnd ) { - if (StaticGeom::UseSortFrontToBackSplits) + if (CStaticGeom::m_isUseSortFrontToBackSplits) { - long SortId[GEOM_COUNT_TYPE_SEGMENTATION_OCTO]; + int SortId[GEOM_COUNT_TYPE_SEGMENTATION_OCTO]; float DistFor[GEOM_COUNT_TYPE_SEGMENTATION_OCTO]; for (int q = 0; q<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++q) { SortId[q] = -1; - if (comsegment->Splits[q]) + if (comsegment->m_aSplits[q]) { - comsegment->Splits[q]->BoundVolumeP->getSphere(&jcenter, &jradius); + comsegment->m_aSplits[q]->m_pBoundVolumeP->getSphere(&jcenter, &jradius); DistFor[q] = SMVector3Length2((jcenter - (*viewpos))) - jradius*jradius; } } @@ -1054,14 +1058,14 @@ void StaticGeom::ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits int tmpCountGreater = 0; for (int i = 0; i<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++i) { - if (comsegment->Splits[i]) + if (comsegment->m_aSplits[i]) { tmpCountGreater = 0; pl1 = DistFor[i]; for (int k = 0; k<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++k) { - if (comsegment->Splits[k]) + if (comsegment->m_aSplits[k]) { pl2 = DistFor[k]; @@ -1086,16 +1090,16 @@ void StaticGeom::ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits for (int j = 0; j<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++j) { - if (SortId[(GEOM_COUNT_TYPE_SEGMENTATION_OCTO - 1) - j] != -1 && comsegment->Splits[SortId[(GEOM_COUNT_TYPE_SEGMENTATION_OCTO - 1) - j]]) - queue->push_back(comsegment->Splits[SortId[(GEOM_COUNT_TYPE_SEGMENTATION_OCTO - 1) - j]]); + if (SortId[(GEOM_COUNT_TYPE_SEGMENTATION_OCTO - 1) - j] != -1 && comsegment->m_aSplits[SortId[(GEOM_COUNT_TYPE_SEGMENTATION_OCTO - 1) - j]]) + queue->push_back(comsegment->m_aSplits[SortId[(GEOM_COUNT_TYPE_SEGMENTATION_OCTO - 1) - j]]); } } else { for (int j = 0; j<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++j) { - if (comsegment->Splits[j]) - queue->push_back(comsegment->Splits[j]); + if (comsegment->m_aSplits[j]) + queue->push_back(comsegment->m_aSplits[j]); } } } @@ -1104,7 +1108,7 @@ void StaticGeom::ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits if ((*count) < curr_splits_ids_render) { arrsplits[(*count)] = comsegment; - comsegment->DistForCamera = SMVector3Length((jcenter - (*viewpos))) - jradius; + comsegment->m_fDistForCamera = SMVector3Length((jcenter - (*viewpos))) - jradius; (*count)++; } /*else @@ -1115,29 +1119,29 @@ void StaticGeom::ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits } } -bool StaticGeom::SortExistsForRender(int sort, ID id_arr) +bool CStaticGeom::sortExistsForRender(int sort, ID id_arr) { //валиден ли id_arr? STATIC_PRECOND_ARRCOMFOR_ERR_ID(id_arr); - Segment** jarrsplits; + CSegment** jarrsplits; ID jidbuff; ID jnumgroup; //проходимся по всем моделям - for (int i = 0, l = AllModels.size(); i < l; ++i) + for (int i = 0, l = m_aAllModels.size(); i < l; ++i) { - if (ArrComFor[id_arr]->arr[i]->CountCom > 0) + if (m_aArrComFor[id_arr]->m_aIRS[i]->m_iCountCom > 0) { - for (int j = 0, jl = ArrComFor[id_arr]->arr[i]->CountCom; j<jl; j++) + for (int j = 0, jl = m_aArrComFor[id_arr]->m_aIRS[i]->m_iCountCom; j<jl; j++) { - jarrsplits = ArrComFor[id_arr]->arr[i]->Arr; - for (int k = 0; k<jarrsplits[j]->CountSubSet; ++k) + jarrsplits = m_aArrComFor[id_arr]->m_aIRS[i]->m_ppSegments; + for (int k = 0; k<jarrsplits[j]->m_uiCountSubSet; ++k) { - jidbuff = AllModels[i]->SubSet[jarrsplits[j]->NumberGroupModel[k]].idbuff; - jnumgroup = jarrsplits[j]->NumberGroup[k]; + jidbuff = m_aAllModels[i]->m_aSubSets[jarrsplits[j]->m_pNumberGroupModel[k]].m_idBuff; + jnumgroup = jarrsplits[j]->m_pNumberGroup[k]; - if (SGCore_MtlGetSort(AllGroups[jnumgroup]->idtex) == sort) + if (SGCore_MtlGetSort(m_aAllGroups[jnumgroup]->m_idTexture) == sort) return true; } } @@ -1147,72 +1151,72 @@ bool StaticGeom::SortExistsForRender(int sort, ID id_arr) return false; } -void StaticGeom::GPURender(DWORD timeDelta, int sort_mtl, ID id_arr, ID exclude_model_id, ID exclude_group_id, bool is_sorted) +void CStaticGeom::render(DWORD timeDelta, int sort_mtl, ID id_arr, ID exclude_model_id, ID exclude_group_id, bool is_sorted) { //валиден ли id_arr? STATIC_PRECOND_ARRCOMFOR_ERR_ID(id_arr); - Segment** jarrsplits; + CSegment** jarrsplits; ID jidbuff; ID jnumgroup; //обнуляем все данные об отрисованном в прошлый раз - for (int i = 0; i < AllGroups.size(); i++) + for (int i = 0; i < m_aAllGroups.size(); i++) { - if (AllGroups[i]) + if (m_aAllGroups[i]) { - for (int k = 0; k < AllGroups[i]->VertexBuffer.size(); ++k) + for (int k = 0; k < m_aAllGroups[i]->m_aVertexBuffers.size(); ++k) { - RTCountDrawPoly[i][k] = 0; + m_ppRTCountDrawPoly[i][k] = 0; - for (int j = 0; j < AllGroups[i]->ArrModels[k].size(); ++j) + for (int j = 0; j < m_aAllGroups[i]->m_aModels[k].size(); ++j) { - RTCountDrawPolyModel[i][k][j] = 0; - RTBeginIndexModel[i][k][j] = -1; + m_pppRTCountDrawPolyModel[i][k][j] = 0; + m_pppRTBeginIndexModel[i][k][j] = -1; } } } } //проходимся по всем моделям - for(int i = 0, l = AllModels.size(); i < l; ++i) + for(int i = 0, l = m_aAllModels.size(); i < l; ++i) { if (exclude_model_id == i && exclude_group_id < 0) continue; - if (AllModels[i]->IsRenderLod) + if (m_aAllModels[i]->m_isRenderLod) { - StaticGeom::DXDevice->SetStreamSource(0, AllModels[i]->Lod0.model->m_pVertexBuffer, 0, sizeof(vertex_static)); - StaticGeom::DXDevice->SetIndices(AllModels[i]->Lod0.model->m_pIndexBuffer); - StaticGeom::DXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl()); - for (int k = 0, kl = AllModels[i]->Lod0.model->m_uiSubsetCount; k < kl; ++k) + CStaticGeom::m_pDXDevice->SetStreamSource(0, m_aAllModels[i]->m_oLod0.m_pModel->m_pVertexBuffer, 0, sizeof(vertex_static)); + CStaticGeom::m_pDXDevice->SetIndices(m_aAllModels[i]->m_oLod0.m_pModel->m_pIndexBuffer); + CStaticGeom::m_pDXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl()); + for (int k = 0, kl = m_aAllModels[i]->m_oLod0.m_pModel->m_uiSubsetCount; k < kl; ++k) { - if (AllModels[i]->Lod0.SortGroup == sort_mtl || sort_mtl == -1) + if (m_aAllModels[i]->m_oLod0.m_iSortGroup == sort_mtl || sort_mtl == -1) { - SGCore_MtlSet(AllModels[i]->Lod0.IDsTexs[k], 0); - SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, AllModels[i]->Lod0.model->m_pVertexCount[k], AllModels[i]->Lod0.model->m_pStartIndex[k], AllModels[i]->Lod0.model->m_pIndexCount[k] / 3); - Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + AllModels[i]->Lod0.model->m_pIndexCount[k] / 3); + SGCore_MtlSet(m_aAllModels[i]->m_oLod0.m_aIDsTextures[k], 0); + SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, m_aAllModels[i]->m_oLod0.m_pModel->m_pVertexCount[k], m_aAllModels[i]->m_oLod0.m_pModel->m_pStartIndex[k], m_aAllModels[i]->m_oLod0.m_pModel->m_pIndexCount[k] / 3); + Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + m_aAllModels[i]->m_oLod0.m_pModel->m_pIndexCount[k] / 3); } } } - else if (ArrComFor[id_arr]->arr[i]->CountCom > 0) + else if (m_aArrComFor[id_arr]->m_aIRS[i]->m_iCountCom > 0) { - for(DWORD j = 0, jl = ArrComFor[id_arr]->arr[i]->CountCom; j<jl; j++) + for (DWORD j = 0, jl = m_aArrComFor[id_arr]->m_aIRS[i]->m_iCountCom; j<jl; j++) { - jarrsplits = ArrComFor[id_arr]->arr[i]->Arr; - for (DWORD k = 0; k<jarrsplits[j]->CountSubSet; ++k) + jarrsplits = m_aArrComFor[id_arr]->m_aIRS[i]->m_ppSegments; + for (DWORD k = 0; k<jarrsplits[j]->m_uiCountSubSet; ++k) { - jidbuff = AllModels[i]->SubSet[jarrsplits[j]->NumberGroupModel[k]].idbuff; - jnumgroup = jarrsplits[j]->NumberGroup[k]; + jidbuff = m_aAllModels[i]->m_aSubSets[jarrsplits[j]->m_pNumberGroupModel[k]].m_idBuff; + jnumgroup = jarrsplits[j]->m_pNumberGroup[k]; - if (exclude_model_id >= 0 && exclude_group_id == jarrsplits[j]->NumberGroupModel[k]) + if (exclude_model_id >= 0 && exclude_group_id == jarrsplits[j]->m_pNumberGroupModel[k]) continue; ID tmpcurrmodel = -1; - for(int q = 0, ql = AllGroups[jnumgroup]->ArrModels[jidbuff].size(); q<ql; ++q) + for(int q = 0, ql = m_aAllGroups[jnumgroup]->m_aModels[jidbuff].size(); q<ql; ++q) { - if (AllGroups[jnumgroup]->ArrModels[jidbuff][q] == AllModels[i]) + if (m_aAllGroups[jnumgroup]->m_aModels[jidbuff][q] == m_aAllModels[i]) { tmpcurrmodel = q; break; @@ -1224,26 +1228,26 @@ void StaticGeom::GPURender(DWORD timeDelta, int sort_mtl, ID id_arr, ID exclude_ int qwert = 0; } - int currsort = AllGroups[jnumgroup]->SortGroup; + int currsort = m_aAllGroups[jnumgroup]->m_iSortGroup; - if (AllGroups[jnumgroup]->SortGroup == sort_mtl || sort_mtl == -1) + if (m_aAllGroups[jnumgroup]->m_iSortGroup == sort_mtl || sort_mtl == -1) { if ( - jarrsplits[j]->CountPoly[k] > 0 && //если количество полигонов больше 0 - RTCountDrawPoly[jnumgroup][jidbuff] + jarrsplits[j]->CountPoly[k] <= AllGroups[jnumgroup]->CountIndex[jidbuff] / 3 //если количество записанных полигонов в данную подгруппу меньше либо равно общему количеству полигонов которое содержит данна¤ подгруппа + jarrsplits[j]->m_pCountPoly[k] > 0 && //если количество полигонов больше 0 + m_ppRTCountDrawPoly[jnumgroup][jidbuff] + jarrsplits[j]->m_pCountPoly[k] <= m_aAllGroups[jnumgroup]->m_aCountIndex[jidbuff] / 3 //если количество записанных полигонов в данную подгруппу меньше либо равно общему количеству полигонов которое содержит данна¤ подгруппа ) { - memcpy(RTCPUArrIndicesPtrs[jnumgroup][jidbuff] + (RTCountDrawPoly[jnumgroup][jidbuff] * 3), - jarrsplits[j]->ArrPoly[k], - jarrsplits[j]->CountPoly[k] * sizeof(uint32_t)* 3); + memcpy(m_pppRTArrIndices[jnumgroup][jidbuff] + (m_ppRTCountDrawPoly[jnumgroup][jidbuff] * 3), + jarrsplits[j]->m_ppArrPoly[k], + jarrsplits[j]->m_pCountPoly[k] * sizeof(uint32_t)* 3); - if (RTBeginIndexModel[jnumgroup][jidbuff][tmpcurrmodel] == -1) + if (m_pppRTBeginIndexModel[jnumgroup][jidbuff][tmpcurrmodel] == -1) { - RTBeginIndexModel[jnumgroup][jidbuff][tmpcurrmodel] = RTCountDrawPoly[jnumgroup][jidbuff]; + m_pppRTBeginIndexModel[jnumgroup][jidbuff][tmpcurrmodel] = m_ppRTCountDrawPoly[jnumgroup][jidbuff]; } - RTCountDrawPoly[jnumgroup][jidbuff] += jarrsplits[j]->CountPoly[k]; - RTCountDrawPolyModel[jnumgroup][jidbuff][tmpcurrmodel] += jarrsplits[j]->CountPoly[k]; + m_ppRTCountDrawPoly[jnumgroup][jidbuff] += jarrsplits[j]->m_pCountPoly[k]; + m_pppRTCountDrawPolyModel[jnumgroup][jidbuff][tmpcurrmodel] += jarrsplits[j]->m_pCountPoly[k]; } } } @@ -1258,57 +1262,57 @@ void StaticGeom::GPURender(DWORD timeDelta, int sort_mtl, ID id_arr, ID exclude_ if (!is_sorted) { //проходимся по всем подгруппам - for(int i = 0, l = AllGroups.size(); i < l; ++i) + for(int i = 0, l = m_aAllGroups.size(); i < l; ++i) { - Group* tmpgroup = AllGroups[i]; - if (!tmpgroup || tmpgroup->CountVertex.size() <= 0 || !(tmpgroup->SortGroup == sort_mtl || sort_mtl == -1)) + CGroup* tmpgroup = m_aAllGroups[i]; + if (!tmpgroup || tmpgroup->m_aCountVertex.size() <= 0 || !(tmpgroup->m_iSortGroup == sort_mtl || sort_mtl == -1)) continue; //проходимся по всем буферам - for(int k = 0, kl = tmpgroup->VertexBuffer.size(); k<kl; ++k) + for (int k = 0, kl = tmpgroup->m_aVertexBuffers.size(); k<kl; ++k) { //если есть что к отрисовке - if (RTCountDrawPoly[i][k] > 0) + if (m_ppRTCountDrawPoly[i][k] > 0) { - RenderIndexBuffer->Lock(0, 0, (void**)&(RTGPUArrIndicesPtrs2), D3DLOCK_DISCARD); - memcpy(RTGPUArrIndicesPtrs2, RTCPUArrIndicesPtrs[i][k], RTCountDrawPoly[i][k] * 3 * sizeof(uint32_t)); - RenderIndexBuffer->Unlock(); + m_pRenderIndexBuffer->Lock(0, 0, (void**)&(RTGPUArrIndicesPtrs2), D3DLOCK_DISCARD); + memcpy(RTGPUArrIndicesPtrs2, m_pppRTArrIndices[i][k], m_ppRTCountDrawPoly[i][k] * 3 * sizeof(uint32_t)); + m_pRenderIndexBuffer->Unlock(); - StaticGeom::DXDevice->SetStreamSource(0, tmpgroup->VertexBuffer[k], 0, sizeof(vertex_static)); - StaticGeom::DXDevice->SetIndices(RenderIndexBuffer); - StaticGeom::DXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl()); + CStaticGeom::m_pDXDevice->SetStreamSource(0, tmpgroup->m_aVertexBuffers[k], 0, sizeof(vertex_static)); + CStaticGeom::m_pDXDevice->SetIndices(m_pRenderIndexBuffer); + CStaticGeom::m_pDXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl()); //если на данную подгруппу назначен раздельный рендер - if (tmpgroup->IsRenderSingly) + if (tmpgroup->m_isRenderSingly) { - long tmpprevcountindex = 0; + int tmpprevcountindex = 0; - for(int j = 0, jl = tmpgroup->ArrModels[k].size(); j < jl; ++j) + for(int j = 0, jl = tmpgroup->m_aModels[k].size(); j < jl; ++j) { - if (RTCountDrawPolyModel[i][k][j] > 0) + if (m_pppRTCountDrawPolyModel[i][k][j] > 0) { //ищем id материала подгруппы //общий id использовать нельзя так как не зря стоит раздельный рендер - for (int q = 0; q < tmpgroup->ArrModels[k][j]->IDTex.size(); ++q) + for (int q = 0; q < tmpgroup->m_aModels[k][j]->m_aIDsTexures.size(); ++q) { - if (i == tmpgroup->ArrModels[k][j]->SubSet[q].idgroup) + if (i == tmpgroup->m_aModels[k][j]->m_aSubSets[q].m_idGroup) { - SGCore_MtlSet(tmpgroup->ArrModels[k][j]->IDTex[q], 0); + SGCore_MtlSet(tmpgroup->m_aModels[k][j]->m_aIDsTexures[q], 0); break; } } - SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, tmpgroup->CountVertex[k], tmpprevcountindex * 3, RTCountDrawPolyModel[i][k][j]); - tmpprevcountindex += RTCountDrawPolyModel[i][k][j]; - Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + RTCountDrawPolyModel[i][k][j]); + SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, tmpgroup->m_aCountVertex[k], tmpprevcountindex * 3, m_pppRTCountDrawPolyModel[i][k][j]); + tmpprevcountindex += m_pppRTCountDrawPolyModel[i][k][j]; + Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + m_pppRTCountDrawPolyModel[i][k][j]); } } } else { - SGCore_MtlSet(tmpgroup->idtex, 0); - SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, tmpgroup->CountVertex[k], 0, RTCountDrawPoly[i][k]); - Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + RTCountDrawPoly[i][k]); + SGCore_MtlSet(tmpgroup->m_idTexture, 0); + SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, tmpgroup->m_aCountVertex[k], 0, m_ppRTCountDrawPoly[i][k]); + Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + m_ppRTCountDrawPoly[i][k]); } } } @@ -1317,142 +1321,142 @@ void StaticGeom::GPURender(DWORD timeDelta, int sort_mtl, ID id_arr, ID exclude_ //иначе рисуем по сортированному списку else { - for (int i = 0; i < DistGroup.size(); ++i) + for (int i = 0; i < m_aDistGroup.size(); ++i) { - InfoGroup* tmpig = DistGroup[i]; - Group* tmpgroup = AllGroups[tmpig->g_group]; + CInfoGroup* tmpig = m_aDistGroup[i]; + CGroup* tmpgroup = m_aAllGroups[tmpig->m_idGlobalGroup]; - if (!tmpgroup || tmpgroup->CountVertex.size() <= 0 || !(tmpgroup->SortGroup == sort_mtl || sort_mtl == -1)) + if (!tmpgroup || tmpgroup->m_aCountVertex.size() <= 0 || !(tmpgroup->m_iSortGroup == sort_mtl || sort_mtl == -1)) continue; - if (exclude_model_id == tmpig->model && (exclude_group_id < 0 || exclude_group_id == tmpig->group)) + if (exclude_model_id == tmpig->m_idModel && (exclude_group_id < 0 || exclude_group_id == tmpig->m_idGroup)) continue; - ID id_buff = AllModels[tmpig->model]->SubSet[tmpig->group].idbuff; + ID id_buff = m_aAllModels[tmpig->m_idModel]->m_aSubSets[tmpig->m_idGroup].m_idBuff; - if (RTCountDrawPoly[tmpig->g_group][id_buff] > 0) + if (m_ppRTCountDrawPoly[tmpig->m_idGlobalGroup][id_buff] > 0) { ID id_model; - for (int j = 0; j < tmpgroup->ArrModels[id_buff].size(); ++j) + for (int j = 0; j < tmpgroup->m_aModels[id_buff].size(); ++j) { - if (tmpgroup->ArrModels[id_buff][j] == AllModels[tmpig->model]) + if (tmpgroup->m_aModels[id_buff][j] == m_aAllModels[tmpig->m_idModel]) { id_model = j; break; } } - RenderIndexBuffer->Lock(0, 0, (void**)&(RTGPUArrIndicesPtrs2), D3DLOCK_DISCARD); - memcpy(RTGPUArrIndicesPtrs2, RTCPUArrIndicesPtrs[tmpig->g_group][id_buff], RTCountDrawPoly[tmpig->g_group][id_buff]/*RTCountDrawPolyModel[tmpig->g_group][id_buff][id_model]*/ * 3 * sizeof(uint32_t)); - RenderIndexBuffer->Unlock(); + m_pRenderIndexBuffer->Lock(0, 0, (void**)&(RTGPUArrIndicesPtrs2), D3DLOCK_DISCARD); + memcpy(RTGPUArrIndicesPtrs2, m_pppRTArrIndices[tmpig->m_idGlobalGroup][id_buff], m_ppRTCountDrawPoly[tmpig->m_idGlobalGroup][id_buff]/*m_pppRTCountDrawPolyModel[tmpig->m_idGlobalGroup][id_buff][id_model]*/ * 3 * sizeof(uint32_t)); + m_pRenderIndexBuffer->Unlock(); - StaticGeom::DXDevice->SetStreamSource(0, tmpgroup->VertexBuffer[id_buff], 0, sizeof(vertex_static)); - StaticGeom::DXDevice->SetIndices(RenderIndexBuffer); - StaticGeom::DXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl()); + CStaticGeom::m_pDXDevice->SetStreamSource(0, tmpgroup->m_aVertexBuffers[id_buff], 0, sizeof(vertex_static)); + CStaticGeom::m_pDXDevice->SetIndices(m_pRenderIndexBuffer); + CStaticGeom::m_pDXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl()); - long tmpprevcountindex = AllModels[tmpig->model]->SubSet[tmpig->group].IndexStart/3; + int tmpprevcountindex = m_aAllModels[tmpig->m_idModel]->m_aSubSets[tmpig->m_idGroup].m_idIndexStart / 3; - if (RTCountDrawPolyModel[tmpig->g_group][id_buff][id_model] > 0) + if (m_pppRTCountDrawPolyModel[tmpig->m_idGlobalGroup][id_buff][id_model] > 0) { //ищем id материала подгруппы - for (int q = 0; q < tmpgroup->ArrModels[id_buff][id_model]->IDTex.size(); ++q) + for (int q = 0; q < tmpgroup->m_aModels[id_buff][id_model]->m_aIDsTexures.size(); ++q) { - if (tmpig->g_group == tmpgroup->ArrModels[id_buff][id_model]->SubSet[q].idgroup) + if (tmpig->m_idGlobalGroup == tmpgroup->m_aModels[id_buff][id_model]->m_aSubSets[q].m_idGroup) { - SGCore_MtlSet(tmpgroup->ArrModels[id_buff][id_model]->IDTex[q], 0); + SGCore_MtlSet(tmpgroup->m_aModels[id_buff][id_model]->m_aIDsTexures[q], 0); break; } } - SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, tmpgroup->CountVertex[id_buff], RTBeginIndexModel[tmpig->g_group][id_buff][id_model] * 3, RTCountDrawPolyModel[tmpig->g_group][id_buff][id_model]); - tmpprevcountindex += RTCountDrawPolyModel[tmpig->g_group][id_buff][id_model]; - Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + RTCountDrawPolyModel[tmpig->g_group][id_buff][id_model]); + SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, tmpgroup->m_aCountVertex[id_buff], m_pppRTBeginIndexModel[tmpig->m_idGlobalGroup][id_buff][id_model] * 3, m_pppRTCountDrawPolyModel[tmpig->m_idGlobalGroup][id_buff][id_model]); + tmpprevcountindex += m_pppRTCountDrawPolyModel[tmpig->m_idGlobalGroup][id_buff][id_model]; + Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + m_pppRTCountDrawPolyModel[tmpig->m_idGlobalGroup][id_buff][id_model]); } } } } } -void StaticGeom::GPURenderSingly(DWORD timeDelta, ID id, ID id_tex) +void CStaticGeom::renderSingly(DWORD timeDelta, ID id, ID id_tex) { STATIC_PRECOND_ARRCOMFOR_ERR_ID_MODEL(id, _VOID); - Segment** jarrsplits; - long jidbuff; - long jnumgroup; + CSegment** jarrsplits; + int jidbuff; + int jnumgroup; //обнуляем все данные об отрисованном в прошлый раз - for (int i = 0; i < AllGroups.size(); i++) + for (int i = 0; i < m_aAllGroups.size(); i++) { - if (AllGroups[i]) + if (m_aAllGroups[i]) { - for (int k = 0; k < AllGroups[i]->VertexBuffer.size(); ++k) + for (int k = 0; k < m_aAllGroups[i]->m_aVertexBuffers.size(); ++k) { - RTCountDrawPoly[i][k] = 0; + m_ppRTCountDrawPoly[i][k] = 0; - for (int j = 0; j < AllGroups[i]->ArrModels[k].size(); ++j) + for (int j = 0; j < m_aAllGroups[i]->m_aModels[k].size(); ++j) { - RTCountDrawPolyModel[i][k][j] = 0; - RTBeginIndexModel[i][k][j] = -1; + m_pppRTCountDrawPolyModel[i][k][j] = 0; + m_pppRTBeginIndexModel[i][k][j] = -1; } } } } - if (AllModels[id]->IsRenderLod) + if (m_aAllModels[id]->m_isRenderLod) { - StaticGeom::DXDevice->SetStreamSource(0, AllModels[id]->Lod0.model->m_pVertexBuffer, 0, sizeof(vertex_static)); - StaticGeom::DXDevice->SetIndices(AllModels[id]->Lod0.model->m_pIndexBuffer); - StaticGeom::DXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl()); - for (int k = 0, kl = AllModels[id]->Lod0.model->m_uiSubsetCount; k < kl; ++k) + CStaticGeom::m_pDXDevice->SetStreamSource(0, m_aAllModels[id]->m_oLod0.m_pModel->m_pVertexBuffer, 0, sizeof(vertex_static)); + CStaticGeom::m_pDXDevice->SetIndices(m_aAllModels[id]->m_oLod0.m_pModel->m_pIndexBuffer); + CStaticGeom::m_pDXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl()); + for (int k = 0, kl = m_aAllModels[id]->m_oLod0.m_pModel->m_uiSubsetCount; k < kl; ++k) { - SGCore_MtlSet((id_tex > 0 ? id_tex : AllModels[id]->Lod0.IDsTexs[k]), 0); - SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, AllModels[id]->Lod0.model->m_pVertexCount[k], AllModels[id]->Lod0.model->m_pStartIndex[k], AllModels[id]->Lod0.model->m_pIndexCount[k] / 3); - Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + AllModels[id]->Lod0.model->m_pIndexCount[k] / 3); + SGCore_MtlSet((id_tex > 0 ? id_tex : m_aAllModels[id]->m_oLod0.m_aIDsTextures[k]), 0); + SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, m_aAllModels[id]->m_oLod0.m_pModel->m_pVertexCount[k], m_aAllModels[id]->m_oLod0.m_pModel->m_pStartIndex[k], m_aAllModels[id]->m_oLod0.m_pModel->m_pIndexCount[k] / 3); + Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + m_aAllModels[id]->m_oLod0.m_pModel->m_pIndexCount[k] / 3); } } - else if (ArrComFor[0]->arr[id]->CountCom > 0) + else if (m_aArrComFor[0]->m_aIRS[id]->m_iCountCom > 0) { - for (DWORD j = 0, jl = ArrComFor[0]->arr[id]->CountCom; j < jl; j++) + for (DWORD j = 0, jl = m_aArrComFor[0]->m_aIRS[id]->m_iCountCom; j < jl; j++) { - jarrsplits = ArrComFor[0]->arr[id]->Arr; - for (DWORD k = 0; k < jarrsplits[j]->CountSubSet; ++k) + jarrsplits = m_aArrComFor[0]->m_aIRS[id]->m_ppSegments; + for (DWORD k = 0; k < jarrsplits[j]->m_uiCountSubSet; ++k) { - jidbuff = AllModels[id]->SubSet[jarrsplits[j]->NumberGroupModel[k]].idbuff; - jnumgroup = jarrsplits[j]->NumberGroup[k]; + jidbuff = m_aAllModels[id]->m_aSubSets[jarrsplits[j]->m_pNumberGroupModel[k]].m_idBuff; + jnumgroup = jarrsplits[j]->m_pNumberGroup[k]; ID tmpcurrmodel = -1; - for (int q = 0, ql = AllGroups[jnumgroup]->ArrModels[jidbuff].size(); q < ql; ++q) + for (int q = 0, ql = m_aAllGroups[jnumgroup]->m_aModels[jidbuff].size(); q < ql; ++q) { - if (AllGroups[jnumgroup]->ArrModels[jidbuff][q] == AllModels[id]) + if (m_aAllGroups[jnumgroup]->m_aModels[jidbuff][q] == m_aAllModels[id]) { tmpcurrmodel = q; break; } } - int currsort = AllGroups[jnumgroup]->SortGroup; + int currsort = m_aAllGroups[jnumgroup]->m_iSortGroup; if ( - jarrsplits[j]->CountPoly[k] > 0 && //если количество полигонов больше 0 - RTCountDrawPoly[jnumgroup][jidbuff] + jarrsplits[j]->CountPoly[k] <= AllGroups[jnumgroup]->CountIndex[jidbuff] / 3 //если количество записанных полигонов в данную подгруппу меньше либо равно общему количеству полигонов которое содержит данна¤ подгруппа + jarrsplits[j]->m_pCountPoly[k] > 0 && //если количество полигонов больше 0 + m_ppRTCountDrawPoly[jnumgroup][jidbuff] + jarrsplits[j]->m_pCountPoly[k] <= m_aAllGroups[jnumgroup]->m_aCountIndex[jidbuff] / 3 //если количество записанных полигонов в данную подгруппу меньше либо равно общему количеству полигонов которое содержит данна¤ подгруппа ) { - memcpy(RTCPUArrIndicesPtrs[jnumgroup][jidbuff] + (RTCountDrawPoly[jnumgroup][jidbuff] * 3), - jarrsplits[j]->ArrPoly[k], - jarrsplits[j]->CountPoly[k] * sizeof(uint32_t)* 3); + memcpy(m_pppRTArrIndices[jnumgroup][jidbuff] + (m_ppRTCountDrawPoly[jnumgroup][jidbuff] * 3), + jarrsplits[j]->m_ppArrPoly[k], + jarrsplits[j]->m_pCountPoly[k] * sizeof(uint32_t)* 3); - if (RTBeginIndexModel[jnumgroup][jidbuff][tmpcurrmodel] == -1) + if (m_pppRTBeginIndexModel[jnumgroup][jidbuff][tmpcurrmodel] == -1) { - RTBeginIndexModel[jnumgroup][jidbuff][tmpcurrmodel] = RTCountDrawPoly[jnumgroup][jidbuff]; + m_pppRTBeginIndexModel[jnumgroup][jidbuff][tmpcurrmodel] = m_ppRTCountDrawPoly[jnumgroup][jidbuff]; } - RTCountDrawPoly[jnumgroup][jidbuff] += jarrsplits[j]->CountPoly[k]; - RTCountDrawPolyModel[jnumgroup][jidbuff][tmpcurrmodel] += jarrsplits[j]->CountPoly[k]; + m_ppRTCountDrawPoly[jnumgroup][jidbuff] += jarrsplits[j]->m_pCountPoly[k]; + m_pppRTCountDrawPolyModel[jnumgroup][jidbuff][tmpcurrmodel] += jarrsplits[j]->m_pCountPoly[k]; } } } @@ -1461,70 +1465,70 @@ void StaticGeom::GPURenderSingly(DWORD timeDelta, ID id, ID id_tex) uint32_t* RTGPUArrIndicesPtrs2; - for (int i = 0; i < AllModels[id]->SubSet.size(); ++i) + for (int i = 0; i < m_aAllModels[id]->m_aSubSets.size(); ++i) { - ID idgroup = AllModels[id]->SubSet[i].idgroup; - Group* tmpgroup = AllGroups[AllModels[id]->SubSet[i].idgroup]; - ID id_buff = AllModels[id]->SubSet[i].idbuff; + ID idgroup = m_aAllModels[id]->m_aSubSets[i].m_idGroup; + CGroup* tmpgroup = m_aAllGroups[m_aAllModels[id]->m_aSubSets[i].m_idGroup]; + ID id_buff = m_aAllModels[id]->m_aSubSets[i].m_idBuff; ID id_model; - for (int j = 0; j < tmpgroup->ArrModels[id_buff].size(); ++j) + for (int j = 0; j < tmpgroup->m_aModels[id_buff].size(); ++j) { - if (tmpgroup->ArrModels[id_buff][j] == AllModels[id]) + if (tmpgroup->m_aModels[id_buff][j] == m_aAllModels[id]) { id_model = j; break; } } - RenderIndexBuffer->Lock(0, 0, (void**)&(RTGPUArrIndicesPtrs2), D3DLOCK_DISCARD); - memcpy(RTGPUArrIndicesPtrs2, RTCPUArrIndicesPtrs[idgroup][id_buff], RTCountDrawPoly[idgroup][id_buff]/*RTCountDrawPolyModel[tmpig->g_group][id_buff][id_model]*/ * 3 * sizeof(uint32_t)); - RenderIndexBuffer->Unlock(); + m_pRenderIndexBuffer->Lock(0, 0, (void**)&(RTGPUArrIndicesPtrs2), D3DLOCK_DISCARD); + memcpy(RTGPUArrIndicesPtrs2, m_pppRTArrIndices[idgroup][id_buff], m_ppRTCountDrawPoly[idgroup][id_buff]/*m_pppRTCountDrawPolyModel[tmpig->m_idGlobalGroup][id_buff][id_model]*/ * 3 * sizeof(uint32_t)); + m_pRenderIndexBuffer->Unlock(); - StaticGeom::DXDevice->SetStreamSource(0, tmpgroup->VertexBuffer[id_buff], 0, sizeof(vertex_static)); - StaticGeom::DXDevice->SetIndices(RenderIndexBuffer); - StaticGeom::DXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl()); + CStaticGeom::m_pDXDevice->SetStreamSource(0, tmpgroup->m_aVertexBuffers[id_buff], 0, sizeof(vertex_static)); + CStaticGeom::m_pDXDevice->SetIndices(m_pRenderIndexBuffer); + CStaticGeom::m_pDXDevice->SetVertexDeclaration(SGCore_StaticModelGetDecl()); - SGCore_MtlSet((id_tex > 0 ? id_tex : tmpgroup->idtex), 0); + SGCore_MtlSet((id_tex > 0 ? id_tex : tmpgroup->m_idTexture), 0); - SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, tmpgroup->CountVertex[id_buff], 0, RTCountDrawPoly[idgroup][id_buff]); - Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + RTCountDrawPoly[idgroup][id_buff]); + SGCore_DIP(D3DPT_TRIANGLELIST, 0, 0, tmpgroup->m_aCountVertex[id_buff], 0, m_ppRTCountDrawPoly[idgroup][id_buff]); + Core_RIntSet(G_RI_INT_COUNT_POLY, Core_RIntGet(G_RI_INT_COUNT_POLY) + m_ppRTCountDrawPoly[idgroup][id_buff]); } } -void StaticGeom::PreSegmentation(Model* mesh, ISXDataStaticModel* model) +void CStaticGeom::preSegmentation(CModel* mesh, ISXDataStaticModel* model) { vertex_static *CreateV; - mem_delete_a(ArrMeshVertex); - mem_delete_a(ArrMeshIndex); - CountVertex = model->m_uiAllVertexCount; + mem_delete_a(m_pCurrArrMeshVertex); + mem_delete_a(m_pCurrArrMeshIndex); + //CountVertex = model->m_uiAllVertexCount; //копируем все вершины для текущих расчетов - ArrMeshVertex = new float3[model->m_uiAllVertexCount]; + m_pCurrArrMeshVertex = new float3[model->m_uiAllVertexCount]; model->m_pVertexBuffer->Lock(0, 0, (void **)&CreateV, 0); for (DWORD i = 0; i<model->m_uiAllVertexCount; i++) { - ArrMeshVertex[i] = (CreateV[i].Pos.operator float3()); + m_pCurrArrMeshVertex[i] = (CreateV[i].Pos.operator float3()); } model->m_pVertexBuffer->Unlock(); - ArrMeshIndex = new UINT[model->m_uiAllIndexCount]; + m_pCurrArrMeshIndex = new UINT[model->m_uiAllIndexCount]; UINT* pInd; model->m_pIndexBuffer->Lock(0, 0, (void **)&pInd, 0); - memcpy(ArrMeshIndex, pInd, sizeof(UINT)* model->m_uiAllIndexCount); + memcpy(m_pCurrArrMeshIndex, pInd, sizeof(UINT)* model->m_uiAllIndexCount); model->m_pIndexBuffer->Unlock(); /////// - mesh->ArrSplits = new Segment(); - mesh->ArrSplits->CountAllPoly = model->m_uiAllIndexCount / 3; - LibReport(REPORT_MSG_LEVEL_NOTICE, "poly: %d, ", mesh->ArrSplits->CountAllPoly); + mesh->m_pArrSplits = new CSegment(); + mesh->m_pArrSplits->m_uiCountAllPoly = model->m_uiAllIndexCount / 3; + LibReport(REPORT_MSG_LEVEL_NOTICE, "poly: %d, ", mesh->m_pArrSplits->m_uiCountAllPoly); - mesh->ArrSplits->BoundVolumeP = SGCore_CrBound(); - mesh->ArrSplits->BoundVolumeP->calcBound(model->m_pVertexBuffer, model->m_uiAllVertexCount, sizeof(vertex_static)); + mesh->m_pArrSplits->m_pBoundVolumeP = SGCore_CrBound(); + mesh->m_pArrSplits->m_pBoundVolumeP->calcBound(model->m_pVertexBuffer, model->m_uiAllVertexCount, sizeof(vertex_static)); float3 tmpMin, tmpMax; - mesh->ArrSplits->BoundVolumeP->getMinMax(&tmpMin, &tmpMax); + mesh->m_pArrSplits->m_pBoundVolumeP->getMinMax(&tmpMin, &tmpMax); int CountSplitsSys = 0; int CountPolyInSegment = GEOM_MIN_COUNT_POLY; @@ -1663,43 +1667,43 @@ void StaticGeom::PreSegmentation(Model* mesh, ISXDataStaticModel* model) } } - mesh->ArrSplits->BoundVolumeSys = SGCore_CrBound(); - mesh->ArrSplits->BoundVolumeSys->setMinMax(&tmpMin, &tmpMax); + mesh->m_pArrSplits->m_pBoundVolumeSys = SGCore_CrBound(); + mesh->m_pArrSplits->m_pBoundVolumeSys->setMinMax(&tmpMin, &tmpMax); //}} - mesh->ArrSplits->CountSubSet = model->m_uiSubsetCount; - mesh->ArrSplits->NumberGroup = new uint32_t[model->m_uiSubsetCount]; - mesh->ArrSplits->NumberGroupModel = new uint32_t[model->m_uiSubsetCount]; - mesh->ArrSplits->CountPoly = new uint32_t[model->m_uiSubsetCount]; + mesh->m_pArrSplits->m_uiCountSubSet = model->m_uiSubsetCount; + mesh->m_pArrSplits->m_pNumberGroup = new uint32_t[model->m_uiSubsetCount]; + mesh->m_pArrSplits->m_pNumberGroupModel = new uint32_t[model->m_uiSubsetCount]; + mesh->m_pArrSplits->m_pCountPoly = new uint32_t[model->m_uiSubsetCount]; ///// //заполняем массив с номаерами подгрупп и массив с количествами полигонов for (DWORD i = 0; i<model->m_uiSubsetCount; i++) { - mesh->ArrSplits->NumberGroupModel[i] = i; - mesh->ArrSplits->NumberGroup[i] = i; - mesh->ArrSplits->CountPoly[i] = model->m_pIndexCount[i] / 3; + mesh->m_pArrSplits->m_pNumberGroupModel[i] = i; + mesh->m_pArrSplits->m_pNumberGroup[i] = i; + mesh->m_pArrSplits->m_pCountPoly[i] = model->m_pIndexCount[i] / 3; } //создаем массивы с полигонами, каждый полигон принадлежит своей подгруппе - mesh->ArrSplits->ArrPoly = new uint32_t*[mesh->ArrSplits->CountSubSet]; - for (DWORD i = 0; i<mesh->ArrSplits->CountSubSet; i++) + mesh->m_pArrSplits->m_ppArrPoly = new uint32_t*[mesh->m_pArrSplits->m_uiCountSubSet]; + for (DWORD i = 0; i<mesh->m_pArrSplits->m_uiCountSubSet; i++) { - mesh->ArrSplits->ArrPoly[i] = new uint32_t[mesh->ArrSplits->CountPoly[i] * 3]; + mesh->m_pArrSplits->m_ppArrPoly[i] = new uint32_t[mesh->m_pArrSplits->m_pCountPoly[i] * 3]; } //заполняем массивы с полигонами for (DWORD i = 0; i<model->m_uiSubsetCount; i++) { - memcpy(mesh->ArrSplits->ArrPoly[i], ArrMeshIndex + model->m_pStartIndex[i], model->m_pIndexCount[i] * sizeof(uint32_t)); + memcpy(mesh->m_pArrSplits->m_ppArrPoly[i], m_pCurrArrMeshIndex + model->m_pStartIndex[i], model->m_pIndexCount[i] * sizeof(uint32_t)); } //если количество полигонов и текущая установка деления позволяют делить дальше - if (mesh->ArrSplits->CountAllPoly >= CountPolyInSegment && CountSplitsSys != 0) + if (mesh->m_pArrSplits->m_uiCountAllPoly >= CountPolyInSegment && CountSplitsSys != 0) { - mesh->ArrSplits->BFNonEnd = true; - CycleSegmentation(mesh->ArrSplits, mesh, model, CountSplitsSys, CountPolyInSegment); + mesh->m_pArrSplits->m_isNonEnd = true; + cycleSegmentation(mesh->m_pArrSplits, mesh, model, CountSplitsSys, CountPolyInSegment); } else { @@ -1707,61 +1711,61 @@ void StaticGeom::PreSegmentation(Model* mesh, ISXDataStaticModel* model) //{{ Array<DWORD> tmpVert; bool isunic = true; - for (DWORD q = 0; q<mesh->ArrSplits->CountSubSet; q++) + for (DWORD q = 0; q<mesh->m_pArrSplits->m_uiCountSubSet; q++) { tmpVert.clear(); - tmpVert.push_back(mesh->ArrSplits->ArrPoly[q][0]); - for (DWORD k = 0; k<mesh->ArrSplits->CountPoly[q] * 3; k++) + tmpVert.push_back(mesh->m_pArrSplits->m_ppArrPoly[q][0]); + for (DWORD k = 0; k<mesh->m_pArrSplits->m_pCountPoly[q] * 3; k++) { isunic = true; for (DWORD j = 0; j<tmpVert.size() && isunic; j++) { - if (mesh->ArrSplits->ArrPoly[q][k] == tmpVert[j]) + if (mesh->m_pArrSplits->m_ppArrPoly[q][k] == tmpVert[j]) { isunic = false; } } if (isunic) - tmpVert.push_back(mesh->ArrSplits->ArrPoly[q][k]); + tmpVert.push_back(mesh->m_pArrSplits->m_ppArrPoly[q][k]); } - SGCore_OptimizeIndecesInSubsetUint32(mesh->ArrSplits->ArrPoly[q], mesh->ArrSplits->CountPoly[q], tmpVert.size()); + SGCore_OptimizeIndecesInSubsetUint32(mesh->m_pArrSplits->m_ppArrPoly[q], mesh->m_pArrSplits->m_pCountPoly[q], tmpVert.size()); } //}} //иначе нельзя делить дальше //приводим индексы куска к глобальному виду уровня - for (DWORD i = 0; i<mesh->ArrSplits->CountSubSet; i++) + for (DWORD i = 0; i<mesh->m_pArrSplits->m_uiCountSubSet; i++) { - for (DWORD k = 0; k<mesh->ArrSplits->CountPoly[i] * 3; k++) + for (DWORD k = 0; k<mesh->m_pArrSplits->m_pCountPoly[i] * 3; k++) { - mesh->ArrSplits->ArrPoly[i][k] -= model->m_pStartVertex[mesh->ArrSplits->NumberGroup[i]]; - mesh->ArrSplits->ArrPoly[i][k] += mesh->SubSet[mesh->ArrSplits->NumberGroup[i]].VertexStart; + mesh->m_pArrSplits->m_ppArrPoly[i][k] -= model->m_pStartVertex[mesh->m_pArrSplits->m_pNumberGroup[i]]; + mesh->m_pArrSplits->m_ppArrPoly[i][k] += mesh->m_aSubSets[mesh->m_pArrSplits->m_pNumberGroup[i]].m_idVertexStart; } - mesh->ArrSplits->NumberGroup[i] = mesh->SubSet[mesh->ArrSplits->NumberGroup[i]].idgroup; + mesh->m_pArrSplits->m_pNumberGroup[i] = mesh->m_aSubSets[mesh->m_pArrSplits->m_pNumberGroup[i]].m_idGroup; } - mesh->ArrSplits->BFNonEnd = false; + mesh->m_pArrSplits->m_isNonEnd = false; } } -void StaticGeom::CycleSegmentation(Segment *Split, Model* mesh, ISXDataStaticModel* model, long CountSplitsSys, long CountPolyInSegment) +void CStaticGeom::cycleSegmentation(CSegment *Split, CModel* mesh, ISXDataStaticModel* model, int CountSplitsSys, int CountPolyInSegment) { - Array<Segment*> queue; - long tmpcount = 0; + Array<CSegment*> queue; + int tmpcount = 0; queue.push_back(Split); while (queue.size()) { - if (queue[0]->BFNonEnd) + if (queue[0]->m_isNonEnd) { - Segmentation(queue[0], mesh, model, CountSplitsSys, CountPolyInSegment, &queue); + segmentation(queue[0], mesh, model, CountSplitsSys, CountPolyInSegment, &queue); for (int i = 0; i < CountSplitsSys; i++) { - if (queue[0]->Splits[i]) - queue.push_back(queue[0]->Splits[i]); + if (queue[0]->m_aSplits[i]) + queue.push_back(queue[0]->m_aSplits[i]); } } @@ -1771,7 +1775,7 @@ void StaticGeom::CycleSegmentation(Segment *Split, Model* mesh, ISXDataStaticMod } -void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* model, long CountSplitsSys, long CountPolyInSegment, Array<Segment*> * queue) +void CStaticGeom::segmentation(CSegment* Split, CModel* mesh, ISXDataStaticModel* model, int CountSplitsSys, int CountPolyInSegment, Array<CSegment*> * queue) { Array<DWORD> ArrPoly[8]; Array<DWORD> ArrGroup[8]; @@ -1779,7 +1783,7 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m for (int i = 0; i<CountSplitsSys; i++) { - Split->Splits[i] = new Segment(); + Split->m_aSplits[i] = new CSegment(); } //получаем ограничивающие для деления и облегаемые объемы @@ -1792,13 +1796,13 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m ArrBound[i] = SGCore_CrBound(); } float3 tmpmin,tmpmax; - SGCore_0ComBoundBoxArr4(Split->BoundVolumeSys, (ArrBound)); + SGCore_0ComBoundBoxArr4(Split->m_pBoundVolumeSys, (ArrBound)); for (int i = 0; i<CountSplitsSys; i++) { - Split->Splits[i]->BoundVolumeSys = ArrBound[i]; - Split->Splits[i]->BoundVolumeSys->getMinMax(&tmpmin, &tmpmax); - Split->Splits[i]->BoundVolumeP = SGCore_CrBound(); - Split->Splits[i]->BoundVolumeP->setMinMax(&tmpmin, &tmpmax); + Split->m_aSplits[i]->m_pBoundVolumeSys = ArrBound[i]; + Split->m_aSplits[i]->m_pBoundVolumeSys->getMinMax(&tmpmin, &tmpmax); + Split->m_aSplits[i]->m_pBoundVolumeP = SGCore_CrBound(); + Split->m_aSplits[i]->m_pBoundVolumeP->setMinMax(&tmpmin, &tmpmax); } } else if (CountSplitsSys == GEOM_COUNT_TYPE_SEGMENTATION_OCTO) @@ -1808,45 +1812,45 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m ArrBound[i] = SGCore_CrBound(); float3 tmpmin, tmpmax; - SGCore_0ComBoundBoxArr8(Split->BoundVolumeSys, ArrBound); + SGCore_0ComBoundBoxArr8(Split->m_pBoundVolumeSys, ArrBound); for (int i = 0; i<CountSplitsSys; i++) { - Split->Splits[i]->BoundVolumeSys = ArrBound[i]; - Split->Splits[i]->BoundVolumeSys->getMinMax(&tmpmin, &tmpmax); - Split->Splits[i]->BoundVolumeP = SGCore_CrBound(); - Split->Splits[i]->BoundVolumeP->setMinMax(&tmpmin, &tmpmax); + Split->m_aSplits[i]->m_pBoundVolumeSys = ArrBound[i]; + Split->m_aSplits[i]->m_pBoundVolumeSys->getMinMax(&tmpmin, &tmpmax); + Split->m_aSplits[i]->m_pBoundVolumeP = SGCore_CrBound(); + Split->m_aSplits[i]->m_pBoundVolumeP->setMinMax(&tmpmin, &tmpmax); } } //}} - bool *tmp_arr_mesh_poly = new bool[Split->CountAllPoly]; - for (DWORD i = 0; i<Split->CountAllPoly; i++) + bool *tmp_arr_mesh_poly = new bool[Split->m_uiCountAllPoly]; + for (DWORD i = 0; i<Split->m_uiCountAllPoly; i++) tmp_arr_mesh_poly[i] = true; DWORD CountInPoly = 0; float3 tmpMin, tmpMax; for (int i = 0; i<CountSplitsSys; i++) { - Split->Splits[i]->BoundVolumeSys->getMinMax(&tmpMin, &tmpMax); - //SGCore_FCreateBoundingBoxMesh(&tmpMin, &tmpMax, &(Split->Splits[i]->BoundBox)); + Split->m_aSplits[i]->m_pBoundVolumeSys->getMinMax(&tmpMin, &tmpMax); + //SGCore_FCreateBoundingBoxMesh(&tmpMin, &tmpMax, &(Split->m_aSplits[i]->BoundBox)); DWORD tmpNumCurrentPoly = 0; - for (DWORD j = 0; j<Split->CountSubSet; j++) + for (DWORD j = 0; j<Split->m_uiCountSubSet; j++) { - for (DWORD k = 0; k<Split->CountPoly[j] * 3; k += 3) + for (DWORD k = 0; k<Split->m_pCountPoly[j] * 3; k += 3) { if (SGCore_0InPosPoints2D(&tmpMin, &tmpMax, - &ArrMeshVertex[Split->ArrPoly[j][k]], - &ArrMeshVertex[Split->ArrPoly[j][k + 1]], - &ArrMeshVertex[Split->ArrPoly[j][k + 2]] + &m_pCurrArrMeshVertex[Split->m_ppArrPoly[j][k]], + &m_pCurrArrMeshVertex[Split->m_ppArrPoly[j][k + 1]], + &m_pCurrArrMeshVertex[Split->m_ppArrPoly[j][k + 2]] ) && tmp_arr_mesh_poly[tmpNumCurrentPoly] ) { - ArrPoly[i].push_back((Split->ArrPoly[j][k])); - ArrPoly[i].push_back((Split->ArrPoly[j][k + 1])); - ArrPoly[i].push_back((Split->ArrPoly[j][k + 2])); - ArrGroup[i].push_back((Split->NumberGroup[j])); + ArrPoly[i].push_back((Split->m_ppArrPoly[j][k])); + ArrPoly[i].push_back((Split->m_ppArrPoly[j][k + 1])); + ArrPoly[i].push_back((Split->m_ppArrPoly[j][k + 2])); + ArrGroup[i].push_back((Split->m_pNumberGroup[j])); tmp_arr_mesh_poly[tmpNumCurrentPoly] = false; CountInPoly++; @@ -1859,22 +1863,22 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m //ИНОГДА ТУТ БЫЛО ЧЕТО НЕПОНЯТНОЕ //ПОСЛЕ ТОГО КАК ГРАФИКА КАКИМ ТО МАГИЧЕСКИМ ОБРАЗОМ СТАЛА ЛУЧШЕ (КОСЯКИ С КУСТАМИ БЫЛИ ПРИ КОМПИЛЯЦИИ С /mt) //ПРОПАЛИ НЕКОТОЫРЕ УЧАСТКИ ОДНОГО ЗДАНИЯ, ПОСЛЕ ТОГО КАК УБРАЛ ЭТОТ КОД ВСЕ СТАЛО НОРМАЛЬНО - if (CountInPoly < Split->CountAllPoly) + if (CountInPoly < Split->m_uiCountAllPoly) { DWORD tmpNumCurrentPolyDec = 0; DWORD tmpNumCurrentPoly = 0; float3 pos0, pos1, pos2, CenterPoly, Length, SphereCenter; float ArrLength[8], ShereRadius; - for (DWORD j = 0; j<Split->CountSubSet; j++) + for (DWORD j = 0; j<Split->m_uiCountSubSet; j++) { - for (DWORD k = 0; k<Split->CountPoly[j] * 3; k += 3) + for (DWORD k = 0; k<Split->m_pCountPoly[j] * 3; k += 3) { if (tmp_arr_mesh_poly[tmpNumCurrentPoly]) { - pos0 = ArrMeshVertex[Split->ArrPoly[j][k]]; - pos1 = ArrMeshVertex[Split->ArrPoly[j][k + 1]]; - pos2 = ArrMeshVertex[Split->ArrPoly[j][k + 2]]; + pos0 = m_pCurrArrMeshVertex[Split->m_ppArrPoly[j][k]]; + pos1 = m_pCurrArrMeshVertex[Split->m_ppArrPoly[j][k + 1]]; + pos2 = m_pCurrArrMeshVertex[Split->m_ppArrPoly[j][k + 2]]; CenterPoly.x = CenterPoly.y = CenterPoly.z = 0; @@ -1886,7 +1890,7 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m for (int q = 0; q<CountSplitsSys; q++) { - Split->Splits[q]->BoundVolumeSys->getSphere(&SphereCenter, &ShereRadius); + Split->m_aSplits[q]->m_pBoundVolumeSys->getSphere(&SphereCenter, &ShereRadius); Length = -SphereCenter + CenterPoly; ArrLength[q] = SMVector3Length(Length); } @@ -1912,10 +1916,10 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m } } - ArrPoly[Key].push_back((Split->ArrPoly[j][k])); - ArrPoly[Key].push_back((Split->ArrPoly[j][k + 1])); - ArrPoly[Key].push_back((Split->ArrPoly[j][k + 2])); - ArrGroup[Key].push_back((Split->NumberGroup[j])); + ArrPoly[Key].push_back((Split->m_ppArrPoly[j][k])); + ArrPoly[Key].push_back((Split->m_ppArrPoly[j][k + 1])); + ArrPoly[Key].push_back((Split->m_ppArrPoly[j][k + 2])); + ArrGroup[Key].push_back((Split->m_pNumberGroup[j])); //ArrSerialNum[Key].push_back((Split->ArrSerialNum[j][k / 3])); tmp_arr_mesh_poly[tmpNumCurrentPolyDec] = false; @@ -1933,11 +1937,11 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m if (ArrPoly[i].size() > 0) { Array<DWORD> tmpNumSubSet; - Split->Splits[i]->CountSubSet = 0; + Split->m_aSplits[i]->m_uiCountSubSet = 0; //предварительно записываем одну подгруппу в массив tmpNumSubSet tmpNumSubSet.push_back(ArrGroup[i][0]); - Split->Splits[i]->CountSubSet++; + Split->m_aSplits[i]->m_uiCountSubSet++; //вычисляем сколько всего у нас подгрупп for (DWORD k = 0; k<ArrGroup[i].size(); k++) { @@ -1951,67 +1955,67 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m if (!tmpIsThereGroup) { tmpNumSubSet.push_back(ArrGroup[i][k]); - Split->Splits[i]->CountSubSet++; + Split->m_aSplits[i]->m_uiCountSubSet++; } } // - Split->Splits[i]->NumberGroup = new uint32_t[Split->Splits[i]->CountSubSet]; - Split->Splits[i]->NumberGroupModel = new uint32_t[Split->Splits[i]->CountSubSet]; + Split->m_aSplits[i]->m_pNumberGroup = new uint32_t[Split->m_aSplits[i]->m_uiCountSubSet]; + Split->m_aSplits[i]->m_pNumberGroupModel = new uint32_t[Split->m_aSplits[i]->m_uiCountSubSet]; - for (DWORD k = 0; k<Split->Splits[i]->CountSubSet; k++) + for (DWORD k = 0; k<Split->m_aSplits[i]->m_uiCountSubSet; k++) { - Split->Splits[i]->NumberGroup[k] = (tmpNumSubSet[k]); - Split->Splits[i]->NumberGroupModel[k] = (tmpNumSubSet[k]); + Split->m_aSplits[i]->m_pNumberGroup[k] = (tmpNumSubSet[k]); + Split->m_aSplits[i]->m_pNumberGroupModel[k] = (tmpNumSubSet[k]); } tmpNumSubSet.clear(); - Split->Splits[i]->CountPoly = new uint32_t[Split->Splits[i]->CountSubSet]; + Split->m_aSplits[i]->m_pCountPoly = new uint32_t[Split->m_aSplits[i]->m_uiCountSubSet]; - //обнуление данных GlobalMesh->SplitMeshes[i]->CountPoly - for (DWORD j = 0; j<Split->Splits[i]->CountSubSet; j++) + //обнуление данных GlobalMesh->SplitMeshes[i]->m_pCountPoly + for (DWORD j = 0; j<Split->m_aSplits[i]->m_uiCountSubSet; j++) { - Split->Splits[i]->CountPoly[j] = 0; + Split->m_aSplits[i]->m_pCountPoly[j] = 0; } - Split->Splits[i]->CountAllPoly = 0; + Split->m_aSplits[i]->m_uiCountAllPoly = 0; //вычисляем сколько полигонов в каждой подгруппе в данном сплите for (DWORD k = 0; k<ArrPoly[i].size(); k += 3) { - for (DWORD j = 0; j<Split->Splits[i]->CountSubSet; j++) + for (DWORD j = 0; j<Split->m_aSplits[i]->m_uiCountSubSet; j++) { - if (Split->Splits[i]->NumberGroup[j] == (ArrGroup[i][k / 3])) + if (Split->m_aSplits[i]->m_pNumberGroup[j] == (ArrGroup[i][k / 3])) { - Split->Splits[i]->CountPoly[j]++; - Split->Splits[i]->CountAllPoly++; + Split->m_aSplits[i]->m_pCountPoly[j]++; + Split->m_aSplits[i]->m_uiCountAllPoly++; } } } - Split->Splits[i]->ArrPoly = new uint32_t*[Split->Splits[i]->CountSubSet]; + Split->m_aSplits[i]->m_ppArrPoly = new uint32_t*[Split->m_aSplits[i]->m_uiCountSubSet]; - for (DWORD j = 0; j<Split->Splits[i]->CountSubSet; j++) + for (DWORD j = 0; j<Split->m_aSplits[i]->m_uiCountSubSet; j++) { - Split->Splits[i]->ArrPoly[j] = new uint32_t[Split->Splits[i]->CountPoly[j] * 3]; + Split->m_aSplits[i]->m_ppArrPoly[j] = new uint32_t[Split->m_aSplits[i]->m_pCountPoly[j] * 3]; } - uint32_t* tmpCountPG = new uint32_t[Split->Splits[i]->CountSubSet]; + uint32_t* tmpCountPG = new uint32_t[Split->m_aSplits[i]->m_uiCountSubSet]; - for (DWORD k = 0; k<Split->Splits[i]->CountSubSet; k++) + for (DWORD k = 0; k<Split->m_aSplits[i]->m_uiCountSubSet; k++) { tmpCountPG[k] = 0; } for (DWORD k = 0; k<ArrPoly[i].size(); k += 3) { - for (DWORD j = 0; j<Split->Splits[i]->CountSubSet; j++) + for (DWORD j = 0; j<Split->m_aSplits[i]->m_uiCountSubSet; j++) { - if (Split->Splits[i]->NumberGroup[j] == (ArrGroup[i][k / 3])) + if (Split->m_aSplits[i]->m_pNumberGroup[j] == (ArrGroup[i][k / 3])) { - Split->Splits[i]->ArrPoly[j][tmpCountPG[j]] = (ArrPoly[i][k]); - Split->Splits[i]->ArrPoly[j][tmpCountPG[j] + 1] = (ArrPoly[i][k + 1]); - Split->Splits[i]->ArrPoly[j][tmpCountPG[j] + 2] = (ArrPoly[i][k + 2]); + Split->m_aSplits[i]->m_ppArrPoly[j][tmpCountPG[j]] = (ArrPoly[i][k]); + Split->m_aSplits[i]->m_ppArrPoly[j][tmpCountPG[j] + 1] = (ArrPoly[i][k + 1]); + Split->m_aSplits[i]->m_ppArrPoly[j][tmpCountPG[j] + 2] = (ArrPoly[i][k + 2]); tmpCountPG[j] += 3; } @@ -2023,93 +2027,93 @@ void StaticGeom::Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* m mem_delete_a(tmpCountPG); - EditVolume(mesh, Split->Splits[i]); - if (Split->Splits[i]->CountAllPoly > 0 && Split->Splits[i]->CountAllPoly > CountPolyInSegment) + editVolume(mesh, Split->m_aSplits[i]); + if (Split->m_aSplits[i]->m_uiCountAllPoly > 0 && Split->m_aSplits[i]->m_uiCountAllPoly > CountPolyInSegment) { - Split->Splits[i]->BFNonEnd = true; + Split->m_aSplits[i]->m_isNonEnd = true; } else { - Split->Splits[i]->BFNonEnd = false; - //EditVolume(mesh, Split->Splits[i]); + Split->m_aSplits[i]->m_isNonEnd = false; + //EditVolume(mesh, Split->m_aSplits[i]); //оптимизация для Post TnL кэша //{{ Array<uint32_t> tmpVert; bool isunic = true; - for (DWORD q = 0; q<Split->Splits[i]->CountSubSet; q++) + for (DWORD q = 0; q<Split->m_aSplits[i]->m_uiCountSubSet; q++) { tmpVert.clear(); - tmpVert.push_back(Split->Splits[i]->ArrPoly[q][0]); - for (DWORD k = 0; k<Split->Splits[i]->CountPoly[q] * 3; k++) + tmpVert.push_back(Split->m_aSplits[i]->m_ppArrPoly[q][0]); + for (DWORD k = 0; k<Split->m_aSplits[i]->m_pCountPoly[q] * 3; k++) { isunic = true; for (DWORD j = 0; j<tmpVert.size() && isunic; j++) { - if (Split->Splits[i]->ArrPoly[q][k] == tmpVert[j]) + if (Split->m_aSplits[i]->m_ppArrPoly[q][k] == tmpVert[j]) { isunic = false; } } if (isunic) - tmpVert.push_back(Split->Splits[i]->ArrPoly[q][k]); + tmpVert.push_back(Split->m_aSplits[i]->m_ppArrPoly[q][k]); } - SGCore_OptimizeIndecesInSubsetUint32(Split->Splits[i]->ArrPoly[q], Split->Splits[i]->CountPoly[q], tmpVert.size()); + SGCore_OptimizeIndecesInSubsetUint32(Split->m_aSplits[i]->m_ppArrPoly[q], Split->m_aSplits[i]->m_pCountPoly[q], tmpVert.size()); } //}} - for (DWORD q = 0; q<Split->Splits[i]->CountSubSet; q++) + for (DWORD q = 0; q<Split->m_aSplits[i]->m_uiCountSubSet; q++) { - for (DWORD k = 0; k<Split->Splits[i]->CountPoly[q] * 3; k++) + for (DWORD k = 0; k<Split->m_aSplits[i]->m_pCountPoly[q] * 3; k++) { - Split->Splits[i]->ArrPoly[q][k] -= model->m_pStartVertex[Split->Splits[i]->NumberGroup[q]]; - Split->Splits[i]->ArrPoly[q][k] += mesh->SubSet[Split->Splits[i]->NumberGroup[q]].VertexStart; + Split->m_aSplits[i]->m_ppArrPoly[q][k] -= model->m_pStartVertex[Split->m_aSplits[i]->m_pNumberGroup[q]]; + Split->m_aSplits[i]->m_ppArrPoly[q][k] += mesh->m_aSubSets[Split->m_aSplits[i]->m_pNumberGroup[q]].m_idVertexStart; } - Split->Splits[i]->NumberGroup[q] = mesh->SubSet[Split->Splits[i]->NumberGroup[q]].idgroup; + Split->m_aSplits[i]->m_pNumberGroup[q] = mesh->m_aSubSets[Split->m_aSplits[i]->m_pNumberGroup[q]].m_idGroup; } } } else { - Split->Splits[i]->CountAllPoly = 0; - Split->Splits[i]->BFNonEnd = false; + Split->m_aSplits[i]->m_uiCountAllPoly = 0; + Split->m_aSplits[i]->m_isNonEnd = false; - mem_delete(Split->Splits[i]); + mem_delete(Split->m_aSplits[i]); } } - mem_delete_a(Split->NumberGroup); + mem_delete_a(Split->m_pNumberGroup); - mem_delete_a(Split->CountPoly); + mem_delete_a(Split->m_pCountPoly); - for (DWORD k = 0; k<Split->CountSubSet; k++) + for (DWORD k = 0; k<Split->m_uiCountSubSet; k++) { - mem_delete_a(Split->ArrPoly[k]); + mem_delete_a(Split->m_ppArrPoly[k]); } - mem_delete_a(Split->ArrPoly); + mem_delete_a(Split->m_ppArrPoly); mem_delete_a(tmp_arr_mesh_poly); } -void StaticGeom::EditVolume(Model* mesh, Segment* Split) +void CStaticGeom::editVolume(CModel* mesh, CSegment* Split) { float3 Max, Min; - Max = ArrMeshVertex[(Split->ArrPoly[0][0])]; - Min = ArrMeshVertex[(Split->ArrPoly[0][0])]; + Max = m_pCurrArrMeshVertex[(Split->m_ppArrPoly[0][0])]; + Min = m_pCurrArrMeshVertex[(Split->m_ppArrPoly[0][0])]; float3 Max2, Min2; - Split->BoundVolumeSys->getMinMax(&Min2, &Max2); + Split->m_pBoundVolumeSys->getMinMax(&Min2, &Max2); float3 tmpf; - for (DWORD i = 0; i<Split->CountSubSet; i++) + for (int i = 0; i<Split->m_uiCountSubSet; ++i) { - for (DWORD k = 0; k<Split->CountPoly[i] * 3; k++) + for (int k = 0; k<Split->m_pCountPoly[i] * 3; ++k) { - tmpf = ArrMeshVertex[(Split->ArrPoly[i][k])]; + tmpf = m_pCurrArrMeshVertex[(Split->m_ppArrPoly[i][k])]; if (tmpf.x > Max.x) Max.x = tmpf.x; if (tmpf.y > Max.y) @@ -2129,41 +2133,41 @@ void StaticGeom::EditVolume(Model* mesh, Segment* Split) //float3 Center = (Min + Max) * 0.5f; //float Radius = SMVector3Length(Center - Max); - //Split->BoundVolumeP->SetSphere(&Center, &Radius); - Split->BoundVolumeP->setMinMax(&Min, &Max); + //Split->m_pBoundVolumeP->SetSphere(&Center, &Radius); + Split->m_pBoundVolumeP->setMinMax(&Min, &Max); } -void StaticGeom::Save(const char* path) +void CStaticGeom::save(const char* path) { FILE* file = fopen(path, "wb"); //записываем количество подгрупп - int32_t countgroup = AllGroups.size(); + int32_t countgroup = m_aAllGroups.size(); fwrite(&countgroup, sizeof(int32_t), 1, file); vertex_static * pData; - for (long i = 0; i < AllGroups.size(); ++i) + for (int i = 0; i < m_aAllGroups.size(); ++i) { - int32_t tmpstrlen = AllGroups[i]->name.length(); + int32_t tmpstrlen = m_aAllGroups[i]->m_sName.length(); fwrite(&tmpstrlen, sizeof(int32_t), 1, file); - fwrite(AllGroups[i]->name.c_str(), sizeof(char), tmpstrlen, file); + fwrite(m_aAllGroups[i]->m_sName.c_str(), sizeof(char), tmpstrlen, file); //записываем количество буферов в подгруппе - int32_t countbuffingroup = AllGroups[i]->VertexBuffer.size(); + int32_t countbuffingroup = m_aAllGroups[i]->m_aVertexBuffers.size(); fwrite(&countbuffingroup, sizeof(int32_t), 1, file); - for (long k = 0; k < AllGroups[i]->CountVertex.size(); ++k) + for (int k = 0; k < m_aAllGroups[i]->m_aCountVertex.size(); ++k) { //записываем количество моделей, которые используют данную подгруппу - int32_t countusingmodels = AllGroups[i]->ArrModels[k].size(); + int32_t countusingmodels = m_aAllGroups[i]->m_aModels[k].size(); fwrite(&countusingmodels, sizeof(int32_t), 1, file); int32_t tmpcountusingmodels = 0; - for (int32_t j = 0; j < AllGroups[i]->ArrModels[k].size(); ++j) + for (int32_t j = 0; j < m_aAllGroups[i]->m_aModels[k].size(); ++j) { - for (int32_t q = 0; q < AllModels.size(); ++q) + for (int32_t q = 0; q < m_aAllModels.size(); ++q) { - if (AllModels[q] == AllGroups[i]->ArrModels[k][j]) + if (m_aAllModels[q] == m_aAllGroups[i]->m_aModels[k][j]) { fwrite(&(q), sizeof(int32_t), 1, file); ++tmpcountusingmodels; @@ -2173,55 +2177,55 @@ void StaticGeom::Save(const char* path) } //записываем количество вершин в буфере подгруппы - fwrite(&AllGroups[i]->CountVertex[k], sizeof(int32_t), 1, file); + fwrite(&m_aAllGroups[i]->m_aCountVertex[k], sizeof(int32_t), 1, file); //записываем количество индексов в буфере подгруппы - fwrite(&AllGroups[i]->CountIndex[k], sizeof(int32_t), 1, file); + fwrite(&m_aAllGroups[i]->m_aCountIndex[k], sizeof(int32_t), 1, file); //записываем весь вершинный буфер подгруппы - AllGroups[i]->VertexBuffer[k]->Lock(0, 0, (void**)&pData, 0); - fwrite(pData, sizeof(vertex_static), AllGroups[i]->CountVertex[k], file); - AllGroups[i]->VertexBuffer[k]->Unlock(); + m_aAllGroups[i]->m_aVertexBuffers[k]->Lock(0, 0, (void**)&pData, 0); + fwrite(pData, sizeof(vertex_static), m_aAllGroups[i]->m_aCountVertex[k], file); + m_aAllGroups[i]->m_aVertexBuffers[k]->Unlock(); } } //записываем количество моделей - int32_t countmodels = AllModels.size(); + int32_t countmodels = m_aAllModels.size(); fwrite(&countmodels, sizeof(int32_t), 1, file); - for (long i = 0; i < AllModels.size(); ++i) + for (int i = 0; i < m_aAllModels.size(); ++i) { - int32_t countsubset = AllModels[i]->SubSet.size(); + int32_t countsubset = m_aAllModels[i]->m_aSubSets.size(); fwrite(&countsubset, sizeof(int32_t), 1, file); - int32_t countlenstr = strlen(AllModels[i]->Name); + int32_t countlenstr = strlen(m_aAllModels[i]->m_szName); fwrite(&countlenstr, sizeof(int32_t), 1, file); - fwrite(&AllModels[i]->Name, sizeof(char), countlenstr, file); + fwrite(&m_aAllModels[i]->m_szName, sizeof(char), countlenstr, file); - countlenstr = strlen(AllModels[i]->PathName); + countlenstr = strlen(m_aAllModels[i]->m_szPathName); fwrite(&countlenstr, sizeof(int32_t), 1, file); - fwrite(&AllModels[i]->PathName, sizeof(char), countlenstr, file); + fwrite(&m_aAllModels[i]->m_szPathName, sizeof(char), countlenstr, file); - fwrite(&AllModels[i]->CountPoly, sizeof(int32_t), 1, file); + fwrite(&m_aAllModels[i]->m_uiCountPoly, sizeof(int32_t), 1, file); - fwrite(&AllModels[i]->Position.x, sizeof(float), 1, file); - fwrite(&AllModels[i]->Position.y, sizeof(float), 1, file); - fwrite(&AllModels[i]->Position.z, sizeof(float), 1, file); + fwrite(&m_aAllModels[i]->m_vPosition.x, sizeof(float), 1, file); + fwrite(&m_aAllModels[i]->m_vPosition.y, sizeof(float), 1, file); + fwrite(&m_aAllModels[i]->m_vPosition.z, sizeof(float), 1, file); - fwrite(&AllModels[i]->Rotation.x, sizeof(float), 1, file); - fwrite(&AllModels[i]->Rotation.y, sizeof(float), 1, file); - fwrite(&AllModels[i]->Rotation.z, sizeof(float), 1, file); + fwrite(&m_aAllModels[i]->m_vRotation.x, sizeof(float), 1, file); + fwrite(&m_aAllModels[i]->m_vRotation.y, sizeof(float), 1, file); + fwrite(&m_aAllModels[i]->m_vRotation.z, sizeof(float), 1, file); - fwrite(&AllModels[i]->Scale.x, sizeof(float), 1, file); - fwrite(&AllModels[i]->Scale.y, sizeof(float), 1, file); - fwrite(&AllModels[i]->Scale.z, sizeof(float), 1, file); + fwrite(&m_aAllModels[i]->m_vScale.x, sizeof(float), 1, file); + fwrite(&m_aAllModels[i]->m_vScale.y, sizeof(float), 1, file); + fwrite(&m_aAllModels[i]->m_vScale.z, sizeof(float), 1, file); - if (AllModels[i]->Lod0.model) + if (m_aAllModels[i]->m_oLod0.m_pModel) { - countlenstr = strlen(AllModels[i]->Lod0.PathName); + countlenstr = strlen(m_aAllModels[i]->m_oLod0.m_szPathName); fwrite(&countlenstr, sizeof(int32_t), 1, file); - fwrite(AllModels[i]->Lod0.PathName, sizeof(char), countlenstr, file); + fwrite(m_aAllModels[i]->m_oLod0.m_szPathName, sizeof(char), countlenstr, file); } else { @@ -2229,18 +2233,18 @@ void StaticGeom::Save(const char* path) fwrite(&countlenstr, sizeof(int32_t), 1, file); } - for (long k = 0; k < AllModels[i]->SubSet.size(); ++k) + for (int k = 0; k < m_aAllModels[i]->m_aSubSets.size(); ++k) { - fwrite(&(AllModels[i]->SubSet[k]), sizeof(Model::GDataBuff), 1, file); + fwrite(&(m_aAllModels[i]->m_aSubSets[k]), sizeof(CModel::CSubSet), 1, file); } - Array<Segment*> queue; - long tmpcount = 0; - queue.push_back(AllModels[i]->ArrSplits); + Array<CSegment*> queue; + int tmpcount = 0; + queue.push_back(m_aAllModels[i]->m_pArrSplits); while (queue.size()) { - SaveSplit(queue[0], file, &queue); + saveSplit(queue[0], file, &queue); queue.erase(0); ++tmpcount; @@ -2250,10 +2254,10 @@ void StaticGeom::Save(const char* path) fclose(file); } -void StaticGeom::SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue) +void CStaticGeom::saveSplit(CSegment* Split, FILE* file, Array<CSegment*> * queue) { float3 jmin, jmax; - Split->BoundVolumeSys->getMinMax(&jmin, &jmax); + Split->m_pBoundVolumeSys->getMinMax(&jmin, &jmax); fwrite(&jmin.x, sizeof(float), 1, file); fwrite(&jmin.y, sizeof(float), 1, file); fwrite(&jmin.z, sizeof(float), 1, file); @@ -2262,7 +2266,7 @@ void StaticGeom::SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue) fwrite(&jmax.y, sizeof(float), 1, file); fwrite(&jmax.z, sizeof(float), 1, file); - Split->BoundVolumeP->getMinMax(&jmin, &jmax); + Split->m_pBoundVolumeP->getMinMax(&jmin, &jmax); fwrite(&jmin.x, sizeof(float), 1, file); fwrite(&jmin.y, sizeof(float), 1, file); fwrite(&jmin.z, sizeof(float), 1, file); @@ -2271,20 +2275,20 @@ void StaticGeom::SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue) fwrite(&jmax.y, sizeof(float), 1, file); fwrite(&jmax.z, sizeof(float), 1, file); - fwrite(&Split->CountAllPoly, sizeof(uint32_t), 1, file); + fwrite(&Split->m_uiCountAllPoly, sizeof(uint32_t), 1, file); - fwrite(&Split->BFNonEnd, sizeof(int8_t), 1, file); + fwrite(&Split->m_isNonEnd, sizeof(int8_t), 1, file); - if (Split->BFNonEnd) + if (Split->m_isNonEnd) { bool isexists = true; for (int i = 0; i<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; i++) { - if (Split->Splits[i]) + if (Split->m_aSplits[i]) { isexists = true; fwrite(&isexists, sizeof(int8_t), 1, file); - queue->push_back(Split->Splits[i]); + queue->push_back(Split->m_aSplits[i]); } else { @@ -2297,22 +2301,22 @@ void StaticGeom::SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue) } else { - fwrite(&Split->CountSubSet, sizeof(uint32_t), 1, file); - fwrite(Split->NumberGroupModel, sizeof(uint32_t)*Split->CountSubSet, 1, file); - fwrite(Split->NumberGroup, sizeof(uint32_t)*Split->CountSubSet, 1, file); - fwrite(Split->CountPoly, sizeof(uint32_t)*Split->CountSubSet, 1, file); + fwrite(&Split->m_uiCountSubSet, sizeof(uint32_t), 1, file); + fwrite(Split->m_pNumberGroupModel, sizeof(uint32_t)*Split->m_uiCountSubSet, 1, file); + fwrite(Split->m_pNumberGroup, sizeof(uint32_t)*Split->m_uiCountSubSet, 1, file); + fwrite(Split->m_pCountPoly, sizeof(uint32_t)*Split->m_uiCountSubSet, 1, file); - for (long i = 0; i < Split->CountSubSet; ++i) + for (int i = 0; i < Split->m_uiCountSubSet; ++i) { - fwrite(Split->ArrPoly[i], sizeof(uint32_t)*Split->CountPoly[i] * 3, 1, file); + fwrite(Split->m_ppArrPoly[i], sizeof(uint32_t)*Split->m_pCountPoly[i] * 3, 1, file); } } } -void StaticGeom::Load(const char* path) +void CStaticGeom::load(const char* path) { - DelArrIndexPtr(); + deleteArrIndexPtr(); FILE* file = fopen(path, "rb"); @@ -2320,61 +2324,61 @@ void StaticGeom::Load(const char* path) fread(&countgroup, sizeof(int32_t), 1, file); Array<Array<Array<int32_t>>> tmpArrIdsModels; vertex_static * pData; - long tmpbigersizebuff = 0; + int tmpbigersizebuff = 0; - for (long i = 0; i < countgroup; ++i) + for (int i = 0; i < countgroup; ++i) { - Group* group = new Group(); + CGroup* group = new CGroup(); tmpbigersizebuff = 0; int32_t tmpstrlen; char texname[1024]; fread(&tmpstrlen, sizeof(int32_t), 1, file); fread(texname, sizeof(char), tmpstrlen, file); texname[tmpstrlen] = 0; - group->name = texname; + group->m_sName = texname; - group->AllCountVertex = 0; - group->AllCountIndex = 0; + group->m_iCountVertex = 0; + group->m_iCountIndex = 0; //записываем количество буферов в подгруппе int32_t countbuffingroup = -1; fread(&countbuffingroup, sizeof(int32_t), 1, file); - for (long k = 0; k < countbuffingroup; ++k) + for (int k = 0; k < countbuffingroup; ++k) { //записываем количество моделей, которые используют данную подгруппу int32_t countusingmodels; fread(&countusingmodels, sizeof(int32_t), 1, file); int32_t tmpnummodel; - for (long j = 0; j < countusingmodels; ++j) + for (int j = 0; j < countusingmodels; ++j) { fread(&tmpnummodel, sizeof(int32_t), 1, file); tmpArrIdsModels[i][k].push_back(tmpnummodel); } //записываем количество вершин в буфере подгруппы - fread(&group->CountVertex[k], sizeof(int32_t), 1, file); - group->AllCountVertex += group->CountVertex[k]; + fread(&group->m_aCountVertex[k], sizeof(int32_t), 1, file); + group->m_iCountVertex += group->m_aCountVertex[k]; //записываем количество индексов в буфере подгруппы - fread(&group->CountIndex[k], sizeof(int32_t), 1, file); - group->AllCountIndex += group->CountIndex[k]; + fread(&group->m_aCountIndex[k], sizeof(int32_t), 1, file); + group->m_iCountIndex += group->m_aCountIndex[k]; - if (tmpbigersizebuff < group->CountIndex[k]) - tmpbigersizebuff = group->CountIndex[k]; + if (tmpbigersizebuff < group->m_aCountIndex[k]) + tmpbigersizebuff = group->m_aCountIndex[k]; IDirect3DVertexBuffer9* vb; - StaticGeom::DXDevice->CreateVertexBuffer(sizeof(vertex_static)* group->CountVertex[k], NULL, NULL, D3DPOOL_MANAGED, &vb, 0); + CStaticGeom::m_pDXDevice->CreateVertexBuffer(sizeof(vertex_static)* group->m_aCountVertex[k], NULL, NULL, D3DPOOL_MANAGED, &vb, 0); //записываем весь вершинный буфер подгруппы vb->Lock(0, 0, (void**)&pData, 0); - fread(pData, sizeof(vertex_static), group->CountVertex[k], file); + fread(pData, sizeof(vertex_static), group->m_aCountVertex[k], file); /*Group::VertexBuff* vborigin = new Group::VertexBuff(); vborigin->count = group->CountVertex[k]; vborigin->arr = new float3_t[vborigin->count]; - for (long j = 0; j < vborigin->count; ++j) + for (int j = 0; j < vborigin->count; ++j) { vborigin->arr[j] = pData[j].Pos; }*/ @@ -2382,109 +2386,109 @@ void StaticGeom::Load(const char* path) //UpdateArrMeshVertex2(group->CountVertex[k], pData); vb->Unlock(); - group->VertexBuffer.push_back(vb); + group->m_aVertexBuffers.push_back(vb); //group->VertexBufferOrigin.push_back(vborigin); } char tmptex[1024]; - sprintf(tmptex, "%s.dds", group->name.c_str()); + sprintf(tmptex, "%s.dds", group->m_sName.c_str()); - group->idtex = SGCore_MtlLoad(tmptex, MTL_TYPE_GEOM); - group->IsRenderSingly = SGCore_MtlGroupRenderIsSingly(group->idtex); - group->SortGroup = SGCore_MtlGetSort(group->idtex); - AllGroups.push_back(group); + group->m_idTexture = SGCore_MtlLoad(tmptex, MTL_TYPE_GEOM); + group->m_isRenderSingly = SGCore_MtlGroupRenderIsSingly(group->m_idTexture); + group->m_iSortGroup = SGCore_MtlGetSort(group->m_idTexture); + m_aAllGroups.push_back(group); - if (RenderIndexBuffer == 0 || SizeRenderIndexBuffer < tmpbigersizebuff) + if (m_pRenderIndexBuffer == 0 || m_iSizeRenderIndexBuffer < tmpbigersizebuff) { - mem_release(RenderIndexBuffer); - SizeRenderIndexBuffer = tmpbigersizebuff; - StaticGeom::DXDevice->CreateIndexBuffer(sizeof(uint32_t)* SizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &RenderIndexBuffer, 0); + mem_release(m_pRenderIndexBuffer); + m_iSizeRenderIndexBuffer = tmpbigersizebuff; + CStaticGeom::m_pDXDevice->CreateIndexBuffer(sizeof(uint32_t)* m_iSizeRenderIndexBuffer, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT/*D3DPOOL_MANAGED*/, &m_pRenderIndexBuffer, 0); } } //записываем количество моделей - int32_t countmodels = AllModels.size(); + int32_t countmodels = m_aAllModels.size(); fread(&countmodels, sizeof(int32_t), 1, file); - for (long i = 0; i < countmodels; ++i) + for (int i = 0; i < countmodels; ++i) { - AllModels.push_back(0); - AllModels[i] = new Model(); + m_aAllModels.push_back(0); + m_aAllModels[i] = new CModel(); int32_t countsubset; fread(&countsubset, sizeof(int32_t), 1, file); int32_t countlenstr = 0; fread(&countlenstr, sizeof(int32_t), 1, file); - fread(&AllModels[i]->Name, sizeof(char), countlenstr, file); - AllModels[i]->Name[countlenstr] = 0; + fread(&m_aAllModels[i]->m_szName, sizeof(char), countlenstr, file); + m_aAllModels[i]->m_szName[countlenstr] = 0; countlenstr = 0; fread(&countlenstr, sizeof(int32_t), 1, file); - fread(&AllModels[i]->PathName, sizeof(char), countlenstr, file); - AllModels[i]->PathName[countlenstr] = 0; + fread(&m_aAllModels[i]->m_szPathName, sizeof(char), countlenstr, file); + m_aAllModels[i]->m_szPathName[countlenstr] = 0; - fread(&AllModels[i]->CountPoly, sizeof(int32_t), 1, file); + fread(&m_aAllModels[i]->m_uiCountPoly, sizeof(int32_t), 1, file); - fread(&AllModels[i]->Position.x, sizeof(float), 1, file); - fread(&AllModels[i]->Position.y, sizeof(float), 1, file); - fread(&AllModels[i]->Position.z, sizeof(float), 1, file); + fread(&m_aAllModels[i]->m_vPosition.x, sizeof(float), 1, file); + fread(&m_aAllModels[i]->m_vPosition.y, sizeof(float), 1, file); + fread(&m_aAllModels[i]->m_vPosition.z, sizeof(float), 1, file); - fread(&AllModels[i]->Rotation.x, sizeof(float), 1, file); - fread(&AllModels[i]->Rotation.y, sizeof(float), 1, file); - fread(&AllModels[i]->Rotation.z, sizeof(float), 1, file); + fread(&m_aAllModels[i]->m_vRotation.x, sizeof(float), 1, file); + fread(&m_aAllModels[i]->m_vRotation.y, sizeof(float), 1, file); + fread(&m_aAllModels[i]->m_vRotation.z, sizeof(float), 1, file); - fread(&AllModels[i]->Scale.x, sizeof(float), 1, file); - fread(&AllModels[i]->Scale.y, sizeof(float), 1, file); - fread(&AllModels[i]->Scale.z, sizeof(float), 1, file); + fread(&m_aAllModels[i]->m_vScale.x, sizeof(float), 1, file); + fread(&m_aAllModels[i]->m_vScale.y, sizeof(float), 1, file); + fread(&m_aAllModels[i]->m_vScale.z, sizeof(float), 1, file); - AllModels[i]->OldPosition = AllModels[i]->Position; - AllModels[i]->OldRotation = AllModels[i]->Rotation; - AllModels[i]->OldScale = AllModels[i]->Scale; + m_aAllModels[i]->m_vOldPosition = m_aAllModels[i]->m_vPosition; + m_aAllModels[i]->m_vOldRotation = m_aAllModels[i]->m_vRotation; + m_aAllModels[i]->m_vOldScale = m_aAllModels[i]->m_vScale; - WorldMat = SMMatrixScaling(AllModels[i]->Scale) * SMMatrixRotationX(AllModels[i]->Rotation.x) * SMMatrixRotationY(AllModels[i]->Rotation.y) * SMMatrixRotationZ(AllModels[i]->Rotation.z) * SMMatrixTranslation(AllModels[i]->Position); + m_mWorld = SMMatrixScaling(m_aAllModels[i]->m_vScale) * SMMatrixRotationX(m_aAllModels[i]->m_vRotation.x) * SMMatrixRotationY(m_aAllModels[i]->m_vRotation.y) * SMMatrixRotationZ(m_aAllModels[i]->m_vRotation.z) * SMMatrixTranslation(m_aAllModels[i]->m_vPosition); fread(&countlenstr, sizeof(int32_t), 1, file); if (countlenstr > 0) { - fread(AllModels[i]->Lod0.PathName, sizeof(char), countlenstr, file); - AllModels[i]->Lod0.PathName[countlenstr] = 0; - SetModelLodPath(i, AllModels[i]->Lod0.PathName); + fread(m_aAllModels[i]->m_oLod0.m_szPathName, sizeof(char), countlenstr, file); + m_aAllModels[i]->m_oLod0.m_szPathName[countlenstr] = 0; + setModelLodPath(i, m_aAllModels[i]->m_oLod0.m_szPathName); } - for (long k = 0; k < countsubset; ++k) + for (int k = 0; k < countsubset; ++k) { - Model::GDataBuff gdb; - fread(&gdb, sizeof(Model::GDataBuff), 1, file); - AllModels[i]->SubSet.push_back(gdb); + CModel::CSubSet gdb; + fread(&gdb, sizeof(CModel::CSubSet), 1, file); + m_aAllModels[i]->m_aSubSets.push_back(gdb); char tmptex[1024]; - sprintf(tmptex, "%s.dds", AllGroups[gdb.idgroup]->name.c_str()); - AllModels[i]->IDTex[k] = SGCore_MtlLoad(tmptex, MTL_TYPE_GEOM); + sprintf(tmptex, "%s.dds", m_aAllGroups[gdb.m_idGroup]->m_sName.c_str()); + m_aAllModels[i]->m_aIDsTexures[k] = SGCore_MtlLoad(tmptex, MTL_TYPE_GEOM); } - Array<Segment**> queue; - long tmpcount = 0; - queue.push_back(&(AllModels[i]->ArrSplits)); + Array<CSegment**> queue; + int tmpcount = 0; + queue.push_back(&(m_aAllModels[i]->m_pArrSplits)); while (queue.size()) { - LoadSplit(queue[0], file, &queue); + loadSplit(queue[0], file, &queue); queue.erase(0); ++tmpcount; } - Segment* tmpsegment = AllModels[i]->ArrSplits; - SetSplitID(AllModels[i]->ArrSplits, &(AllModels[i]->SplitsIDs), (&AllModels[i]->SplitsIDsRender)); + CSegment* tmpsegment = m_aAllModels[i]->m_pArrSplits; + setSplitID(m_aAllModels[i]->m_pArrSplits, &(m_aAllModels[i]->m_idCountSplits), (&m_aAllModels[i]->m_idCountSplitsRender)); - AddModelInArrCom(i); + addModelInArrCom(i); float3 jmin, jmax, jmin2, jmax2; - AllModels[i]->ArrSplits->BoundVolumeP->getMinMax(&jmin, &jmax); - BoundVolume->getMinMax(&jmin2, &jmax2); + m_aAllModels[i]->m_pArrSplits->m_pBoundVolumeP->getMinMax(&jmin, &jmax); + m_pBoundVolume->getMinMax(&jmin2, &jmax2); if (jmin2.x > jmin.x) jmin2.x = jmin.x; @@ -2500,29 +2504,29 @@ void StaticGeom::Load(const char* path) if (jmax2.z < jmax.z) jmax2.z = jmax.z; - BoundVolume->setMinMax(&jmin2, &jmax2); + m_pBoundVolume->setMinMax(&jmin2, &jmax2); } - for (long i = 0; i < AllGroups.size(); ++i) + for (int i = 0; i < m_aAllGroups.size(); ++i) { - for (long k = 0; k < tmpArrIdsModels[i].size(); ++k) + for (int k = 0; k < tmpArrIdsModels[i].size(); ++k) { - for (long j = 0; j < tmpArrIdsModels[i][k].size(); ++j) + for (int j = 0; j < tmpArrIdsModels[i][k].size(); ++j) { - AllGroups[i]->ArrModels[k][j] = AllModels[tmpArrIdsModels[i][k][j]]; + m_aAllGroups[i]->m_aModels[k][j] = m_aAllModels[tmpArrIdsModels[i][k][j]]; } } } - InitArrIndexPtr(); + initArrIndexPtr(); fclose(file); } -void StaticGeom::LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue) +void CStaticGeom::loadSplit(CSegment** Split, FILE* file, Array<CSegment**> * queue) { float3 jmin, jmax; - (*Split) = new Segment(); + (*Split) = new CSegment(); fread(&jmin.x, sizeof(float), 1, file); fread(&jmin.y, sizeof(float), 1, file); @@ -2532,8 +2536,8 @@ void StaticGeom::LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue fread(&jmax.y, sizeof(float), 1, file); fread(&jmax.z, sizeof(float), 1, file); - (*Split)->BoundVolumeSys = SGCore_CrBound(); - (*Split)->BoundVolumeSys->setMinMax(&jmin, &jmax); + (*Split)->m_pBoundVolumeSys = SGCore_CrBound(); + (*Split)->m_pBoundVolumeSys->setMinMax(&jmin, &jmax); fread(&jmin.x, sizeof(float), 1, file); @@ -2544,14 +2548,14 @@ void StaticGeom::LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue fread(&jmax.y, sizeof(float), 1, file); fread(&jmax.z, sizeof(float), 1, file); - (*Split)->BoundVolumeP = SGCore_CrBound(); - (*Split)->BoundVolumeP->setMinMax(&jmin, &jmax); + (*Split)->m_pBoundVolumeP = SGCore_CrBound(); + (*Split)->m_pBoundVolumeP->setMinMax(&jmin, &jmax); - fread(&(*Split)->CountAllPoly, sizeof(uint32_t), 1, file); + fread(&(*Split)->m_uiCountAllPoly, sizeof(uint32_t), 1, file); - fread(&(*Split)->BFNonEnd, sizeof(int8_t), 1, file); + fread(&(*Split)->m_isNonEnd, sizeof(int8_t), 1, file); - if ((*Split)->BFNonEnd) + if ((*Split)->m_isNonEnd) { bool isexists = false; @@ -2559,80 +2563,80 @@ void StaticGeom::LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue { fread(&isexists, sizeof(int8_t), 1, file); if (isexists) - queue->push_back(&((*Split)->Splits[i])); + queue->push_back(&((*Split)->m_aSplits[i])); isexists = false; } } else { - fread(&(*Split)->CountSubSet, sizeof(uint32_t), 1, file); + fread(&(*Split)->m_uiCountSubSet, sizeof(uint32_t), 1, file); - (*Split)->NumberGroupModel = new uint32_t[(*Split)->CountSubSet]; - (*Split)->NumberGroup = new uint32_t[(*Split)->CountSubSet]; - (*Split)->CountPoly = new uint32_t[(*Split)->CountSubSet]; + (*Split)->m_pNumberGroupModel = new uint32_t[(*Split)->m_uiCountSubSet]; + (*Split)->m_pNumberGroup = new uint32_t[(*Split)->m_uiCountSubSet]; + (*Split)->m_pCountPoly = new uint32_t[(*Split)->m_uiCountSubSet]; - fread((*Split)->NumberGroupModel, sizeof(uint32_t)*(*Split)->CountSubSet, 1, file); - fread((*Split)->NumberGroup, sizeof(uint32_t)*(*Split)->CountSubSet, 1, file); - fread((*Split)->CountPoly, sizeof(uint32_t)*(*Split)->CountSubSet, 1, file); + fread((*Split)->m_pNumberGroupModel, sizeof(uint32_t)*(*Split)->m_uiCountSubSet, 1, file); + fread((*Split)->m_pNumberGroup, sizeof(uint32_t)*(*Split)->m_uiCountSubSet, 1, file); + fread((*Split)->m_pCountPoly, sizeof(uint32_t)*(*Split)->m_uiCountSubSet, 1, file); - (*Split)->ArrPoly = new uint32_t*[(*Split)->CountSubSet]; + (*Split)->m_ppArrPoly = new uint32_t*[(*Split)->m_uiCountSubSet]; - for (long i = 0; i < (*Split)->CountSubSet; ++i) + for (int i = 0; i < (*Split)->m_uiCountSubSet; ++i) { - (*Split)->ArrPoly[i] = new uint32_t[(*Split)->CountPoly[i] * 3]; - fread((*Split)->ArrPoly[i], sizeof(uint32_t)*(*Split)->CountPoly[i] * 3, 1, file); + (*Split)->m_ppArrPoly[i] = new uint32_t[(*Split)->m_pCountPoly[i] * 3]; + fread((*Split)->m_ppArrPoly[i], sizeof(uint32_t)*(*Split)->m_pCountPoly[i] * 3, 1, file); } } } -void StaticGeom::SortGroup(float3* viewpos, int sort_mtl) +void CStaticGeom::sortGroup(const float3* viewpos, int sort_mtl) { float tmpradius = 0; float tmpsidt = 0; float3 tmpcenter = float3(0,0,0); - Model* tmpmodel; + CModel* tmpmodel; Array<float> arr_dist; - long tmp_index_gd = 0; + int tmp_index_gd = 0; float tmpdist = 999999; - for (int i = 0; i < AllModels.size(); ++i) + for (int i = 0; i < m_aAllModels.size(); ++i) { - tmpmodel = AllModels[i]; - for (int k = 0; k < tmpmodel->SubSet.size(); ++k) + tmpmodel = m_aAllModels[i]; + for (int k = 0; k < tmpmodel->m_aSubSets.size(); ++k) { - //if (sort_mtl == AllGroups[tmpmodel->SubSet[k].idgroup]->SortGroup) + //if (sort_mtl == m_aAllGroups[tmpmodel->m_aSubSets[k].idgroup]->SortGroup) - tmpcenter = (tmpmodel->SubSet[k].Min + tmpmodel->SubSet[k].Max) * 0.5f; - tmpradius = SMVector3Length(tmpcenter - tmpmodel->SubSet[k].Max); + tmpcenter = (tmpmodel->m_aSubSets[k].m_vMin + tmpmodel->m_aSubSets[k].m_vMax) * 0.5f; + tmpradius = SMVector3Length(tmpcenter - tmpmodel->m_aSubSets[k].m_vMax); //tmpmodel->GroupDist[k] = SMVector3Length((tmpcenter - (*viewpos))) - tmpradius; - if (DistGroup.size() <= tmp_index_gd || !DistGroup[tmp_index_gd]) - DistGroup[tmp_index_gd] = new InfoGroup(); + if (m_aDistGroup.size() <= tmp_index_gd || !m_aDistGroup[tmp_index_gd]) + m_aDistGroup[tmp_index_gd] = new CInfoGroup(); - DistGroup[tmp_index_gd]->count = 0; - DistGroup[tmp_index_gd]->dist = SMVector3Length((tmpcenter - (*viewpos))) - tmpradius; - DistGroup[tmp_index_gd]->group = k; - DistGroup[tmp_index_gd]->g_group = tmpmodel->SubSet[k].idgroup; - DistGroup[tmp_index_gd]->model = i; + //m_aDistGroup[tmp_index_gd]->m_iCount = 0; + m_aDistGroup[tmp_index_gd]->m_fDist = SMVector3Length((tmpcenter - (*viewpos))) - tmpradius; + m_aDistGroup[tmp_index_gd]->m_idGroup = k; + m_aDistGroup[tmp_index_gd]->m_idGlobalGroup = tmpmodel->m_aSubSets[k].m_idGroup; + m_aDistGroup[tmp_index_gd]->m_idModel = i; ++tmp_index_gd; } } - for (int i = 0; i < DistGroup.size(); ++i) + for (int i = 0; i < m_aDistGroup.size(); ++i) { - InfoGroup* tmpig = DistGroup[i]; + CInfoGroup* tmpig = m_aDistGroup[i]; int pos = i; - for (int k = i+1; k < DistGroup.size(); ++k) + for (int k = i+1; k < m_aDistGroup.size(); ++k) { - InfoGroup* tmpig2 = DistGroup[k]; + CInfoGroup* tmpig2 = m_aDistGroup[k]; int qwert = 0; - if (tmpig->dist > tmpig2->dist) + if (tmpig->m_fDist > tmpig2->m_fDist) { pos = k; tmpig = tmpig2; @@ -2641,27 +2645,27 @@ void StaticGeom::SortGroup(float3* viewpos, int sort_mtl) } } - DistGroup[pos] = DistGroup[i]; - DistGroup[i] = tmpig; + m_aDistGroup[pos] = m_aDistGroup[i]; + m_aDistGroup[i] = tmpig; int qwert = 0; } } -void StaticGeom::GetIntersectedRayY2(float3* pos, Segment** arrsplits, DWORD *count, Segment* comsegment, ID curr_splits_ids_render) +void CStaticGeom::getIntersectedRayY2(float3* pos, CSegment** arrsplits, int *count, CSegment* comsegment, ID curr_splits_ids_render) { float3 jmin, jmax; - comsegment->BoundVolumeP->getMinMax(&jmin, &jmax); + comsegment->m_pBoundVolumeP->getMinMax(&jmin, &jmax); - if (comsegment->CountAllPoly > 0 && pos->x >= jmin.x && pos->z >= jmin.z && pos->x <= jmax.x && pos->z <= jmax.z) + if (comsegment->m_uiCountAllPoly > 0 && pos->x >= jmin.x && pos->z >= jmin.z && pos->x <= jmax.x && pos->z <= jmax.z) { - if (comsegment->BFNonEnd) + if (comsegment->m_isNonEnd) { for (int j = 0; j<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; j++) { - if (comsegment->Splits[j]) - GetIntersectedRayY2(pos, arrsplits, count, comsegment->Splits[j], curr_splits_ids_render); + if (comsegment->m_aSplits[j]) + getIntersectedRayY2(pos, arrsplits, count, comsegment->m_aSplits[j], curr_splits_ids_render); } } else @@ -2676,8 +2680,11 @@ void StaticGeom::GetIntersectedRayY2(float3* pos, Segment** arrsplits, DWORD *co } } -bool StaticGeom::GetIntersectedRayY(float3* pos) +bool CStaticGeom::getIntersectedRayY(float3* pos) { + D3DXVECTOR3 jpos; + float3 jvec0, jvec1, jvec2; + jpos = (D3DXVECTOR3)*pos; BOOL Hit; float u, v, Dist, CountDist; @@ -2686,47 +2693,47 @@ bool StaticGeom::GetIntersectedRayY(float3* pos) CountDist = -1000; bool is_find = false; - for (int id = 0; id < AllModels.size(); ++id) + for (int id = 0; id < m_aAllModels.size(); ++id) { - ArrComFor[1]->arr[id]->CountCom = 0; + m_aArrComFor[1]->m_aIRS[id]->m_iCountCom = 0; - GetIntersectedRayY2(pos, ArrComFor[1]->arr[id]->Arr, &(ArrComFor[1]->arr[id]->CountCom), AllModels[id]->ArrSplits, ArrComFor[1]->arr[id]->Count); + getIntersectedRayY2(pos, m_aArrComFor[1]->m_aIRS[id]->m_ppSegments, &(m_aArrComFor[1]->m_aIRS[id]->m_iCountCom), m_aAllModels[id]->m_pArrSplits, m_aArrComFor[1]->m_aIRS[id]->m_iCount); - for (DWORD k = 0; k<ArrComFor[1]->arr[id]->CountCom; ++k) + for (DWORD k = 0; k<m_aArrComFor[1]->m_aIRS[id]->m_iCountCom; ++k) { - for (DWORD group = 0; group<ArrComFor[1]->arr[id]->Arr[k]->CountSubSet; group++) + for (DWORD group = 0; group<m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_uiCountSubSet; group++) { - if (AllGroups[ArrComFor[1]->arr[id]->Arr[k]->NumberGroup[group]]->SortGroup > 0) + if (m_aAllGroups[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pNumberGroup[group]]->m_iSortGroup > 0) continue; - ID idbuff = AllModels[id]->SubSet[ArrComFor[1]->arr[id]->Arr[k]->NumberGroupModel[group]].idbuff; - ID idgroup = ArrComFor[1]->arr[id]->Arr[k]->NumberGroup[group]; + ID idbuff = m_aAllModels[id]->m_aSubSets[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pNumberGroupModel[group]].m_idBuff; + ID idgroup = m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pNumberGroup[group]; vertex_static* pData = 0; - if (FAILED(AllGroups[idgroup]->VertexBuffer[idbuff]->Lock(0, 0, (void**)&pData, 0))) + if (FAILED(m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Lock(0, 0, (void**)&pData, 0))) continue; - for (DWORD numpoly = 0; numpoly<ArrComFor[1]->arr[id]->Arr[k]->CountPoly[group] * 3; numpoly += 3) + for (DWORD numpoly = 0; numpoly<m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pCountPoly[group] * 3; numpoly += 3) { Dist = -1000.f; //находим все 3 вершины - /*jvec0 = ArrMeshVertex2[ArrComFor[1].arr[id]->Arr[k]->ArrPoly[group][numpoly]]; - jvec1 = ArrMeshVertex2[ArrComFor[1].arr[id]->Arr[k]->ArrPoly[group][numpoly + 1]]; - jvec2 = ArrMeshVertex2[ArrComFor[1].arr[id]->Arr[k]->ArrPoly[group][numpoly + 2]];*/ + /*jvec0 = ArrMeshVertex2[m_aArrComFor[1].arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly]]; + jvec1 = ArrMeshVertex2[m_aArrComFor[1].arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 1]]; + jvec2 = ArrMeshVertex2[m_aArrComFor[1].arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 2]];*/ - //jvec0 = AllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly]]; - //jvec1 = AllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly + 1]]; - //jvec2 = AllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly + 2]]; + //jvec0 = m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr[m_aArrComFor[1]->arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly]]; + //jvec1 = m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr[m_aArrComFor[1]->arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 1]]; + //jvec2 = m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr[m_aArrComFor[1]->arr[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 2]]; - jvec0 = pData[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly]].Pos; - jvec1 = pData[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly + 1]].Pos; - jvec2 = pData[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly + 2]].Pos; + jvec0 = pData[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly]].Pos; + jvec1 = pData[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 1]].Pos; + jvec2 = pData[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 2]].Pos; Hit = D3DXIntersectTri(&(jvec0.operator D3DXVECTOR3()), &(jvec1.operator D3DXVECTOR3()), &(jvec2.operator D3DXVECTOR3()), &(jpos), - &jvevyn, &u, &v, &Dist); + &gс_vYmin, &u, &v, &Dist); if (Hit && tmpy < (pos->y - Dist * 1000)) { @@ -2739,7 +2746,7 @@ bool StaticGeom::GetIntersectedRayY(float3* pos) &(jvec1.operator D3DXVECTOR3()), &(jvec2.operator D3DXVECTOR3()), &(jpos), - &jvevyp, &u, &v, &Dist); + &gс_vYmax, &u, &v, &Dist); if (Hit) { pos->y += Dist * 1000; @@ -2749,7 +2756,7 @@ bool StaticGeom::GetIntersectedRayY(float3* pos) } } - AllGroups[idgroup]->VertexBuffer[idbuff]->Unlock(); + m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Unlock(); } } } @@ -2757,30 +2764,30 @@ bool StaticGeom::GetIntersectedRayY(float3* pos) return is_find; } -void StaticGeom::GetMinMax(float3* min, float3* max) +void CStaticGeom::getMinMax(float3* min, float3* max) { - BoundVolume->getMinMax(min, max); + m_pBoundVolume->getMinMax(min, max); } -ID StaticGeom::AddArrForCom() +ID CStaticGeom::addArrForCom() { - IRSData* ttmpdata = new IRSData(); + CIRSData* ttmpdata = new CIRSData(); - for (int i = 0; i < AllModels.size(); ++i) + for (int i = 0; i < m_aAllModels.size(); ++i) { - InfoRenderSegments* tmpirs = new InfoRenderSegments(); - tmpirs->Count = AllModels[i]->SplitsIDsRender; - tmpirs->Arr = new Segment*[AllModels[i]->SplitsIDsRender]; - tmpirs->CountCom = 0; - ttmpdata->arr.push_back(tmpirs); + CInfoRenderSegments* tmpirs = new CInfoRenderSegments(); + tmpirs->m_iCount = m_aAllModels[i]->m_idCountSplitsRender; + tmpirs->m_ppSegments = new CSegment*[m_aAllModels[i]->m_idCountSplitsRender]; + tmpirs->m_iCountCom = 0; + ttmpdata->m_aIRS.push_back(tmpirs); } ID id_arr = -1; - for (int i = 0; i < ArrComFor.size(); ++i) + for (int i = 0; i < m_aArrComFor.size(); ++i) { - if (ArrComFor[i] == 0) + if (m_aArrComFor[i] == 0) { - ArrComFor[i] = ttmpdata; + m_aArrComFor[i] = ttmpdata; id_arr = i; break; } @@ -2788,212 +2795,212 @@ ID StaticGeom::AddArrForCom() if (id_arr == -1) { - ArrComFor.push_back(ttmpdata); - id_arr = ArrComFor.size() - 1; + m_aArrComFor.push_back(ttmpdata); + id_arr = m_aArrComFor.size() - 1; } return id_arr; } -bool StaticGeom::existsArrForCom(ID id) +bool CStaticGeom::existsArrForCom(ID id) { - return (ArrComFor.size() > id); + return (m_aArrComFor.size() > id); } -void StaticGeom::DelArrForCom(ID id_arr) +void CStaticGeom::deleteArrForCom(ID id_arr) { STATIC_PRECOND_ARRCOMFOR_ERR_ID(id_arr); - mem_delete(ArrComFor[id_arr]); + mem_delete(m_aArrComFor[id_arr]); } -void StaticGeom::AddModelInArrCom(ID id_model) +void CStaticGeom::addModelInArrCom(ID id_model) { STATIC_PRECOND_ARRCOMFOR_ERR_ID_MODEL(id_model, _VOID); - for (long i = 0; i < ArrComFor.size(); ++i) + for (int i = 0; i < m_aArrComFor.size(); ++i) { - InfoRenderSegments* tmpirs = new InfoRenderSegments(); - tmpirs->Count = AllModels[id_model]->SplitsIDsRender; - tmpirs->Arr = new Segment*[AllModels[id_model]->SplitsIDsRender]; - tmpirs->CountCom = 0; - ArrComFor[i]->arr.push_back(tmpirs); + CInfoRenderSegments* tmpirs = new CInfoRenderSegments(); + tmpirs->m_iCount = m_aAllModels[id_model]->m_idCountSplitsRender; + tmpirs->m_ppSegments = new CSegment*[m_aAllModels[id_model]->m_idCountSplitsRender]; + tmpirs->m_iCountCom = 0; + m_aArrComFor[i]->m_aIRS.push_back(tmpirs); } } -void StaticGeom::DelModelInArrCom(ID id_model) +void CStaticGeom::deleteModelInArrCom(ID id_model) { STATIC_PRECOND_ARRCOMFOR_ERR_ID_MODEL(id_model, _VOID); - for (int i = 0; i < ArrComFor.size(); ++i) + for (int i = 0; i < m_aArrComFor.size(); ++i) { - if (!(ArrComFor[i])) + if (!(m_aArrComFor[i])) continue; - mem_delete(ArrComFor[i]->arr[id_model]); - ArrComFor[i]->arr.erase(id_model); + mem_delete(m_aArrComFor[i]->m_aIRS[id_model]); + m_aArrComFor[i]->m_aIRS.erase(id_model); } } /// -char* StaticGeom::GetModelName(ID id) +char* CStaticGeom::getModelName(ID id) { - if (id < AllModels.size()) - return AllModels[id]->Name; + if (id < m_aAllModels.size()) + return m_aAllModels[id]->m_szName; return 0; } -const char* StaticGeom::GetModelPathName(ID id) +const char* CStaticGeom::getModelPathName(ID id) { - if (id < AllModels.size()) - return AllModels[id]->PathName; + if (id < m_aAllModels.size()) + return m_aAllModels[id]->m_szPathName; return 0; } -long StaticGeom::GetModelCountPoly(ID id) +int CStaticGeom::getModelCountPoly(ID id) { - if (id < AllModels.size()) - return AllModels[id]->CountPoly; + if (id < m_aAllModels.size()) + return m_aAllModels[id]->m_uiCountPoly; return -1; } -void StaticGeom::GetModelMinMax(ID id, float3* min, float3* max) +void CStaticGeom::getModelMinMax(ID id, float3* min, float3* max) { - if (id >= AllModels.size()) + if (id >= m_aAllModels.size()) return; - AllModels[id]->ArrSplits->BoundVolumeP->getMinMax(min, max); + m_aAllModels[id]->m_pArrSplits->m_pBoundVolumeP->getMinMax(min, max); } -float3* StaticGeom::GetModelPosition(ID id) +float3* CStaticGeom::getModelPosition(ID id) { - if (id < AllModels.size()) - return &AllModels[id]->Position; + if (id < m_aAllModels.size()) + return &m_aAllModels[id]->m_vPosition; return 0; } -float3* StaticGeom::GetModelRotation(ID id) +float3* CStaticGeom::getModelRotation(ID id) { - if (id < AllModels.size()) - return &AllModels[id]->Rotation; + if (id < m_aAllModels.size()) + return &m_aAllModels[id]->m_vRotation; return 0; } -float3* StaticGeom::GetModelScale(ID id) +float3* CStaticGeom::getModelScale(ID id) { - if (id < AllModels.size()) - return &AllModels[id]->Scale; + if (id < m_aAllModels.size()) + return &m_aAllModels[id]->m_vScale; return 0; } -const char* StaticGeom::GetModelLodPath(ID id) +const char* CStaticGeom::getModelLodPath(ID id) { - if (id < AllModels.size()) - return AllModels[id]->Lod0.PathName; + if (id < m_aAllModels.size()) + return m_aAllModels[id]->m_oLod0.m_szPathName; return 0; } -void StaticGeom::SetModelLodPath(ID id, const char* path) +void CStaticGeom::setModelLodPath(ID id, const char* path) { - if (id < AllModels.size() && def_str_validate(path)) + if (id < m_aAllModels.size() && def_str_validate(path)) { - mem_delete(AllModels[id]->Lod0.model); - AllModels[id]->Lod0.IDsTexs.clear(); - //AllModels[id]->Lod0.model = new DataStaticModel(); + mem_delete(m_aAllModels[id]->m_oLod0.m_pModel); + m_aAllModels[id]->m_oLod0.m_aIDsTextures.clear(); + //m_aAllModels[id]->m_oLod0.model = new DataStaticModel(); char tmppath[1024]; sprintf(tmppath, "%s%s", Core_RStringGet(G_RI_STRING_PATH_GS_MESHES), path); - SGCore_StaticModelLoad(tmppath, &(AllModels[id]->Lod0.model)); + SGCore_StaticModelLoad(tmppath, &(m_aAllModels[id]->m_oLod0.m_pModel)); char tmptex[1024]; ID tmpidmat; - for (int i = 0; i < AllModels[id]->Lod0.model->m_uiSubsetCount; ++i) + for (int i = 0; i < m_aAllModels[id]->m_oLod0.m_pModel->m_uiSubsetCount; ++i) { - sprintf(tmptex, "%s.dds", AllModels[id]->Lod0.model->m_ppTextures[i]); + sprintf(tmptex, "%s.dds", m_aAllModels[id]->m_oLod0.m_pModel->m_ppTextures[i]); tmpidmat = SGCore_MtlLoad(tmptex, MTL_TYPE_GEOM); - AllModels[id]->Lod0.IDsTexs.push_back(tmpidmat); - AllModels[id]->Lod0.SortGroup = SGCore_MtlGetSort(tmpidmat); + m_aAllModels[id]->m_oLod0.m_aIDsTextures.push_back(tmpidmat); + m_aAllModels[id]->m_oLod0.m_iSortGroup = SGCore_MtlGetSort(tmpidmat); } - sprintf(AllModels[id]->Lod0.PathName,"%s",path); + sprintf(m_aAllModels[id]->m_oLod0.m_szPathName,"%s",path); - AllModels[id]->Lod0.BoundVolume->calcBound(AllModels[id]->Lod0.model->m_pVertexBuffer, AllModels[id]->Lod0.model->m_uiAllVertexCount, sizeof(vertex_static)); + m_aAllModels[id]->m_oLod0.m_pBoundVolume->calcBound(m_aAllModels[id]->m_oLod0.m_pModel->m_pVertexBuffer, m_aAllModels[id]->m_oLod0.m_pModel->m_uiAllVertexCount, sizeof(vertex_static)); - ApplyTransformLod(id); + applyTransformLod(id); } } -void StaticGeom::ApplyTransform(ID id) +void CStaticGeom::applyTransform(ID id) { - if (id >= AllModels.size()) + if (id >= m_aAllModels.size()) return; - Model* tmpmodel = AllModels[id]; + CModel* tmpmodel = m_aAllModels[id]; - float3 tmppos = tmpmodel->Position - tmpmodel->OldPosition; - float3 tmprot = tmpmodel->Rotation - tmpmodel->OldRotation; - float3 tmpscale = tmpmodel->Scale / tmpmodel->OldScale; + float3 tmppos = tmpmodel->m_vPosition - tmpmodel->m_vOldPosition; + float3 tmprot = tmpmodel->m_vRotation - tmpmodel->m_vOldRotation; + float3 tmpscale = tmpmodel->m_vScale / tmpmodel->m_vOldScale; float3 jmin, jmax; - tmpmodel->ArrSplits->BoundVolumeP->getMinMax(&jmin, &jmax); + tmpmodel->m_pArrSplits->m_pBoundVolumeP->getMinMax(&jmin, &jmax); float3 jcentererpos = (jmax + jmin)*0.5f; - RotationMat = SMMatrixRotationX(tmprot.x) * SMMatrixRotationY(tmprot.y) * SMMatrixRotationZ(tmprot.z); - WorldMat = SMMatrixScaling(tmpscale) * RotationMat * SMMatrixTranslation(tmppos); + m_mRotation = SMMatrixRotationX(tmprot.x) * SMMatrixRotationY(tmprot.y) * SMMatrixRotationZ(tmprot.z); + m_mWorld = SMMatrixScaling(tmpscale) * m_mRotation * SMMatrixTranslation(tmppos); - ApplyTransformLod(id); + applyTransformLod(id); vertex_static* pData; float3_t* pData2; - long idgroup; - long idbuff; + int idgroup; + int idbuff; - long vertexstart, vertexcount; + int vertexstart, vertexcount; - for (long i = 0; i < tmpmodel->SubSet.size(); ++i) + for (int i = 0; i < tmpmodel->m_aSubSets.size(); ++i) { - tmpmodel->SubSet[i].Center = SMVector3Transform(tmpmodel->SubSet[i].Center, WorldMat); - D3DXPlaneTransform(&tmpmodel->SubSet[i].Plane, &tmpmodel->SubSet[i].Plane, &(WorldMat.operator D3DXMATRIX())); + tmpmodel->m_aSubSets[i].m_vCenter = SMVector3Transform(tmpmodel->m_aSubSets[i].m_vCenter, m_mWorld); + D3DXPlaneTransform(&tmpmodel->m_aSubSets[i].m_oPlane, &tmpmodel->m_aSubSets[i].m_oPlane, &(m_mWorld.operator D3DXMATRIX())); - tmpmodel->SubSet[i].Min.x -= jcentererpos.x; - tmpmodel->SubSet[i].Min.y -= jcentererpos.y; - tmpmodel->SubSet[i].Min.z -= jcentererpos.z; + tmpmodel->m_aSubSets[i].m_vMin.x -= jcentererpos.x; + tmpmodel->m_aSubSets[i].m_vMin.y -= jcentererpos.y; + tmpmodel->m_aSubSets[i].m_vMin.z -= jcentererpos.z; - tmpmodel->SubSet[i].Min = SMVector3Transform(tmpmodel->SubSet[i].Min, WorldMat); + tmpmodel->m_aSubSets[i].m_vMin = SMVector3Transform(tmpmodel->m_aSubSets[i].m_vMin, m_mWorld); - tmpmodel->SubSet[i].Min.x += jcentererpos.x; - tmpmodel->SubSet[i].Min.y += jcentererpos.y; - tmpmodel->SubSet[i].Min.z += jcentererpos.z; + tmpmodel->m_aSubSets[i].m_vMin.x += jcentererpos.x; + tmpmodel->m_aSubSets[i].m_vMin.y += jcentererpos.y; + tmpmodel->m_aSubSets[i].m_vMin.z += jcentererpos.z; - tmpmodel->SubSet[i].Max.x -= jcentererpos.x; - tmpmodel->SubSet[i].Max.y -= jcentererpos.y; - tmpmodel->SubSet[i].Max.z -= jcentererpos.z; + tmpmodel->m_aSubSets[i].m_vMax.x -= jcentererpos.x; + tmpmodel->m_aSubSets[i].m_vMax.y -= jcentererpos.y; + tmpmodel->m_aSubSets[i].m_vMax.z -= jcentererpos.z; - tmpmodel->SubSet[i].Max = SMVector3Transform(tmpmodel->SubSet[i].Max, WorldMat); + tmpmodel->m_aSubSets[i].m_vMax = SMVector3Transform(tmpmodel->m_aSubSets[i].m_vMax, m_mWorld); - tmpmodel->SubSet[i].Max.x += jcentererpos.x; - tmpmodel->SubSet[i].Max.y += jcentererpos.y; - tmpmodel->SubSet[i].Max.z += jcentererpos.z; + tmpmodel->m_aSubSets[i].m_vMax.x += jcentererpos.x; + tmpmodel->m_aSubSets[i].m_vMax.y += jcentererpos.y; + tmpmodel->m_aSubSets[i].m_vMax.z += jcentererpos.z; - idgroup = tmpmodel->SubSet[i].idgroup; - idbuff = tmpmodel->SubSet[i].idbuff; - //pData2 = AllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr; - if (!FAILED(AllGroups[idgroup]->VertexBuffer[idbuff]->Lock(0, 0, (void**)&pData, 0))) + idgroup = tmpmodel->m_aSubSets[i].m_idGroup; + idbuff = tmpmodel->m_aSubSets[i].m_idBuff; + //pData2 = m_aAllGroups[idgroup]->VertexBufferOrigin[idbuff]->arr; + if (!FAILED(m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Lock(0, 0, (void**)&pData, 0))) { - vertexstart = tmpmodel->SubSet[i].VertexStart; - vertexcount = tmpmodel->SubSet[i].VertexCount; + vertexstart = tmpmodel->m_aSubSets[i].m_idVertexStart; + vertexcount = tmpmodel->m_aSubSets[i].m_uiVertexCount; for (int k = 0; k < vertexcount; ++k) { @@ -3001,53 +3008,53 @@ void StaticGeom::ApplyTransform(ID id) pData[vertexstart + k].Pos.y -= jcentererpos.y; pData[vertexstart + k].Pos.z -= jcentererpos.z; - pData[vertexstart + k].Pos = SMVector3Transform(pData[vertexstart + k].Pos, WorldMat); - pData[vertexstart + k].Norm = SMVector3Transform(pData[vertexstart + k].Norm, RotationMat); + pData[vertexstart + k].Pos = SMVector3Transform(pData[vertexstart + k].Pos, m_mWorld); + pData[vertexstart + k].Norm = SMVector3Transform(pData[vertexstart + k].Norm, m_mRotation); pData[vertexstart + k].Pos.x += jcentererpos.x; pData[vertexstart + k].Pos.y += jcentererpos.y; pData[vertexstart + k].Pos.z += jcentererpos.z; } - AllGroups[idgroup]->VertexBuffer[idbuff]->Unlock(); + m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Unlock(); } } - Array<Segment*, GEOM_DEFAULT_RESERVE_COM> queue; - long tmpcount = 0; - queue.push_back(tmpmodel->ArrSplits); + Array<CSegment*, GEOM_DEFAULT_RESERVE_COM> queue; + int tmpcount = 0; + queue.push_back(tmpmodel->m_pArrSplits); float3 tmpmin, tmpmax; while (queue.size()) { - queue[0]->BoundVolumeSys->getMinMax(&tmpmin, &tmpmax); + queue[0]->m_pBoundVolumeSys->getMinMax(&tmpmin, &tmpmax); tmpmin -= jcentererpos; tmpmax -= jcentererpos; - tmpmin = SMVector3Transform(tmpmin, WorldMat); - tmpmax = SMVector3Transform(tmpmax, WorldMat); + tmpmin = SMVector3Transform(tmpmin, m_mWorld); + tmpmax = SMVector3Transform(tmpmax, m_mWorld); tmpmin += jcentererpos; tmpmax += jcentererpos; - queue[0]->BoundVolumeSys->setMinMax(&tmpmin, &tmpmax); + queue[0]->m_pBoundVolumeSys->setMinMax(&tmpmin, &tmpmax); - queue[0]->BoundVolumeP->getMinMax(&tmpmin, &tmpmax); + queue[0]->m_pBoundVolumeP->getMinMax(&tmpmin, &tmpmax); tmpmin -= jcentererpos; tmpmax -= jcentererpos; - tmpmin = SMVector3Transform(tmpmin, WorldMat); - tmpmax = SMVector3Transform(tmpmax, WorldMat); + tmpmin = SMVector3Transform(tmpmin, m_mWorld); + tmpmax = SMVector3Transform(tmpmax, m_mWorld); tmpmin += jcentererpos; tmpmax += jcentererpos; - queue[0]->BoundVolumeP->setMinMax(&tmpmin, &tmpmax); + queue[0]->m_pBoundVolumeP->setMinMax(&tmpmin, &tmpmax); - if (queue[0]->BFNonEnd) + if (queue[0]->m_isNonEnd) { for (int i = 0; i<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++i) { - if (queue[0]->Splits[i]) - queue.push_back(queue[0]->Splits[i]); + if (queue[0]->m_aSplits[i]) + queue.push_back(queue[0]->m_aSplits[i]); } } @@ -3055,101 +3062,101 @@ void StaticGeom::ApplyTransform(ID id) ++tmpcount; } - tmpmodel->OldPosition = tmpmodel->Position; - tmpmodel->OldRotation = tmpmodel->Rotation; - tmpmodel->OldScale = tmpmodel->Scale; + tmpmodel->m_vOldPosition = tmpmodel->m_vPosition; + tmpmodel->m_vOldRotation = tmpmodel->m_vRotation; + tmpmodel->m_vOldScale = tmpmodel->m_vScale; } -void StaticGeom::ApplyTransformLod(ID id) +void CStaticGeom::applyTransformLod(ID id) { - if (id >= AllModels.size() || AllModels[id]->Lod0.model == 0) + if (id >= m_aAllModels.size() || m_aAllModels[id]->m_oLod0.m_pModel == 0) return; - Model* tmpmodel = AllModels[id]; + CModel* tmpmodel = m_aAllModels[id]; vertex_static* pData; float3 jmin, jmax; - AllModels[id]->Lod0.BoundVolume->getMinMax(&jmin, &jmax); + m_aAllModels[id]->m_oLod0.m_pBoundVolume->getMinMax(&jmin, &jmax); float3 jcentererpos = (jmax + jmin)*0.5f; - tmpmodel->Lod0.model->m_pVertexBuffer->Lock(0, 0, (void**)&pData, 0); + tmpmodel->m_oLod0.m_pModel->m_pVertexBuffer->Lock(0, 0, (void**)&pData, 0); - for (long i = 0; i < tmpmodel->Lod0.model->m_uiAllVertexCount; ++i) + for (int i = 0; i < tmpmodel->m_oLod0.m_pModel->m_uiAllVertexCount; ++i) { pData[i].Pos.x -= jcentererpos.x; pData[i].Pos.y -= jcentererpos.y; pData[i].Pos.z -= jcentererpos.z; - pData[i].Pos = SMVector3Transform(pData[i].Pos, WorldMat); + pData[i].Pos = SMVector3Transform(pData[i].Pos, m_mWorld); pData[i].Pos.x += jcentererpos.x; pData[i].Pos.y += jcentererpos.y; pData[i].Pos.z += jcentererpos.z; } - tmpmodel->Lod0.model->m_pVertexBuffer->Unlock(); + tmpmodel->m_oLod0.m_pModel->m_pVertexBuffer->Unlock(); jmin -= jcentererpos; jmax -= jcentererpos; - jmin = SMVector3Transform(jmin, WorldMat); - jmax = SMVector3Transform(jmax, WorldMat); + jmin = SMVector3Transform(jmin, m_mWorld); + jmax = SMVector3Transform(jmax, m_mWorld); jmin += jcentererpos; jmax += jcentererpos; - tmpmodel->Lod0.BoundVolume->setMinMax(&jmin, &jmax); + tmpmodel->m_oLod0.m_pBoundVolume->setMinMax(&jmin, &jmax); } -void StaticGeom::Clear() +void CStaticGeom::clear() { - DelArrIndexPtr(); - for (long i = 0; i < AllGroups.size(); ++i) + deleteArrIndexPtr(); + for (int i = 0; i < m_aAllGroups.size(); ++i) { - mem_delete(AllGroups[i]); + mem_delete(m_aAllGroups[i]); } - AllGroups.clear(); + m_aAllGroups.clear(); - while (AllModels.size() > 0) + while (m_aAllModels.size() > 0) { - DelModelInArrCom(0); - mem_delete(AllModels[0]); - AllModels.erase(0); + deleteModelInArrCom(0); + mem_delete(m_aAllModels[0]); + m_aAllModels.erase(0); } - AllModels.clear(); + m_aAllModels.clear(); - while (ArrComFor.size() > 2) + while (m_aArrComFor.size() > 2) { - mem_delete(ArrComFor[2]); - ArrComFor.erase(2); + mem_delete(m_aArrComFor[2]); + m_aArrComFor.erase(2); } - mem_delete_a(ArrMeshVertex); - mem_delete_a(ArrMeshIndex); - CountVertex = 0; + mem_delete_a(m_pCurrArrMeshVertex); + mem_delete_a(m_pCurrArrMeshIndex); + //CountVertex = 0; float3 jmin(0, 0, 0), jmax(0, 0, 0); - BoundVolume->setMinMax(&jmin,&jmax); + m_pBoundVolume->setMinMax(&jmin, &jmax); } -void StaticGeom::GetArrBuffsGeom(float3_t*** arr_vertex, int32_t** arr_count_vertex, uint32_t*** arr_index, ID*** arr_mtl, int32_t** arr_count_index, int32_t* count_models) +void CStaticGeom::getArrBuffsGeom(float3_t*** arr_vertex, int32_t** arr_count_vertex, uint32_t*** arr_index, ID*** arr_mtl, int32_t** arr_count_index, int32_t* count_models) { - (*count_models) = AllModels.size(); - (*arr_vertex) = new float3_t*[AllModels.size()]; - (*arr_index) = new uint32_t*[AllModels.size()]; - (*arr_mtl) = new ID*[AllModels.size()]; - (*arr_count_vertex) = new int32_t[AllModels.size()]; - (*arr_count_index) = new int32_t[AllModels.size()]; + (*count_models) = m_aAllModels.size(); + (*arr_vertex) = new float3_t*[m_aAllModels.size()]; + (*arr_index) = new uint32_t*[m_aAllModels.size()]; + (*arr_mtl) = new ID*[m_aAllModels.size()]; + (*arr_count_vertex) = new int32_t[m_aAllModels.size()]; + (*arr_count_index) = new int32_t[m_aAllModels.size()]; vertex_static* pData; - for (long i = 0; i < AllModels.size(); ++i) + for (int i = 0; i < m_aAllModels.size(); ++i) { - long sizevertex = 0; - long sizeindex = 0; - for (long k = 0; k < AllModels[i]->SubSet.size(); ++k) + int sizevertex = 0; + int sizeindex = 0; + for (int k = 0; k < m_aAllModels[i]->m_aSubSets.size(); ++k) { - sizevertex += AllModels[i]->SubSet[k].VertexCount; - sizeindex += AllModels[i]->SubSet[k].IndexCount; + sizevertex += m_aAllModels[i]->m_aSubSets[k].m_uiVertexCount; + sizeindex += m_aAllModels[i]->m_aSubSets[k].m_uiIndexCount; } (*arr_vertex)[i] = new float3_t[sizevertex]; @@ -3159,50 +3166,50 @@ void StaticGeom::GetArrBuffsGeom(float3_t*** arr_vertex, int32_t** arr_count_ver (*arr_count_vertex)[i] = sizevertex; (*arr_count_index)[i] = sizeindex; - Array<long,1024> tmpbiasindex; + Array<int,1024> tmpbiasindex; - long curr_size_vertex = 0; - long tmp_pre_bias = 0; - for (long k = 0; k < AllModels[i]->SubSet.size(); ++k) + int curr_size_vertex = 0; + int tmp_pre_bias = 0; + for (int k = 0; k < m_aAllModels[i]->m_aSubSets.size(); ++k) { - AllGroups[AllModels[i]->SubSet[k].idgroup]->VertexBuffer[AllModels[i]->SubSet[k].idbuff]->Lock(0, 0, (void**)&pData, 0); + m_aAllGroups[m_aAllModels[i]->m_aSubSets[k].m_idGroup]->m_aVertexBuffers[m_aAllModels[i]->m_aSubSets[k].m_idBuff]->Lock(0, 0, (void**)&pData, 0); - for (long j = 0; j < AllModels[i]->SubSet[k].VertexCount; ++j) + for (int j = 0; j < m_aAllModels[i]->m_aSubSets[k].m_uiVertexCount; ++j) { - (*arr_vertex)[i][curr_size_vertex] = (float3_t)pData[AllModels[i]->SubSet[k].VertexStart + j].Pos; + (*arr_vertex)[i][curr_size_vertex] = (float3_t)pData[m_aAllModels[i]->m_aSubSets[k].m_idVertexStart + j].Pos; ++curr_size_vertex; } tmpbiasindex[k] = 0; - tmpbiasindex[k] = (tmpbiasindex[k] - AllModels[i]->SubSet[k].VertexStart) + tmp_pre_bias; - tmp_pre_bias += AllModels[i]->SubSet[k].VertexCount; + tmpbiasindex[k] = (tmpbiasindex[k] - m_aAllModels[i]->m_aSubSets[k].m_idVertexStart) + tmp_pre_bias; + tmp_pre_bias += m_aAllModels[i]->m_aSubSets[k].m_uiVertexCount; - AllGroups[AllModels[i]->SubSet[k].idgroup]->VertexBuffer[AllModels[i]->SubSet[k].idbuff]->Unlock(); + m_aAllGroups[m_aAllModels[i]->m_aSubSets[k].m_idGroup]->m_aVertexBuffers[m_aAllModels[i]->m_aSubSets[k].m_idBuff]->Unlock(); } - Array<Segment*, GEOM_DEFAULT_RESERVE_COM> queue; - long tmpcount = 0; - queue.push_back(AllModels[i]->ArrSplits); - long curr_size_index = 0; + Array<CSegment*, GEOM_DEFAULT_RESERVE_COM> queue; + int tmpcount = 0; + queue.push_back(m_aAllModels[i]->m_pArrSplits); + int curr_size_index = 0; while (queue.size()) { - if (queue[0]->BFNonEnd) + if (queue[0]->m_isNonEnd) { for (int i = 0; i<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++i) { - if (queue[0]->Splits[i]) - queue.push_back(queue[0]->Splits[i]); + if (queue[0]->m_aSplits[i]) + queue.push_back(queue[0]->m_aSplits[i]); } } else { - Segment* split = queue[0]; - for (long k = 0; k < split->CountSubSet; ++k) + CSegment* split = queue[0]; + for (int k = 0; k < split->m_uiCountSubSet; ++k) { - for (long j = 0; j < split->CountPoly[k]*3; ++j) + for (int j = 0; j < split->m_pCountPoly[k]*3; ++j) { - (*arr_index)[i][curr_size_index] = split->ArrPoly[k][j] + tmpbiasindex[split->NumberGroupModel[k]]; - (*arr_mtl)[i][curr_size_index] = AllGroups[split->NumberGroup[k]]->idtex; + (*arr_index)[i][curr_size_index] = split->m_ppArrPoly[k][j] + tmpbiasindex[split->m_pNumberGroupModel[k]]; + (*arr_mtl)[i][curr_size_index] = m_aAllGroups[split->m_pNumberGroup[k]]->m_idTexture; ++curr_size_index; } } @@ -3214,63 +3221,63 @@ void StaticGeom::GetArrBuffsGeom(float3_t*** arr_vertex, int32_t** arr_count_ver } } -ID StaticGeom::GetModelCountGroups(ID id) +ID CStaticGeom::getModelCountGroups(ID id) { STATIC_PRECOND_ARRCOMFOR_ERR_ID_MODEL(id, -1); - return AllModels[id]->SubSet.size(); + return m_aAllModels[id]->m_aSubSets.size(); } -ID StaticGeom::GetModelGroupIDMat(ID id, ID group) +ID CStaticGeom::getModelGroupIDMat(ID id, ID group) { STATIC_PRECOND_ERR_ID_GROUP(id, group , - 1); - return AllModels[id]->IDTex[group]; + return m_aAllModels[id]->m_aIDsTexures[group]; } -void StaticGeom::GetModelGroupCenter(ID id, ID group, float3_t* center) +void CStaticGeom::getModelGroupCenter(ID id, ID group, float3_t* center) { STATIC_PRECOND_ERR_ID_GROUP(id, group, _VOID); - *center = AllModels[id]->SubSet[group].Center; + *center = m_aAllModels[id]->m_aSubSets[group].m_vCenter; } -void StaticGeom::GetModelGroupMin(ID id, ID group, float3_t* min) +void CStaticGeom::getModelGroupMin(ID id, ID group, float3_t* min) { STATIC_PRECOND_ERR_ID_GROUP(id, group, _VOID); - *min = AllModels[id]->SubSet[group].Min; + *min = m_aAllModels[id]->m_aSubSets[group].m_vMin; } -void StaticGeom::GetModelGroupMax(ID id, ID group, float3_t* max) +void CStaticGeom::getModelGroupMax(ID id, ID group, float3_t* max) { STATIC_PRECOND_ERR_ID_GROUP(id, group, _VOID); - *max = AllModels[id]->SubSet[group].Max; + *max = m_aAllModels[id]->m_aSubSets[group].m_vMax; } -void StaticGeom::GetModelGroupPlane(ID id, ID group, D3DXPLANE* plane) +void CStaticGeom::getModelGroupPlane(ID id, ID group, D3DXPLANE* plane) { STATIC_PRECOND_ERR_ID_GROUP(id, group, _VOID); - *plane = AllModels[id]->SubSet[group].Plane; + *plane = m_aAllModels[id]->m_aSubSets[group].m_oPlane; } -void StaticGeom::GetPartBeam(float3* pos, float3 * dir, Segment** arrsplits, DWORD *count, Segment* comsegment, ID curr_splits_ids_render) +void CStaticGeom::getPartBeam(const float3* pos, const float3 * dir, CSegment** arrsplits, int *count, CSegment* comsegment, ID curr_splits_ids_render) { float3 center; float radius; - comsegment->BoundVolumeP->getSphere(¢er, &radius); + comsegment->m_pBoundVolumeP->getSphere(¢er, &radius); float distsqr = SGCore_0DistancePointBeam2(center, *pos, *dir); - if (comsegment->CountAllPoly > 0 && distsqr <= radius*radius) + if (comsegment->m_uiCountAllPoly > 0 && distsqr <= radius*radius) { - if (comsegment->BFNonEnd) + if (comsegment->m_isNonEnd) { for (int j = 0; j<GEOM_COUNT_TYPE_SEGMENTATION_OCTO; ++j) { - if (comsegment->Splits[j]) - GetPartBeam(pos, dir, arrsplits, count, comsegment->Splits[j], curr_splits_ids_render); + if (comsegment->m_aSplits[j]) + getPartBeam(pos, dir, arrsplits, count, comsegment->m_aSplits[j], curr_splits_ids_render); } } else @@ -3285,9 +3292,9 @@ void StaticGeom::GetPartBeam(float3* pos, float3 * dir, Segment** arrsplits, DWO } } -bool StaticGeom::TraceBeam(float3* start, float3* dir, float3* _res, ID* idmodel, ID* idmtl) +bool CStaticGeom::traceBeam(const float3* start, const float3* dir, float3* _res, ID* idmodel, ID* idmtl) { - if (AllModels.size() <= 0) + if (m_aAllModels.size() <= 0) return false; SXTriangle tmptri; @@ -3300,28 +3307,28 @@ bool StaticGeom::TraceBeam(float3* start, float3* dir, float3* _res, ID* idmodel il = (*dir) * 10000.0f; bool found = false; - for (int id = 0; id < AllModels.size(); ++id) + for (int id = 0; id < m_aAllModels.size(); ++id) { - ArrComFor[1]->arr[id]->CountCom = 0; + m_aArrComFor[1]->m_aIRS[id]->m_iCountCom = 0; - GetPartBeam(start, dir, ArrComFor[1]->arr[id]->Arr, &(ArrComFor[1]->arr[id]->CountCom), AllModels[id]->ArrSplits, ArrComFor[1]->arr[id]->Count); + getPartBeam(start, dir, m_aArrComFor[1]->m_aIRS[id]->m_ppSegments, &(m_aArrComFor[1]->m_aIRS[id]->m_iCountCom), m_aAllModels[id]->m_pArrSplits, m_aArrComFor[1]->m_aIRS[id]->m_iCount); - for (DWORD k = 0; k<ArrComFor[1]->arr[id]->CountCom; ++k) + for (DWORD k = 0; k<m_aArrComFor[1]->m_aIRS[id]->m_iCountCom; ++k) { - for (DWORD group = 0; group<ArrComFor[1]->arr[id]->Arr[k]->CountSubSet; group++) + for (DWORD group = 0; group<m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_uiCountSubSet; group++) { - ID idbuff = AllModels[id]->SubSet[ArrComFor[1]->arr[id]->Arr[k]->NumberGroupModel[group]].idbuff; - ID idgroup = ArrComFor[1]->arr[id]->Arr[k]->NumberGroup[group]; + ID idbuff = m_aAllModels[id]->m_aSubSets[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pNumberGroupModel[group]].m_idBuff; + ID idgroup = m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pNumberGroup[group]; vertex_static* pData = 0; - if (FAILED(AllGroups[idgroup]->VertexBuffer[idbuff]->Lock(0, 0, (void**)&pData, 0))) + if (FAILED(m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Lock(0, 0, (void**)&pData, 0))) continue; - for (DWORD numpoly = 0; numpoly<ArrComFor[1]->arr[id]->Arr[k]->CountPoly[group] * 3; numpoly += 3) + for (DWORD numpoly = 0; numpoly<m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_pCountPoly[group] * 3; numpoly += 3) { - tmptri.a = pData[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly]].Pos; - tmptri.b = pData[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly + 1]].Pos; - tmptri.c = pData[ArrComFor[1]->arr[id]->Arr[k]->ArrPoly[group][numpoly + 2]].Pos; + tmptri.a = pData[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly]].Pos; + tmptri.b = pData[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 1]].Pos; + tmptri.c = pData[m_aArrComFor[1]->m_aIRS[id]->m_ppSegments[k]->m_ppArrPoly[group][numpoly + 2]].Pos; if (tmptri.IntersectLine((*start), il, &ip)) { @@ -3334,12 +3341,12 @@ bool StaticGeom::TraceBeam(float3* start, float3* dir, float3* _res, ID* idmodel *idmodel = id; if (idmtl) - *idmtl = AllGroups[idgroup]->idtex; + *idmtl = m_aAllGroups[idgroup]->m_idTexture; } } } - AllGroups[idgroup]->VertexBuffer[idbuff]->Unlock(); + m_aAllGroups[idgroup]->m_aVertexBuffers[idbuff]->Unlock(); } } } diff --git a/source/geom/static_geom.h b/source/geom/static_geom.h index a4c1acbc3c3ea4380a4498e794d841210b9f43ca..a6c4d21a006c1b96c635bb82bbab0ce4efa8369a 100644 --- a/source/geom/static_geom.h +++ b/source/geom/static_geom.h @@ -12,308 +12,532 @@ See the license in LICENSE #include <gcore/sxgcore.h> #include "sxgeom.h" +//########################################################################## + #define STATIC_PRECOND_ARRCOMFOR_ERR_ID(id_arr) \ -if (!(id_arr < ArrComFor.size()))\ +if (!(id_arr < m_aArrComFor.size()))\ {\ LibReport(REPORT_MSG_LEVEL_ERROR, "%s - static: unresolved id '%d' for array of compute visible", GEN_MSG_LOCATION, id_arr); \ } #define STATIC_PRECOND_ARRCOMFOR_ERR_ID_MODEL(id_model, retval) \ -if (!(id_model < AllModels.size() && AllModels[id_model]))\ +if (!(id_model < m_aAllModels.size() && m_aAllModels[id_model]))\ {\ LibReport(REPORT_MSG_LEVEL_ERROR, "%s - static: unresolved id '%d' for array of models", GEN_MSG_LOCATION, id_model); \ return retval;\ } #define STATIC_PRECOND_ERR_ID_GROUP(id_model,id_group, ret_val) \ -if (!(id_model < AllModels.size() && AllModels[id_model] && id_group < AllModels[id_model]->SubSet.size()))\ +if (!(id_model < m_aAllModels.size() && m_aAllModels[id_model] && id_group < m_aAllModels[id_model]->m_aSubSets.size()))\ {\ LibReport(REPORT_MSG_LEVEL_ERROR, "%s - static: unresolved id '%d' for array of group in model '%d'", GEN_MSG_LOCATION, id_group, id_model); \ return ret_val; \ } -//типы деления +//########################################################################## + +/*! \name Типы деления +@{*/ + +//! квадро деление #define GEOM_COUNT_TYPE_SEGMENTATION_QUAD 4 + +//! октоделение #define GEOM_COUNT_TYPE_SEGMENTATION_OCTO 8 -#define GEOM_DEFAULT_RESERVE_COM 512 /* резервация для просчетов */ -class StaticGeom +//! резервное количество элементов для массива просчетов +#define GEOM_DEFAULT_RESERVE_COM 512 + +//!@} + +//************************************************************************** + +/*! Экстремумы Y координаты уровня +@{*/ + +//! минимальное значение по оси Y +const D3DXVECTOR3 gс_vYmin = D3DXVECTOR3(0.0f, -1000.0f, 0.0f); + +//! максимальное значение по оси Y +const D3DXVECTOR3 gс_vYmax = D3DXVECTOR3(0.0f, 1000.0f, 0.0f); + +//!@} + +//########################################################################## + +//! вся геометрия уровня +class CStaticGeom { public: - static bool UseSortFrontToBackSplits; - static bool UseSortFrontToBackModels; - static IDirect3DDevice9* DXDevice; - static float DistForLod; + //! сортировать ли сплиты от ближнего к дальнему + static bool m_isUseSortFrontToBackSplits; + + + //static bool m_isUseSortFrontToBackModels; + + //! direct3d device + static IDirect3DDevice9 *m_pDXDevice; + + //! дистанция после которой будет рисоваться лод + static float m_fDistForLod; - StaticGeom(); - ~StaticGeom(); + //********************************************************************** + + CStaticGeom(); + ~CStaticGeom(); SX_ALIGNED_OP_MEM + + //********************************************************************** - //сегмент, кусок модели - struct Segment + //! сегмент, кусок модели + struct CSegment { - Segment(); - ~Segment(); + CSegment(); + ~CSegment(); + + //! массив из 4/8 частей данного участка + CSegment* m_aSplits[GEOM_COUNT_TYPE_SEGMENTATION_OCTO]; + + //! двумерный массив по количеству подгрупп, вложенный массив - все полигоны для данной подгруппы + uint32_t **m_ppArrPoly; + + //! массив с количеством полигонов на каждую подгруппу + uint32_t *m_pCountPoly; + + //! массив с номерами подгрупп в контексте уровня + uint32_t *m_pNumberGroup; + + //! массив с номерами подгрупп в контексте модели + uint32_t *m_pNumberGroupModel; + + //! количество подгрупп + uint32_t m_uiCountSubSet; - Segment* Splits[GEOM_COUNT_TYPE_SEGMENTATION_OCTO]; //массив из 4/8 частей данного участка + //! общее количество полигонов + uint32_t m_uiCountAllPoly; - //для геометрии - uint32_t** ArrPoly; //двумерный массив по количеству подгрупп, вложенный массив - все полигоны для данной подгруппы - uint32_t* CountPoly; //массив с количеством полигонов на каждую подгруппу - uint32_t* NumberGroup; //массив с номерами подгрупп в контексте уровня - uint32_t* NumberGroupModel;//массив с номерами подгрупп в контексте модели - uint32_t CountSubSet; //количество подгрупп - uint32_t CountAllPoly; //общее количество полигонов - ISXBound* BoundVolumeSys; //выравненный ограничивающий объем для равномерного деления - ISXBound* BoundVolumeP; //облегающий ограничивающий объем + //! выравненный ограничивающий объем для равномерного деления + ISXBound *m_pBoundVolumeSys; - float DistForCamera; + //! облегающий ограничивающий объем + ISXBound *m_pBoundVolumeP; - DWORD ID; //идентификатор куска - DWORD SID; //порядковый номер куска из массива рисующихся кусков + //! текущее расстояние до камеры (для определения когда рисовать лод) + float m_fDistForCamera; + + //! идентификатор куска + ID m_ID; + + //! порядковый номер куска из массива рисующихся кусков + ID m_SID; + + //! имеет ли кусок куски внутри себя? + bool m_isNonEnd; //ID3DXMesh* BoundBox; //ограничивающий параллелепипед (меш) - bool BFNonEnd;//имеет ли кусок куски внутри себя? }; - + //********************************************************************** - //модель, главный юнит уровня - struct Model + //! модель, главный юнит уровня + struct CModel { - Model(); - ~Model(); + CModel(); + ~CModel(); SX_ALIGNED_OP_MEM - struct Lod + /*! Лод - низкополигональная модель, которая рисуется вместо оригинальной модели когда игрок на достаточном удалении от модели + \warning Все материалы должны быть одного сорта!!! + */ + struct CLod { - Lod(); - ~Lod(); - - int SortGroup; - char PathName[1024]; - ISXDataStaticModel* model; - Array<ID> IDsTexs; - ISXBound* BoundVolume; + CLod(); + ~CLod(); + + //! сорт материала, принимается только один сорт, последней текстуры + int m_iSortGroup; + + //! путь до модели лода в папке статиечской геометрии + char m_szPathName[1024]; + + //! указатель на объект ISXDataStaticModel + ISXDataStaticModel *m_pModel; + + //! массив идентификаторов текстур, все текстуры должны быть одного сорта + Array<ID> m_aIDsTextures; + + //! ограничивающий объем лода + ISXBound *m_pBoundVolume; }; - struct GDataBuff + //****************************************************************** + + /*! подгруппа модели */ + struct CSubSet { - int32_t idgroup;//id подгруппы в контексте уровня - int32_t idbuff; //id буфера (в подгруппе) в который заисаны данные геометрии модели - int32_t IndexStart; - int32_t IndexCount; - int32_t VertexStart; - int32_t VertexCount; - - D3DXPLANE Plane; - float3_t Max; - float3_t Min; - float3_t Center; + //! id подгруппы в контексте уровня + int32_t m_idGroup; + + //! id буфера (в подгруппе) в который записаны данные геометрии модели + int32_t m_idBuff; + + //! id стартового индекса подгруппы + int32_t m_idIndexStart; + + //! количество индексов в подгруппе + int32_t m_uiIndexCount; + + //! id стартовой вершины подгруппы + int32_t m_idVertexStart; + + //! количество вершин в подгруппе + int32_t m_uiVertexCount; + + + //! плоскость подгруппы + D3DXPLANE m_oPlane; + + //! максимум подгруппы + float3_t m_vMax; + + //! минимум подгруппы + float3_t m_vMin; + + //! центр подгруппы + float3_t m_vCenter; }; + //****************************************************************** - float3 Position; - float3 Rotation; - float3 Scale; + //! позиция модели + float3 m_vPosition; + + //! повороты модели в радианах + float3 m_vRotation; + + //! масштаб модели + float3 m_vScale; + - float3 OldPosition; - float3 OldRotation; - float3 OldScale; + //! предыдущая позиция модели + float3 m_vOldPosition; - char Name[64]; - char PathName[1024]; - int32_t CountPoly; + //! предыдущие повороты модели в радианах + float3 m_vOldRotation; - Lod Lod0; + //! предыдущий масштаб модели + float3 m_vOldScale; - bool IsRenderLod; - Array<GDataBuff> SubSet; //описание каждой подгруппы модели - Array<float> GroupDist; - Array<ID> IDTex; - Segment* ArrSplits; //массив с сегментами - ID SplitsIDs; //общее количество сегментов/спилтов - ID SplitsIDsRender; //количество рисубщихся сегментов + //! имя модели + char m_szName[64]; + + //! путь до модели + char m_szPathName[1024]; + + //! количество полигонов + int32_t m_uiCountPoly; + + //! лод модели + CLod m_oLod0; + + //! рисовать ил в данный момент лод или целую модель? + bool m_isRenderLod; + + + //! описание каждой подгруппы модели + Array<CSubSet> m_aSubSets; + + Array<float> m_aGroupDist; + + //! массив идентификаторов текстур для каждой подгруппы + Array<ID> m_aIDsTexures; + + //! массив с сегментами + CSegment *m_pArrSplits; + + //! общее количество сегментов/спилтов + ID m_idCountSplits; + + //! количество рисующихся сегментов + ID m_idCountSplitsRender; }; + //********************************************************************** - //подгруппа уровня - struct Group + /*! подгруппа статической геометрии уровня + \note Подгруппа внутри имеет массив, в каждом из которых не более GEOM_MAX_POLY_IN_GROUP полигонов, поэтому можно шибко не беспокоится о количестве полигонов для конкретной подгруппы + */ + struct CGroup { - Group(); - ~Group(); + CGroup(); + ~CGroup(); - /*struct VertexBuff - { - VertexBuff(); - ~VertexBuff(); - - float3_t* arr; - long count; - };*/ - - bool IsRenderSingly; - int SortGroup;//тип/вид/сорт подгруппы, для ранжирования рендера - String name;//имя текстуры - ID idtex; //идентификатор текстуры - long AllCountVertex; //общее количество вершин - long AllCountIndex; //общее количество индексов - Array<int32_t, 4> CountVertex; //количество вершин в буферах - Array<int32_t, 4> CountIndex; //количество индексов в буферах - Array<Array<Model*>> ArrModels; - Array<IDirect3DVertexBuffer9*, 4> VertexBuffer; - //Array<VertexBuff*, 4> VertexBufferOrigin; + //! рисовать ли полигоны этой подгруппы отдельно для каждой модели? это может понадобится к примеру для полупрозрачных материалов + bool m_isRenderSingly; + + //! тип/вид/сорт подгруппы, для ранжирования рендера + int m_iSortGroup; + + //! имя текстуры + String m_sName; + + //! идентификатор текстуры + ID m_idTexture; + + //! общее количество вершин + int m_iCountVertex; + + //! общее количество индексов + int m_iCountIndex; + + //! количество вершин в буферах + Array<int32_t, 4> m_aCountVertex; + + //! количество индексов в буферах + Array<int32_t, 4> m_aCountIndex; + + //! массив массивов моделей в текущей подгруппе, в каждом элементе массива не более GEOM_MAX_POLY_IN_GROUP полигонов + Array<Array<CModel*>> m_aModels; + + //! массив буферов вершин + Array<IDirect3DVertexBuffer9*, 4> m_aVertexBuffers; }; - //структура содержащая минимальную необходимую информацию о сегменте модели - struct InfoRenderSegments + //********************************************************************** + + //! структура содержащая минимальную необходимую информацию о сегменте модели для рендера + struct CInfoRenderSegments { - InfoRenderSegments(); - ~InfoRenderSegments(); - Segment** Arr; //массив хранящий в себе указатели на сегменты REALTIME - DWORD Count; //размер Arr - DWORD CountCom; //сколько сегментов записано в Arr REALTIME + CInfoRenderSegments(); + ~CInfoRenderSegments(); + + //! массив хранящий в себе указатели на сегменты REALTIME + CSegment **m_ppSegments; + + //! размер m_ppSegments + int m_iCount; + + //! сколько сегментов записано в m_ppSegments REALTIME + int m_iCountCom; }; - struct IRSData + //********************************************************************** + + //! данные для просчетов видимости + struct CIRSData { - IRSData(); - ~IRSData(); - Array<Segment*, GEOM_DEFAULT_RESERVE_COM> queue; - Array<InfoRenderSegments*> arr; + CIRSData(); + ~CIRSData(); + + //! очередь обработки просчетов видимости для каждого сегмента + Array<CSegment*, GEOM_DEFAULT_RESERVE_COM> m_aQueue; + + //! массив информации для рендера сегментов + Array<CInfoRenderSegments*> m_aIRS; }; - void OnLostDevice(); - void OnResetDevice(); + //###################################################################### - void Clear(); - void Save(const char* path); - void Load(const char* path); + void onLostDevice(); + void onResetDevice(); - void SortGroup(float3* viewpos, int sort_mtl); + void clear(); + void save(const char *szPath); + void load(const char *szPath); + + void sortGroup(const float3 *pViewPos, int iSortMtl); - long GetCountModel(); + int getCountModel(); - void CPUFillingArrIndeces(const ISXFrustum* frustum, float3* viewpos, ID id_arr = 0); - bool GetIntersectedRayY(float3* pos); + void comArrIndeces(const ISXFrustum *pFrustum, const float3 *pViewPos, ID idArr = 0); + bool getIntersectedRayY(float3 *pPos); - bool SortExistsForRender(int sort, ID id_arr = 0); + bool sortExistsForRender(int iSortMtl, ID idArr = 0); - void GPURender(DWORD timeDelta, int sort_mtl, ID id_arr = 0, ID exclude_model_id = -1, ID exclude_group_id = -1, bool is_sorted = false); - void GPURenderSingly(DWORD timeDelta, ID id, ID id_tex); - ID AddModel(const char* path, const char* lod1, const char* name); - void DelModel(ID id); - - void GetMinMax(float3* min,float3* max); - - ID AddArrForCom(); - bool existsArrForCom(ID id); - void DelArrForCom(ID id_arr); - - char* GetModelName(ID id); - const char* GetModelPathName(ID id); - long GetModelCountPoly(ID id); - void GetModelMinMax(ID id, float3* min, float3* max); - - float3* GetModelPosition(ID id); - float3* GetModelRotation(ID id); - float3* GetModelScale(ID id); - - const char* GetModelLodPath(ID id); - void SetModelLodPath(ID id, const char* path); - - void ApplyTransform(ID id); - - ID GetModelCountGroups(ID id); - ID GetModelGroupIDMat(ID id, ID group); - void GetModelGroupCenter(ID id, ID group, float3_t* center); - void GetModelGroupMin(ID id, ID group, float3_t* min); - void GetModelGroupMax(ID id, ID group, float3_t* max); - void GetModelGroupPlane(ID id, ID group, D3DXPLANE* plane); - - void GetArrBuffsGeom(float3_t*** arr_vertex, int32_t** arr_count_vertex, uint32_t*** arr_index, ID*** arr_mtl, int32_t** arr_count_index, int32_t* count_models); - /* - (*arr_vertex)[num_model][num_vertex] - вершины модели - (*arr_count_vertex)[num_model] - количество вершин для модели - (*arr_index)[num_model][num_vertex] - индексы модели - (*arr_mtl)[num_model][num_vertex] - материал для индекса - (*arr_count_index)[num_model] - количество индексов для модели - (*count_model); количество моделей - */ + void render(DWORD timeDelta, int iSortMtl, ID idArr = 0, ID idExcludeModel = -1, ID isExcludeGroup = -1, bool isSorted = false); + void renderSingly(DWORD timeDelta, ID idModel, ID idTexture); + ID addModel(const char *szPath, const char *szLod1, const char *szName); + void deleteModel(ID idModel); - - bool TraceBeam(float3* start, float3* dir, float3* _res, ID* idmodel, ID* idmtl); + void getMinMax(float3 *pMin, float3 *pMax); + + ID addArrForCom(); + bool existsArrForCom(ID idArr); + void deleteArrForCom(ID idArr); + + char* getModelName(ID idModel); + const char* getModelPathName(ID idModel); + int getModelCountPoly(ID idModel); + void getModelMinMax(ID idModel, float3 *pMin, float3 *pMax); + + float3* getModelPosition(ID idModel); + float3* getModelRotation(ID idModel); + float3* getModelScale(ID idModel); + + const char* getModelLodPath(ID idModel); + void setModelLodPath(ID idModel, const char *szPath); + + void applyTransform(ID idModel); + + ID getModelCountGroups(ID idModel); + ID getModelGroupIDMat(ID idModel, ID idGroup); + void getModelGroupCenter(ID idModel, ID idGroup, float3_t *pCenter); + void getModelGroupMin(ID idModel, ID idGroup, float3_t *pMin); + void getModelGroupMax(ID idModel, ID idGroup, float3_t *pMax); + void getModelGroupPlane(ID idModel, ID idGroup, D3DXPLANE *pPlane); + + void getArrBuffsGeom( + float3_t ***pppArrVertex, //!< (*arr_vertex)[num_model][num_vertex] - вершины модели + int32_t **ppArrCountVertex, //!< (*arr_count_vertex)[num_model] - количество вершин для модели + uint32_t ***pppArrIndex, //!< (*arr_index)[num_model][num_vertex] - индексы модели + ID ***pppArrMtl, //!< (*arr_mtl)[num_model][num_vertex] - материал для индекса + int32_t **ppArrCountIndex, //!< (*arr_count_index)[num_model] - количество индексов для модели + int32_t *pCountModels //!< (*count_model); количество моделей + ); + + bool traceBeam(const float3 *pStart, const float3 *Dir, float3 *pResult, ID *pIDmodel, ID *pIDmtl); protected: - struct InfoGroup + //! структура для сортировки моделей и их подгрупп по дальности от камеры + struct CInfoGroup { - ID model; - ID group; - ID g_group; - float dist; - int count; + //! id модели + ID m_idModel; + + //! id подгруппы модели + ID m_idGroup; + + //! id подгруппы модели в контексте уровня + ID m_idGlobalGroup; + + //! дистанция до наблюдателя + float m_fDist; + + //int m_iCount; }; - Array<InfoGroup*> DistGroup; - Array<IRSData*> ArrComFor; //информация о сегментах для рендера - void AddModelInArrCom(ID id_model); - void DelModelInArrCom(ID id_model); - float4x4 WorldMat; - float4x4 RotationMat; - void ApplyTransformLod(ID id); + //! массив для сортировки подгрупп по дальности (для рендера полупрозрачных поверхностей) + Array<CInfoGroup*> m_aDistGroup; + + //********************************************************************* + + //! информация о сегментах для рендера + Array<CIRSData*> m_aArrComFor; - ISXBound* BoundVolume; + //! добавляет данные о модели к данным для рендера + void addModelInArrCom(ID idModel); - void GetPartBeam(float3* pos, float3 * dir, Segment** arrsplits, DWORD *count, Segment* comsegment, ID curr_splits_ids_render); + //! удаляет данные о модели из данных о рендере + void deleteModelInArrCom(ID idModel); - void GetIntersectedRayY2(float3* pos, Segment** arrsplits, DWORD *count, Segment* comsegment, ID curr_splits_ids_render); + //********************************************************************** - void SaveSplit(Segment* Split, FILE* file, Array<Segment*> * queue); - void LoadSplit(Segment** Split, FILE* file, Array<Segment**> * queue); + //! мировая матрица трансформаций + float4x4 m_mWorld; + + //! матрица трансформации поворотов (для нормалей) + float4x4 m_mRotation; + + //! применяет трансформации для лода модели + void applyTransformLod(ID id); + + //********************************************************************** + + //! ограничивающий объем всего уровня + ISXBound *m_pBoundVolume; + + //********************************************************************** + + //! сохраняет сплит в файл + void saveSplit(CSegment *pSplit, FILE *pFile, Array<CSegment*> *pQueue); + + //! читает сплит из файла + void loadSplit(CSegment **ppSplit, FILE *pFile, Array<CSegment**> *pQueue); + + //********************************************************************** + + void getPartBeam(const float3 *pPos, const float3 *pDir, CSegment **ppSplits, int *iCount, CSegment *pSegment, ID idCurrSplitRender); + + void getIntersectedRayY2(float3 *pPos, CSegment **ppSplits, int *iCount, CSegment *pSegment, ID idCurrSplitRender); + + void comRecArrIndeces(const ISXFrustum *pFrustum, CSegment **ppSplits, int *iCount, CSegment *pSegment, const float3 *pViewPos, Array<CSegment*, GEOM_DEFAULT_RESERVE_COM> *pQueue, ID idCurrSplitRender); + + //************************************************************************* + + //! подготовительный этап сегментации + void preSegmentation(CModel *pMesh, ISXDataStaticModel *pModel); + + //! сегментации модели + void segmentation(CSegment *pSplit, CModel *pMesh, ISXDataStaticModel *pModel, int iCountSplitsSys, int iCountPolyInSegment, Array<CSegment*> *pQueue); + + //! рекусривный вызов сегментации + void cycleSegmentation(CSegment *pSplit, CModel *pMesh, ISXDataStaticModel *pModel, int iCountSplitsSys, int iCountPolyInSegment); + + //! устанавливает m_pBoundVolumeP сплита так чтобы он полностью облегал сплит + void editVolume(CModel *pMesh, CSegment *pSplit); + + //! установка каждому куску идентификатора, удаление пустых кусков + void setSplitID(CSegment *pSplit, ID * SplitsIDs, ID * SplitsIDsRender); + + //********************************************************************** + + /*! Данные текущей загружаемой модели + @{*/ + + //! массив вершин текущей модели + float3 *m_pCurrArrMeshVertex; + + //! массив индексов текущей модели + UINT *m_pCurrArrMeshIndex; + + //!@} + + //********************************************************************** + + //! массив моделей + Array<CModel*> m_aAllModels; + + //! массив подгрупп + Array<CGroup*> m_aAllGroups; + + //********************************************************************** + + /*! real-time данные для рендера моделей + @{*/ + + //! создает основные массивы + void initArrIndexPtr(); + + //! удаляет все основные массивы + void deleteArrIndexPtr(); + - void PreSegmentation(Model* mesh, ISXDataStaticModel* model); //подготовительный этап сегментации - void Segmentation(Segment* Split, Model* mesh, ISXDataStaticModel* model, long CountSplitsSys, long CountPolyInSegment, Array<Segment*> * queue); //сегментации модели - void CycleSegmentation(Segment* Split, Model* mesh, ISXDataStaticModel* model, long CountSplitsSys, long CountPolyInSegment); //рекусривный вызов сегментации - void EditVolume(Model* mesh, Segment* Split); - void SetSplitID(Segment* Split, ID* SplitsIDs, ID* SplitsIDsRender); //установка каждому куску идентификатора, удаление пустых кусков - void SetSplitID2(Segment* Split, ID* SplitsIDs, ID* SplitsIDsRender, Array<Segment*>* queue); - void ComRecArrIndeces(const ISXFrustum* frustum, Segment** arrsplits, DWORD *count, Segment* comsegment, float3* viewpos, Array<Segment*, GEOM_DEFAULT_RESERVE_COM>* queue, ID curr_splits_ids_render); + //! массив для хранения всех индексов которые будут отправлены на рендер сейчас + uint32_t ***m_pppRTArrIndices; - //рабочие данные, используются внутри в методах - //{{ - float3* ArrMeshVertex; - UINT* ArrMeshIndex; - long CountVertex; + //! массив для хранения размеров для каждого из массивов RTCPUArrIndicesPtrs + uint32_t **m_ppRTCountDrawPoly; - D3DXVECTOR3 jpos; - D3DXVECTOR3 jvevyp; - D3DXVECTOR3 jvevyn; - float3 jvec0, jvec1, jvec2; + //! массив для хранения количества рисуемых полигонов для каждой подгруппы для каждой модели + uint32_t ***m_pppRTCountDrawPolyModel; - //}} + //! массив для хранения начала индексов для каждой подгруппы для каждой модели + uint32_t ***m_pppRTBeginIndexModel; - //функции удаления и создания массивов RTCPUArrIndicesPtrs и RTCountDrawPoly - //при добавлении новой модели - void DelArrIndexPtr(); - void InitArrIndexPtr(); - uint32_t*** RTCPUArrIndicesPtrs; //массив для хранения всех индексов которые будут отправлены на рендер сейчас - uint32_t** RTCountDrawPoly; //массив для хранения размеров для каждого из массивов RTCPUArrIndicesPtrs - uint32_t*** RTCountDrawPolyModel; //массив для хранения количества рисуемых полигонов для каждой подгруппы для каждой модели - uint32_t*** RTBeginIndexModel; //массив для хранения начала индексов для каждой подгруппы для каждой модели + //! размер в элементах m_pRenderIndexBuffer + int m_iSizeRenderIndexBuffer; - Array<Model*> AllModels; //массив моделей - Array<Group*> AllGroups; //массив подгрупп - //IDirect3DVertexDeclaration9* VertexDeclarationStatic; + //! индексный буфер, используется и изменяется в реайлтайме при рендере уровня, имеет размер самого большого индексного буфера из всех подгрупп моделей, создается в момент загрузки моделей + IDirect3DIndexBuffer9* m_pRenderIndexBuffer; - long SizeRenderIndexBuffer; //размер в элементах RenderIndexBuffer - IDirect3DIndexBuffer9* RenderIndexBuffer; //индексный буфер, используется и изменяется в реайлтайме при рендере уровня + //!@} }; #endif diff --git a/source/geom/sxgeom.cpp b/source/geom/sxgeom.cpp index 72a2facd12ad736617d1913646a448a7a79ff267..3e7b1551a544f5bd66aff962d5193fea4f636c1b 100644 --- a/source/geom/sxgeom.cpp +++ b/source/geom/sxgeom.cpp @@ -11,26 +11,28 @@ See the license in LICENSE #include "static_geom.h" #include "green.h" -bool StaticGeom::UseSortFrontToBackSplits = true; -bool StaticGeom::UseSortFrontToBackModels = true; -IDirect3DDevice9* StaticGeom::DXDevice = 0; -float StaticGeom::DistForLod = 200.f; +//########################################################################## + +bool CStaticGeom::m_isUseSortFrontToBackSplits = true; +//bool CStaticGeom::m_isUseSortFrontToBackModels = true; +IDirect3DDevice9* CStaticGeom::m_pDXDevice = 0; +float CStaticGeom::m_fDistForLod = 200.f; -int Green::CurrentFreqGrass = 100; -float2_t Green::DistLods = float2_t(50, 100); -float Green::BeginEndLessening = 30; -bool Green::UseSortFrontToBackSplits = false; -IDirect3DDevice9* Green::DXDevice = 0; +int CGreen::m_iRenderFreqGrass = 100; +float2_t CGreen::m_vDistLods = float2_t(50, 100); +float CGreen::m_fDistGrassLessening = 30; +bool CGreen::m_isUseSortFrontToBackSplits = false; +IDirect3DDevice9* CGreen::m_pDXDevice = 0; #if !defined(DEF_STD_REPORT) #define DEF_STD_REPORT report_func g_fnReportf = DefReport; #endif -StaticGeom* GeometryObj = 0; -Green* GreenObj = 0; +CStaticGeom *g_pGeometry = 0; +CGreen *g_pGreen = 0; -#define GEOM_PRECOND(retval) if(!GeometryObj || !GreenObj){LibReport(REPORT_MSG_LEVEL_ERROR, "%s - sxgeom is not init", GEN_MSG_LOCATION); return retval;} +#define GEOM_PRECOND(retval) if(!g_pGeometry || !g_pGreen){LibReport(REPORT_MSG_LEVEL_ERROR, "%s - sxgeom is not init", GEN_MSG_LOCATION); return retval;} //########################################################################## @@ -58,18 +60,18 @@ SX_LIB_API void SGeom_0Create(const char *szName, bool isUnic) } else { - StaticGeom::DXDevice = SGCore_GetDXDevice(); - Green::DXDevice = SGCore_GetDXDevice(); - GeometryObj = new StaticGeom(); - GreenObj = new Green(); + CStaticGeom::m_pDXDevice = SGCore_GetDXDevice(); + CGreen::m_pDXDevice = SGCore_GetDXDevice(); + g_pGeometry = new CStaticGeom(); + g_pGreen = new CGreen(); } } else { - StaticGeom::DXDevice = SGCore_GetDXDevice(); - Green::DXDevice = SGCore_GetDXDevice(); - GeometryObj = new StaticGeom(); - GreenObj = new Green(); + CStaticGeom::m_pDXDevice = SGCore_GetDXDevice(); + CGreen::m_pDXDevice = SGCore_GetDXDevice(); + g_pGeometry = new CStaticGeom(); + g_pGreen = new CGreen(); } } else @@ -78,24 +80,24 @@ SX_LIB_API void SGeom_0Create(const char *szName, bool isUnic) SX_LIB_API void SGeom_AKill() { - mem_delete(GeometryObj); - mem_delete(GreenObj); + mem_delete(g_pGeometry); + mem_delete(g_pGreen); } SX_LIB_API void SGeom_OnLostDevice() { GEOM_PRECOND(_VOID); - GreenObj->OnLostDevice(); - GeometryObj->OnLostDevice(); + g_pGreen->onLostDevice(); + g_pGeometry->onLostDevice(); } SX_LIB_API void SGeom_OnResetDevice() { GEOM_PRECOND(_VOID); - GreenObj->OnResetDevice(); - GeometryObj->OnResetDevice(); + g_pGreen->onResetDevice(); + g_pGeometry->onResetDevice(); } //########################################################################## @@ -113,64 +115,64 @@ SX_LIB_API bool SGeom_0SettModelsGetSortFrontToBackModels() SX_LIB_API void SGeom_0SettModelsSetSortFrontToBackSplits(bool val) { - StaticGeom::UseSortFrontToBackSplits = val; + CStaticGeom::m_isUseSortFrontToBackSplits = val; } SX_LIB_API bool SGeom_0SettModelsGetSortFrontToBackSplits() { - return StaticGeom::UseSortFrontToBackSplits; + return CStaticGeom::m_isUseSortFrontToBackSplits; } SX_LIB_API float SGeom_0SettGreenGetDistLods1() { - return Green::DistLods.x; + return CGreen::m_vDistLods.x; } SX_LIB_API float SGeom_0SettGreenGetDistLods2() { - return Green::DistLods.y; + return CGreen::m_vDistLods.y; } SX_LIB_API int SGeom_0SettGreenGetFreqGrass() { - return Green::CurrentFreqGrass; + return CGreen::m_iRenderFreqGrass; } SX_LIB_API float SGeom_0SettGreenGetBeginEndLessening() { - return Green::BeginEndLessening; + return CGreen::m_fDistGrassLessening; } SX_LIB_API bool SGeom_0SettGreenGetSortFrontToBackSplits() { - return Green::UseSortFrontToBackSplits; + return CGreen::m_isUseSortFrontToBackSplits; } SX_LIB_API void SGeom_0SettGreenSetDistLods1(float val) { - Green::DistLods.x = val; + CGreen::m_vDistLods.x = val; } SX_LIB_API void SGeom_0SettGreenSetDistLods2(float val) { - Green::DistLods.y = val; + CGreen::m_vDistLods.y = val; } SX_LIB_API void SGeom_0SettGreenSetFreqGrass(int val) { - Green::CurrentFreqGrass = val; + CGreen::m_iRenderFreqGrass = val; } SX_LIB_API void SGeom_0SettGreenSetBeginEndLessening(float val) { - Green::BeginEndLessening = val; + CGreen::m_fDistGrassLessening = val; } SX_LIB_API void SGeom_0SettGreenSetSortFrontToBackSplits(bool val) { - Green::UseSortFrontToBackSplits = val; + CGreen::m_isUseSortFrontToBackSplits = val; } //########################################################################## @@ -178,434 +180,435 @@ SX_LIB_API void SGeom_0SettGreenSetSortFrontToBackSplits(bool val) SX_LIB_API void SGeom_ModelsClear() { GEOM_PRECOND(_VOID); - GeometryObj->Clear(); + g_pGeometry->clear(); } -SX_LIB_API void SGeom_ModelsSave(const char* path) +SX_LIB_API void SGeom_ModelsSave(const char *szPath) { GEOM_PRECOND(_VOID); - GeometryObj->Save(path); + g_pGeometry->save(szPath); } -SX_LIB_API void SGeom_ModelsLoad(const char* path) +SX_LIB_API void SGeom_ModelsLoad(const char *szPath) { GEOM_PRECOND(_VOID); - GeometryObj->Load(path); + g_pGeometry->load(szPath); } -SX_LIB_API long SGeom_ModelsGetCount() +SX_LIB_API int SGeom_ModelsGetCount() { GEOM_PRECOND(-1); - return GeometryObj->GetCountModel(); + return g_pGeometry->getCountModel(); } -SX_LIB_API void SGeom_ModelsComVisible(const ISXFrustum* frustum, float3* viewpos, ID id_arr) +SX_LIB_API void SGeom_ModelsComVisible(const ISXFrustum *pFrustum, const float3 *pViewPos, ID idArr) { GEOM_PRECOND(_VOID); - GeometryObj->CPUFillingArrIndeces(frustum, viewpos, id_arr); + g_pGeometry->comArrIndeces(pFrustum, pViewPos, idArr); } -SX_LIB_API bool SGeom_ModelsSortExistsForRender(int sort, ID id_arr) +SX_LIB_API bool SGeom_ModelsSortExistsForRender(int iSort, ID idArr) { GEOM_PRECOND(false); - return GeometryObj->SortExistsForRender(sort, id_arr); + return g_pGeometry->sortExistsForRender(iSort, idArr); } -SX_LIB_API void SGeom_ModelsRender(DWORD timeDelta, int sort_mtl, ID id_arr, bool is_sorted, ID exclude_model_id, ID exclude_group_id) +SX_LIB_API void SGeom_ModelsRender(DWORD timeDelta, int iSortMtl, ID idArr, bool isSorted, ID idExcludeModel, ID idExcludeGroup) { GEOM_PRECOND(_VOID); - GeometryObj->GPURender(timeDelta, sort_mtl, id_arr, exclude_model_id, exclude_group_id, is_sorted); + g_pGeometry->render(timeDelta, iSortMtl, idArr, idExcludeModel, idExcludeGroup, isSorted); } -SX_LIB_API void SGeom_ModelsRenderSingly(DWORD timeDelta, ID id, ID id_tex) +SX_LIB_API void SGeom_ModelsRenderSingly(DWORD timeDelta, ID idModel, ID idTexture) { GEOM_PRECOND(_VOID); - GeometryObj->GPURenderSingly(timeDelta, id, id_tex); + g_pGeometry->renderSingly(timeDelta, idModel, idTexture); } -SX_LIB_API ID SGeom_ModelsAddModel(const char* path, const char* lod1, const char* name) +SX_LIB_API ID SGeom_ModelsAddModel(const char *szPath, const char *szLod1, const char *szName) { GEOM_PRECOND(-1); - return GeometryObj->AddModel(path, lod1, name); + return g_pGeometry->addModel(szPath, szLod1, szName); } -SX_LIB_API void SGeom_ModelsDelModel(ID id) +SX_LIB_API void SGeom_ModelsDelModel(ID idModel) { GEOM_PRECOND(_VOID); - GeometryObj->DelModel(id); + g_pGeometry->deleteModel(idModel); } -SX_LIB_API void SGeom_ModelsGetMinMax(float3* min, float3* max) +SX_LIB_API void SGeom_ModelsGetMinMax(float3 *pMin, float3 *pMax) { GEOM_PRECOND(_VOID); - GeometryObj->GetMinMax(min, max); + g_pGeometry->getMinMax(pMin, pMax); } SX_LIB_API ID SGeom_ModelsAddArrForCom() { GEOM_PRECOND(-1); - return GeometryObj->AddArrForCom(); + return g_pGeometry->addArrForCom(); } -SX_LIB_API bool SGeom_ModelsExistsArrForCom(ID id) +SX_LIB_API bool SGeom_ModelsExistsArrForCom(ID idModel) { GEOM_PRECOND(false); - return GeometryObj->existsArrForCom(id); + return g_pGeometry->existsArrForCom(idModel); } -SX_LIB_API void SGeom_ModelsDelArrForCom(ID id_arr) +SX_LIB_API void SGeom_ModelsDelArrForCom(ID idArr) { GEOM_PRECOND(_VOID); - GeometryObj->DelArrForCom(id_arr); + g_pGeometry->deleteArrForCom(idArr); } -SX_LIB_API void SGeom_ModelsMGetMinMax(ID id, float3* min, float3* max) +SX_LIB_API void SGeom_ModelsMGetMinMax(ID idModel, float3 *pMin, float3 *pMax) { GEOM_PRECOND(_VOID); - return GeometryObj->GetModelMinMax(id, min, max); + return g_pGeometry->getModelMinMax(idModel, pMin, pMax); } -SX_LIB_API char* SGeom_ModelsMGetName(ID id) +SX_LIB_API char* SGeom_ModelsMGetName(ID idModel) { GEOM_PRECOND(0); - return GeometryObj->GetModelName(id); + return g_pGeometry->getModelName(idModel); } -SX_LIB_API const char* SGeom_ModelsMGetPathName(ID id) +SX_LIB_API const char* SGeom_ModelsMGetPathName(ID idModel) { GEOM_PRECOND(0); - return GeometryObj->GetModelPathName(id); + return g_pGeometry->getModelPathName(idModel); } -SX_LIB_API long SGeom_ModelsMGetCountPoly(ID id) +SX_LIB_API int SGeom_ModelsMGetCountPoly(ID idModel) { GEOM_PRECOND(-1); - return GeometryObj->GetModelCountPoly(id); + return g_pGeometry->getModelCountPoly(idModel); } -SX_LIB_API float3* SGeom_ModelsMGetPosition(ID id) +SX_LIB_API float3* SGeom_ModelsMGetPosition(ID idModel) { GEOM_PRECOND(0); - return GeometryObj->GetModelPosition(id); + return g_pGeometry->getModelPosition(idModel); } -SX_LIB_API float3* SGeom_ModelsMGetRotation(ID id) +SX_LIB_API float3* SGeom_ModelsMGetRotation(ID idModel) { GEOM_PRECOND(0); - return GeometryObj->GetModelRotation(id); + return g_pGeometry->getModelRotation(idModel); } -SX_LIB_API float3* SGeom_ModelsMGetScale(ID id) +SX_LIB_API float3* SGeom_ModelsMGetScale(ID idModel) { GEOM_PRECOND(0); - return GeometryObj->GetModelScale(id); + return g_pGeometry->getModelScale(idModel); } -SX_LIB_API const char* SGeom_ModelsMGetLodPath(ID id) +SX_LIB_API const char* SGeom_ModelsMGetLodPath(ID idModel) { GEOM_PRECOND(0); - return GeometryObj->GetModelLodPath(id); + return g_pGeometry->getModelLodPath(idModel); } -SX_LIB_API void SGeom_ModelsMSetLodPath(ID id, const char* path) +SX_LIB_API void SGeom_ModelsMSetLodPath(ID idModel, const char *szPath) { GEOM_PRECOND(_VOID); - GeometryObj->SetModelLodPath(id, path); + g_pGeometry->setModelLodPath(idModel, szPath); } -SX_LIB_API void SGeom_ModelsMApplyTransform(ID id) +SX_LIB_API void SGeom_ModelsMApplyTransform(ID idModel) { GEOM_PRECOND(_VOID); - GeometryObj->ApplyTransform(id); + g_pGeometry->applyTransform(idModel); } -SX_LIB_API void SGeom_ModelsMSortGroups(float3* viewpos, int sort_mtl) +SX_LIB_API void SGeom_ModelsMSortGroups(const float3 *pViewPos, int iSortMtl) { GEOM_PRECOND(_VOID); - GeometryObj->SortGroup(viewpos, sort_mtl); + g_pGeometry->sortGroup(pViewPos, iSortMtl); } -SX_LIB_API ID SGeom_ModelsMGetCountGroups(ID id) +SX_LIB_API ID SGeom_ModelsMGetCountGroups(ID idModel) { GEOM_PRECOND(-1); - return GeometryObj->GetModelCountGroups(id); + return g_pGeometry->getModelCountGroups(idModel); } -SX_LIB_API ID SGeom_ModelsMGetGroupIDMat(ID id, ID group) +SX_LIB_API ID SGeom_ModelsMGetGroupIDMat(ID idModel, ID idGroup) { GEOM_PRECOND(-1); - return GeometryObj->GetModelGroupIDMat(id, group); + return g_pGeometry->getModelGroupIDMat(idModel, idGroup); } -SX_LIB_API void SGeom_ModelsMGetGroupCenter(ID id, ID group, float3_t* center) +SX_LIB_API void SGeom_ModelsMGetGroupCenter(ID idModel, ID idGroup, float3_t *pCenter) { GEOM_PRECOND(_VOID); - return GeometryObj->GetModelGroupCenter(id, group, center); + return g_pGeometry->getModelGroupCenter(idModel, idGroup, pCenter); } -SX_LIB_API void SGeom_ModelsMGetGroupMin(ID id, ID group, float3_t* min) +SX_LIB_API void SGeom_ModelsMGetGroupMin(ID idModel, ID idGroup, float3_t *pMin) { GEOM_PRECOND(_VOID); - return GeometryObj->GetModelGroupMin(id, group, min); + return g_pGeometry->getModelGroupMin(idModel, idGroup, pMin); } -SX_LIB_API void SGeom_ModelsMGetGroupMax(ID id, ID group, float3_t* max) +SX_LIB_API void SGeom_ModelsMGetGroupMax(ID idModel, ID idGroup, float3_t *pMax) { GEOM_PRECOND(_VOID); - return GeometryObj->GetModelGroupMax(id, group, max); + return g_pGeometry->getModelGroupMax(idModel, idGroup, pMax); } -SX_LIB_API void SGeom_ModelsMGetGroupPlane(ID id, ID group, D3DXPLANE* plane) +SX_LIB_API void SGeom_ModelsMGetGroupPlane(ID idModel, ID idGroup, D3DXPLANE *pPlane) { GEOM_PRECOND(_VOID); - return GeometryObj->GetModelGroupPlane(id, group, plane); + return g_pGeometry->getModelGroupPlane(idModel, idGroup, pPlane); } -SX_LIB_API void SGeom_ModelsGetArrBuffsGeom(float3_t*** arr_vertex, int32_t** arr_count_vertex, uint32_t*** arr_index, ID*** arr_mtl, int32_t** arr_count_index, int32_t* count_models) +SX_LIB_API void SGeom_ModelsGetArrBuffsGeom(float3_t ***pppArrVertex, int32_t **ppArrCountVertex, uint32_t ***pppArrIndex, ID ***pppArrMtl, int32_t **ppArrCountIndex, int32_t *pCountModels) { GEOM_PRECOND(_VOID); - GeometryObj->GetArrBuffsGeom(arr_vertex, arr_count_vertex, arr_index, arr_mtl, arr_count_index, count_models); + g_pGeometry->getArrBuffsGeom(pppArrVertex, ppArrCountVertex, pppArrIndex, pppArrMtl, ppArrCountIndex, pCountModels); } -SX_LIB_API void SGeom_ModelsClearArrBuffsGeom(float3_t** arr_vertex, int32_t* arr_count_vertex, uint32_t** arr_index, ID** arr_mtl, int32_t* arr_count_index, int32_t count_models) +SX_LIB_API void SGeom_ModelsClearArrBuffsGeom(float3_t **ppArrVertex, int32_t *pArrCountVertex, uint32_t **ppArrIndex, ID **ppArrMtl, int32_t *pArrCountIndex, int32_t iCountModels) { - for(int32_t i = 0; i < count_models; ++i) + for (int i = 0; i < iCountModels; ++i) { - mem_delete_a(arr_vertex[i]); - mem_delete_a(arr_index[i]); - mem_delete_a(arr_mtl[i]); + mem_delete_a(ppArrVertex[i]); + mem_delete_a(ppArrIndex[i]); + mem_delete_a(ppArrMtl[i]); } - mem_delete_a(arr_vertex); - mem_delete_a(arr_count_vertex); - mem_delete_a(arr_index); - mem_delete_a(arr_mtl); - mem_delete_a(arr_count_index); + mem_delete_a(ppArrVertex); + mem_delete_a(pArrCountVertex); + mem_delete_a(ppArrIndex); + mem_delete_a(ppArrMtl); + mem_delete_a(pArrCountIndex); } -SX_LIB_API bool SGeom_ModelsTraceBeam(float3* start, float3* dir, float3* _res, ID* idmodel, ID* idmtl) +SX_LIB_API bool SGeom_ModelsTraceBeam(const float3 *pStart, const float3 *pDir, float3 *pResult, ID *pIDmodel, ID *pIDmtl) { GEOM_PRECOND(false); - return GeometryObj->TraceBeam(start, dir, _res, idmodel, idmtl); + return g_pGeometry->traceBeam(pStart, pDir, pResult, pIDmodel, pIDmtl); } //########################################################################## -SX_LIB_API ID SGeom_GreenAddGreen(const char* name, - const char* path_mask, - float count_max, - const char* path, const char* lod1, const char* lod2, - const char* navmesh) +SX_LIB_API ID SGeom_GreenAddGreen( + const char *szName, + const char *szPathMask, + float fCountMax, + const char *szPathLod0, const char *szPathLod1, const char *szPathLod2, + const char *szNavMesh) { GEOM_PRECOND(-1); - return GreenObj->Init(GeometryObj, name, path_mask, count_max, path, lod1, lod2, navmesh); + return g_pGreen->init(g_pGeometry, szName, szPathMask, fCountMax, szPathLod0, szPathLod1, szPathLod2, szNavMesh); } -SX_LIB_API ID SGeom_GreenAddObject(ID id, float3* pos, ID* idsplit) +SX_LIB_API ID SGeom_GreenAddObject(ID idGreen, float3 *pPos, ID *pIDsplit) { GEOM_PRECOND(-1); - return GreenObj->AddObject(id, pos, 0, idsplit); + return g_pGreen->addObject(idGreen, pPos, 0, pIDsplit); } -SX_LIB_API void SGeom_GreenDelObject(ID id, ID idsplit, ID idobj) +SX_LIB_API void SGeom_GreenDelObject(ID idGreen, ID idSplit, ID idObj) { GEOM_PRECOND(_VOID); - return GreenObj->DelObject(id, idsplit, idobj); + return g_pGreen->deleteObject(idGreen, idSplit, idObj); } -SX_LIB_API void SGeom_GreenGetPosObject(ID id, ID idsplit, ID idobj, float3_t* pos) +SX_LIB_API void SGeom_GreenGetPosObject(ID idGreen, ID idSplit, ID idObj, float3_t *pPos) { GEOM_PRECOND(_VOID); - GreenObj->GetPosObject(id, idsplit, idobj, pos); + g_pGreen->getPosObject(idGreen, idSplit, idObj, pPos); } -SX_LIB_API void SGeom_GreenSetPosObject(ID id, ID* idsplit, ID* idobj, float3_t* pos) +SX_LIB_API void SGeom_GreenSetPosObject(ID idGreen, ID *pIDsplit, ID *pIDobj, float3_t *pPos) { GEOM_PRECOND(_VOID); - GreenObj->SetPosObject(id, idsplit, idobj, pos); + g_pGreen->setPosObject(idGreen, pIDsplit, pIDobj, pPos); } -SX_LIB_API void SGeom_GreenDelGreen(ID id) +SX_LIB_API void SGeom_GreenDelGreen(ID idGreen) { GEOM_PRECOND(_VOID); - GreenObj->DelGreen(id); + g_pGreen->deleteGreen(idGreen); } SX_LIB_API ID SGeom_GreenAddArrForCom() { GEOM_PRECOND(-1); - return GreenObj->AddArrForCom(); + return g_pGreen->addArrForCom(); } -SX_LIB_API bool SGeom_GreenExistsArrForCom(ID id) +SX_LIB_API bool SGeom_GreenExistsArrForCom(ID idGreen) { GEOM_PRECOND(false); - return GreenObj->existsArrForCom(id); + return g_pGreen->existsArrForCom(idGreen); } -SX_LIB_API void SGeom_GreenDelArrForCom(ID id_arr) +SX_LIB_API void SGeom_GreenDelArrForCom(ID idArr) { GEOM_PRECOND(_VOID); - GreenObj->DelArrForCom(id_arr); + g_pGreen->deleteArrForCom(idArr); } -SX_LIB_API void SGeom_GreenSave(const char* path) +SX_LIB_API void SGeom_GreenSave(const char *szPath) { GEOM_PRECOND(_VOID); - GreenObj->Save(path); + g_pGreen->save(szPath); } -SX_LIB_API void SGeom_GreenLoad(const char* path) +SX_LIB_API void SGeom_GreenLoad(const char *szPath) { GEOM_PRECOND(_VOID); - GreenObj->Load(path); + g_pGreen->load(szPath); } SX_LIB_API void SGeom_GreenClear() { GEOM_PRECOND(_VOID); - GreenObj->Clear(); + g_pGreen->clear(); } -SX_LIB_API void SGeom_GreenComVisible(const ISXFrustum* frustum, float3* viewpos, ID id_arr) +SX_LIB_API void SGeom_GreenComVisible(const ISXFrustum* frustum, float3 *pViewPos, ID idArr) { GEOM_PRECOND(_VOID); - GreenObj->CPUFillingArrIndeces(frustum, viewpos, id_arr); + g_pGreen->comArrIndeces(frustum, pViewPos, idArr); } -SX_LIB_API void SGeom_GreenRender(DWORD timeDelta, float3* viewpos, GREEN_TYPE type, ID id_arr) +SX_LIB_API void SGeom_GreenRender(DWORD timeDelta, float3 *pViewPos, GREEN_TYPE type, ID idArr) { GEOM_PRECOND(_VOID); - GreenObj->GPURender(timeDelta, viewpos, type, id_arr); + g_pGreen->render(timeDelta, pViewPos, type, idArr); } -SX_LIB_API void SGeom_GreenRenderSingly(DWORD timeDelta, float3* viewpos, ID id, ID id_tex) +SX_LIB_API void SGeom_GreenRenderSingly(DWORD timeDelta, float3 *pViewPos, ID idGreen, ID idTexture) { GEOM_PRECOND(_VOID); - GreenObj->GPURenderSingly(timeDelta, viewpos, id, id_tex); + g_pGreen->renderSingly(timeDelta, pViewPos, idGreen, idTexture); } -SX_LIB_API void SGeom_GreenRenderObject(DWORD timeDelta, float3* viewpos, ID id, ID split, ID idobj, ID id_tex) +SX_LIB_API void SGeom_GreenRenderObject(DWORD timeDelta, float3 *pViewPos, ID idGreen, ID idSplit, ID idObj, ID idTexture) { GEOM_PRECOND(_VOID); - GreenObj->GPURenderObject(timeDelta, viewpos, id, split, idobj, id_tex); + g_pGreen->renderObject(timeDelta, pViewPos, idGreen, idSplit, idObj, idTexture); } -SX_LIB_API long SGeom_GreenGetCount() +SX_LIB_API int SGeom_GreenGetCount() { GEOM_PRECOND(-1); - return GreenObj->GetCountGreen(); + return g_pGreen->getCountGreen(); } -SX_LIB_API char* SGeom_GreenMGetName(ID id) +SX_LIB_API char* SGeom_GreenMGetName(ID idGreen) { GEOM_PRECOND(0); - return GreenObj->GetGreenName(id); + return g_pGreen->getGreenName(idGreen); } -SX_LIB_API long SGeom_GreenMGetCountGen(ID id) +SX_LIB_API int SGeom_GreenMGetCountGen(ID idGreen) { GEOM_PRECOND(0); - return GreenObj->GetGreenCountGen(id); + return g_pGreen->getGreenCountGen(idGreen); } -SX_LIB_API long SGeom_GreenMGetCountPoly(ID id) +SX_LIB_API int SGeom_GreenMGetCountPoly(ID idGreen) { GEOM_PRECOND(0); - return GreenObj->GetGreenCountPoly(id); + return g_pGreen->getGreenCountPoly(idGreen); } -SX_LIB_API int SGeom_GreenMGetTypeCountGen(ID id) +SX_LIB_API int SGeom_GreenMGetTypeCountGen(ID idGreen) { GEOM_PRECOND(-1); - return GreenObj->GetGreenTypeCountGen(id); + return g_pGreen->getGreenTypeCountGen(idGreen); } -SX_LIB_API const char* SGeom_GreenMGetModel(ID id) +SX_LIB_API const char* SGeom_GreenMGetModel(ID idGreen) { GEOM_PRECOND(0); - return GreenObj->GetGreenModel(id); + return g_pGreen->getGreenModel(idGreen); } -SX_LIB_API const char* SGeom_GreenMGetLod1(ID id) +SX_LIB_API const char* SGeom_GreenMGetLod1(ID idGreen) { GEOM_PRECOND(0); - return GreenObj->GetGreenLod1(id); + return g_pGreen->getGreenLod1(idGreen); } -SX_LIB_API const char* SGeom_GreenMGetLod2(ID id) +SX_LIB_API const char* SGeom_GreenMGetLod2(ID idGreen) { GEOM_PRECOND(0); - return GreenObj->GetGreenLod2(id); + return g_pGreen->getGreenLod2(idGreen); } -SX_LIB_API const char* SGeom_GreenMGetMask(ID id) +SX_LIB_API const char* SGeom_GreenMGetMask(ID idGreen) { GEOM_PRECOND(0); - return GreenObj->GetGreenMask(id); + return g_pGreen->getGreenMask(idGreen); } -SX_LIB_API const char* SGeom_GreenMGetNav(ID id) +SX_LIB_API const char* SGeom_GreenMGetNav(ID idGreen) { GEOM_PRECOND(0); - return GreenObj->GetGreenNav(id); + return g_pGreen->getGreenNav(idGreen); } -SX_LIB_API void SGeom_GreenMSetLod(ID id, int lod, const char* pathname) +SX_LIB_API void SGeom_GreenMSetLod(ID idGreen, int iLod, const char *szPathName) { GEOM_PRECOND(_VOID); - GreenObj->SetGreenLod(id, lod, pathname); + g_pGreen->setGreenLod(idGreen, iLod, szPathName); } -SX_LIB_API void SGeom_GreenMSetNav(ID id, const char* pathname) +SX_LIB_API void SGeom_GreenMSetNav(ID idGreen, const char *szPathName) { GEOM_PRECOND(_VOID); - GreenObj->SetGreenNav(id, pathname); + g_pGreen->setGreenNav(idGreen, szPathName); } -SX_LIB_API void SGeom_GreenGetNavMeshAndTransform(float3_t*** arr_vertex, int32_t** arr_count_vertex, uint32_t*** arr_index, ID*** arr_mtl, int32_t** arr_count_index, GreenDataVertex*** arr_transform, int32_t** arr_count_transform, int32_t* arr_count_green) +SX_LIB_API void SGeom_GreenGetNavMeshAndTransform(float3_t ***pppArrVertex, int32_t **ppArrVountVertex, uint32_t ***pppArrIndex, ID ***pppArrMtl, int32_t **ppArrCountIndex, CGreenDataVertex ***pppArrTransform, int32_t **ppArrCountTransform, int32_t *pArrCountGreen) { GEOM_PRECOND(_VOID); - GreenObj->GetNavMeshAndTransform(arr_vertex, arr_count_vertex, arr_index, arr_mtl, arr_count_index, arr_transform, arr_count_transform, arr_count_green); + g_pGreen->getNavMeshAndTransform(pppArrVertex, ppArrVountVertex, pppArrIndex, pppArrMtl, ppArrCountIndex, pppArrTransform, ppArrCountTransform, pArrCountGreen); } -SX_LIB_API void SGeom_GreenClearNavMeshAndTransform(float3_t** arr_vertex, int32_t* arr_count_vertex, uint32_t** arr_index, ID** arr_mtl, int32_t* arr_count_index, GreenDataVertex** arr_transform, int32_t* arr_count_transform, int32_t arr_count_green) +SX_LIB_API void SGeom_GreenClearNavMeshAndTransform(float3_t **ppArrVertex, int32_t *pArrCountVertex, uint32_t **ppArrIndex, ID **ppArrMtl, int32_t *pArrCountIndex, CGreenDataVertex **ppArrTransform, int32_t *pArrCountTransform, int32_t iCountGreen) { GEOM_PRECOND(_VOID); - for (int i = 0; i < arr_count_green; ++i) + for (int i = 0; i < iCountGreen; ++i) { - mem_delete_a(arr_vertex[i]); - mem_delete_a(arr_index[i]); - mem_delete_a(arr_mtl[i]); - mem_delete_a(arr_transform[i]); + mem_delete_a(ppArrVertex[i]); + mem_delete_a(ppArrIndex[i]); + mem_delete_a(ppArrMtl[i]); + mem_delete_a(ppArrTransform[i]); } - mem_delete_a(arr_vertex); - mem_delete_a(arr_count_vertex); - mem_delete_a(arr_index); - mem_delete_a(arr_mtl); - mem_delete_a(arr_transform); - mem_delete_a(arr_count_transform); - mem_delete_a(arr_count_index); + mem_delete_a(ppArrVertex); + mem_delete_a(pArrCountVertex); + mem_delete_a(ppArrIndex); + mem_delete_a(ppArrMtl); + mem_delete_a(ppArrTransform); + mem_delete_a(pArrCountTransform); + mem_delete_a(pArrCountIndex); } -SX_LIB_API bool SGeom_GreenTraceBeam(float3* start, float3* dir, float3* _res, ID* idgreen, ID* idsplits, ID* idobj, ID* idmtl) +SX_LIB_API bool SGeom_GreenTraceBeam(float3 *pStart, float3 *pDir, float3 *pResult, ID *pIDgreen, ID *pIDsplits, ID *pIDobj, ID *pIDmtl) { GEOM_PRECOND(false); - return GreenObj->TraceBeam(start, dir, _res, idgreen, idsplits, idobj, idmtl); + return g_pGreen->traceBeam(pStart, pDir, pResult, pIDgreen, pIDsplits, pIDobj, pIDmtl); } -SX_LIB_API bool SGeom_GreenGetOccurencessLeafGrass(float3* bbmin, float3* bbmax, int physic_mtl) +SX_LIB_API bool SGeom_GreenGetOccurencessLeafGrass(float3 *pMin, float3 *pMax, int iPhysicMtl) { GEOM_PRECOND(false); - return GreenObj->GetOccurencessLeafGrass(bbmin, bbmax, physic_mtl); + return g_pGreen->getOccurencessLeafGrass(pMin, pMax, iPhysicMtl); } diff --git a/source/geom/sxgeom.h b/source/geom/sxgeom.h index 9da30798cc20fcf6481ef33aa2a78a521687363f..10c92c88f7e63663740913e3aead8e25fa264f19 100644 --- a/source/geom/sxgeom.h +++ b/source/geom/sxgeom.h @@ -47,7 +47,7 @@ See the license in LICENSE SX_LIB_API long SGeom_0GetVersion(); //! установить новую функцию вывода сообщений -SX_LIB_API void SGeom_Dbg_Set(report_func rf); +SX_LIB_API void SGeom_Dbg_Set(report_func fnFunc); //! инициализация подсистемы SX_LIB_API void SGeom_0Create( @@ -182,32 +182,32 @@ SX_LIB_API void SGeom_ModelsSave(const char *szPath); SX_LIB_API void SGeom_ModelsLoad(const char *szPath); //! количество моделей в текущем списке -SX_LIB_API long SGeom_ModelsGetCount(); +SX_LIB_API int SGeom_ModelsGetCount(); //! просчитать видимость всех моделей для фрустума SX_LIB_API void SGeom_ModelsComVisible( const ISXFrustum *pFrustum, //!< фрустум для которого считаем видимость моделей - float3 *vViewPos, //!< позиция источника фрустума чтобы просчитать дистанцию - ID idArr = 0 //!< идентификатор массива информации о видимости для фрустума, создается через #SGeom_ModelsAddArrForCom, если 0 то считаем в дефолтный + const float3 *pViewPos, //!< позиция источника фрустума чтобы просчитать дистанцию + ID idArr = 0 //!< идентификатор массива информации о видимости для фрустума, создается через #SGeom_ModelsAddArrForCom, если 0 то считаем в дефолтный ); -//! есть ли сорт материала sort который просчитан к отрисовке в массиве просчетов id_arr +//! есть ли сорт материала iSort который просчитан к отрисовке в массиве просчетов idArr SX_LIB_API bool SGeom_ModelsSortExistsForRender( int iSort, //!< искомый сорт ID idArr = 0 //!< идентификатор массива информации о видимости для фрустума, создается через #SGeom_ModelsAddArrForCom, если 0 то считаем в дефолтный ); -//! отрисовка всех моделей, на основе информации о видимости из массива видимости id_arr +//! отрисовка всех моделей, на основе информации о видимости из массива видимости idArr SX_LIB_API void SGeom_ModelsRender( - DWORD timeDelta, //!< время рендера кадра в млсек + DWORD timeDelta, //!< время рендера кадра в млсек int iSort, //!< сорт материала, для ранжирования геометрии по "сортам", по умолчанию 0 - ID idArr = 0, //!< идентификатор массива с информацией о видимости - bool canSorted = false, //!< использовать ли информацию о сортировке подгрупп front to back + ID idArr = 0, //!< идентификатор массива с информацией о видимости + bool canSorted = false, //!< использовать ли информацию о сортировке подгрупп front to back ID idExcludeModel = -1, //!< идентификатор модели которую необходимо исключить из рендера (на случай отрисовки отражений) ID idExcludeGroup = -1 //!< идентификатор подгруппы которую надо исключить из рендера, либо указать значение меньше 0, тогда отсекется целая модель с id exclude_model_id ); -//! индивидуальная отрисовка модели, на основе информации о видимости из массива видимости id_arr = 0 +//! индивидуальная отрисовка модели, на основе информации о видимости из массива видимости idArr = 0 SX_LIB_API void SGeom_ModelsRenderSingly( DWORD timeDelta,//!< время рендера кадра в млсек ID idModel, //!< идентификатор модели @@ -227,7 +227,7 @@ SX_LIB_API ID SGeom_ModelsAddModel( /*! удалить модель под номером id \warning Поверхностные тесты не дали ошибок, однако внутренняя организация хранения данных чрезвычайно сложна (по нашему мнению), поэтому могут быть ошибки, в том числе и критические, но пока обнаружить их не удалось */ -SX_LIB_API void SGeom_ModelsDelModel(ID id); +SX_LIB_API void SGeom_ModelsDelModel(ID idModel); //! получить общий ограничивающий объем всего списка моделей SX_LIB_API void SGeom_ModelsGetMinMax(float3 *pMin, float3 *pMax); @@ -268,7 +268,7 @@ SX_LIB_API char* SGeom_ModelsMGetName(ID idModel); SX_LIB_API const char* SGeom_ModelsMGetPathName(ID idModel); //! получить количество полигонов модели -SX_LIB_API long SGeom_ModelsMGetCountPoly(ID idModel); +SX_LIB_API int SGeom_ModelsMGetCountPoly(ID idModel); //! получить позицию модели @@ -299,8 +299,8 @@ SX_LIB_API void SGeom_ModelsMApplyTransform(ID idModel); \note Рендер по этой сортировке возможен только индивидуально для каждой подгруппы модели. В данной версии сделано для поддержки полупрозрачных поверхностей. */ SX_LIB_API void SGeom_ModelsMSortGroups( - float3 *pViewPos, //!< позиция наблюдателя относительно которой будет произведена сортировка - int iSortMtl //!< сорт материала для которого будет произведена сортировка + const float3 *pViewPos, //!< позиция наблюдателя относительно которой будет произведена сортировка + int iSortMtl //!< сорт материала для которого будет произведена сортировка ); //************************************************************************** @@ -326,7 +326,7 @@ SX_LIB_API void SGeom_ModelsMGetGroupCenter(ID idModel, ID idGroup, float3_t *pC SX_LIB_API void SGeom_ModelsMGetGroupMin(ID idModel, ID idGroup, float3_t *pMin); //! записвыает в max максимум (максимальную позицию) центр подгруппы group -SX_LIB_API void SGeom_ModelsMGetGroupMax(ID idModel, ID idGroup, float3_t* max); +SX_LIB_API void SGeom_ModelsMGetGroupMax(ID idModel, ID idGroup, float3_t *pMax); //! записвыает в plane плоскость подгруппы group SX_LIB_API void SGeom_ModelsMGetGroupPlane(ID idModel, ID idGroup, D3DXPLANE *pPlane); @@ -358,7 +358,14 @@ SX_LIB_API void SGeom_ModelsClearArrBuffsGeom( int32_t CountModels //!< count_model - количество моделей ); -SX_LIB_API bool SGeom_ModelsTraceBeam(float3 *pStart, float3 *pDir, float3 *pRes, ID *idModel, ID *idMtl); +//! трассировка луча, из pStart в направлении pDir, в случае пересечения возвращает true, иначе false, в pRes записывает координаты пересечения если есть +SX_LIB_API bool SGeom_ModelsTraceBeam( + const float3 *pStart, //!< стартовая точка луча + const float3 *pDir, //!< направление луча + float3 *pRes, //!< если есть пересечение запишет координаты + ID *idModel, //!< если есть пересечение запишет id модели + ID *idMtl //!< если есть пересечение запишет id материала + ); //!@} sxgeom @@ -408,7 +415,7 @@ enum GREEN_TYPE }; //! структура трансформаций растительности -struct GreenDataVertex +struct CGreenDataVertex { float3_t m_vPosition; //!< позиция float3_t m_vTexCoord; //!< x - общий масштаб,y - поворот по оси y, z - @@ -460,21 +467,21 @@ SX_LIB_API ID SGeom_GreenAddGreen( //! добавить объект растительности SX_LIB_API ID SGeom_GreenAddObject( - ID id, //!< идентификатор растительности к которой добавляем + ID idGreen, //!< идентификатор растительности к которой добавляем float3 *vPos, //!< позиция в которой будет находится объект ID *pIDsplit //!< запишет идентификатор сплита, в котором был добавлен объект ); //! удалить объект растительности SX_LIB_API void SGeom_GreenDelObject( - ID id, //!< идентификатор растительности + ID idGreen, //!< идентификатор растительности ID idSplit, //!< идентификатор слпита из которого надо удалить ID idObj //!< идентификатор объекта который надо удалить ); //! в pos записывает позицию объекта растительности SX_LIB_API void SGeom_GreenGetPosObject( - ID id, //!< идентификатор растительности + ID idGreen, //!< идентификатор растительности ID idSplit, //!< идентификатор слпита ID idObj, //!< идентификатор объекта float3_t *pPos //!< вектор в который будет записана позиция @@ -484,14 +491,14 @@ SX_LIB_API void SGeom_GreenGetPosObject( \note Так как новая позиция объекта растительности может выходит за пределы текущего сплита и может входить в другой сплит, то указатели idsplit и idobj могут быть изменены после вызова данной функции */ SX_LIB_API void SGeom_GreenSetPosObject( - ID id, //!< идентификатор растительности + ID idGreen, //!< идентификатор растительности ID* idSplit, //!< идентификатор слпита ID* idObj, //!< идентификатор объекта float3_t *pPos //!< пновая позиция объекта растительности ); //! удалить единицу растительности -SX_LIB_API void SGeom_GreenDelGreen(ID id); +SX_LIB_API void SGeom_GreenDelGreen(ID idGreen); //************************************************************************** @@ -506,7 +513,7 @@ SX_LIB_API void SGeom_GreenDelGreen(ID id); SX_LIB_API ID SGeom_GreenAddArrForCom(); //! существует ли массив просчетов с номером id -SX_LIB_API bool SGeom_GreenExistsArrForCom(ID id); +SX_LIB_API bool SGeom_GreenExistsArrForCom(ID idGreen); //! удалить массив просчетов SX_LIB_API void SGeom_GreenDelArrForCom(ID idArr); @@ -527,23 +534,23 @@ SX_LIB_API void SGeom_GreenClear(); //! просчитать видимость всей растительности для фрустума SX_LIB_API void SGeom_GreenComVisible( const ISXFrustum *pFrustum, //!< фрустум для которого считаем видимость моделей - float3 *pViewPos, //!< позиция источника фрустума чтобы просчитать дистанцию - ID idArr = 0 //!< идентификатор массива информации о видимости для фрустума, создается через #SGeom_ModelsAddArrForCom, если 0 то считаем в дефолтный + float3 *pViewPos, //!< позиция источника фрустума чтобы просчитать дистанцию + ID idArr = 0 //!< идентификатор массива информации о видимости для фрустума, создается через #SGeom_ModelsAddArrForCom, если 0 то считаем в дефолтный ); //! отрисовка растительности SX_LIB_API void SGeom_GreenRender( - DWORD timeDelta, //!< время рендера кадра - float3 *pViewPos, //!< позиция наблюдателя (для которого будет рендер) - GREEN_TYPE typeGreen,//!< тип рисуемой растительности из перечисления GeomGreenType, указав GeomGreenType::ggtr_all будут отрисованы все типы растительности - ID idArr = 0 //!< идентификатор массива просчетов видимости (создается #SGeom_GreenAddArrForCom) + DWORD timeDelta, //!< время рендера кадра + float3 *pViewPos, //!< позиция наблюдателя (для которого будет рендер) + GREEN_TYPE typeGreen, //!< тип рисуемой растительности из перечисления GeomGreenType, указав GeomGreenType::ggtr_all будут отрисованы все типы растительности + ID idArr = 0 //!< идентификатор массива просчетов видимости (создается #SGeom_GreenAddArrForCom) ); //! индивидуальная отрисовка растительности по идентификатору, массив просчетов по умолчанию (0) SX_LIB_API void SGeom_GreenRenderSingly( DWORD timeDelta, //!< время рендера кадра float3 *pViewPos, //!< позиция наблюдателя (для которого будет рендер) - ID id, //!< идентификатор растительности + ID idGreen, //!< идентификатор растительности ID idTex = -1 //!< идентификатор материала, который будет применен ко всем объектам и подгруппам растительности, -1 если надо использовать назначенные материалы ); @@ -551,14 +558,14 @@ SX_LIB_API void SGeom_GreenRenderSingly( SX_LIB_API void SGeom_GreenRenderObject( DWORD timeDelta, //!< время рендера кадра float3 *pViewPos, //!< позиция наблюдателя (для которого будет рендер) - ID id, //!< идентификатор растительности + ID idGreen, //!< идентификатор растительности ID idSplit, //!< идентификатор сплита (в котором находится объект) ID idObj, //!< идентификатор объекта (в сплите) ID idTex = -1 //!< идентификатор материала, который будет применен ко всем объектам и подгруппам растительности, -1 если надо использовать назначенные материалы ); //!< получить количество единиц растительности (по видам есесно) -SX_LIB_API long SGeom_GreenGetCount(); +SX_LIB_API int SGeom_GreenGetCount(); //************************************************************************** @@ -567,38 +574,39 @@ SX_LIB_API long SGeom_GreenGetCount(); @{*/ //! получить имя -SX_LIB_API char* SGeom_GreenMGetName(ID id); +SX_LIB_API char* SGeom_GreenMGetName(ID idGreen); //! получить количество сгенерированных элементов -SX_LIB_API long SGeom_GreenMGetCountGen(ID id); +SX_LIB_API int SGeom_GreenMGetCountGen(ID idGreen); //! получить количество в модели (0 лод) -SX_LIB_API long SGeom_GreenMGetCountPoly(ID id); +SX_LIB_API int SGeom_GreenMGetCountPoly(ID idGreen); //! получить тип растительности -SX_LIB_API int SGeom_GreenMGetTypeCountGen(ID id); +SX_LIB_API int SGeom_GreenMGetTypeCountGen(ID idGreen); //! получить путь до модели относительно стандартного пути -SX_LIB_API const char* SGeom_GreenMGetModel(ID id); +SX_LIB_API const char* SGeom_GreenMGetModel(ID idGreen); //! получить путь до первого лода модели относительно стандартного пути -SX_LIB_API const char* SGeom_GreenMGetLod1(ID id); +SX_LIB_API const char* SGeom_GreenMGetLod1(ID idGreen); //! получить путь до второго лода модели относительно стандартного пути -SX_LIB_API const char* SGeom_GreenMGetLod2(ID id); +SX_LIB_API const char* SGeom_GreenMGetLod2(ID idGreen); //! получить путь до маски по которой сгенерирована растительность, относительно стандартного пути -SX_LIB_API const char* SGeom_GreenMGetMask(ID id); +SX_LIB_API const char* SGeom_GreenMGetMask(ID idGreen); //! получить путь до лода навигации относительно стандартного пути -SX_LIB_API const char* SGeom_GreenMGetNav(ID id); +SX_LIB_API const char* SGeom_GreenMGetNav(ID idGreen); //! установить лод (для рендера) SX_LIB_API void SGeom_GreenMSetLod( - ID id, //!< идентификатор единицы растительности + ID idGreen, //!< идентификатор единицы растительности int iLod, //!< номер лода от 0 до 2 включительно const char *szPathName //!< путь до модели относительно стандартного пути ); + SX_LIB_API void SGeom_GreenMSetNav(ID id, const char *szPathName); //!< установить лод навигации, pathname путь до модели относительно стандартного пути //!@} @@ -610,13 +618,13 @@ SX_LIB_API void SGeom_GreenMSetNav(ID id, const char *szPathName); //!< уста */ SX_LIB_API void SGeom_GreenGetNavMeshAndTransform( float3_t ***pppVertices, //!< (*arr_vertex)[num_green_mesh_nav][num_vertex] - вершины модели - int32_t **ppCountVertices, //!< (*arr_count_vertex)[num_green_mesh_nav] - количество вершин для модели - uint32_t ***pppIndeces, //!< (*arr_index)[num_green_mesh_nav][num_vertex] - индексы модели - ID ***pppMtl, //!< (*arr_mtl)[num_green_mesh_nav][num_vertex] - материал для индекса - int32_t **ppCountIndeces, //!< (*arr_count_index)[num_green_mesh_nav] - количество индексов для модели - GreenDataVertex ***pppTransforms,//!< (*arr_transform)[num_green_mesh_nav][num_obj] - трансформации модели навигации - int32_t **ppCountTransforms, //!< (*arr_count_transform)[num_green_mesh_nav] - количество матриц для трансформаций - int32_t *pCountGreens //!< (*arr_count_green) - количество единиц растительности по видам + int32_t **ppCountVertices, //!< (*arr_count_vertex)[num_green_mesh_nav] - количество вершин для модели + uint32_t ***pppIndeces, //!< (*arr_index)[num_green_mesh_nav][num_vertex] - индексы модели + ID ***pppMtl, //!< (*arr_mtl)[num_green_mesh_nav][num_vertex] - материал для индекса + int32_t **ppCountIndeces, //!< (*arr_count_index)[num_green_mesh_nav] - количество индексов для модели + CGreenDataVertex ***pppTransforms, //!< (*arr_transform)[num_green_mesh_nav][num_obj] - трансформации модели навигации + int32_t **ppCountTransforms, //!< (*arr_count_transform)[num_green_mesh_nav] - количество матриц для трансформаций + int32_t *pCountGreens //!< (*arr_count_green) - количество единиц растительности по видам ); /*! Очищает папять, выделенную в SGeom_GreenGetNavMeshAndTransform @@ -627,7 +635,7 @@ SX_LIB_API void SGeom_GreenClearNavMeshAndTransform( uint32_t **ppIndeces, //!< (*arr_index)[num_green_mesh_nav][num_vertex] - индексы модели ID **ppMtl, //!< (*arr_mtl)[num_green_mesh_nav][num_vertex] - материал для индекса int32_t *pCountIndeces, //!< (*arr_count_index)[num_green_mesh_nav] - количество индексов для модели - GreenDataVertex **ppTransforms, //!< (*arr_transform)[num_type_green][num_elem] - трансформации модели навигации + CGreenDataVertex **ppTransforms,//!< (*arr_transform)[num_type_green][num_elem] - трансформации модели навигации int32_t *pCountTransforms, //!< (*arr_count_transform)[num_type_green] - количество матриц для трансформаций int32_t iCountGreens //!< (*arr_count_green) - количество единиц растительности по видам ); diff --git a/source/physics/PhyWorld.cpp b/source/physics/PhyWorld.cpp index c58e7a5f889da2addf227d8936bee5f796267645..96673b9700b6f8192fa2c3cf95af9f22004e1dc1 100644 --- a/source/physics/PhyWorld.cpp +++ b/source/physics/PhyWorld.cpp @@ -187,7 +187,7 @@ void PhyWorld::LoadGeom(const char * file) uint32_t** green_arr_index; ID** green_arr_mtl; int32_t* green_arr_count_index; - GreenDataVertex** green_arr_transform; + CGreenDataVertex** green_arr_transform; int32_t* green_arr_count_transform; int32_t green_arr_count_green; diff --git a/source/score/sxscore.cpp b/source/score/sxscore.cpp index a4dc51178cb68bc1a3566a3bca666538b10f8ab7..31197743bc4f962a26158c20ad0dba38b8edc33e 100644 --- a/source/score/sxscore.cpp +++ b/source/score/sxscore.cpp @@ -14,9 +14,9 @@ See the license in LICENSE report_func g_fnReportf = DefReport; #endif -MainSound* MSound = 0; +MainSound *g_pManagerSound = 0; -#define SCORE_PRECOND(retval) if(!MSound){LibReport(-1, "%s - sxsound is not init", GEN_MSG_LOCATION); return retval;} +#define SCORE_PRECOND(retval) if(!g_pManagerSound){LibReport(-1, "%s - sxsound is not init", GEN_MSG_LOCATION); return retval;} //########################################################################## @@ -30,13 +30,13 @@ SX_LIB_API void SSCore_Dbg_Set(report_func rf) g_fnReportf = rf; } -SX_LIB_API void SSCore_0Create(const char* name, HWND hwnd, bool is_unic) +SX_LIB_API void SSCore_0Create(const char *szName, HWND hWnd, bool isUnic) { - if (name && strlen(name) > 1) + if (szName && strlen(szName) > 1) { - if (is_unic) + if (isUnic) { - HANDLE hMutex = CreateMutex(NULL, FALSE, name); + HANDLE hMutex = CreateMutex(NULL, FALSE, szName); if (GetLastError() == ERROR_ALREADY_EXISTS) { CloseHandle(hMutex); @@ -44,14 +44,14 @@ SX_LIB_API void SSCore_0Create(const char* name, HWND hwnd, bool is_unic) } else { - MSound = new MainSound(); - MSound->Init(hwnd); + g_pManagerSound = new MainSound(); + g_pManagerSound->Init(hWnd); } } else { - MSound = new MainSound(); - MSound->Init(hwnd); + g_pManagerSound = new MainSound(); + g_pManagerSound->Init(hWnd); } } else @@ -60,7 +60,7 @@ SX_LIB_API void SSCore_0Create(const char* name, HWND hwnd, bool is_unic) SX_LIB_API void SSCore_AKill() { - mem_delete(MSound); + mem_delete(g_pManagerSound); } //############################################################################# @@ -69,259 +69,259 @@ SX_LIB_API void SSCore_Clear() { SCORE_PRECOND(_VOID); - MSound->Clear(); + g_pManagerSound->Clear(); } -SX_LIB_API void SSCore_Update(const float3* viewpos, const float3* viewdir) +SX_LIB_API void SSCore_Update(const float3 *pViewPos, const float3 *pViewDir) { SCORE_PRECOND(_VOID); - MSound->Update(viewpos, viewdir); + g_pManagerSound->Update(pViewPos, pViewDir); } SX_LIB_API int SSCore_SndsPlayCountGet() { SCORE_PRECOND(0); - return MSound->SoundsPlayCountGet(); + return g_pManagerSound->SoundsPlayCountGet(); } SX_LIB_API int SSCore_SndsLoadCountGet() { SCORE_PRECOND(0); - return MSound->SoundsLoadCountGet(); + return g_pManagerSound->SoundsLoadCountGet(); } -SX_LIB_API ID SSCore_SndCreate2d(const char *file, bool looping, DWORD size_stream) +SX_LIB_API ID SSCore_SndCreate2d(const char *szFile, bool isLooping, UINT uiSizeStream) { SCORE_PRECOND(-1); - return MSound->SoundCreate2d(file, looping, size_stream); + return g_pManagerSound->SoundCreate2d(szFile, isLooping, uiSizeStream); } -SX_LIB_API ID SSCore_SndCreate3d(const char *file, bool looping, DWORD size_stream, float dist, float shift_pan) +SX_LIB_API ID SSCore_SndCreate3d(const char *szFile, bool isLooping, UINT uiSizeStream, float fDist, float fShiftPan) { SCORE_PRECOND(-1); - return MSound->SoundCreate3d(file, looping, size_stream, dist, shift_pan); + return g_pManagerSound->SoundCreate3d(szFile, isLooping, uiSizeStream, fDist, fShiftPan); } -SX_LIB_API ID SSCore_SndCreate2dInst(const char *file, bool looping, DWORD size_stream) +SX_LIB_API ID SSCore_SndCreate2dInst(const char *szFile, bool isLooping, UINT uiSizeStream) { SCORE_PRECOND(-1); - return MSound->SoundCreate2dInst(file, looping, size_stream); + return g_pManagerSound->SoundCreate2dInst(szFile, isLooping, uiSizeStream); } -SX_LIB_API ID SSCore_SndCreate3dInst(const char *file, bool looping, DWORD size_stream, float dist, float shift_pan) +SX_LIB_API ID SSCore_SndCreate3dInst(const char *szFile, bool isLooping, UINT uiSizeStream, float fDist, float fShiftPan) { SCORE_PRECOND(-1); - return MSound->SoundCreate3dInst(file, looping, size_stream, dist, shift_pan); + return g_pManagerSound->SoundCreate3dInst(szFile, isLooping, uiSizeStream, fDist, fShiftPan); } -SX_LIB_API ID SSCore_SndFind2dInst(const char *file) +SX_LIB_API ID SSCore_SndFind2dInst(const char *szFile) { SCORE_PRECOND(-1); - return MSound->SoundFind2dInst(file); + return g_pManagerSound->SoundFind2dInst(szFile); } -SX_LIB_API ID SSCore_SndFind3dInst(const char *file) +SX_LIB_API ID SSCore_SndFind3dInst(const char *szFile) { SCORE_PRECOND(-1); - return MSound->SoundFind3dInst(file); + return g_pManagerSound->SoundFind3dInst(szFile); } -SX_LIB_API void SSCore_SndInstancePlay2d(ID id, int volume, int pan) +SX_LIB_API void SSCore_SndInstancePlay2d(ID idSound, int iVolume, int iPan) { SCORE_PRECOND(_VOID); - MSound->SoundInstancePlay2d(id, volume, pan); + g_pManagerSound->SoundInstancePlay2d(idSound, iVolume, iPan); } -SX_LIB_API void SSCore_SndInstancePlay3d(ID id, const float3* pos) +SX_LIB_API void SSCore_SndInstancePlay3d(ID idSound, const float3 *pPos) { SCORE_PRECOND(_VOID); - MSound->SoundInstancePlay3d(id, pos); + g_pManagerSound->SoundInstancePlay3d(idSound, pPos); } -SX_LIB_API bool SSCore_SndIsInit(ID id) +SX_LIB_API bool SSCore_SndIsInit(ID idSound) { SCORE_PRECOND(false); - return MSound->SoundIsInit(id); + return g_pManagerSound->SoundIsInit(idSound); } -SX_LIB_API void SSCore_SndDelete(ID id) +SX_LIB_API void SSCore_SndDelete(ID idSound) { SCORE_PRECOND(_VOID); - MSound->SoundDelete(id); + g_pManagerSound->SoundDelete(idSound); } -SX_LIB_API void SSCore_SndPlay(ID id, int looping) +SX_LIB_API void SSCore_SndPlay(ID idSound, int isLooping) { SCORE_PRECOND(_VOID); - MSound->SoundPlay(id, looping); + g_pManagerSound->SoundPlay(idSound, isLooping); } -SX_LIB_API void SSCore_SndPause(ID id) +SX_LIB_API void SSCore_SndPause(ID idSound) { SCORE_PRECOND(_VOID); - MSound->SoundPause(id); + g_pManagerSound->SoundPause(idSound); } -SX_LIB_API void SSCore_SndStop(ID id) +SX_LIB_API void SSCore_SndStop(ID idSound) { SCORE_PRECOND(_VOID); - MSound->SoundStop(id); + g_pManagerSound->SoundStop(idSound); } -SX_LIB_API void SSCore_SndStateSet(ID id, SOUND_OBJSTATE state) +SX_LIB_API void SSCore_SndStateSet(ID idSound, SOUND_OBJSTATE state) { SCORE_PRECOND(_VOID); - MSound->SoundStateSet(id, state); + g_pManagerSound->SoundStateSet(idSound, state); } -SX_LIB_API SOUND_OBJSTATE SSCore_SndStateGet(ID id) +SX_LIB_API SOUND_OBJSTATE SSCore_SndStateGet(ID idSound) { SCORE_PRECOND(SOUND_OBJSTATE_STOP); - return MSound->SoundStateGet(id); + return g_pManagerSound->SoundStateGet(idSound); } -SX_LIB_API void SSCore_SndPosCurrSet(ID id, DWORD pos, int type) +SX_LIB_API void SSCore_SndPosCurrSet(ID idSound, UINT uiPos, int iType) { SCORE_PRECOND(_VOID); - MSound->SoundPosCurrSet(id, pos, type); + g_pManagerSound->SoundPosCurrSet(idSound, uiPos, iType); } -SX_LIB_API DWORD SSCore_SndPosCurrGet(ID id, int type) +SX_LIB_API UINT SSCore_SndPosCurrGet(ID idSound, int iType) { SCORE_PRECOND(0); - return MSound->SoundPosCurrGet(id, type); + return g_pManagerSound->SoundPosCurrGet(idSound, iType); } -SX_LIB_API void SSCore_SndVolumeSet(ID id, long volume, int type) +SX_LIB_API void SSCore_SndVolumeSet(ID idSound, int iVolume, int iType) { SCORE_PRECOND(_VOID); - MSound->SoundVolumeSet(id, volume, type); + g_pManagerSound->SoundVolumeSet(idSound, iVolume, iType); } -SX_LIB_API long SSCore_SndVolumeGet(ID id, int type) +SX_LIB_API int SSCore_SndVolumeGet(ID idSound, int iType) { SCORE_PRECOND(0); - return MSound->SoundVolumeGet(id, type); + return g_pManagerSound->SoundVolumeGet(idSound, iType); } -SX_LIB_API void SSCore_SndPanSet(ID id, long value, int type) +SX_LIB_API void SSCore_SndPanSet(ID idSound, int iValue, int iType) { SCORE_PRECOND(_VOID); - MSound->SoundPanSet(id, value, type); + g_pManagerSound->SoundPanSet(idSound, iValue, iType); } -SX_LIB_API long SSCore_SndPanGet(ID id, int type) +SX_LIB_API int SSCore_SndPanGet(ID idSound, int iType) { SCORE_PRECOND(0); - return MSound->SoundPanGet(id, type); + return g_pManagerSound->SoundPanGet(idSound, iType); } -SX_LIB_API void SSCore_SndFreqCurrSet(ID id, DWORD value) +SX_LIB_API void SSCore_SndFreqCurrSet(ID idSound, UINT fValue) { SCORE_PRECOND(_VOID); - MSound->SoundFreqCurrSet(id, value); + g_pManagerSound->SoundFreqCurrSet(idSound, fValue); } -SX_LIB_API DWORD SSCore_SndFreqCurrGet(ID id) +SX_LIB_API UINT SSCore_SndFreqCurrGet(ID idSound) { SCORE_PRECOND(0); - return MSound->SoundFreqCurrGet(id); + return g_pManagerSound->SoundFreqCurrGet(idSound); } -SX_LIB_API DWORD SSCore_SndFreqOriginGet(ID id) +SX_LIB_API UINT SSCore_SndFreqOriginGet(ID idSound) { SCORE_PRECOND(0); - return MSound->SoundFreqOriginGet(id); + return g_pManagerSound->SoundFreqOriginGet(idSound); } -SX_LIB_API void SSCore_SndPosWSet(ID id, const float3* pos) +SX_LIB_API void SSCore_SndPosWSet(ID idSound, const float3 *pPos) { SCORE_PRECOND(_VOID); - MSound->SoundPosWSet(id, pos); + g_pManagerSound->SoundPosWSet(idSound, pPos); } -SX_LIB_API void SSCore_SndPosWGet(ID id, float3* pos) +SX_LIB_API void SSCore_SndPosWGet(ID idSound, float3 *pPos) { SCORE_PRECOND(_VOID); - MSound->SoundPosWGet(id, pos); + g_pManagerSound->SoundPosWGet(idSound, pPos); } -SX_LIB_API int SSCore_SndLengthSecGet(ID id) +SX_LIB_API int SSCore_SndLengthSecGet(ID idSound) { SCORE_PRECOND(0); - return MSound->SoundLengthSecGet(id); + return g_pManagerSound->SoundLengthSecGet(idSound); } -SX_LIB_API DWORD SSCore_SndBytesPerSecGet(ID id) +SX_LIB_API UINT SSCore_SndBytesPerSecGet(ID idSound) { SCORE_PRECOND(0); - return MSound->SoundBytesPerSecGet(id); + return g_pManagerSound->SoundBytesPerSecGet(idSound); } -SX_LIB_API DWORD SSCore_SndSizeGet(ID id) +SX_LIB_API UINT SSCore_SndSizeGet(ID idSound) { SCORE_PRECOND(0); - return MSound->SoundSizeGet(id); + return g_pManagerSound->SoundSizeGet(idSound); } -SX_LIB_API void SSCore_SndFileGet(ID id, char* path) +SX_LIB_API void SSCore_SndFileGet(ID idSound, char *szPath) { SCORE_PRECOND(_VOID); - MSound->SoundFileGet(id, path); + g_pManagerSound->SoundFileGet(idSound, szPath); } -SX_LIB_API float SSCore_SndDistAudibleGet(ID id) +SX_LIB_API float SSCore_SndDistAudibleGet(ID idSound) { SCORE_PRECOND(0); - return MSound->SoundDistAudibleGet(id); + return g_pManagerSound->SoundDistAudibleGet(idSound); } -SX_LIB_API void SSCore_SndDistAudibleSet(ID id, float value) +SX_LIB_API void SSCore_SndDistAudibleSet(ID idSound, float fValue) { SCORE_PRECOND(_VOID); - MSound->SoundDistAudibleSet(id, value); + g_pManagerSound->SoundDistAudibleSet(idSound, fValue); } diff --git a/source/score/sxscore.h b/source/score/sxscore.h index 60bb521832c017a0e3248c2cafca5a11e28f3512..05472b192f826f93ca89438953b55c8265245ca9 100644 --- a/source/score/sxscore.h +++ b/source/score/sxscore.h @@ -35,7 +35,7 @@ See the license in LICENSE #undef SX_LIB_API #define SX_LIB_API extern "C" __declspec (dllimport) -#include <core\\sxcore.h> +#include <core/sxcore.h> #ifdef SX_DLL #undef SX_LIB_API @@ -51,13 +51,13 @@ See the license in LICENSE SX_LIB_API long SSCore_0GetVersion(); //! установить новую функцию вывода сообщений -SX_LIB_API void SSCore_Dbg_Set(report_func rf); +SX_LIB_API void SSCore_Dbg_Set(report_func fnFunc); //! инициализация подсистемы SX_LIB_API void SSCore_0Create( - const char* name, //!< имя - HWND hwnd, - bool is_unic = true //!< должна ли подсистема быть уникальной по имени + const char *szName, //!< имя + HWND hWnd, //!< хэндл окна к которому привязывается звук + bool isUnic = true //!< должна ли подсистема быть уникальной по имени ); //! уничтожение подсистемы @@ -136,8 +136,8 @@ SX_LIB_API void SSCore_Clear(); //! обновление состояний всех звуков SX_LIB_API void SSCore_Update( - const float3* viewpos, //!< текущая позиция наблюдателя - const float3* viewdir //!< текущее направление взгляда + const float3 *pViewPpos,//!< текущая позиция наблюдателя + const float3 *pViewDir //!< текущее направление взгляда ); //! количество проигрываемых на данный момент звуков @@ -148,144 +148,144 @@ SX_LIB_API int SSCore_SndsLoadCountGet(); //! загрузка 2d (фонового) звука SX_LIB_API ID SSCore_SndCreate2d( - const char *file, //!< путь до файла, относительно стандартного - bool looping = false, //!< зацикливать ли воспроизведение - DWORD size_stream = 0 //!< размер потока в байтах для потокового воспроизведения, если 0 тогда полностью грузить в память + const char *szFile, //!< путь до файла, относительно стандартного + bool isLooping = false, //!< зацикливать ли воспроизведение + UINT uiSizeStream = 0 //!< размер потока в байтах для потокового воспроизведения, если 0 тогда полностью грузить в память ); //! загрузка 3d звука SX_LIB_API ID SSCore_SndCreate3d( - const char *file, //!< путь до файла, относительно стандартного - bool looping, //!< зацикливать ли воспроизведение - DWORD size_stream, //!< размер потока в байтах для потокового воспроизведения, если 0 тогда полностью грузить в память - float dist, //!< радиус слышимости в метрах - float shift_pan = 0.1f //!< изменение позиционирования звука [0-1], на сколько будет смещен звук (между ушами слушателя) при поворотах камеры к источнику звука, чем ближе к объекту тем меньше разница в позиционировании при поворотах + const char *szFile, //!< путь до файла, относительно стандартного + bool isLooping, //!< зацикливать ли воспроизведение + UINT uiSizeStream, //!< размер потока в байтах для потокового воспроизведения, если 0 тогда полностью грузить в память + float fDist, //!< радиус слышимости в метрах + float fShiftPan = 0.1f //!< изменение позиционирования звука [0-1], на сколько будет смещен звук (между ушами слушателя) при поворотах камеры к источнику звука, чем ближе к объекту тем меньше разница в позиционировании при поворотах ); //! воспроизведение инстанса 2d звука SX_LIB_API void SSCore_SndInstancePlay2d( - ID id, //!< идентификатор звука - int volume = 100, //!< громкость [0-100] - int pan = 0 //!< смещение между ушами [-100 - 100] + ID idSound, //!< идентификатор звука + int iVolume = 100, //!< громкость [0-100] + int iPan = 0 //!< смещение между ушами [-100 - 100] ); //! воспроизведение инстанса 3d звука SX_LIB_API void SSCore_SndInstancePlay3d( - ID id, //!< идентификатор звука - const float3* pos //!< позиция воспроизведения инстанса + ID idSound, //!< идентификатор звука + const float3 *pPos //!< позиция воспроизведения инстанса ); //! загрузка 2d звукового файла и пометка его как объект выдающий инстансы, аргументы аналогичны #SSCore_SndCreate2d -SX_LIB_API ID SSCore_SndCreate2dInst(const char *file, bool looping = false, DWORD size_stream = 0); +SX_LIB_API ID SSCore_SndCreate2dInst(const char *szFile, bool isLooping = false, UINT uiSizeStream = 0); //! загрузка 3d звукового файла и пометка его как объект выдающий инстансы, аргументы аналогичны #SSCore_SndCreate3d -SX_LIB_API ID SSCore_SndCreate3dInst(const char *file, bool looping, DWORD size_stream, float dist, float shift_pan = 0.1f); +SX_LIB_API ID SSCore_SndCreate3dInst(const char *szFile, bool isLooping, UINT uiSizeStream, float fDist, float fShiftPan = 0.1f); //! поиск 2d звука (выдающего инстансы) по относительному пути загрузки,возвращает его ID (в случае успеха) иначе <0 -SX_LIB_API ID SSCore_SndFind2dInst(const char * file); +SX_LIB_API ID SSCore_SndFind2dInst(const char *szFile); //! поиск 3d звука (выдающего инстансы) по относительному пути загрузки,возвращает его ID (в случае успеха) иначе <0 -SX_LIB_API ID SSCore_SndFind3dInst(const char * file); +SX_LIB_API ID SSCore_SndFind3dInst(const char *szFile); //! инициализирован ли звук с идентификатором id -SX_LIB_API bool SSCore_SndIsInit(ID id); +SX_LIB_API bool SSCore_SndIsInit(ID idSound); //! удалить звук по его id -SX_LIB_API void SSCore_SndDelete(ID id); +SX_LIB_API void SSCore_SndDelete(ID idSound); //! воспроизвести звук, looping зацикливать ли воспроизведение, 0 - нет, >0 да, <0 не учитывать данное значение -SX_LIB_API void SSCore_SndPlay(ID id, int looping = -1); +SX_LIB_API void SSCore_SndPlay(ID idSound, int looping = -1); //! приостановить -SX_LIB_API void SSCore_SndPause(ID id); +SX_LIB_API void SSCore_SndPause(ID idSound); //! остановить -SX_LIB_API void SSCore_SndStop(ID id); +SX_LIB_API void SSCore_SndStop(ID idSound); //! устанавливает состояние проигрывания звука -SX_LIB_API void SSCore_SndStateSet(ID id, SOUND_OBJSTATE state); +SX_LIB_API void SSCore_SndStateSet(ID idSound, SOUND_OBJSTATE state); //! возвращает состояние проигрывания звука на данный момент -SX_LIB_API SOUND_OBJSTATE SSCore_SndStateGet(ID id); +SX_LIB_API SOUND_OBJSTATE SSCore_SndStateGet(ID idSound); //! устанавить позицию проигрывания SX_LIB_API void SSCore_SndPosCurrSet( - ID id, //!< идентификатор звука - DWORD pos, //!< значение позиции исходя из параметра type - int type = SOUND_POS_BYTES //!< тип значения pos, SOUND_POS_ + ID idSound, //!< идентификатор звука + UINT uiPos, //!< значение позиции исходя из параметра type + int iType = SOUND_POS_BYTES //!< тип значения pos, SOUND_POS_ ); //! возвращает позицию проигрывания -SX_LIB_API DWORD SSCore_SndPosCurrGet( - ID id, //!< идентификатор звука - int type = SOUND_POS_BYTES //!< тип возвращаемого значения, SOUND_POS_ +SX_LIB_API UINT SSCore_SndPosCurrGet( + ID idSound, //!< идентификатор звука + int iType = SOUND_POS_BYTES //!< тип возвращаемого значения, SOUND_POS_ ); //! устанавить громкость SX_LIB_API void SSCore_SndVolumeSet( - ID id, //!< идентификатор звука - long volume, //!< значение громкости исходя из параметра type - int type = SOUND_VOL_PCT //!< тип значения volume, SOUND_VOL_ + ID idSound, //!< идентификатор звука + int iVolume, //!< значение громкости исходя из параметра type + int iType = SOUND_VOL_PCT //!< тип значения volume, SOUND_VOL_ ); //! возвращает громкость -SX_LIB_API long SSCore_SndVolumeGet( - ID id, //!< идентификатор звука - int type = SOUND_VOL_PCT //!< тип возвращаемого значения, SOUND_VOL_ +SX_LIB_API int SSCore_SndVolumeGet( + ID idSound, //!< идентификатор звука + int iType = SOUND_VOL_PCT //!< тип возвращаемого значения, SOUND_VOL_ ); //! установка позиционирования между ушами SX_LIB_API void SSCore_SndPanSet( - ID id, //!< идентификатор звука - long value, //!< значение позиционирования исходя из параметра type - int type = SOUND_VOL_PCT //!< тип значения value, SOUND_VOL_ + ID idSound, //!< идентификатор звука + int iValue, //!< значение позиционирования исходя из параметра type + int iType = SOUND_VOL_PCT //!< тип значения value, SOUND_VOL_ ); //! возвращает позиционирование между ушами -SX_LIB_API long SSCore_SndPanGet( - ID id, //!< идентификатор звука +SX_LIB_API int SSCore_SndPanGet( + ID idSound, //!< идентификатор звука int type = SOUND_VOL_PCT //!< тип возвращаемого значения, SOUND_VOL_ ); //! установка частоты воспроизведения -SX_LIB_API void SSCore_SndFreqCurrSet(ID id, DWORD value); +SX_LIB_API void SSCore_SndFreqCurrSet(ID idSound, UINT uiValue); //! возвращает текущую частоту воспроизведения -SX_LIB_API DWORD SSCore_SndFreqCurrGet(ID id); +SX_LIB_API UINT SSCore_SndFreqCurrGet(ID idSound); //! возвращает оригинальную частоту воспроизведения -SX_LIB_API DWORD SSCore_SndFreqOriginGet(ID id); +SX_LIB_API UINT SSCore_SndFreqOriginGet(ID idSound); //! установка мировой позиции звука (только для 3d звуков) -SX_LIB_API void SSCore_SndPosWSet(ID id, const float3* pos); +SX_LIB_API void SSCore_SndPosWSet(ID idSound, const float3 *pPos); //! возвращает мировую позицию звука (только для 3d звуков) -SX_LIB_API void SSCore_SndPosWGet(ID id, float3* pos); +SX_LIB_API void SSCore_SndPosWGet(ID idSound, float3 *pPos); //! длина в секундах -SX_LIB_API int SSCore_SndLengthSecGet(ID id); +SX_LIB_API int SSCore_SndLengthSecGet(ID idSound); //! количество байт в секунде -SX_LIB_API DWORD SSCore_SndBytesPerSecGet(ID id); +SX_LIB_API UINT SSCore_SndBytesPerSecGet(ID idSound); //! размер в байтах PCM данных -SX_LIB_API DWORD SSCore_SndSizeGet(ID id); +SX_LIB_API UINT SSCore_SndSizeGet(ID idSound); //! относительный путь до звукового файла -SX_LIB_API void SSCore_SndFileGet(ID id, char* path); +SX_LIB_API void SSCore_SndFileGet(ID idSound, char *szPath); //! возвращает дистанцию слышимости -SX_LIB_API float SSCore_SndDistAudibleGet(ID id); +SX_LIB_API float SSCore_SndDistAudibleGet(ID idSound); //! установка дистанции слышимости в метрах -SX_LIB_API void SSCore_SndDistAudibleSet(ID id, float value); +SX_LIB_API void SSCore_SndDistAudibleSet(ID idSound, float fVfalue); //!@}