void Model::AddCylinder(float radius, float height)
{
const double M_PI = 3.14159265358979;
int round = 6;
uint16_t startIndex = GetNextVertexIndex();
for(int i = 0; i <= round; i++)
{
double sangle = i * M_PI * 2. / round;
for (int t = -1; t <= 1; t += 2)
{
Vector3f v = Vector3f(cos(sangle) * radius, sin(sangle) * radius, t * height);
AddVertex(Vertex(v, Color(127, 0, 127, 255), float(i), float(t), Vector3f(cos(sangle), sin(sangle), 0)));
}
}
// Renumber indices
for (uint16_t s = 0; s < round; s++)
{
uint16_t s1 = s + 1;
auto get = [&](uint16_t s, uint16_t t){
return s * 2 + t + startIndex;
};
AddTriangle(get(s, 0),
get(s, 1),
get(s1, 0));
AddTriangle(get(s1, 0),
get(s, 1),
get(s1, 1));
}
}
//{CodeReview:Triangulation}
void EarClipper::Triangulate_R(VertexListIteratorList& ears, std::vector<const FVector2*>& triangles)
{
if (vertices.size() == 3)
{
AddTriangle(triangles, vertices.begin(), true);
}
else if (vertices.size() < 3)
{
AddRemainingTriangles(triangles);
}
else
{
assert( !ears.empty() );
VertexList::iterator ear = ears.front();
ears.pop_front();
VertexList::iterator firstAdjacent = ear.previous();
VertexList::iterator secondAdjacent = ear.next();
AddTriangle(triangles, ear, false);
vertices.erase(ear);
ReclassifyVertex(firstAdjacent, ears);
ReclassifyVertex(secondAdjacent, ears);
AdjustForPossibleResultingCollinearity(ears, firstAdjacent, secondAdjacent);
Triangulate_R(ears, triangles);
}
}
void RayTracingEnvironment::AddQuad(
int32 id, const Vector &v1, const Vector &v2, const Vector &v3,
const Vector &v4, // specify vertices in cw or ccw order
const Vector &color)
{
AddTriangle(id,v1,v2,v3,color);
AddTriangle(id+1,v1,v3,v4,color);
}
void RayTracingEnvironment::AddBSPFace(int id,dface_t const &face)
{
if (face.dispinfo!=-1) // displacements must be dealt with elsewhere
return;
texinfo_t *tx =(face.texinfo>=0)?&(texinfo[face.texinfo]):0;
// if (tx && (tx->flags & (SURF_SKY|SURF_NODRAW)))
// return;
if (tx)
{
printf("id %d flags=%x\n",id,tx->flags);
}
printf("side: ");
for(int v=0; v<face.numedges; v++)
{
printf("(%f %f %f) ",XYZ(VertCoord(face,v)));
}
printf("\n");
int ntris=face.numedges-2;
for(int tri=0; tri<ntris; tri++)
{
AddTriangle(id,VertCoord(face,0),VertCoord(face,(tri+1)%face.numedges),
VertCoord(face,(tri+2)%face.numedges),Vector(1,1,1)); //colors[id % NELEMS(colors)]);
}
}
void Mesh::ComputeConvexHull(const double * const pts,
const size_t nPts)
{
ResizePoints(0);
ResizeTriangles(0);
btConvexHullComputer ch;
ch.compute(pts, 3 * sizeof(double), (int) nPts, -1.0, -1.0);
for (int v = 0; v < ch.vertices.size(); v++)
{
AddPoint(Vec3<double>(ch.vertices[v].getX(), ch.vertices[v].getY(), ch.vertices[v].getZ()));
}
const int nt = ch.faces.size();
for (int t = 0; t < nt; ++t)
{
const btConvexHullComputer::Edge * sourceEdge = &(ch.edges[ch.faces[t]]);
int a = sourceEdge->getSourceVertex();
int b = sourceEdge->getTargetVertex();
const btConvexHullComputer::Edge * edge = sourceEdge->getNextEdgeOfFace();
int c = edge->getTargetVertex();
while (c != a)
{
AddTriangle(Vec3<int>(a, b, c));
edge = edge->getNextEdgeOfFace();
b = c;
c = edge->getTargetVertex();
}
}
}
void AddNewShape(const std::vector<std::string> & inputParts, std::vector<std::shared_ptr<CShape>> & figures, std::vector<std::shared_ptr<sf::Shape>> & shapes)
{
if (inputParts.size() == 4 && inputParts[0].compare(std::string("point")) == 0)
{
AddPoint(inputParts, figures, shapes);
}
else if (inputParts.size() == 6 && inputParts[0].compare(std::string("line")) == 0)
{
AddLine(inputParts, figures, shapes);
}
else if (inputParts.size() == 9 && inputParts[0].compare(std::string("triangle")) == 0)
{
AddTriangle(inputParts, figures, shapes);
}
else if (inputParts.size() == 7 && inputParts[0].compare(std::string("rectangle")) == 0)
{
AddRectangle(inputParts, figures, shapes);
}
else if (inputParts.size() == 6 && inputParts[0].compare(std::string("circle")) == 0 && std::stod(inputParts[3]) >= 0)
{
AddCircle(inputParts, figures, shapes);
}
else
{
throw std::invalid_argument("Incorrect command");
}
}
//---------------------------------------------------------
void Poly3D::BuildTriangles()
//---------------------------------------------------------
{
// Calculate the center of the polygon
umWARNING("Poly3D::BuildTriangles()", "TODO: Check from where this is called!");
int Nr=m_xyz.num_rows(), Nc=m_xyz.num_cols();
DMat t_xyz; t_xyz.borrow(Nr,Nc, m_xyz.data());
DVec cent = t_xyz.row_sums() / (double)m_N;
//DVec cent = sum(poly.m_xyz,2) / (double)m_N;
// Sort the points by angle where the angle is
// measured from the center of the polygon
SortPoints(cent);
// now build triangles
DVec a,b; double totalarea = 0.0;
for (int i=1; i<=m_N; ++i) {
a = t_xyz(All,i);
//b = poly.m_xyz(All, mod(i,poly.m_N)+1);
b = t_xyz(All, 1 + (i%m_N));
AddTriangle(cent, a, b);
totalarea += m_areas(i);
}
// Clear the polygon if the total area
// of the polygon is too small.
double tol = 1e-6;
if (totalarea < tol) {
Clear();
}
}
bool CMesh::Init(CGeometry *pOrgGeom, CStrAny sMatSemantic, uint8_t btMatSemanticIndex)
{
ASSERT(pOrgGeom && pOrgGeom->m_ePrimitiveType == CGeometry::PT_TRIANGLELIST);
UINT uiVertices, uiIndices, i;
m_pOrgGeom = pOrgGeom;
uiVertices = pOrgGeom->GetVBVertexCount();
uiIndices = pOrgGeom->GetIBIndexCount();
ASSERT(uiVertices && uiIndices);
CAutoDeleteArrayPtr<TVertex *> pVertices(new TVertex *[uiVertices]);
static CStrAny sPOSITION(ST_CONST, "POSITION");
int iPosIndex, iPosOffset, iVertSize;
int iMatIndex, iMatOffset;
CInputDesc::TInputElement *pPosElem, *pMatElem;
pPosElem = pOrgGeom->m_pInputDesc->GetElementInfo(sPOSITION, 0, &iPosIndex);
ASSERT(pPosElem && pPosElem->m_Type == CInputDesc::T_FLOAT && pPosElem->m_btElements == 3);
iPosOffset = pOrgGeom->m_pInputDesc->GetElementOffset(iPosIndex);
iVertSize = pOrgGeom->m_pInputDesc->GetSize();
if (sMatSemantic.Length()) {
pMatElem = pOrgGeom->m_pInputDesc->GetElementInfo(sMatSemantic, btMatSemanticIndex, &iMatIndex);
ASSERT(pMatElem && pMatElem->m_Type == CInputDesc::T_FLOAT);
iMatOffset = pOrgGeom->m_pInputDesc->GetElementOffset(iMatIndex);
} else
iMatOffset = -1;
UINT uiVertMapFlags = (pOrgGeom->m_pVB->m_uiFlags & CResource::RF_KEEPSYSTEMCOPY) ? CResource::RMF_SYSTEM_ONLY : 0;
uint8_t *pVertex = pOrgGeom->m_pVB->Map(0, uiVertMapFlags);
ASSERT(pVertex);
int iMatID = 0;
for (i = 0; i < uiVertices; i++) {
CVector<3> *pPos = (CVector<3> *) (pVertex + iPosOffset);
if (iMatOffset >= 0)
iMatID = (int) *(float *) (pVertex + iMatOffset);
pVertices[i] = AddVertex(*pPos, iMatID);
pVertex += iVertSize;
}
pOrgGeom->m_pVB->Unmap();
UINT uiIndMapFlags = (pOrgGeom->m_pIB->m_uiFlags & CResource::RF_KEEPSYSTEMCOPY) ? CResource::RMF_SYSTEM_ONLY : 0;
uint16_t *pIndex = (uint16_t *) pOrgGeom->m_pIB->Map(0, uiIndMapFlags);
ASSERT(pIndex);
for (i = 0; i < uiIndices; i += 3) {
ASSERT(pIndex[0] < uiVertices && pIndex[1] < uiVertices && pIndex[2] < uiVertices);
AddTriangle(pVertices[pIndex[0]], pVertices[pIndex[1]], pVertices[pIndex[2]]);
pIndex += 3;
}
pOrgGeom->m_pIB->Unmap();
return true;
}
void Model::AddSphere(float scale)
{
const double M_PI = 3.14159265358979;
int slices = 16, stacks = 8;
uint16_t startIndex = GetNextVertexIndex();
Vector3f northPos(0, scale, 0);
AddVertex(Vertex(northPos, Color(127, 127, 127, 255), 0, 1, northPos));
Vector3f southPos(0, -scale, 0);
AddVertex(Vertex(southPos, Color(127, 127, 127, 255), 0, 0, southPos));
for (int s = 0; s <= slices; s++)
{
double sangle = s * M_PI * 2. / slices;
for (int t = 0; t <= stacks; t++)
{
double tangle = t * M_PI / stacks - M_PI;
Vector3f v = Vector3f(cos(sangle) * sin(tangle), cos(tangle), sin(sangle) * sin(tangle));
AddVertex(Vertex(v * scale, Color(127,127,127,255), float(s), float(t), v));
}
}
startIndex += 2;
// Renumber indices
for (uint16_t s = 0; s < slices; s++)
{
for (uint16_t t = 0; t < stacks; t++)
{
uint16_t s1 = s + 1;
uint16_t t1 = t + 1;
auto get = [&](uint16_t s, uint16_t t){
return s * (stacks + 1) + t + startIndex;
};
AddTriangle(get(s, t),
get(s1, t),
get(s, t1));
AddTriangle(get(s1, t),
get(s1, t1),
get(s, t1));
}
}
}
unsigned int Triangulation::Create(cdt_skeleton cdt_skel){
for(unsigned int i = 0; i < cdt_skel.size(); i++){
StartNewLayer();
for(unsigned int j = 0; j < cdt_skel[i].size(); j++){
AddTriangle(UP);
for(unsigned int k = 0; k < cdt_skel[i][j]; k++) AddTriangle(DOWN);
}
}
//Add cap to top of triangulation
StartNewLayer();
for(unsigned int i = 0; i < LastLayer->size(); i++){
if((*LastLayer)[i]->orientation == DOWN) AddTriangle(UP);
}
StartNewLayer();
Simplex.pop_back();
return 0;
}
BOOL CConvexHullGenerator::FindFirstPairTriangles(CArrayExtremeTrianglePtr* papcTriangles, int iMaxXIndex, int iMinXIndex, int iFarIndex)
{
CHalfSpaceHelper cHalfSpace;
int i;
CExtremeTriangle* pcTriangleUp;
CExtremeTriangle* pcTriangleDown;
SFloat3* psPosition;
pcTriangleUp = AddTriangle(GetPosition(mpsPoints, iStride, iMaxXIndex),
GetPosition(mpsPoints, iStride, iMinXIndex),
GetPosition(mpsPoints, iStride, iFarIndex));
pcTriangleDown = AddTriangle(GetPosition(mpsPoints, iStride, iMaxXIndex),
GetPosition(mpsPoints, iStride, iFarIndex),
GetPosition(mpsPoints, iStride, iMinXIndex));
for (i = 0; i < iNumPoints; i++)
{
psPosition = GetPosition(mpsPoints, iStride, i);
if ((i != iMaxXIndex) && (i != iMinXIndex) && (i != iFarIndex))
{
if (!pcTriangleUp->Contains(psPosition))
{
pcTriangleUp->maiVisible.Add(i);
}
else if (!pcTriangleDown->Contains(psPosition))
{
pcTriangleDown->maiVisible.Add(i);
}
else
{
gcUserError.Set("No triangle contained point");
return FALSE;
}
}
}
//These triangles ARE sorted at this point.
papcTriangles->Add(&pcTriangleUp);
papcTriangles->Add(&pcTriangleDown);
return TRUE;
}
void Geometry::BuildRep1()
{
tr.clear();
for(int i=0;i<face.size();i++)
{
//printf("%d %d %d | ",face[i].x,face[i].y,face[i].z);
AddTriangle(vert[face[i].x],vert[face[i].y],vert[face[i].z]);
}
RebuildTrBB();
}
// TODO: if this is only called to add a fresh start triangle, all vertices must be added
void CBlockOption::AddOneTriangle(
STri * const pTri,
const CObject * const pOb)
{
int i;
// Add the triangle to the block
AddTriangle(pTri);
// Add the vertices to the block
for(i = 0; i < 3; ++i)
AddVertexCheckDup(&pOb->m_pVtx[pTri->pwIdx[i]]);
}
void onea::Lumiere::Generate(vector< LigneShape<float> > &vec)
{
m_shape.clear();
float buf=(M_PI*2)/(float)m_qualite;
for(unsigned int i=0; i < m_qualite; ++i)
{
AddTriangle(sf::Vector2f((float)((float)m_rayon*cos((float)i*buf))
,(float)((float)m_rayon*sin((float)i*buf))) ,
sf::Vector2f((float)((float)m_rayon*cos((float)(i+1)*buf))
,(float)((float)m_rayon*sin((float)(i+1)*buf))), 0, vec);
}
}
void CBlockOption::Add(
const CBlockOption * const pSrc,
const CObject * const pOb)
{
int i;
// Add vertices from job to block
for(i = 0; i < pSrc->nVtxNum; ++i)
AddVertexCheckDup(pSrc->psVtx[i]);
// Add triangles from job to block
for(i = 0; i < pSrc->nTriNum; ++i)
AddTriangle(pSrc->psTri[i]);
}
void TLFFaceImageDescriptor::AddTriangle(TLFTriangle* t)
{
if (t == NULL)
return;
if (t->GetChild(0) == 0 && t->GetParent() != NULL)
{
this->m_List.AddTriangle(t);
}
else
{
for (int i = 0; i < 4; i++)
{
AddTriangle(t->GetChild(i));
}
}
}
/** Draws a wireframe mesh */
void BaseLineRenderer::AddWireframeMesh(const std::vector<ExVertexStruct>& vertices, const std::vector<VERTEX_INDEX>& indices, const D3DXVECTOR4& color, const D3DXMATRIX* world)
{
for(int i=0;i<indices.size();i+=3)
{
D3DXVECTOR3 vx[3];
for(int v=0;v<3;v++)
{
if(world)
D3DXVec3TransformCoord(&vx[v], vertices[indices[i + v]].Position.toD3DXVECTOR3(), world);
else
vx[v] = *vertices[indices[i + v]].Position.toD3DXVECTOR3();
}
AddTriangle(vx[0], vx[1], vx[2], color);
}
}
bool MeshMaterialGraphicsObject::InitializeAsync()
{
assert(_mesh != nullptr);
SetMaterial(material());
for (size_t i = 0; i < _mesh->vertices->size(); i++)
{
AddVertex((*_mesh->vertices)[i], (*_mesh->texCoords)[i], (*_mesh->normals)[i]);
}
for (Vector<3, unsigned> triangle : *_mesh->triangles)
{
AddTriangle(triangle[0], triangle[1], triangle[2]);
}
for (Vector<4, unsigned> quad : *_mesh->quads)
{
AddQuad(quad[0], quad[1], quad[2], quad[3]);
}
return VboGraphicsObject::InitializeAsync();
}
void Game1::Update(unsigned int time)
{
KeyboardState cState = Keyboard::GetState();
MouseState mState = Mouse::GetState();
world->Step(time * 0.001f, 6, 2);
if (cState.IsKeyDown(SDLK_y) && !oldState.IsKeyDown(SDLK_y))
{
AddCube(mState.X, mState.Y, mState.RelX, mState.RelY);
}
if (cState.IsKeyDown(SDLK_x) && !oldState.IsKeyDown(SDLK_x))
{
AddCircle(mState.X, mState.Y, mState.RelX * 10, mState.RelY * 10);
}
if (cState.IsKeyDown(SDLK_c) && !oldState.IsKeyDown(SDLK_c))
{
AddTriangle(mState.X, mState.Y, mState.RelX * 10, mState.RelY * 10);
}
if (cState.IsKeyDown(SDLK_v) && !oldState.IsKeyDown(SDLK_v))
{
AddRope(mState.X, mState.Y);
}
oldState = cState;
}
void onea::Lumiere::AddTriangle(Vector2f pt1, Vector2f pt2, int minimum_wall, vector< LigneShape<float> > &m_wall)
{
int w = minimum_wall;
for(std::vector< LigneShape<float> >::iterator IterWall=m_wall.begin()+minimum_wall; IterWall!=m_wall.end(); ++IterWall,++w)
{
// l1 et l2 sont les positions relatives au centre de la lumière des deux extrémités du mur
sf::Vector2f l1(IterWall->pt1.position.x-m_position.x, IterWall->pt1.position.y-m_position.y);
sf::Vector2f l2(IterWall->pt2.position.x-m_position.x, IterWall->pt2.position.y -m_position.y);
if(l1.x * l1.x + l1.y * l1.y < m_rayon * m_rayon) {
Vector2f i = Intersect(pt1,pt2,sf::Vector2f (0,0),l1);
if (pt1 != i && pt2 != i)
if((pt1.x >= i.x && pt2.x <= i.x) || (pt1.x <= i.x && pt2.x >= i.x))
if((pt1.y >= i.y && pt2.y <= i.y) || (pt1.y <= i.y && pt2.y >= i.y))
if((l1.y >= 0 && i.y >= 0) || (l1.y <= 0 && i.y <= 0))
if((l1.x >= 0 && i.x >= 0) || (l1.x <= 0 && i.x <= 0))
AddTriangle(i, pt2, w, m_wall), pt2 = i;
}
if(l2.x * l2.x + l2.y * l2.y < m_rayon * m_rayon) {
sf::Vector2f i = Intersect(pt1,pt2,sf::Vector2f (0,0),l2);
if (pt1 != i && pt2 != i)
if((pt1.x >= i.x && pt2.x <= i.x) || (pt1.x <= i.x && pt2.x >= i.x))
if((pt1.y >= i.y && pt2.y <= i.y) || (pt1.y <= i.y && pt2.y >= i.y))
if((l2.y >= 0 && i.y >= 0) || (l2.y <= 0 && i.y <= 0))
if((l2.x >= 0 && i.x >= 0) || (l2.x <= 0 && i.x <= 0))
AddTriangle(pt1, i, w, m_wall), pt1 = i;
}
sf::Vector2f m = Collision(l1, l2, sf::Vector2f(0,0), pt1);
sf::Vector2f n = Collision(l1, l2, sf::Vector2f(0,0), pt2);
sf::Vector2f o = Collision(l1, l2, pt1, pt2);
if((m.x != 0 || m.y != 0) && (n.x != 0 || n.y != 0))
pt1 = m, pt2 = n;
else
{
if((m.x != 0 || m.y != 0) && (o.x != 0 || o.y != 0))
AddTriangle(m ,o , w, m_wall), pt1 = o;
if((n.x != 0 || n.y != 0) && (o.x != 0 || o.y != 0))
AddTriangle(o ,n , w, m_wall), pt2 = o;
}
}
float intensity;
m_shape.push_back(Triangle());
m_shape.back().AddPoint(0, 0, sf::Color((int)(m_intensite*m_couleur.r/255),
(int)(m_intensite*m_couleur.g/255),
(int)(m_intensite*m_couleur.b/255)),sf::Color(255,255,255)
);
intensity = m_intensite-sqrt(pt1.x*pt1.x + pt1.y*pt1.y)*m_intensite/m_rayon;
m_shape.back().AddPoint(pt1.x, pt1.y, sf::Color((int)(intensity*m_couleur.r/255),
(int)(intensity*m_couleur.g/255),
(int)(intensity*m_couleur.b/255)),sf::Color(255,255,255));
intensity = m_intensite-sqrt(pt2.x*pt2.x + pt2.y*pt2.y)*m_intensite/m_rayon;
m_shape.back().AddPoint(pt2.x, pt2.y, sf::Color((int)(intensity*m_couleur.r/255),
(int)(intensity*m_couleur.g/255),
(int)(intensity*m_couleur.b/255)),sf::Color(255,255,255));
m_shape.back().setPosition(m_position);
}
bool TLFFaceImageDescriptor::CreateTriangles(int depth)
{
if (this->IsEmpty())
return false;
for (int i = 0; i < 32; i++)
{
if (this->m_Triangles[i] != NULL)
{
delete this->m_Triangles[i];
this->m_Triangles[i] = NULL;
}
}
this->m_List.Clear();
// FILE* f = fopen("index.txt", "r+t");
int d = depth;
// int k,i2,i3;
for (int i = 0; i < 22;i++)
{
// fscanf(f,"%d\t%d\t%d\t%d\n", &k,&i1,&i2,&i3);
m_tindex[i] = gtri[i];
m_Triangles[i] = new TLFTriangle(m_points[gtri[i].v1], m_points[gtri[i].v2], m_points[gtri[i].v3], NULL, d, i);
AddTriangle(m_Triangles[i]);
}
/*
m_Triangles[0] = new TLFTriangle(m_points[0], m_points[18], m_points[19], NULL, d, 0);
fprintf(f,"%d\t%d\t%d\t%d\n", 0,0,18,19);
m_Triangles[1] = new TLFTriangle(m_points[0], m_points[19], m_points[1], NULL, d, 1);
fprintf(f,"%d\t%d\t%d\t%d\n", 1,0,19,1);
m_Triangles[2] = new TLFTriangle(m_points[1], m_points[19], m_points[20], NULL, d, 2);
fprintf(f,"%d\t%d\t%d\t%d\n", 2,1,19,20);
m_Triangles[3] = new TLFTriangle(m_points[2], m_points[21], m_points[22], NULL, d, 3);
fprintf(f,"%d\t%d\t%d\t%d\n", 3,2,21,22);
m_Triangles[4] = new TLFTriangle(m_points[2], m_points[22], m_points[3], NULL, d, 4);
fprintf(f,"%d\t%d\t%d\t%d\n", 4,2,22,3);
m_Triangles[5] = new TLFTriangle(m_points[3], m_points[22], m_points[23], NULL, d, 5);
fprintf(f,"%d\t%d\t%d\t%d\n", 5,3,22,23);
m_Triangles[6] = new TLFTriangle(m_points[16], m_points[6], m_points[8], NULL, d, 6);
fprintf(f,"%d\t%d\t%d\t%d\n", 6,16,6,8);
m_Triangles[7] = new TLFTriangle(m_points[20], m_points[4], m_points[5], NULL, d, 7);
fprintf(f,"%d\t%d\t%d\t%d\n", 7,20,4,5);
m_Triangles[8] = new TLFTriangle(m_points[20], m_points[5], m_points[21], NULL, d, 8);
fprintf(f,"%d\t%d\t%d\t%d\n", 8,20,5,21);
m_Triangles[9] = new TLFTriangle(m_points[21], m_points[5], m_points[6], NULL, d, 9);
fprintf(f,"%d\t%d\t%d\t%d\n", 9,21,5,6);
m_Triangles[10] = new TLFTriangle(m_points[10], m_points[7], m_points[4], NULL, d, 10);
fprintf(f,"%d\t%d\t%d\t%d\n", 10,10,7,4);
m_Triangles[11] = new TLFTriangle(m_points[7], m_points[4], m_points[5], NULL, d, 11);
fprintf(f,"%d\t%d\t%d\t%d\n", 11,7,4,5);
m_Triangles[12] = new TLFTriangle(m_points[7], m_points[5], m_points[8], NULL, d, 12);
fprintf(f,"%d\t%d\t%d\t%d\n", 12,7,5,8);
m_Triangles[13] = new TLFTriangle(m_points[8], m_points[5], m_points[6], NULL, d, 13);
fprintf(f,"%d\t%d\t%d\t%d\n", 13,8,5,6);
m_Triangles[14] = new TLFTriangle(m_points[7], m_points[13], m_points[8], NULL, d, 14);
fprintf(f,"%d\t%d\t%d\t%d\n", 14,7,13,8);
m_Triangles[15] = new TLFTriangle(m_points[1], m_points[20], m_points[4], NULL, d, 15);
fprintf(f,"%d\t%d\t%d\t%d\n", 15,1,20,4);
m_Triangles[16] = new TLFTriangle(m_points[2], m_points[21], m_points[6], NULL, d, 16);
fprintf(f,"%d\t%d\t%d\t%d\n", 16,2,21,6);
m_Triangles[17] = new TLFTriangle(m_points[0], m_points[1], m_points[4], NULL, d, 17);
fprintf(f,"%d\t%d\t%d\t%d\n", 17,0,1,4);
m_Triangles[18] = new TLFTriangle(m_points[2], m_points[3], m_points[6], NULL, d, 18);
fprintf(f,"%d\t%d\t%d\t%d\n", 18,2,3,6);
m_Triangles[19] = new TLFTriangle(m_points[23], m_points[3], m_points[17], NULL, d, 19);
fprintf(f,"%d\t%d\t%d\t%d\n", 19,23,3,17);
m_Triangles[20] = new TLFTriangle(m_points[3], m_points[6], m_points[17], NULL, d, 20);
fprintf(f,"%d\t%d\t%d\t%d\n", 20,3,6,17);
m_Triangles[21] = new TLFTriangle(m_points[17], m_points[6], m_points[16], NULL, d, 21);
fprintf(f,"%d\t%d\t%d\t%d\n", 21,17,6,16);
m_Triangles[22] = new TLFTriangle(m_points[16], m_points[8], m_points[15], NULL, d, 22);
fprintf(f,"%d\t%d\t%d\t%d\n", 2,16,8,15);
m_Triangles[23] = new TLFTriangle(m_points[15], m_points[8], m_points[14], NULL, d, 23);
fprintf(f,"%d\t%d\t%d\t%d\n", 23,15,8,14);
m_Triangles[24] = new TLFTriangle(m_points[13], m_points[8], m_points[14], NULL, d, 24);
fprintf(f,"%d\t%d\t%d\t%d\n", 24,13,8,14);
m_Triangles[25] = new TLFTriangle(m_points[7], m_points[12], m_points[13], NULL, d, 25);
fprintf(f,"%d\t%d\t%d\t%d\n", 25,7,12,13);
m_Triangles[26] = new TLFTriangle(m_points[7], m_points[12], m_points[13], NULL, d, 26);
fprintf(f,"%d\t%d\t%d\t%d\n", 26,7,12,13);
m_Triangles[27] = new TLFTriangle(m_points[7], m_points[11], m_points[12], NULL, d, 27);
fprintf(f,"%d\t%d\t%d\t%d\n", 27,7,11,12);
m_Triangles[28] = new TLFTriangle(m_points[7], m_points[10], m_points[11], NULL, d, 28);
fprintf(f,"%d\t%d\t%d\t%d\n", 28,7,10,11);
m_Triangles[29] = new TLFTriangle(m_points[4], m_points[10], m_points[9], NULL, d, 29);
fprintf(f,"%d\t%d\t%d\t%d\n", 29,4,10,9);
m_Triangles[30] = new TLFTriangle(m_points[4], m_points[9], m_points[0], NULL, d, 30);
fprintf(f,"%d\t%d\t%d\t%d\n", 30,4,9,0);
m_Triangles[31] = new TLFTriangle(m_points[18], m_points[0], m_points[9], NULL, d, 31);
fprintf(f,"%d\t%d\t%d\t%d\n", 31,18,0,9);
fclose(f);
f = fopen("index22.txt", "r+t");
for (int i = 0; i < 32; i++)
{
fscanf(f, "%d\t%d\t%d\t%d\n", &m_tindex[i].idx, &m_tindex[i].v1, &m_tindex[i].v2, &m_tindex[i].v3);
}
*/
// fclose(f);
return true;
}
void CMesh::CollapseEdge(TEdge *pEdge, bool bRemoveSecond)
{
TVertex *p2Remain, *p2Remove;
CArray<TVertex *> arrInvalVerts;
TEdgeHash hashEvaluatedEdges;
int i, iTri;
ASSERT(pEdge);
p2Remain = pEdge->m_pVertices[!bRemoveSecond];
p2Remove = pEdge->m_pVertices[bRemoveSecond];
for (i = 0; i < p2Remove->m_pTriangles->m_iCount; i++) {
TVertex *pOther0, *pOther1;
p2Remove->m_pTriangles->At(i)->GetOtherVertices(p2Remove, pOther0, pOther1);
arrInvalVerts.Append(pOther0);
arrInvalVerts.Append(pOther1);
}
ASSERT(pEdge->m_pTriangles[0]);
// Order of removal is important, if we remove the first one first and it's the only one left,
// the edge will get deleted and the attempt to remove the other one will crash
RemoveTriangle(pEdge->m_pTriangles[1]);
RemoveTriangle(pEdge->m_pTriangles[0]);
ASSERT(!GetEdge(p2Remain, p2Remove));
/*
#ifdef _DEBUG
{
for (int i = 0; i < p2Remove->m_pTriangles->m_iCount; i++) {
TVertex *pVert0, *pVert1;
TTriangle *pTri = p2Remove->m_pTriangles->At(i);
pTri->GetOtherVertices(p2Remove, pVert0, pVert1);
TTriangle kTestTri(p2Remain, pVert0, pVert1);
TTriangleHash::TIter it = m_hashTriangles.Find(&kTestTri);
ASSERT(!it);
if (it)
TEdge *pE = GetEdge(pVert0, pVert1);
}
}
#endif
*/
while (p2Remove->m_pTriangles->m_iCount > 0) {
TVertex *pVert0, *pVert1;
TTriangle *pTri = p2Remove->m_pTriangles->At(p2Remove->m_pTriangles->m_iCount - 1);
pTri->GetOtherVertices(p2Remove, pVert0, pVert1);
int iTriIndex = pTri->m_iIndex;
RemoveTriangle(pTri);
AddTriangle(p2Remain, pVert0, pVert1, iTriIndex);
}
m_hashVertices.RemoveValue(p2Remove);
delete p2Remove;
for (i = 0; i < arrInvalVerts.m_iCount; i++) {
for (iTri = 0; iTri < arrInvalVerts[i]->m_pTriangles->m_iCount; iTri++) {
TVertex *pOther[2];
TEdge *pEdge;
int iVert;
arrInvalVerts[i]->m_pTriangles->At(iTri)->GetOtherVertices(arrInvalVerts[i], pOther[0], pOther[1]);
for (iVert = 0; iVert < 2; iVert++) {
pEdge = GetEdge(arrInvalVerts[i], pOther[iVert]);
if (hashEvaluatedEdges.Find(pEdge))
continue;
EvaluateEdge(pEdge, false);
EvaluateEdge(pEdge, true);
hashEvaluatedEdges.Add(pEdge);
}
}
}
}
void Model::AddSolidColorBox(float x1, float y1, float z1,
float x2, float y2, float z2,
Color c)
{
float t;
if(x1 > x2)
{
t = x1;
x1 = x2;
x2 = t;
}
if(y1 > y2)
{
t = y1;
y1 = y2;
y2 = t;
}
if(z1 > z2)
{
t = z1;
z1 = z2;
z2 = t;
}
// Cube vertices and their normals.
Vector3f CubeVertices[][3] =
{
Vector3f(x1, y2, z1), Vector3f(z1, x1), Vector3f(0.0f, 1.0f, 0.0f),
Vector3f(x2, y2, z1), Vector3f(z1, x2), Vector3f(0.0f, 1.0f, 0.0f),
Vector3f(x2, y2, z2), Vector3f(z2, x2), Vector3f(0.0f, 1.0f, 0.0f),
Vector3f(x1, y2, z2), Vector3f(z2, x1), Vector3f(0.0f, 1.0f, 0.0f),
Vector3f(x1, y1, z1), Vector3f(z1, x1), Vector3f(0.0f, -1.0f, 0.0f),
Vector3f(x2, y1, z1), Vector3f(z1, x2), Vector3f(0.0f, -1.0f, 0.0f),
Vector3f(x2, y1, z2), Vector3f(z2, x2), Vector3f(0.0f, -1.0f, 0.0f),
Vector3f(x1, y1, z2), Vector3f(z2, x1), Vector3f(0.0f, -1.0f, 0.0f),
Vector3f(x1, y1, z2), Vector3f(z2, y1), Vector3f(-1.0f, 0.0f, 0.0f),
Vector3f(x1, y1, z1), Vector3f(z1, y1), Vector3f(-1.0f, 0.0f, 0.0f),
Vector3f(x1, y2, z1), Vector3f(z1, y2), Vector3f(-1.0f, 0.0f, 0.0f),
Vector3f(x1, y2, z2), Vector3f(z2, y2), Vector3f(-1.0f, 0.0f, 0.0f),
Vector3f(x2, y1, z2), Vector3f(z2, y1), Vector3f(1.0f, 0.0f, 0.0f),
Vector3f(x2, y1, z1), Vector3f(z1, y1), Vector3f(1.0f, 0.0f, 0.0f),
Vector3f(x2, y2, z1), Vector3f(z1, y2), Vector3f(1.0f, 0.0f, 0.0f),
Vector3f(x2, y2, z2), Vector3f(z2, y2), Vector3f(1.0f, 0.0f, 0.0f),
Vector3f(x1, y1, z1), Vector3f(x1, y1), Vector3f(0.0f, 0.0f, -1.0f),
Vector3f(x2, y1, z1), Vector3f(x2, y1), Vector3f(0.0f, 0.0f, -1.0f),
Vector3f(x2, y2, z1), Vector3f(x2, y2), Vector3f(0.0f, 0.0f, -1.0f),
Vector3f(x1, y2, z1), Vector3f(x1, y2), Vector3f(0.0f, 0.0f, -1.0f),
Vector3f(x1, y1, z2), Vector3f(x1, y1), Vector3f(0.0f, 0.0f, 1.0f),
Vector3f(x2, y1, z2), Vector3f(x2, y1), Vector3f(0.0f, 0.0f, 1.0f),
Vector3f(x2, y2, z2), Vector3f(x2, y2), Vector3f(0.0f, 0.0f, 1.0f),
Vector3f(x1, y2, z2), Vector3f(x1, y2), Vector3f(0.0f, 0.0f, 1.0f)
};
uint16_t startIndex = GetNextVertexIndex();
enum
{
CubeVertexCount = sizeof(CubeVertices) / sizeof(CubeVertices[0]),
CubeIndexCount = sizeof(CubeIndices) / sizeof(CubeIndices[0])
};
for(int v = 0; v < CubeVertexCount; v++)
{
AddVertex(Vertex(CubeVertices[v][0], c, CubeVertices[v][1].x, CubeVertices[v][1].y, CubeVertices[v][2]));
}
// Renumber indices
for(int i = 0; i < CubeIndexCount / 3; i++)
{
AddTriangle(CubeIndices[i * 3] + startIndex,
CubeIndices[i * 3 + 1] + startIndex,
CubeIndices[i * 3 + 2] + startIndex);
}
}
int LoadSU2Elements(FILE *FilHdl, Mesh *Msh)
{
int ref=1;
char str[1024];
int iMark, NbrMark=0, CptElt;
int iElt, NbrElt=0, typ, is[8], swi[8], buf, s, idx, res;
Msh->NbrTri = Msh->NbrTet = Msh->NbrHex = Msh->NbrEfr = Msh->NbrQua = Msh->NbrPyr = Msh->NbrPri = 0;
rewind(FilHdl);
do
{
res = fscanf(FilHdl, "%s", str);
}while( (res != EOF) && strcmp(str, "NELEM=") );
fscanf(FilHdl, "%d", &NbrElt);
fgets (str, sizeof str, FilHdl);
idx=0;
for (iElt=0; iElt<NbrElt; iElt++) {
fscanf(FilHdl, "%d", &typ);
if ( typ == SU2_TRIANGLE ) {
for (s=0; s<3; s++) {
fscanf(FilHdl, "%d", &buf);
swi[s] = buf+1;
if ( swi[s] > Msh->NbrVer ) {
printf(" ## ERROR LoadSU2Elements: vertex out of bound (vid=%d)\n", swi[s]);
return 0;
}
}
fscanf(FilHdl, "%d", &buf);
Msh->NbrTri++;
if ( Msh->NbrTri > Msh->MaxNbrTri ) {
printf(" ## ERROR LoadSU2Elements: triangle out of bound (tid=%d, max=%d)\n", Msh->NbrTri, Msh->MaxNbrTri);
return 0;
}
switchTriIdx(swi,is);
AddTriangle(Msh,Msh->NbrTri,is,ref);
}
else if ( typ == SU2_TETRAHEDRAL ) {
for (s=0; s<4; s++) {
fscanf(FilHdl, "%d", &buf);
swi[s] = buf+1;
}
idx++;
Msh->NbrTet++;
if ( Msh->NbrTet > Msh->MaxNbrTet ) {
printf(" ## ERROR LoadSU2Elements: tetra out of bound (tid=%d)\n", Msh->NbrTet);
return 0;
}
switchTetIdx(swi,is);
AddTetrahedron(Msh,Msh->NbrTet,is,ref);
}
else if ( typ == SU2_HEXAHEDRAL ) {
for (s=0; s<8; s++) {
fscanf(FilHdl, "%d", &buf);
swi[s] = buf+1;
}
fscanf(FilHdl, "%d", &idx);
Msh->NbrHex++;
if ( Msh->NbrHex > Msh->MaxNbrHex ) {
printf(" ## ERROR LoadSU2Elements: hexahedron out of bound (hid=%d)\n", Msh->NbrHex);
return 0;
}
switchHexIdx(swi,is);
AddHexahedron(Msh,Msh->NbrHex,is,ref);
}
else if ( typ == SU2_PYRAMID ) {
for (s=0; s<5; s++) {
fscanf(FilHdl, "%d", &buf);
swi[s] = buf+1;
is[s] = buf+1;
}
fscanf(FilHdl, "%d", &idx);
Msh->NbrPyr++;
if ( Msh->NbrPyr > Msh->MaxNbrPyr ) {
printf(" ## ERROR LoadSU2Elements: pyramid out of bound (id=%d)\n", Msh->NbrPyr);
return 0;
}
//switchPyrIdx(swi,is);
AddPyramid(Msh,Msh->NbrPyr,is,ref);
int i=Msh->NbrPyr;
if ( i== 1 )
printf("PYR %d : %d %d %d %d %d\n", i, Msh->Pyr[i][0], Msh->Pyr[i][1], Msh->Pyr[i][2], Msh->Pyr[i][3], Msh->Pyr[i][4]);
}
else if ( typ == SU2_RECTANGLE ) {
for (s=0; s<4; s++) {
fscanf(FilHdl, "%d", &buf);
swi[s] = buf+1;
}
Msh->NbrQua++;
if ( Msh->NbrQua > Msh->MaxNbrQua ) {
printf(" ## ERROR LoadSU2Elements: quad out of bound (id=%d)\n", Msh->NbrQua);
return 0;
}
switchQuaIdx(swi,is);
//DefaultQuadrilateral(Msh,Msh->NbrQua,&Msh->Qua[NbrQua],is,ref);
AddQuadrilateral(Msh,Msh->NbrQua,is,ref);
}
else if ( typ == SU2_WEDGE ) {
for (s=0; s<6; s++) {
fscanf(FilHdl, "%d", &buf);
swi[s] = buf+1;
is[s] = buf+1;
}
fscanf(FilHdl, "%d", &idx);
Msh->NbrPri++;
if ( Msh->NbrPri > Msh->MaxNbrPri ) {
printf(" ## ERROR LoadSU2Elements: prism out of bound (id=%d)\n", Msh->NbrPri);
return 0;
}
//switchPriIdx(swi,is);
//DefaultPrism(Msh,Msh->NbrPri,&Msh->Pri[NbrPri],is,ref);
AddPrism(Msh,Msh->NbrPri,is,ref);
}
//else if ( typ == SU2_LINE ) {
// for (s=0; s<2; s++) {
// fscanf(FilHdl, "%d", &buf);
// swi[s] = buf+1;
// }
// NbrEfr++;
//
// if ( NbrEfr > Msh->MaxNbrEfr ) {
// printf(" ## ERROR LoadSU2Elements: boundary edge out of bound (id=%d, max=%d)\n", NbrEfr,Msh->MaxNbrEfr );
// return 0;
// }
//
// DefaultBdyEdge(Msh,Msh->NbrEfr,&Msh->Efr[NbrEfr],swi,ref);
//}
//else if ( typ == SU2_LINEP2 ) {
//
// fscanf(FilHdl, "%d %d %d", &swi[0], &swi[1], &swi[2]);
// for (s=0; s<3; s++)
// swi[s]++;
//
// NbrP2Efr++;
//
// if ( NbrP2Efr > Msh->MaxNbrP2Efr ) {
// printf(" ## ERROR LoadSU2Elements: P2 boundary edge out of bound (id=%d, max=%d)\n", NbrP2Efr,Msh->MaxNbrP2Efr );
// return 0;
// }
//
// switchP2EfrIdx(swi,is);
// NbrEfr++;
// if ( NbrEfr > Msh->MaxNbrEfr ) {
// printf(" ## ERROR LoadSU2Elements: P1 boundary edge out of bound (id=%d, max=%d)\n", NbrEfr,Msh->MaxNbrEfr );
// return 0;
// }
// DefaultBdyEdge(Msh,NbrEfr,&Msh->Efr[NbrEfr],is,ref);
// DefaultP2BdyEdge(Msh,NbrP2Efr,&Msh->Efr[NbrP2Efr],is[2],NbrEfr,&Msh->Efr[NbrEfr]);
//}
//else if ( typ == SU2_TRIANGLEP2 ) {
//
// //fscanf(FilHdl, "%d %d %d %d %d %d", &swi[0],&swi[3],&swi[1],&swi[4],&swi[2],&swi[5]);
// //fscanf(FilHdl, "%d %d %d %d %d %d", &swi[3],&swi[0],&swi[4],&swi[1],&swi[5],&swi[2]);
// //fscanf(FilHdl, "%d %d %d %d %d %d", &swi[0],&swi[1],&swi[2],&swi[3],&swi[4],&swi[5]);
// fscanf(FilHdl, "%d %d %d %d %d %d", &swi[0],&swi[3],&swi[1],&swi[5],&swi[4],&swi[2]);
// for (s=0; s<6; s++)
// swi[s]++;
//
//
// NbrP2Tri++;
//
// if ( NbrP2Tri > Msh->MaxNbrP2Tri ) {
// printf(" ## ERROR LoadSU2Elements: P2 triangle out of bound (id=%d, max=%d)\n", NbrP2Tri,Msh->MaxNbrP2Tri );
// return 0;
// }
//
// switchP2TriIdx(swi,is);
//
//
// NbrTri++;
//
// if ( NbrTri > Msh->MaxNbrTri ) {
// printf(" ## ERROR LoadSU2Elements: P1 triangle out of bound (id=%d, max=%d)\n", NbrTri,Msh->MaxNbrTri );
// return 0;
// }
//
// DefaultTriangle(Msh,NbrTri,&Msh->Tri[NbrTri],is,ref);
// DefaultP2Triangle(Msh,NbrP2Tri,&Msh->P2Tri[NbrP2Tri],&is[3],NbrTri,&Msh->Tri[NbrTri]);
//
//}
//
else {
printf(" ## ERROR : Unknown element type %d\n", typ);
return 0;
}
fgets (str, sizeof str, FilHdl);
}//for iElt
//--- Read boundary elements
//rewind(FilHdl);
//do
//{
// res = fscanf(FilHdl, "%s", str);
//}while( (res != EOF) && strcmp(str, "NMARK=") );
//fscanf(FilHdl, "%d", &NbrMark);
//fgets (str, sizeof str, FilHdl);
rewind(FilHdl);
NbrMark = GetSU2KeywordValue (FilHdl, "NMARK=");
for (iMark=1; iMark<=NbrMark; iMark++) {
GetSU2KeywordValueStr (FilHdl, "MARKER_TAG=", str);
//printf(" Tag %s becomes reference %d\n", str, iMark);
if ( !strcmp(str,"SEND_RECEIVE") ) {
printf(" Tag %s was ignored.\n", str);
continue;
}
CptElt = GetSU2KeywordValue (FilHdl, "MARKER_ELEMS=");
for (iElt=0; iElt<CptElt; iElt++) {
fscanf(FilHdl, "%d", &typ);
if ( typ == SU2_TRIANGLE ) {
for (s=0; s<3; s++) {
fscanf(FilHdl, "%d", &buf);
swi[s] = buf+1;
}
Msh->NbrTri++;
if ( Msh->NbrTri > Msh->MaxNbrTri ) {
printf(" ## ERROR LoadSU2Elements: triangle out of bound (tid=%d, max=%d)\n", Msh->NbrTri, Msh->MaxNbrTri);
return 0;
}
switchTriIdx(swi,is);
AddTriangle(Msh,Msh->NbrTri,is,iMark);
}
else if ( typ == SU2_RECTANGLE ) {
for (s=0; s<4; s++) {
fscanf(FilHdl, "%d", &buf);
swi[s] = buf+1;
}
Msh->NbrQua++;
if ( Msh->NbrQua > Msh->MaxNbrQua ) {
printf(" ## ERROR LoadSU2Elements: quad out of bound (id=%d)\n", Msh->NbrQua);
return 0;
}
switchQuaIdx(swi,is);
//DefaultQuadrilateral(Msh,Msh->NbrQua,&Msh->Qua[NbrQua],is,iMark);
AddQuadrilateral(Msh,Msh->NbrQua,is,iMark);
}
else if ( typ == SU2_LINE ) {
for (s=0; s<2; s++) {
fscanf(FilHdl, "%d", &buf);
swi[s] = buf+1;
}
Msh->NbrEfr++;
if ( Msh->NbrEfr > Msh->MaxNbrEfr ) {
printf(" ## ERROR LoadSU2Elements: boundary edge out of bound (id=%d, max=%d)\n", Msh->NbrEfr, Msh->MaxNbrEfr);
return 0;
}
//DefaultBdyEdge(Msh,Msh->NbrEfr,&Msh->Efr[NbrEfr],swi,iMark);
AddEdge(Msh,Msh->NbrEfr,swi,iMark);
}
//else if ( typ == SU2_LINEP2 ) {
//
// fscanf(FilHdl, "%d %d %d", &swi[0], &swi[2], &swi[1]);
// for (s=0; s<3; s++)
// swi[s]++;
//
// NbrP2Efr++;
// if ( NbrP2Efr > Msh->MaxNbrP2Efr ) {
// printf(" ## ERROR LoadSU2Elements: P2 boundary edge out of bound (id=%d, max=%d)\n", NbrP2Efr,Msh->MaxNbrP2Efr );
// return 0;
// }
//
// switchP2EfrIdx(swi,is);
//
// NbrEfr++;
// if ( NbrEfr > Msh->MaxNbrEfr ) {
// printf(" ## ERROR LoadSU2Elements: P1 boundary edge out of bound (id=%d, max=%d)\n", NbrEfr,Msh->MaxNbrEfr );
// return 0;
// }
//
// DefaultBdyEdge(Msh,NbrEfr,&Msh->Efr[NbrEfr],is,iMark);
// DefaultP2BdyEdge(Msh,NbrP2Efr,&Msh->Efr[NbrP2Efr],is[2],NbrEfr,&Msh->Efr[NbrEfr]);
//}
else {
printf(" ## ERROR : Unknown element type %d\n", typ);
return 0;
}
fgets (str, sizeof str, FilHdl);
}
}
return 1;
}
void CXMLParser::TraverseGetInformation(TiXmlElement* root)
{
TiXmlElement *childroot=root->FirstChildElement();
while(childroot!=NULL)
{
if(strcmp(childroot->Value(),"VertexBuffer")==0)
{
char *pointStr=(char *)childroot->FirstChildElement()->GetText();
AddPoint(pointStr);
char *normalStr=(char *)childroot->FirstChildElement()->NextSiblingElement()->GetText();
AddNormals(normalStr);
}
else if(strcmp(childroot->Value(),"Faces")==0)
{
TiXmlElement *triangleElem=childroot->FirstChildElement();
while (triangleElem!=NULL)
{
if(strcmp(triangleElem->Value(),"Face")==0)
{
TiXmlAttribute *triangleAttribute=triangleElem->FirstAttribute();
while(triangleAttribute!=NULL)
{
if(strcmp(triangleAttribute->Name(),"triangles")==0)
{
char *triangleStr=(char *)triangleAttribute->Value();
if(IsTriangleStrWithSplit(triangleStr)==true)
{
AddTriangle(triangleStr);
}
else
{
AddIdTriangle(triangleStr);
}
}
if(strcmp(triangleAttribute->Name(),"strips")==0)
{
char *stripStr=(char *)triangleAttribute->Value();
AddStrips(stripStr);
}
if(strcmp(triangleAttribute->Name(),"fans")==0)
{
char *fanStr=(char *)triangleAttribute->Value();
AddFans(fanStr);
}
triangleAttribute=triangleAttribute->Next();
}
}
triangleElem=triangleElem->NextSiblingElement();
}
}
else if(strcmp(childroot->Value(),"Edges")==0)
{
TiXmlElement *polyElem=childroot->FirstChildElement();
while(polyElem!=NULL)
{
if(strcmp(polyElem->Value(),"Polyline")==0)
{
char *polyStr=(char *)polyElem->FirstAttribute()->Value();
AddPoly(polyStr);
}
polyElem=polyElem->NextSiblingElement();
}
}
/*else if (strcmp(childroot->Value(),"PolygonalLOD")==0)
{
TiXmlElement *triangleElem=childroot->FirstChildElement()->FirstChildElement();
while (triangleElem!=NULL)
{
if(strcmp(triangleElem->Value(),"Face")==0)
{
TiXmlAttribute *triangleAttribute=triangleElem->FirstAttribute();
while(triangleAttribute!=NULL)
{
if(strcmp(triangleAttribute->Name(),"triangles")==0)
{
char *triangleStr=(char *)triangleAttribute->Value();
if(IsTriangleStrWithSplit(triangleStr)==true)
{
AddTriangle(triangleStr);
}
else
{
AddIdTriangle(triangleStr);
}
}
if(strcmp(triangleAttribute->Name(),"strips")==0)
{
char *stripStr=(char *)triangleAttribute->Value();
AddStrips(stripStr);
}
if(strcmp(triangleAttribute->Name(),"fans")==0)
{
char *fanStr=(char *)triangleAttribute->Value();
AddFans(fanStr);
}
triangleAttribute=triangleAttribute->Next();
}
}
triangleElem=triangleElem->NextSiblingElement();
}
}*/
childroot=childroot->NextSiblingElement();
}
}
void DebugRenderer::AddTriangle(const Vector3& v1, const Vector3& v2, const Vector3& v3, const Color& color, bool depthTest)
{
AddTriangle(v1, v2, v3, color.ToUInt(), depthTest);
}
void DebugRenderer::AddPolygon(const Vector3& v1, const Vector3& v2, const Vector3& v3, const Vector3& v4, unsigned color, bool depthTest)
{
AddTriangle(v1, v2, v3, color, depthTest);
AddTriangle(v3, v4, v1, color, depthTest);
}
void Graphics_LayerRenderer(bool isOpenGLMode)
{
StartGraphicsTest();
SetGLEnable(isOpenGLMode);
asd::Log* log = asd::Log_Imp::Create(u"graphics.html", u"レイヤー");
auto window = asd::Window_Imp::Create(640, 480, asd::ToAString(u"レイヤー").c_str(), log, false, asd::WindowPositionType::Default, isOpenGLMode ? asd::GraphicsDeviceType::OpenGL : asd::GraphicsDeviceType::DirectX11, asd::ColorSpaceType::LinearSpace, false);
ASSERT_TRUE(window != nullptr);
auto synchronizer = std::make_shared<asd::Synchronizer>();
auto file = asd::File_Imp::Create(synchronizer);
ASSERT_TRUE(file != nullptr);
asd::GraphicsOption go;
go.IsFullScreen = false;
go.IsReloadingEnabled = false;
go.ColorSpace = asd::ColorSpaceType::LinearSpace;
go.GraphicsDevice = isOpenGLMode ? asd::GraphicsDeviceType::OpenGL : asd::GraphicsDeviceType::DirectX11;
auto graphics = asd::Graphics_Imp::Create(window, isOpenGLMode ? asd::GraphicsDeviceType::OpenGL : asd::GraphicsDeviceType::DirectX11, log, file, go);
ASSERT_TRUE(graphics != nullptr);
auto renderer = new asd::LayerRenderer(graphics);
ASSERT_TRUE(renderer != nullptr);
auto texture = graphics->CreateTexture2D(asd::ToAString(u"Data/Texture/Sample1.png").c_str());
ASSERT_TRUE(texture != nullptr);
int32_t time = 0;
while (window->DoEvent())
{
graphics->Begin();
graphics->Clear(true, false, asd::Color(0, 0, 0, 255));
{
asd::Vector2DF lpos[4];
lpos[0].X = 0;
lpos[0].Y = 0;
lpos[1].X = 600;
lpos[1].Y = 0;
lpos[2].X = 640;
lpos[2].Y = 480;
lpos[3].X = 0;
lpos[3].Y = 440;
renderer->SetWindowSize(asd::Vector2DI(640, 480));
renderer->SetTexture(texture.get());
renderer->SetLayerPosition(lpos);
}
{
asd::Vector2DF positions[4];
asd::Color colors[4];
asd::Vector2DF uvs[4];
colors[0] = asd::Color(255, 255, 255, 255);
colors[1] = asd::Color(255, 255, 255, 255);
colors[2] = asd::Color(255, 255, 255, 255);
positions[0].X = 0.0f;
positions[0].Y = 0.0f;
positions[1].X = 1.0f;
positions[1].Y = 0.0f;
positions[2].X = 1.0f;
positions[2].Y = 1.0f;
uvs[0].X = 0;
uvs[0].Y = 0;
uvs[1].X = 1;
uvs[1].Y = 0;
uvs[2].X = 1;
uvs[2].Y = 1;
renderer->AddTriangle(positions, colors, uvs);
}
{
asd::Vector2DF positions[4];
asd::Color colors[4];
asd::Vector2DF uvs[4];
colors[0] = asd::Color(255, 255, 255, 255);
colors[1] = asd::Color(255, 255, 255, 255);
colors[2] = asd::Color(255, 255, 255, 255);
positions[0].X = 0.0f;
positions[0].Y = 0.0f;
positions[1].X = 0.5f;
positions[1].Y = 1.0f;
positions[2].X = 0.0f;
positions[2].Y = 0.5f;
uvs[0].X = 0;
uvs[0].Y = 0;
uvs[1].X = 1;
uvs[1].Y = 1;
uvs[2].X = 0;
uvs[2].Y = 1;
renderer->AddTriangle(positions, colors, uvs);
}
renderer->DrawCache();
renderer->ClearCache();
graphics->Present();
graphics->End();
if (time == 10)
{
SAVE_SCREEN_SHOT(graphics, 0);
}
if (time == 11)
{
window->Close();
}
time++;
}
texture.reset();
renderer->Release();
graphics->Release();
file->Release();
window->Release();
delete log;
}
CShpereMeshNode::CShpereMeshNode(float fRadius, uint uSlices, uint uStacks)
:m_fRadius(fRadius), m_uSlices(uSlices), m_uStacks(uStacks)
{
m_uVertNum = uSlices * uStacks * 6;
float drho = (float)(3.141592653589) / (float)uSlices;
float dtheta = 2.0f * (float)(3.141592653589) / (float)uSlices;
float ds = 1.0f / (float)uSlices;
float dt = 1.0f / (float)uSlices;
float t = 1.0f;
float s = 0.0f;
uint i, j; // Looping variables
for (i = 0; i < uSlices; i++)
{
float rho = (float)i * drho;
float srho = (float)(sin(rho));
float crho = (float)(cos(rho));
float srhodrho = (float)(sin(rho + drho));
float crhodrho = (float)(cos(rho + drho));
s = 0.0f;
CVector3 vVertex[4];
CVector3 vNormal[4];
CVector2 vTexture[4];
for (j = 0; j < uSlices; j++)
{
float theta = (j == uSlices) ? 0.0f : j * dtheta;
float stheta = (float)(-sin(theta));
float ctheta = (float)(cos(theta));
float x = stheta * srho;
float y = ctheta * srho;
float z = crho;
vTexture[0].x = s;
vTexture[0].y = t;
vNormal[0].x = x;
vNormal[0].y = y;
vNormal[0].z = z;
vVertex[0].x = x * fRadius;
vVertex[0].y = y * fRadius;
vVertex[0].z = z * fRadius;
x = stheta * srhodrho;
y = ctheta * srhodrho;
z = crhodrho;
vTexture[1].x = s;
vTexture[1].y = t - dt;
vNormal[1].x = x;
vNormal[1].y = y;
vNormal[1].z = z;
vVertex[1].x = x * fRadius;
vVertex[1].y = y * fRadius;
vVertex[1].z = z * fRadius;
theta = ((j + 1) == uSlices) ? 0.0f : (j + 1) * dtheta;
stheta = (float)(-sin(theta));
ctheta = (float)(cos(theta));
x = stheta * srho;
y = ctheta * srho;
z = crho;
s += ds;
vTexture[2].x = s;
vTexture[2].y = t;
vNormal[2].x = x;
vNormal[2].y = y;
vNormal[2].z = z;
vVertex[2].x = x * fRadius;
vVertex[2].y = y * fRadius;
vVertex[2].z = z * fRadius;
x = stheta * srhodrho;
y = ctheta * srhodrho;
z = crhodrho;
vTexture[3].x = s;
vTexture[3].y = t - dt;
vNormal[3].x = x;
vNormal[3].y = y;
vNormal[3].z = z;
vVertex[3].x = x * fRadius;
vVertex[3].y = y * fRadius;
vVertex[3].z = z * fRadius;
AddTriangle(vVertex, vNormal, vTexture);
// Rearrange for next triangle
memcpy(&vVertex[0], &vVertex[1], sizeof(CVector3));
memcpy(&vNormal[0], &vNormal[1], sizeof(CVector3));
memcpy(&vTexture[0], &vTexture[1], sizeof(CVector2));
memcpy(&vVertex[1], &vVertex[3], sizeof(CVector3));
memcpy(&vNormal[1], &vNormal[3], sizeof(CVector3));
memcpy(&vTexture[1], &vTexture[3], sizeof(CVector2));
AddTriangle(vVertex, vNormal, vTexture);
}
t -= dt;
}
}
void Geometry::AddQuad(vec3 a,vec3 b,vec3 c,vec3 d)
{
AddTriangle(a,b,c);
AddTriangle(a,c,d);
}
