void AQuadTree::GenerateMesh(FAQuadNode* node)
{
if (node == 0) return;
//Generate the mesh for the node
LatheMesh(node);
//Progress through the children
GenerateMesh(node->m_Children[0]);
GenerateMesh(node->m_Children[1]);
GenerateMesh(node->m_Children[2]);
GenerateMesh(node->m_Children[3]);
}
void AQuadTree::LoadQuadTree()
{
LoadMap();
Initialize();
Create();
GenerateMesh();
}
HRESULT CXMesh::RestoreDeviceObjects()
{
for(int i=0; i<m_Materials.GetSize(); i++)
m_Materials[i]->RestoreDeviceObjects();
if(m_SkinMesh) return GenerateMesh();
else return S_OK;
}
void ASimpleCubeActor::BeginPlay()
{
Super::BeginPlay();
GenerateMesh();
// Fix for PCM location/rotation/scale since the whole component is Transient
ProcMesh->SetWorldLocation(this->GetActorLocation());
ProcMesh->SetWorldRotation(this->GetActorRotation());
ProcMesh->SetWorldScale3D(this->GetActorScale3D());
}
void ABranchingLinesActor::OnConstruction(const FTransform& Transform)
{
Super::OnConstruction(Transform);
PreCacheCrossSection();
// We need to re-construct the buffers since values can be changed in editor
Vertices.Empty();
Triangles.Empty();
bHaveBuffersBeenInitialized = false;
GenerateMesh();
}
DrawableLine::DrawableLine(const glm::vec3 & start, const glm::vec3 & end, const glm::vec4& color) :
m_start(start),
m_end(end),
m_color(color)
{
m_mesh.vao = nullptr;
m_mesh.ibo = nullptr;
m_mesh.vertices.clear();
m_mesh.indices.clear();
GenerateMesh();
}
void ASimpleCylinderActor::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
{
Super::PostEditChangeProperty(PropertyChangedEvent);
FName MemberPropertyChanged = (PropertyChangedEvent.MemberProperty ? PropertyChangedEvent.MemberProperty->GetFName() : NAME_None);
if ((MemberPropertyChanged == GET_MEMBER_NAME_CHECKED(ASimpleCylinderActor, Radius)) || (MemberPropertyChanged == GET_MEMBER_NAME_CHECKED(ASimpleCylinderActor, Height)) || (MemberPropertyChanged == GET_MEMBER_NAME_CHECKED(ASimpleCylinderActor, bSmoothNormals)))
{
// Same vert count, so just regen mesh with same buffers
GenerateMesh();
}
else if ((MemberPropertyChanged == GET_MEMBER_NAME_CHECKED(ASimpleCylinderActor, RadialSegmentCount)) || (MemberPropertyChanged == GET_MEMBER_NAME_CHECKED(ASimpleCylinderActor, bCapEnds)) || (MemberPropertyChanged == GET_MEMBER_NAME_CHECKED(ASimpleCylinderActor, bDoubleSided)))
{
// Vertice count has changed, so reset buffer and then regen mesh
Vertices.Empty();
Triangles.Empty();
SetupMeshBuffers();
GenerateMesh();
}
else if ((MemberPropertyChanged == GET_MEMBER_NAME_CHECKED(ASimpleCylinderActor, Material)))
{
MeshComponent->SetMaterial(0, Material);
}
}
void SinglePatchJob::OnRun() // RUNS IN ANOTHER THREAD!! MUST BE THREAD SAFE!
{
BasePatchJob::OnRun();
const SSingleSplitRequest &srd = *mData;
// fill out the data
GenerateMesh(mData.get());
// add this patches data
SSingleSplitResult *sr = new SSingleSplitResult(srd.patchID.GetPatchFaceIdx(), srd.depth);
sr->addResult(srd.heights, srd.normals, srd.colors,
srd.v0, srd.v1, srd.v2, srd.v3,
srd.patchID.NextPatchID(srd.depth+1, 0));
// store the result
mpResults = sr;
}
void QuadPatchJob::OnRun() // RUNS IN ANOTHER THREAD!! MUST BE THREAD SAFE!
{
BasePatchJob::OnRun();
if(s_abort)
return;
const SQuadSplitRequest &srd = *mData;
const vector3d v01 = (srd.v0+srd.v1).Normalized();
const vector3d v12 = (srd.v1+srd.v2).Normalized();
const vector3d v23 = (srd.v2+srd.v3).Normalized();
const vector3d v30 = (srd.v3+srd.v0).Normalized();
const vector3d cn = (srd.centroid).Normalized();
//
const vector3d vecs[4][4] = {
{srd.v0, v01, cn, v30},
{v01, srd.v1, v12, cn},
{cn, v12, srd.v2, v23},
{v30, cn, v23, srd.v3}
};
SQuadSplitResult *sr = new SQuadSplitResult(srd.patchID.GetPatchFaceIdx(), srd.depth);
for (int i=0; i<4; i++)
{
if(s_abort) {
delete sr;
return;
}
// fill out the data
GenerateMesh(srd.heights[i], srd.normals[i], srd.colors[i], srd.borderHeights[i].get(), srd.borderVertexs[i].get(),
vecs[i][0], vecs[i][1], vecs[i][2], vecs[i][3],
srd.edgeLen, srd.fracStep, srd.pTerrain.Get());
// add this patches data
sr->addResult(i, srd.heights[i], srd.normals[i], srd.colors[i],
vecs[i][0], vecs[i][1], vecs[i][2], vecs[i][3],
srd.patchID.NextPatchID(srd.depth+1, i));
}
mpResults = sr;
}
void SinglePatchJob::OnRun() // RUNS IN ANOTHER THREAD!! MUST BE THREAD SAFE!
{
BasePatchJob::OnRun();
if(s_abort)
return;
const SSingleSplitRequest &srd = *mData;
// fill out the data
GenerateMesh(srd.heights, srd.normals, srd.colors, srd.borderHeights.get(), srd.borderVertexs.get(),
srd.v0, srd.v1, srd.v2, srd.v3,
srd.edgeLen, srd.fracStep, srd.pTerrain.Get());
// add this patches data
SSingleSplitResult *sr = new SSingleSplitResult(srd.patchID.GetPatchFaceIdx(), srd.depth);
sr->addResult(srd.heights, srd.normals, srd.colors,
srd.v0, srd.v1, srd.v2, srd.v3,
srd.patchID.NextPatchID(srd.depth+1, 0));
// store the result
mpResults = sr;
}
void Chunk::Load(ConcurrentMeshData* meshData, int meshStorageID)
{
meshStorage_ = meshData;
meshStorageID_ = meshStorageID;
glm::ivec3 worldPos;
glm::ivec3 pos;
Block* b;
bool visible = false;
for(int i = 0; i < CHUNK_SIZE; i++)
{
for(int j = 0; j < CHUNK_SIZE; j++)
{
for(int k = 0; k < CHUNK_SIZE; k++)
{
b = &blocks_[i][j][k];
pos = glm::vec3(i,j,k);
worldPos = pos + (glm::ivec3)position_;
if(GetBlockType(worldPos.x, worldPos.y, worldPos.z) == 1)
{
b->SetVisible(1);
visible = true;
}
else
{
b->SetVisible(0);
}
b->SetVisible(1);
visible = true;
}
}
}
GenerateMesh(visible);
}
// This is called when actor is already in level and map is opened
void ASimpleCylinderActor::PostLoad()
{
Super::PostLoad();
GenerateMesh();
}
// This is called when actor is spawned (at runtime or when you drop it into the world in editor)
void ASimpleCylinderActor::PostActorCreated()
{
Super::PostActorCreated();
GenerateMesh();
}
void CTerrainEntity::RandGenerateMesh()
{
RandHeightMap();
GenerateMesh();
}
void ABranchingLinesActor::BeginPlay()
{
Super::BeginPlay();
PreCacheCrossSection();
GenerateMesh();
}
void ASimpleCubeActor::OnConstruction(const FTransform& Transform)
{
Super::OnConstruction(Transform);
GenerateMesh();
}
void SpriteRenderer::Start() {
_mesh = MeshPtr(new Mesh());
GenerateMesh(_mesh.get());
}
HRESULT CXMesh::LoadFromXData(char* Filename, LPDIRECTXFILEDATA XObj)
{
HRESULT res = S_OK;
CBRenderD3D* Rend = (CBRenderD3D*)Game->m_Renderer;
// get name
res = CXModel::LoadName(this, XObj);
if(FAILED(res))
{
Game->LOG(res, "Error loading mesh name");
return res;
}
// load mesh
LPD3DXBUFFER BufMaterials = NULL;
LPD3DXBUFFER BufAdjacency = NULL;
LPD3DXBUFFER BufBoneOffset = NULL;
UINT NumFaces;
DWORD NumMaterials;
#ifdef WME_D3D9
LPD3DXMESH Mesh;
LPD3DXSKININFO SkinInfo;
res = D3DXLoadSkinMeshFromXof(XObj, D3DXMESH_MANAGED, Rend->m_Device, &BufAdjacency,
&BufMaterials, NULL, &NumMaterials, &SkinInfo, &Mesh);
if(SUCCEEDED(res)) m_SkinMesh = new CSkinMeshHelper(Mesh, SkinInfo);
#else
LPD3DXBUFFER BufBoneNames = NULL;
LPD3DXSKINMESH SkinMesh;
res = D3DXLoadSkinMeshFromXof(XObj, D3DXMESH_MANAGED, Rend->m_Device, &BufAdjacency,
&BufMaterials, &NumMaterials, &BufBoneNames, &BufBoneOffset, &SkinMesh);
if(SUCCEEDED(res)) m_SkinMesh = new CSkinMeshHelper(SkinMesh, BufBoneOffset, BufBoneNames);
#endif
if(FAILED(res))
{
Game->LOG(res, "Error loading skin mesh");
return res;
}
NumFaces = m_SkinMesh->GetNumFaces();
DWORD NumBones = m_SkinMesh->GetNumBones();
// Process skinning data
if(NumBones)
{
// bones are available
m_BoneMatrices = new D3DXMATRIX*[NumBones];
DWORD* Adjacency = (DWORD*)(BufAdjacency->GetBufferPointer());
m_SkinAdjacency = new DWORD[NumFaces * 3];
memcpy(m_SkinAdjacency, Adjacency, NumFaces * 3 * sizeof(DWORD));
GenerateMesh();
}
else
{
// no bones are found, blend the mesh and use it as a static mesh
m_SkinMesh->GetOriginalMesh(&m_StaticMesh);
m_StaticMesh->CloneMeshFVF(m_StaticMesh->GetOptions(), m_StaticMesh->GetFVF(), Rend->m_Device, &m_BlendedMesh);
SAFE_DELETE(m_SkinMesh);
m_NumAttrs = NumMaterials;
if(m_BlendedMesh)
{
NumFaces = m_BlendedMesh->GetNumFaces();
m_Adjacency = new DWORD[NumFaces * 3];
m_BlendedMesh->GenerateAdjacency(0, m_Adjacency);
}
}
// check for materials
if((BufMaterials == NULL) || (NumMaterials == 0))
{
// no materials are found, create default material
C3DMaterial* Mat = new C3DMaterial(Game);
Mat->m_Material.Diffuse.r = 0.5f;
Mat->m_Material.Diffuse.g = 0.5f;
Mat->m_Material.Diffuse.b = 0.5f;
Mat->m_Material.Specular = Mat->m_Material.Diffuse;
Mat->m_Material.Ambient = Mat->m_Material.Diffuse;
m_Materials.Add(Mat);
m_NumAttrs = 1;
}
else
{
// texture relative path base
char PathTemp[MAX_PATH+1];
int PathLength;
for (PathLength = strlen(Filename); PathLength--;)
{
if(Filename[PathLength] == '/' || Filename[PathLength] == '\\' )
{
PathLength++;
break;
}
}
strncpy(PathTemp, Filename, PathLength);
// load the materials
D3DXMATERIAL* FileMats = (D3DXMATERIAL*)BufMaterials->GetBufferPointer();
for(int i = 0; i < (int)NumMaterials; i++)
{
C3DMaterial* Mat = new C3DMaterial(Game);
Mat->m_Material = FileMats[i].MatD3D;
Mat->m_Material.Ambient = Mat->m_Material.Diffuse;
if(FileMats[i].pTextureFilename != NULL)
{
strcpy(PathTemp + PathLength, FileMats[i].pTextureFilename);
Mat->SetTexture(PathTemp, true);
}
m_Materials.Add(Mat);
}
m_NumAttrs = m_Materials.GetSize();
}
RELEASE(BufAdjacency);
RELEASE(BufMaterials);
RELEASE(BufBoneOffset);
return S_OK;
}
void AQuadTree::GenerateMesh()
{
GenerateMesh(m_nodes);
}
