//----------------------------------------------------------------------------
PX2::Movable *SceneBuilder::BuildGeometry (INode *maxNode, PX2::Node *relatParent, bool hasSkin)
{
// 建立并且链接几何图形物体到场景
// maxNode：
// Max场景中节点的指针
// relatParent:
// 当前新节点要绑定到的父亲节点
// 如果Max“几何图形”节点没有孩子节点，直接在relatParent下添加几何图形。
// 如果Max“几何图形”节点有孩子节点，会新建一个Node节点，将孩子几何图形节
// 点添加到这个新建的Node节点下。
PX2::Movable *child = 0;
PX2::Node *link = 0;
int numMaxChildren = maxNode->NumberOfChildren();
for (int i=0; i<numMaxChildren; i++)
{
ObjectState objectState = maxNode->GetChildNode(i)
->EvalWorldState(mTimeStart);
if (objectState.obj->SuperClassID() == GEOMOBJECT_CLASS_ID ||
objectState.obj->SuperClassID() == HELPER_CLASS_ID)
{
link = BuildNode(maxNode, relatParent);
break;
}
}
if (link == 0)
{
if (mSettings->IncludeMeshes && !maxNode->IsHidden())
{
child = BuildMesh(maxNode, relatParent, hasSkin);
}
else
{
child = BuildNode(maxNode, relatParent);
}
return child;
}
else
{
if (mSettings->IncludeMeshes && !maxNode->IsHidden())
{
child = BuildMesh(maxNode, link, hasSkin);
}
else
{
child = BuildNode(maxNode, link);
}
return link;
}
}
//-----------------------------------------------------------------------------
// Purpose: Builds all navigation meshes
//-----------------------------------------------------------------------------
bool CRecastMgr::Build( bool loadDefaultMeshes )
{
double fStartTime = Plat_FloatTime();
// Load map mesh
if( !LoadMapMesh() )
{
Warning("CRecastMesh::Build: failed to load map data!\n");
return false;
}
// Insert all meshes first
if( loadDefaultMeshes )
{
InitDefaultMeshes();
}
CUtlVector<CRecastMesh *> meshesToBuild;
for ( int i = m_Meshes.First(); i != m_Meshes.InvalidIndex(); i = m_Meshes.Next(i ) )
{
if( IsMeshBuildDisabled( m_Meshes[i]->GetName() ) )
continue;
meshesToBuild.AddToTail( m_Meshes[i] );
}
// Create meshes
if( recast_build_threaded.GetBool() )
{
// Build threaded
CParallelProcessor<CRecastMesh *, CFuncJobItemProcessor<CRecastMesh *>, 2 > processor;
processor.m_ItemProcessor.Init( &ThreadedBuildMesh, &PreThreadedBuildMesh, &PostThreadedBuildMesh );
processor.Run( meshesToBuild.Base(), meshesToBuild.Count(), 1, recast_build_numthreads.GetInt(), g_pThreadPool );
}
else
{
if( V_strlen( recast_build_single.GetString() ) > 0 )
{
BuildMesh( m_pMapMesh, recast_build_single.GetString() );
}
else
{
for( int i = 0; i < meshesToBuild.Count(); i++ )
{
BuildMesh( m_pMapMesh, meshesToBuild[i]->GetName() );
}
}
}
m_bLoaded = true;
DevMsg( "CRecastMgr: Finished generating %d meshes in %f seconds\n", m_Meshes.Count(), Plat_FloatTime() - fStartTime );
return true;
}
void
TouchSensorObject::GetWorldBoundBox(TimeValue t, INode* inode, ViewExp* vpt,
Box3& box )
{
Matrix3 tm;
BuildMesh(t); // 000829 --prs.
GetMat(t,inode,vpt,tm);
BuildMesh(t);
int nv = mesh.getNumVerts();
box.Init();
for (int i=0; i<nv; i++)
box += tm*mesh.getVert(i);
}
int
BackgroundObject::Display(TimeValue t, INode* inode, ViewExp *vpt, int flags)
{
float radius;
pblock->GetValue(PB_BG_SIZE, t, radius, FOREVER);
if (radius <= 0.0)
return 0;
BuildMesh(t);
Matrix3 m;
GraphicsWindow *gw = vpt->getGW();
Material *mtl = gw->getMaterial();
DWORD rlim = gw->getRndLimits();
gw->setRndLimits(GW_WIREFRAME|GW_EDGES_ONLY|GW_BACKCULL);
GetMat(t,inode,vpt,m);
gw->setTransform(m);
if (inode->Selected())
gw->setColor( LINE_COLOR, 1.0f, 1.0f, 1.0f);
else if(!inode->IsFrozen())
gw->setColor( LINE_COLOR, 1.0f, 1.0f, 0.0f);
mesh.render( gw, mtl, NULL, COMP_ALL);
gw->setRndLimits(rlim);
return(0);
}
int
FogObject::Display(TimeValue t, INode* inode, ViewExp *vpt, int flags)
{
if ( ! vpt || ! vpt->IsAlive() )
{
// why are we here?
DbgAssert(!"Doing Display() on invalid view port!");
return FALSE;
}
float radius;
pblock->GetValue(PB_FOG_SIZE, t, radius, FOREVER);
if (radius <= 0.0)
return 0;
BuildMesh(t);
Matrix3 m;
GraphicsWindow *gw = vpt->getGW();
Material *mtl = gw->getMaterial();
DWORD rlim = gw->getRndLimits();
gw->setRndLimits(GW_WIREFRAME|GW_EDGES_ONLY|GW_BACKCULL| (rlim&GW_Z_BUFFER) );
GetMat(t,inode,*vpt,m);
gw->setTransform(m);
if (inode->Selected())
gw->setColor( LINE_COLOR, 1.0f, 1.0f, 1.0f);
else if(!inode->IsFrozen())
gw->setColor( LINE_COLOR, 1.0f, 0.0f, 0.0f);
mesh.render( gw, mtl, NULL, COMP_ALL);
gw->setRndLimits(rlim);
return(0);
}
TargetObject::TargetObject() : GeomObject() {
if (!meshBuilt) {
BuildMesh();
meshBuilt = 1;
}
}
void
Cal3DObject::GetLocalBoundBox(TimeValue t, INode *inode, ViewExp *vpt,
Box3 &box)
{
BuildMesh(t); // 000829 --prs.
box = mesh.getBoundingBox();
}
// The following methdos had to be redefined because Luminaires have
// a different mesh than its base object
void LuminaireObject::UpdateMesh()
{
if (!(dumFlags&MESH_VALID))
{
BuildMesh();
dumFlags |= MESH_VALID;
}
}
void
SwitchObject::GetLocalBoundBox(TimeValue t, INode *inode, ViewExp *vpt,
Box3 &box)
{
Matrix3 m = inode->GetObjectTM(t);
BuildMesh(t);
box = mesh.getBoundingBox();
}
ProtHelpObject::ProtHelpObject() : HelperObject()
{
editting = 0;
created = 0;
refNode[0] = refNode[1] = NULL;
suspendSnap = FALSE;
ivalid.SetEmpty();
BuildMesh();
}
//------------------------------------------------------------------------------
void GLMesh::Restore() noexcept
{
if(m_vertexDataBackup && m_invalidData)
{
BuildMesh(m_vertexDataBackup.get(), m_vertexDataSize, m_indexDataBackup.get(), m_indexDataSize);
m_invalidData = false;
}
}
void
NavInfoObject::GetLocalBoundBox(TimeValue t, INode* inode, ViewExp* /*vpt*/,
Box3& box )
{
BuildMesh(t);
Matrix3 m = inode->GetObjectTM(t);
box = mesh.getBoundingBox();
}
void
NavInfoObject::GetWorldBoundBox(TimeValue t, INode* inode, ViewExp* vpt,
Box3& box )
{
if ( ! vpt || ! vpt->IsAlive() )
{
// why are we here?
box.Init();
return;
}
Matrix3 tm;
BuildMesh(t); // 000829 --prs.
GetMat(t,inode,*vpt,tm);
BuildMesh(t);
int nv = mesh.getNumVerts();
box.Init();
for (int i=0; i<nv; i++)
box += tm*mesh.getVert(i);
}
BombObject::BombObject()
{
pblock = NULL;
ReplaceReference(0,CreateParameterBlock(descV2,10,BOMB_VERSION));
pblock->SetValue(PB_STRENGTH, TimeValue(0), 1.0f);
pblock->SetValue(PB_GRAVITY, TimeValue(0), 1.0f);
pblock->SetValue(PB_DETONATION, TimeValue(0), 800);
pblock->SetValue(PB_MINFRAG, TimeValue(0), 1);
pblock->SetValue(PB_MAXFRAG, TimeValue(0), 1);
pblock->SetValue(PB_FALLOFF, TimeValue(0), 100.0f);
BuildMesh(TimeValue(0),mesh);
mesh.EnableEdgeList(1);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void CSModelProvider::CreateResourceFromFile(StorageLocation in_location, const std::string& in_filePath, const IResourceOptionsBaseCSPtr& in_options, const ResourceSPtr& out_resource)
{
MeshSPtr meshResource = std::static_pointer_cast<Mesh>(out_resource);
MeshDescriptor descriptor;
if (ReadFile(in_location, in_filePath, descriptor) == false)
{
meshResource->SetLoadState(Resource::LoadState::k_failed);
return;
}
BuildMesh(nullptr, descriptor, meshResource);
}
//------------------------------------------------------------------------------
GLMesh::GLMesh(const u8* vertexData, u32 vertexDataSize, const u8* indexData, u32 indexDataSize, ChilliSource::RenderMesh* renderMesh) noexcept
: m_vertexDataSize(vertexDataSize), m_indexDataSize(indexDataSize), m_renderMesh(renderMesh)
{
BuildMesh(vertexData, vertexDataSize, indexData, indexDataSize);
if(k_shouldBackupMeshDataFromMemory && renderMesh->ShouldBackupData())
{
u8* vertextDataCopy = new u8[vertexDataSize];
memcpy(vertextDataCopy, vertexData, vertexDataSize);
m_vertexDataBackup = std::unique_ptr<const u8[]>(vertextDataCopy);
u8* indexDataCopy = new u8[indexDataSize];
memcpy(indexDataCopy, indexData, indexDataSize);
m_indexDataBackup = std::unique_ptr<const u8[]>(indexDataCopy);
}
}
//+-----------------------------------------------------------------------------
//| Renders the geoset
//+-----------------------------------------------------------------------------
VOID MODEL_GEOSET::Render(CONST SEQUENCE_TIME& time, BOOL Animated)
{
BuildMesh();
glUseProgram(Graphics.Program());
ESMatrix modelviewMatrix;
ESMatrix perspectiveMatrix;
ESMatrix mvpMatrix;
int aspect;
aspect = (GLfloat) 600 / (GLfloat) 800;
esMatrixLoadIdentity(&perspectiveMatrix);
esPerspective(&perspectiveMatrix, 60.0f, aspect, 1.0f, 20.0f);
esMatrixLoadIdentity(&modelviewMatrix);
esScale(&modelviewMatrix, 1.0f, 1.0f, 1.0f);
esTranslate(&modelviewMatrix, 0.0f, 0.0f, 0.0f);
static float angle = 0.0f;
esRotate(&modelviewMatrix,angle, 1.0f, 0.0f, 0.0f);
angle += 0.2f;
esMatrixLoadIdentity(&mvpMatrix);
esMatrixMultiply(&mvpMatrix, &modelviewMatrix, &perspectiveMatrix);
glUniformMatrix4fv(Graphics.WVPMatrix(), 1, GL_FALSE, (GLfloat*) mvpMatrix.m);
glEnable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE0);
glActiveTexture(GL_TEXTURE0);
glEnableVertexAttribArray(Graphics.Position());
glEnableVertexAttribArray(Graphics.TexturePosition());
glUniform1i(Graphics.Texture(), 0);
glVertexAttribPointer(Graphics.Position(), 3, GL_FLOAT, GL_FALSE, sizeof(FLOAT) * 3, vertices);
glVertexAttribPointer(Graphics.TexturePosition(), 2, GL_FLOAT, GL_FALSE, 2 * sizeof(FLOAT), TexturePositions);
glDrawElements(GL_TRIANGLES, GeosetData.FaceContainer.GetTotalSize() * 3, GL_UNSIGNED_INT, indices);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE0);
glDisableVertexAttribArray(Graphics.TexturePosition());
glDisableVertexAttribArray(Graphics.Texture());
}
TapeHelpObject::TapeHelpObject() : HelperObject()
{
ParamBlockDesc desc[] = {
{ TYPE_FLOAT, NULL, TRUE }
};
// RB: Need to make a reference to the parameter block!
pblock = NULL;
ReplaceReference( 0, CreateParameterBlock( desc, 1 ));
enable = 0;
editting = 0;
lastDist = 0.0f;
SetLength( TimeValue(0), dlgLength );
specLenState = dlgSpecLen;
BuildMesh();
dirPt.x = dirPt.y = dirPt.z = 0.0f;
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void CSModelProvider::LoadMeshDataTask(StorageLocation in_location, const std::string& in_filePath, const AsyncLoadDelegate& in_delegate, const MeshSPtr& out_resource)
{
//read the mesh data into a MoStaticDeclaration
MeshDescriptor descriptor;
if (false == ReadFile(in_location, in_filePath, descriptor))
{
out_resource->SetLoadState(Resource::LoadState::k_failed);
Application::Get()->GetTaskScheduler()->ScheduleTask(TaskType::k_mainThread, [=](const TaskContext&) noexcept
{
in_delegate(out_resource);
});
}
//start a main thread task for loading the data into a mesh
Application::Get()->GetTaskScheduler()->ScheduleTask(TaskType::k_large, [=](const TaskContext&) noexcept
{
BuildMesh(in_delegate, descriptor, out_resource);
});
}
BOOL CoGXEventTrigger::Initialize(CoExecutive* pExecutive,GXSchedulePROC pProc,DWORD dwFlag)
{
CGXMapObject::Cleanup();
m_pExecutive = pExecutive;
m_EventTriggerDesc.dwColor = 0xffffffff;
SET_VECTOR3(&m_EventTriggerDesc.v3Pos,0.0f);
SET_VECTOR3(&m_EventTriggerDesc.v3Rot,0.0f);
SET_VECTOR3(&m_EventTriggerDesc.v3Scale,1.0f);
SET_VECTOR3(&m_v3DefaultLength,100.0f);
BuildMesh();
m_dwID = 0xfffffff4;
m_pHashHandle = NULL;
m_dwPropertyFlag = dwFlag;
m_dwObjectType = GX_MAP_OBJECT_TYPE_TRIGGER;
m_pProc = pProc;
return TRUE;
}
int
Cal3DObject::Display(TimeValue t, INode *inode, ViewExp *vpt, int flags)
{
pblock->GetValue(PB_CAL_SIZE, t, scale, FOREVER);
if (scale <= 0.0)
return 0;
BuildMesh(t);
Matrix3 m;
GraphicsWindow *gw = vpt->getGW();
Material *mtl = gw->getMaterial();
DWORD rlim = gw->getRndLimits();
gw->setRndLimits(/*GW_WIREFRAME*/ GW_ILLUM | GW_FLAT | GW_Z_BUFFER | GW_BACKCULL);
GetMat(t, inode, vpt, m);
gw->setTransform(m);
if (inode->Selected())
gw->setColor(LINE_COLOR, 1.0f, 1.0f, 1.0f);
else if (!inode->IsFrozen())
gw->setColor(LINE_COLOR, 0.0f, 1.0f, 0.0f);
mesh.render(gw, mtl, NULL, COMP_ALL);
gw->setRndLimits(rlim);
return (0);
}
void MeshExporter::Export()
{
mRoot = new Root;
mResourceManager = new ResourceManager;
mRenderSystem = new NullRenderSystem;
mWorld = new World;
try
{
IGameConversionManager* cm = GetConversionManager();
cm->SetCoordSystem(IGameConversionManager::IGAME_D3D);
mGameScene->InitialiseIGame(ExportConfig::Instance()->IsExportSelected());
mGameScene->SetStaticFrame(0);
int nodeCount = mGameScene->GetTopLevelNodeCount();
if (nodeCount == 0)
{
MessageBox(GetActiveWindow(), "No nodes available!", "Error", MB_OK);
goto __end;
}
mMeshSource = MeshManager::Instance()->NewMesh("MaxExporter");
// extract skeleton
for (int i = 0; i < nodeCount; ++i)
{
IGameNode* node = mGameScene->GetTopLevelNode(i);
if (node->IsNodeHidden())
continue ;
ExtractSkeleton(node);
}
// extract mesh
mMeshData.Clear();
for (int i = 0; i < nodeCount; ++i)
{
IGameNode* node = mGameScene->GetTopLevelNode(i);
if (node->IsNodeHidden())
continue ;
ExtractMesh(node);
}
if (mMMPairs.Size() == 0)
{
MessageBox(GetActiveWindow(), "No Objects!", "Error", MB_OK);
goto __end;
}
BuildMesh();
// save mesh
MeshSerializer::Save(mMeshSource.c_ptr(), ExportConfig::Instance()->GetExportFilename());
MessageBox(GetActiveWindow(), "Export OK!", "Info", MB_ICONINFORMATION);
}
catch (...)
{
MessageBox(GetActiveWindow(), "Error!", "Error", MB_ICONEXCLAMATION);
}
__end:
mMeshSource = NULL;
delete mWorld;
delete mRenderSystem;
delete mResourceManager;
delete mRoot;
}
void SimpleObject::UpdateMesh(TimeValue t)
{
if (!ivalid.InInterval(t) ) {
BuildMesh(t);
}
}
void CoGXEventTrigger::SetScale(VECTOR3* pv3Scale)
{
m_EventTriggerDesc.v3Scale = *pv3Scale;
BuildMesh();
}
void CoGXEventTrigger::SetRotation(VECTOR3* pv3Rot)
{
m_EventTriggerDesc.v3Rot = *pv3Rot;
BuildMesh();
}
Mesh::Mesh(const char* objName) : Object(){
built = false;
BuildMesh(objName);
}
osg::Geode* BuildMesh(const TopoDS_Face &face, const osg::Vec4 &color, double deflection)
{
osg::ref_ptr<osg::Geode> geode = new osg::Geode();
BuildMesh(geode, face, color, deflection);
return geode.release();
}
void CoGXEventTrigger::SetPosition(VECTOR3* pv3Pos)
{
m_EventTriggerDesc.v3Pos = *pv3Pos;
BuildMesh();
}
