/**************************************************************************** Copyright (c) 2011-2013,WebJet Business Division,CYOU http://www.genesis-3d.com.cn Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ****************************************************************************/ #include "stdneb.h" #include "appframework/actor.h" #include "graphicfeature/graphicsfeatureprotocol.h" #include "graphicfeature/graphicsfeature.h" #include "resource/resourceserver.h" #include "graphicsystem/GraphicObjectManager.h" #include "vegetationfeature/components/vegetationrendercomponent.h" #include "resource/meshres.h" #include "vegetation/VegetationServer.h" #include "vegetation/VegetationObejct.h" #include "vegetation/GrassInstanceMap.h" #include "app/basegamefeature/managers/timesource.h" #include "apputil/intersectutil.h" #include "apputil/manuresutil.h" #include "math/intersection.h" #include "math/ray.h" namespace App { using namespace Resources; using namespace Vegetation; using namespace RenderBase; using namespace Graphic; __ImplementClass(App::VegetationRenderComponent, 'VERC', App::Component); const Resources::ResourceId DefalutShaderID("shd:Common_Diffuse.shader"); //------------------------------------------------------------------------ VegetationRenderComponent::VegetationRenderComponent() :mVisible(true) ,mAttached(false) #ifdef __GENESIS_EDITOR__ ,m_bEditorVis(true) #endif { } //------------------------------------------------------------------------ VegetationRenderComponent::~VegetationRenderComponent() { } //------------------------------------------------------------------------ void VegetationRenderComponent::SetupCallbacks(void) { mActor->RegisterComponentCallback(this, BeginFrame ); mActor->RegisterComponentCallback(this, OnFrame ); mActor->RegisterComponentCallback(this, MoveBefore ); mActor->RegisterComponentCallback(this, MoveAfter ); Super::SetupCallbacks(); } //------------------------------------------------------------------------ void VegetationRenderComponent::SetupAcceptedMessages() { Super::SetupAcceptedMessages(); } //------------------------------------------------------------------------ void VegetationRenderComponent::HandleMessage(const GPtr& msg) { n_assert(msg); Super::HandleMessage(msg); } //------------------------------------------------------------------------ void VegetationRenderComponent::SetShaderId(GPtr& pVegeObj, IndexT iSubMesh , const Resources::ResourceId& shaderID) { if ( iSubMesh < 0 || !shaderID.IsValid() ) { return; } if ( iSubMesh >= pVegeObj->GetShaderCount() ) { while( iSubMesh >= pVegeObj->GetShaderCount() ) { pVegeObj->SetShaderID(iSubMesh, shaderID); } } else { const GPtr& pmat = pVegeObj->GetMaterial(iSubMesh); if ( pmat->GetShaderID() != shaderID) { pVegeObj->SetShaderID(iSubMesh,shaderID); } } } //------------------------------------------------------------------------ void VegetationRenderComponent::OnActivate() { if(mVisible) { BuildRenderData(); AttachRenderObjects(); } Super::OnActivate(); } //------------------------------------------------------------------------ void VegetationRenderComponent::OnDeactivate() { #if __GENESIS_EDITOR__ if(m_bEditorVis) #else if(mVisible) #endif { DeattachRenderObjects(); DiscardRenderData(); } Super::OnDeactivate(); } //------------------------------------------------------------------------ void VegetationRenderComponent::OnDestroy() { Super::OnDestroy(); } //------------------------------------------------------------------------ #if __GENESIS_EDITOR__ void VegetationRenderComponent::SetEditorVisible(bool bVis) { m_bEditorVis = bVis; if (IsActive()) { for (int nObj = 0; nObj < mRenderDates.Size(); ++nObj) { mRenderDates[nObj]->SetEditorVisible(bVis); } } } #endif //------------------------------------------------------------------------ void VegetationRenderComponent::SetVisible(bool bVisible) { if ( bVisible == mVisible ) { return; } mVisible = bVisible; if (IsActive()) { if (mVisible) { BuildRenderData(); AttachRenderObjects(); } else { DeattachRenderObjects(); DiscardRenderData(); } } } //------------------------------------------------------------------------ void VegetationRenderComponent::_OnBeginFrame() { //TODO : mRenderDates[i].UpdateBushMesh(); for (int i = 0; iGetFrameTime(); static float time = 0.0f; time += (float)fTick; for (int i = 0; imIsAllTexLoaded) { return; } else { SizeT count = pVegObj->GetMaterialCount(); for (IndexT index = 0; index < count; ++index) { if ( pVegObj->GetRenderType() == Vegetation::eRT_DetailMesh ) break; pVegObj->SetShaderConstantParam(index, "uTime", time); } } _UpdateRenderData(pVegObj); } //TODO : renderable update //UpdateRenderData(); } //-------------------------------------------------------------------------------- void VegetationRenderComponent::_OnMoveBefore() { //Math::float4 pos = mActor->GetPosition(); const Math::matrix44& invMatrix = Math::matrix44::inverse(mActor->GetWorldTransform()); for (int i = 0; i< mRenderDates.Size(); i++) { Vegetation::VegetationObjectPtr& pVegObj = mRenderDates[i]; if (pVegObj.isvalid()) { pVegObj->SetWorldMatrix(invMatrix); } } } //-------------------------------------------------------------------------------- void VegetationRenderComponent::_OnMoveAfter() { //Math::matrix44 tempMatrix = mActor->GetWorldTransform(); //TODO : setobject offset Matrix for (int i = 0; i< mRenderDates.Size(); i++) { Vegetation::VegetationObjectPtr& pVegObj = mRenderDates[i]; if (pVegObj.isvalid()) { pVegObj->SetWorldMatrix(mActor->GetWorldTransform()); //recalculate all vegobject bbox for bug2264 ReCalcBBox(pVegObj); } } } //------------------------------------------------------------------------ void VegetationRenderComponent::BuildRenderData( void ) { //TODO : foreach object for (int i = 0; i< mRenderDates.Size(); i++) { Vegetation::VegetationObjectPtr& pVegObj = mRenderDates[i]; //pVegObj->Active(); if ( !pVegObj->GetPrimHandle().IsValid()) { _BuildRenderData(pVegObj); } } } //------------------------------------------------------------------------ void VegetationRenderComponent::_BuildRenderData( GPtr& pVegObj ) { if ( pVegObj->mIsBuildRenderable ) return; const VegeInstanceMapPtr& pVegInstMap = pVegObj->GetInstanceMap(); if ( !pVegInstMap.isvalid() || pVegInstMap->GetInstanceCount()<1 ) return; pVegInstMap->SetParentVegeObject(pVegObj); pVegInstMap->Active(); VegetationObject::RenderObjectPtr& renderObject = pVegObj->GetRenderObject(); if (!renderObject.isvalid()) { renderObject = VegetationObject::RenderObjectType::Create(); } renderObject->SetOwner(pVegObj.get(), mActor? mActor->GetLayerID() : 0, mActor->GetRenderScene()); Graphic::RenderableResUnitArray& resArray = pVegObj->GetResUnits(); Vegetation::RenderType etype = pVegObj->GetRenderType(); if( etype == Vegetation::eRT_Grass ) { VegetationObject::RenderObjectType::RenderableType* renderable = resArray[0].ResetRenderable(); pVegObj->mRenderQueueDirty = true; renderable->Set(0 ,0, Vegetation::g_VertexCount, 0 ,Vegetation::g_IndexCount); //-START Math::bbox worldBB = Math::bbox(); //worldBB.transform(mActor->GetWorldTransform()); _CalculateBBox( worldBB, pVegInstMap); renderObject->SetBoundingBox( worldBB ); //-END pVegInstMap->BuildPrimitive(); pVegObj->mIsBuildRenderable = true; } else { const Resources::PrimitiveResInfo* meshInfo = pVegObj->GetMeshInfo(); if ( !meshInfo ) return; const GPtr& _resourceinfo= meshInfo->GetRes(); if ( !_resourceinfo.isvalid()) { return; } const GPtr& meshRes = _resourceinfo.downcast(); if ( meshRes.isvalid() && meshRes->GetState() == Resource::Loaded ) { Math::bbox worldBB = meshRes->GetBoundingBox(); _CalculateBBox( worldBB, pVegInstMap); renderObject->SetBoundingBox( worldBB ); bool bAllRenderableSet = true; for ( IndexT subIndex = 0; subIndex < meshRes->GetSubMeshCount(); ++subIndex ) { if ( pVegObj->GetShaderCount() > subIndex) { SubMesh* subMesh = meshRes->GetSubMesh(subIndex); n_assert(subMesh); VegetationObject::RenderObjectType::RenderableType* renderable = resArray[subIndex].ResetRenderable(); pVegObj->mRenderQueueDirty = true; renderable->Set(subIndex , subMesh->firstVertex, subMesh->numVertex, subMesh->FirstIndex, subMesh->numIndex); } else { bAllRenderableSet = false; } } //pVegObj->SetPrimHandle(NULL); // fix bug4031 if ( pVegInstMap->BuildPrimitive() ) { if (bAllRenderableSet) pVegObj->mIsBuildRenderable = true; } } else { //TODO : reload meshres pVegObj->mIsBuildRenderable = false; pVegObj->mMeshDirty = true; } } } //------------------------------------------------------------------------ void VegetationRenderComponent::UpdateRenderData(void) { //TODO : foreach object for ( IndexT index = 0; index < mRenderDates.Size(); ++index ) { Vegetation::VegetationObjectPtr pVegObj = mRenderDates[index]; _UpdateRenderData(pVegObj); } } //-------------------------------------------------------------------------------- void VegetationRenderComponent::_UpdateRenderData( GPtr& pVegObj) { if ( !pVegObj->mIsAttached || !pVegObj->mIsBuildRenderable) { Graphic::RenderableResUnitArray& resArray = pVegObj->GetResUnits(); SizeT rndcount = resArray.Size(); for (IndexT rndIndex = 0; rndIndex < rndcount; ++rndIndex) { VegetationObject::RenderObjectType::RenderableType* vrptr = resArray[rndIndex].GetRenderableFast(); if ( vrptr ) { vrptr->Set(pVegObj,rndIndex); } } } else { Vegetation::RenderType etype = pVegObj->GetRenderType(); //GPtr& pPG = pVegObj->GetPrimGroup(); RenderBase::PrimitiveHandle& pPH = pVegObj->GetPrimHandle(); if( etype == Vegetation::eRT_Grass && pPH.IsValid())// && pPG.isvalid()) { } else { const Resources::PrimitiveResInfo* meshInfo = pVegObj->GetMeshInfo(); const GPtr& meshres = meshInfo->GetRes().downcast(); if ( meshres.isvalid() && meshres->GetState() == Resource::Loaded && meshInfo->GetHandle().IsValid() ) { Graphic::RenderableResUnitArray& resArray = pVegObj->GetResUnits(); int count = resArray.Size(); for (SizeT sub = 0; sub < count; ++sub) { if (sub >= meshres->GetSubMeshCount()) continue; SubMesh* subMesh = meshres->GetSubMesh( sub ); VegetationObject::RenderObjectType::RenderableType* renderable = resArray[sub].GetRenderableFast(); if ( NULL == renderable) { pVegObj->mIsBuildRenderable = false; return; } renderable->Set(sub , subMesh->firstVertex, subMesh->numVertex, subMesh->FirstIndex, subMesh->numIndex); } } } } } //------------------------------------------------------------------------ void VegetationRenderComponent::DiscardRenderData(void) { for (int nObj = 0; nObj < mRenderDates.Size(); ++nObj) { _DiscardRenderData(mRenderDates[nObj]); } } //------------------------------------------------------------------------ void VegetationRenderComponent::_DiscardRenderData( GPtr& pvegeobj ) { pvegeobj->mIsBuildRenderable = false; if ( pvegeobj->GetPrimHandle().IsValid() ) { //GraphicSystem::Instance()->RemovePrimitive(pvegeobj->GetPrimHandle()); App::GraphicObjectManager::Instance()->DiscardPrimitiveHandle(pvegeobj->GetPrimHandle()); pvegeobj->SetPrimHandle(NULL ); } } //------------------------------------------------------------------------ void VegetationRenderComponent::_CleanRenderData() { for (int nObj = 0; nObj < mRenderDates.Size(); ++nObj) { GPtr& pvegeobj = mRenderDates[nObj]; for ( IndexT iMat = 0 ; iMat < pvegeobj->GetShaderCount(); ++iMat ) { GPtr mat = pvegeobj->GetMaterial(iMat); if ( mat.isvalid() ) { pvegeobj->RemoveShader(iMat); mat = 0; } } } mRenderDates.Clear(); } //------------------------------------------------------------------------ void VegetationRenderComponent::AttachRenderObjects(void) { mAttached = true; for (int nObj = 0; nObj < mRenderDates.Size(); ++nObj) { _AttachRenderObject(mRenderDates[nObj]); } } //------------------------------------------------------------------------ void VegetationRenderComponent::_AttachRenderObject( GPtr& pvegeobj ) { if ( !pvegeobj->mIsBuildRenderable ) { pvegeobj->mIsAttached = false; return; } if ( pvegeobj->mIsAttached ) { return; } pvegeobj->mIsAttached = true; VegetationObject::RenderObjectPtr& renderObject = pvegeobj->GetRenderObject(); if (renderObject.isvalid()) { renderObject->Attach(mActor->GetRenderScene()); } } //------------------------------------------------------------------------ void VegetationRenderComponent::DeattachRenderObjects(void) { //TODO : foreach object mAttached = false; for (int nObj = 0; nObj < mRenderDates.Size(); ++nObj) { _DeattachRenderObject(mRenderDates[nObj]); } } //------------------------------------------------------------------------ void VegetationRenderComponent::_DeattachRenderObject( GPtr& pvegeobj ) { if ( !pvegeobj->mIsAttached ) { return; } pvegeobj->mIsAttached = false; VegetationObject::RenderObjectPtr& renderObject = pvegeobj->GetRenderObject(); if (renderObject.isvalid()) { renderObject->Detach(); } } //-------------------------------------------------------------------------------- void VegetationRenderComponent::OnRenderSceneChanged() { for (int i = 0; iGetRenderObject() && pVegObj->GetRenderObject()->Attached()) { pVegObj->GetRenderObject()->Attach(mActor->GetRenderScene()); } } } //-------------------------------------------------------------------------------- void VegetationRenderComponent::AddVegetationObject(const GPtr& obj) { mRenderDates.Append(obj); CreateInstanceMap(obj); } //-------------------------------------------------------------------------------- void VegetationRenderComponent::InsetVegetationObject(IndexT nIdx, const GPtr& obj) { mRenderDates.Insert(nIdx, obj); CreateInstanceMap(obj); } //------------------------------------------------------------------------ GPtr& VegetationRenderComponent::CreateVegetationObject(Vegetation::RenderType etype, const Resources::ResourceId& meshID) { //TODO : append a vegetationObject to component's mRenderDates GPtr vegeobj = Vegetation::VegetationObject::Create(); vegeobj->SetRenderType(etype); if ( meshID.IsValid() ) { vegeobj->SetMeshID(meshID); } mRenderDates.Append(vegeobj); CreateInstanceMap(vegeobj); return mRenderDates.Back(); } //-------------------------------------------------------------------------------- void VegetationRenderComponent::RemoveVegetationObject(IndexT nIdx) { if (mRenderDates.Size() <= nIdx) { return; } _DeattachRenderObject(mRenderDates[nIdx]); mRenderDates[nIdx]->ClearRenderables(); mRenderDates[nIdx]->DeActive(); mRenderDates[nIdx] = NULL; mRenderDates.EraseIndex(nIdx); } //------------------------------------------------------------------------ void VegetationRenderComponent::UpdateRenderLayer() { for (int i = 0; iGetRenderObject(); if (obj.isvalid()) { obj->SetLayerID(mActor->GetLayerID()); } } } //------------------------------------------------------------------------ bool VegetationRenderComponent::_LoadBrushRes(GPtr& pVegeObj) { //TODO: bool bRet = false; if ( !pVegeObj.isvalid()) { return false; } // while grass , no Meshres // or else meshres has been loaded, return true if ( pVegeObj->GetRenderType() == eRT_Grass ) { bRet = true; } else { //VegetationBrushPtr& pVegeBrush = pVegeObj->GetBrush(); //if ( !pVegeBrush.isvalid()) // return false; //const Resources::ResourceId& tResID = pVegeBrush->GetMeshID(); if ( pVegeObj->mMeshDirty) { const Resources::PrimitiveResInfo* pInfo = pVegeObj->GetMeshInfo(); if( pInfo && pInfo->GetRes().isvalid()) { const GPtr& tMeshres = pInfo->GetRes().downcast(); if ( tMeshres ) { bRet = true; pVegeObj->mMeshDirty = false; } } } } return bRet; } //------------------------------------------------------------------------ bool VegetationRenderComponent::_LoadBrushMaterials(GPtr& pVegeObj) { bool bRet = true; //VegetationBrushPtr& pVegeBrush = pVegeObj->GetBrush(); if ( !pVegeObj.isvalid()) { return false; } if (pVegeObj->mIsAllTexLoaded) { return bRet; } if (pVegeObj->mMatDirty) { bool hasMatDirty = false; //pVegeBrush->SetTexAllLoad(true); pVegeObj->mIsAllTexLoaded = true; for ( IndexT iMat = 0; iMat < pVegeObj->GetShaderCount(); ++iMat ) { const GPtr& mat = pVegeObj->GetMaterial(iMat); if (!pVegeObj->mCanCreateMaterial) { //pVegeBrush->SetCanCreateMat(true); pVegeObj->mCanCreateMaterial = true; //error SetShaderId(pVegeObj, iMat,mat->GetShaderID()); //pVegeObj->SetShaderId(iMat,mat->m_shaderID); if (iMat < pVegeObj->GetShaderCount() -1) { pVegeObj->mCanCreateMaterial = false; } } if ( !mat->IsAllLoaded() ) { //pVegeBrush->SetTexAllLoad(false); pVegeObj->mIsAllTexLoaded = false; } hasMatDirty |= mat->IsDirty(); } bRet ^= hasMatDirty; pVegeObj->mMatDirty = hasMatDirty; //pVegeBrush->SetMatDirty(hasMatDirty); //mRenderQueueDirty = true; } return bRet; } void VegetationRenderComponent::SetMeshID(GPtr& pVegeObj, const Resources::ResourceId& meshID ) { pVegeObj->SetMeshID(meshID); pVegeObj->mMeshDirty = true; } //-------------------------------------------------------------------------------- void VegetationRenderComponent::SetMeshID(IndexT idx, const Resources::ResourceId& meshID) { } //-------------------------------------------------------------------------------- IndexT VegetationRenderComponent::IntersectInstance(const Actor* camerActor, const Math::float2& mousepos, IndexT nIdx, Math::scalar& fout) { IndexT retIdx = -1; Math::Ray worldray; bool bcompute = AppUtil::IntersectUtil::ComputeDefaultWorldMouseRay( camerActor, mousepos, worldray ); //if ( GetWorldRay(mousepos, worldray)) if(bcompute) { if ( nIdx >= mRenderDates.Size()) { return retIdx; } const GPtr& vegeobj = mRenderDates[nIdx]; if ( !vegeobj.isvalid()) { return retIdx; } const GPtr& instMap = vegeobj->GetInstanceMap(); if (instMap.isvalid()) { Math::vector objscale = vegeobj->GetScale(); Math::quaternion objrot = vegeobj->GetRotation(); if ( vegeobj->GetRenderType() == eRT_Grass ) { SizeT nInstCount = instMap->GetInstanceCount(); for (IndexT i = 0; i < nInstCount; ++i) { INSTANCEDATA_POS* tmpInst = instMap->GetInstance(i); Math::float4 _pos(tmpInst->pos.x(),tmpInst->pos.y(), tmpInst->pos.z(), 1); // while in the visual range , draw a single Tree Math::quaternion _quat = Math::quaternion::rotationyawpitchroll( tmpInst->rotate.y() * N_PI / 180.0f , tmpInst->rotate.x()* N_PI / 180.0f, tmpInst->rotate.z()* N_PI / 180.0f); _quat = Math::quaternion::multiply(_quat,objrot); Math::float4 _scale = Math::float4(tmpInst->scale.x() * objscale.x(), tmpInst->scale.y()* objscale.y(), tmpInst->scale.z()* objscale.z(), 0); Math::matrix44 _mat = Math::matrix44::transformation( _scale, _quat, _pos ); Math::matrix44 invWorldM = Math::matrix44::inverse( _mat ); Math::Ray localray = worldray.Tramsform(invWorldM); const PrimitiveTopology::Code type = PrimitiveTopology::TriangleList; const VEGE_VERTEX_INSTANCE* instanceVertex = &vegeobj->GetVertices()[0];//pg->GetVertexBuffer()->GetPtr(); const Resources::Index16Container::value_type* indicies32 = (const Resources::Index16Container::value_type*)&vegeobj->GetIndices()[0];//pg->GetIndexBuffer()->GetPtr(); //scalar interPoint = N_INFINITY; Math::scalar tempOut; for (IndexT nIdx = 0; nIdx < 2; ++nIdx) { Resources::Index16Container::value_type index0 = indicies32[i*6 + nIdx*3]; Resources::Index16Container::value_type index1 = indicies32[i*6 + nIdx*3 + 1]; Resources::Index16Container::value_type index2 = indicies32[i*6 + nIdx*3 + 2]; if ( Math::Intersection::Intersect(localray, instanceVertex[index0].pos, instanceVertex[index1].pos, instanceVertex[index2].pos, tempOut ) ) { //interPoint = n_min( interPoint, fout ); if ( fout > tempOut) { fout = tempOut; retIdx = i; } } } } } else { //const GPtr& vegebrush = vegeobj->GetBrush(); const GPtr& mesh = vegeobj->GetMeshInfo()->GetRes().downcast(); SizeT nInstCount = instMap->GetInstanceCount(); for (IndexT i = 0; i < nInstCount; ++i) { INSTANCEDATA_POS* tmpInst = instMap->GetInstance(i); Math::float4 _pos(tmpInst->pos.x(),tmpInst->pos.y(), tmpInst->pos.z(), 1); // while in the visual range , draw a single Tree //Math::float3 tscale = tmpInst->scale * objscale; //Math::float4 _scale(tscale.x(), tscale.y(), tscale.z(), 0); //Math::vector _axis(0, tmpInst->rotate.x(),0 ); //Math::quaternion _quat = Math::quaternion::rotationaxis(_axis, (tmpInst->rotate.y() + objrot) * 5 * N_PI); //Math::matrix44 _mat = Math::matrix44::transformation( _scale, _quat, _pos ); Math::quaternion _quat = Math::quaternion::rotationyawpitchroll( tmpInst->rotate.y()* N_PI / 180.0f, tmpInst->rotate.x()* N_PI / 180.0f, tmpInst->rotate.z()* N_PI / 180.0f); _quat = Math::quaternion::multiply(_quat,objrot); Math::float4 _scale = Math::float4(tmpInst->scale.x()* objscale.x(), tmpInst->scale.y()* objscale.y(), tmpInst->scale.z()* objscale.z(), 0); Math::matrix44 _mat = Math::matrix44::transformation( _scale, _quat, _pos ); matrix44 invWorldM = Math::matrix44::inverse( _mat ); Math::Ray localray = worldray.Tramsform(invWorldM); if ( AppUtil::IntersectUtil::IntersectMesh(localray, mesh, fout) ) { return i; } } } } } return retIdx; } //-------------------------------------------------------------------------------- void VegetationRenderComponent::NotifiedTerrainChanged(const STR_TERRAINBLOCK& terrblock,const Math::scalar& scaleX,const Math::scalar& scaleZ) { //TODO : get whether there were some vegetations, and then SizeT vegetcount = mRenderDates.Size(); for (IndexT nCurVeget = 0; nCurVeget < vegetcount; ++nCurVeget) { GPtr& instMap = mRenderDates[nCurVeget]->GetInstanceMap(); if ( !instMap.isvalid()) continue; float flposx = terrblock.xmin /terrblock.heimapX * terrblock.terrainWidth; float flposz = terrblock.ymin /terrblock.heimapY * terrblock.terrainHeight; float frposx = (terrblock.xmin + terrblock.width) /terrblock.heimapX * terrblock.terrainWidth; float frposz = (terrblock.ymin + terrblock.height) /terrblock.heimapY * terrblock.terrainHeight; //float fWidthTileX = terrblock.terrainWidth / terrblock.heimapX; //float fWidthTileY = terrblock.terrainHeight / terrblock.heimapY; const Math::vector& actorPos = mActor->GetWorldPosition(); SizeT instCount = instMap->GetInstanceCount(); for ( IndexT nCurInst = 0; nCurInst < instCount; ++nCurInst) { INSTANCEDATA_POS* curInst = instMap->GetInstance(nCurInst); // transform from world coordinate to terrain actor(curInst is world pos) Math::float3 posAtCoornidateActor; posAtCoornidateActor.set(curInst->pos.x() - actorPos.x(), curInst->pos.y() - actorPos.y(), curInst->pos.z() - actorPos.z()); bool bReplace = (posAtCoornidateActor.x() > flposx) && (posAtCoornidateActor.x() < frposx); //bReplace &= (posAtCoornidateActor.z() > leftupPos.y()) && (posAtCoornidateActor.z() < rightdownPos.y()); if (!bReplace) continue; bReplace = (posAtCoornidateActor.z() > flposz) && (posAtCoornidateActor.z() < frposz); if ( bReplace ) { //TODO : if there be , get y-value via (x,z)-value from terrain's data GPtr com ; GPtr TerrCom; com = mActor->FindComponent( TerrainRenderComponent::RTTI ); if ( com.isvalid() ) { TerrCom = com.downcast(); if (TerrCom) { //float fTerrainHeight = pTVView->GetTerrainHeight(actorID, xmin+x, ymin+y); //int xtile = (int)(posAtCoornidateActor.x() / terrblock.terrainWidth * terrblock.heimapX ); //int ytile = (int)(posAtCoornidateActor.z() / terrblock.terrainHeight * terrblock.heimapY ); //float insty = TerrCom->GetTerrainData()->GetHeightMap()->GetHeight(xtile, ytile); float insty = TerrCom->GetWorldYAtActorCoord(posAtCoornidateActor.x() , posAtCoornidateActor.z()); //transform to world coordinate insty += actorPos.y(); //TODO : set Instance date (replace) Math::scalar fXAtActorCoor = posAtCoornidateActor.x() * scaleX; Math::scalar fZAtActorCoor = posAtCoornidateActor.z() * scaleZ; fXAtActorCoor += actorPos.x(); fZAtActorCoor += actorPos.z(); curInst->pos = Math::float3(fXAtActorCoor, insty,fZAtActorCoor); } } } } } } //------------------------------------------------------------------------ void VegetationRenderComponent::NotifiedTerrainHole( const STR_TERRAINBLOCK& terrblock) { //TODO : get whether there were some vegetations, and then SizeT vegetcount = mRenderDates.Size(); for (IndexT nCurVeget = 0; nCurVeget < vegetcount; ++nCurVeget) { GPtr& instMap = mRenderDates[nCurVeget]->GetInstanceMap(); if ( !instMap.isvalid()) continue; float flposx = terrblock.xmin /terrblock.heimapX * terrblock.terrainWidth; float flposz = terrblock.ymin /terrblock.heimapY * terrblock.terrainHeight; float frposx = (terrblock.xmin + terrblock.width) /terrblock.heimapX * terrblock.terrainWidth; float frposz = (terrblock.ymin + terrblock.height) /terrblock.heimapY * terrblock.terrainHeight; //float fWidthTileX = terrblock.terrainWidth / terrblock.heimapX; //float fWidthTileY = terrblock.terrainHeight / terrblock.heimapY; SizeT instCount = instMap->GetInstanceCount(); for ( IndexT nCurInst = instCount - 1; nCurInst >= 0; --nCurInst) { INSTANCEDATA_POS* curInst = instMap->GetInstance(nCurInst); bool bReplace = (curInst->pos.x() > flposx) && (curInst->pos.x() < frposx); //bReplace &= (curInst->pos.z() > leftupPos.y()) && (curInst->pos.z() < rightdownPos.y()); if (!bReplace) continue; bReplace = (curInst->pos.z() > flposz) && (curInst->pos.z() < frposz); if ( bReplace ) { //TODO : if there be , get y-value via (x,z)-value from terrain's data GPtr com ; GPtr TerrCom; com = mActor->FindComponent( TerrainRenderComponent::RTTI ); if ( com.isvalid() ) { TerrCom = com.downcast(); if (TerrCom) { mRenderDates[nCurVeget]->RemoveInstance(nCurInst); } } } } } } //-------------------------------------------------------------------------------- void VegetationRenderComponent::_CalculateBBox(Math::bbox& box, const GPtr& instmap) { n_assert(instmap.isvalid()); scalar minX = Math::N_INFINITY; scalar minY = Math::N_INFINITY; scalar minZ = Math::N_INFINITY; scalar maxX = -Math::N_INFINITY; scalar maxY = -Math::N_INFINITY; scalar maxZ = -Math::N_INFINITY; SizeT PosIndex = 0; while (PosIndex < instmap->GetInstanceCount()) { Math::float3 curPos = instmap->GetInstance(PosIndex)->pos; Math::float3 curScal = instmap->GetInstance(PosIndex)->scale; /*if(curPos.x() < minX) minX = curPos.x(); else if(curPos.x() > maxX) maxX = curPos.x();*/ Math::scalar curMaxX = curPos.x() + box.pmax.x() * curScal.x(); if(curPos.x() < minX) minX = curPos.x(); else if(curMaxX > maxX) maxX = curMaxX; Math::scalar curMaxY = curPos.y() + box.pmax.y() * curScal.y(); if(curPos.y() < minY) minY = curPos.y(); else if(curMaxY > maxY) maxY = curMaxY; /* if(curPos.z() < minZ) minZ = curPos.z(); else if(curPos.z() > maxZ) maxZ = curPos.z();*/ Math::scalar curMaxZ = curPos.z() + box.pmax.z() * curScal.z(); if(curPos.z() < minZ) minZ = curPos.z(); else if(curMaxZ > maxZ) maxZ = curMaxZ; PosIndex++; } box.pmin = Math::point(minX,minY,minZ); box.pmax = Math::point(maxX,maxY,maxZ); } //------------------------------------------------------------------------ void VegetationRenderComponent::ReCalcBBox(const GPtr& pVegObj) { GPtr& pVegInstMap = pVegObj->GetInstanceMap(); if (!pVegInstMap) { return; } VegetationObject::RenderObjectPtr& renderObject = pVegObj->GetRenderObject(); if (!renderObject.isvalid()) { return; } Vegetation::RenderType etype = pVegObj->GetRenderType(); if( etype == Vegetation::eRT_Grass ) { if (!renderObject.isvalid()) return; pVegObj->mRenderQueueDirty = true; Math::bbox worldBB = Math::bbox(); _CalculateBBox( worldBB, pVegInstMap); renderObject->SetBoundingBox( worldBB ); } else { const Resources::PrimitiveResInfo* meshInfo = pVegObj->GetMeshInfo(); if ( !meshInfo ) return; const GPtr& _resourceinfo= meshInfo->GetRes(); if ( !_resourceinfo.isvalid()) { return; } const GPtr& meshRes = _resourceinfo.downcast(); if ( meshRes.isvalid() && meshRes->GetState() == Resource::Loaded ) { //TODO : Instance Map trav // build new renderable bool bAllRenderableSet = true; Math::bbox worldBB = meshRes->GetBoundingBox(); //worldBB.transform(mActor->GetWorldTransform()); _CalculateBBox( worldBB, pVegInstMap); renderObject->SetBoundingBox( worldBB ); } } } //------------------------------------------------------------------------ void VegetationRenderComponent::GetReferenceResourceId(Util::Array& list) const { for (int i = 0; i< mRenderDates.Size(); i++) { Vegetation::VegetationObjectPtr& pVegObj = mRenderDates[i]; if (pVegObj.isvalid()) { pVegObj->GetReferenceResourceId(list); } } Super::GetReferenceResourceId(list); } bool VegetationRenderComponent::CreateInstanceMap( const GPtr& obj ) { Vegetation::VegeInstanceMapPtr& pInstMap = obj->GetInstanceMap(); if ( !pInstMap.isvalid() ) { const Util::String& tplpath = obj->GetInstanceFilePath(); if ( tplpath.IsEmpty() ) return false; if( VegetationServer::Instance()->OpenTemplateFile( tplpath ) ) pInstMap = VegetationServer::Instance()->CreateFromTemplate( tplpath ); if ( !pInstMap.isvalid() ) pInstMap = obj->CreateInstanceMap(); obj->SetInstanceMap(pInstMap); } return true; } }