C++ Mesh::AddVertex方法代码示例

TEST_F(MeshRendererTest, Triangle)
{
	MeshRenderer* mesh_renderer = static_cast<MeshRenderer*>(go->AddComponent<MeshRenderer>());
	EXPECT_NE(mesh_renderer, nullptr);

	Mesh mesh;

	EXPECT_EQ(mesh.IsDirty(), true);

	mesh.AddVertex(Vertex(Vec3f(0, 0, 0), Vec4f(1, 0, 0, 1)));
	mesh.AddVertex(Vertex(Vec3f(1, 0, 0), Vec4f(0, 1, 0, 1)));
	mesh.AddVertex(Vertex(Vec3f(0, 1, 0), Vec4f(0, 0, 1, 1)));

	EXPECT_EQ(mesh.GetVertexCount(), 3u);

	mesh.AddIndex(0);
	mesh.AddIndex(1);
	mesh.AddIndex(2);

	EXPECT_EQ(mesh.GetIndexCount(), 3u);
	EXPECT_EQ(mesh.IsDirty(), true);

	mesh.UpdateMesh();
	EXPECT_EQ(mesh.IsDirty(), false);

	anjing::gfx::Shader* shader = anjing::gfx::Shader::LoadShaderProgram("default/default.vs", "default/default.fs");

	anjing::gfx::Material* mat = Anew anjing::gfx::Material;
	mat->SetShader(shader);

	mesh_renderer->SetMaterial(mat);
	mesh_renderer->SetMesh(&mesh);

	anjing::core::Scene::GetInstance().Render();
}

TEST_F(GraphicsLightTest, TestLightTwoSided) {
  // Clear.
  glClearColor(0.2f, 0.4f, 0.6f, 0.f);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glEnable(GL_DEPTH_TEST);

  // Setup camera.
  glMatrixMode(GL_PROJECTION);
  glFrontFace(GL_CW);
  glFrustumf(-0.5f, 0.5f, -0.5f, 0.5f, 1.f, 30.f);
  glMatrixMode(GL_MODELVIEW);
  glTranslatef(0.f, 0.f, -2.f);
  glEnable(GL_LIGHTING);

  // Setup triangle mesh.
  Mesh triangle;
  triangle.AddVertex().Position(0.f, 0.f, 0.f).Normal(0.f, 0.f, 1.f);
  triangle.AddVertex().Position(1.f, 0.f, 0.f).Normal(0.f, 0.f, 1.f);
  triangle.AddVertex().Position(1.f, 1.f, 0.f).Normal(0.f, 0.f, 1.f);
  glEnableClientState(GL_VERTEX_ARRAY);
  glVertexPointer(3, GL_FLOAT, 0, triangle.Positions());
  glEnableClientState(GL_NORMAL_ARRAY);
  glNormalPointer(GL_FLOAT, 0, triangle.Normals());

  // Front light (green).
  const float front[] = {0.f, 0.f, -5.f, 1.f};
  glEnable(GL_LIGHT0);
  glLightfv(GL_LIGHT0, GL_POSITION, front);
  glLightfv(GL_LIGHT0, GL_AMBIENT, kRed);
  glLightfv(GL_LIGHT0, GL_DIFFUSE, kRed);

  // Back light (red).
  const float back[] = {0.f, 0.f, 5.f, 1.f};
  glEnable(GL_LIGHT1);
  glLightfv(GL_LIGHT1, GL_POSITION, back);
  glLightfv(GL_LIGHT1, GL_AMBIENT, kGreen);
  glLightfv(GL_LIGHT1, GL_DIFFUSE, kGreen);

  // Draw triangle, enable two-sided lighting, and draw it again
  // slightly offset.
  glTranslatef(-1.f, -1.f, 0.f);
  glDrawArrays(GL_TRIANGLES, 0, triangle.VertexCount());
  glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 1.f);
  glTranslatef(1.f, 1.f, 0.f);
  glDrawArrays(GL_TRIANGLES, 0, triangle.VertexCount());

  glDisableClientState(GL_NORMAL_ARRAY);
  glDisableClientState(GL_VERTEX_ARRAY);
  EXPECT_IMAGE();
}

    void GuiElement::GenerateMesh()
    {
        if(m_NeedsUpdate) {
            Mesh* mesh = new Mesh();
            Vec2 Pos = Vec2(0,0);
            mesh->AddVertex(Vec3(Pos.x,Pos.y, 0));
            mesh->AddTexCoord(Vec2(0,0));

            mesh->AddVertex(Vec3(Pos.x,Pos.y + m_Size.y,0));
            mesh->AddTexCoord(Vec2(0,1));

            mesh->AddVertex(Vec3(Pos.x + m_Size.x,Pos.y,0));
            mesh->AddTexCoord(Vec2(1,0));


            mesh->AddVertex(Vec3(Pos.x + m_Size.x,Pos.y,0));
            mesh->AddTexCoord(Vec2(1,0));

            mesh->AddVertex(Vec3(Pos.x,Pos.y + m_Size.y,0));
            mesh->AddTexCoord(Vec2(0,1));

            mesh->AddVertex(Vec3(Pos + m_Size,0));
            mesh->AddTexCoord(Vec2(1,1));

            //if(m_Font)
                //m_Font->AddToMesh(mesh, InnerText_,Vec3(0,0,0),(i32)m_Size.x, FontSize_);

            m_Component->SetMesh(mesh);
            m_NeedsUpdate = false;
        }
    }

	void Model::InitMesh(const aiMesh* mesh)
	{
		MeshInfo* meshInfo = new MeshInfo;
		meshInfo->NumVertices = mesh->mNumVertices;
		meshInfo->NumIndices  = mesh->mNumFaces * 3;
		Mesh* modelMesh = new Mesh(this, meshInfo);

		/*READ VERTS INTO MODEL MESH*/
		size_t numVerts = mesh->mNumVertices;
		for(size_t i = 0; i < numVerts; i++)
		{
			aiVector3D vertex = mesh->mVertices[i];
			aiVector3D tangent = aiVector3D(0.0f);
			if(mesh->HasTangentsAndBitangents()) {
				tangent = mesh->mTangents[i];
			}
			aiVector3D normal(0.0f);
			float u = 0.0f;
			float v = 0.0f;
			if(mesh->HasNormals()) {
				normal = mesh->mNormals[i];
			}
			if(mesh->HasTextureCoords(0)) {
				aiVector3D uvs = mesh->mTextureCoords[0][i];
				u = uvs.x;
				v = uvs.y;
			}
			meshInfo->Vertices.push_back(Vec3(vertex.x, vertex.y, vertex.z));
			modelMesh->AddVertex(vertex.x, vertex.y, vertex.z,
							     normal.x, normal.y, normal.z,
								 u, v,
								 tangent.x, tangent.y, tangent.z);
		}

		/*READ FACES INTO MODEL MESH*/
		size_t numFaces = mesh->mNumFaces;
		for(size_t i = 0; i < numFaces; i++)
		{
			aiFace face = mesh->mFaces[i];
			modelMesh->AddFace(face.mIndices[0],
							   face.mIndices[1],
							   face.mIndices[2]);
		}

		/*INITIALIZE MESH*/
		modelMesh->Init();

		/*ADD MODELMESH TO COLLECTION*/
		m_meshes.push_back(modelMesh);

	}

int main(int argc, char *argv[])
{
   // 1. Initialize MPI.
   int num_procs, myid;
   MPI_Init(&argc, &argv);
   MPI_Comm_size(MPI_COMM_WORLD, &num_procs);
   MPI_Comm_rank(MPI_COMM_WORLD, &myid);

   // 2. Parse command-line options.
   int elem_type = 1;
   int ref_levels = 2;
   int amr = 0;
   int order = 2;
   bool always_snap = false;
   bool visualization = 1;

   OptionsParser args(argc, argv);
   args.AddOption(&elem_type, "-e", "--elem",
                  "Type of elements to use: 0 - triangles, 1 - quads.");
   args.AddOption(&order, "-o", "--order",
                  "Finite element order (polynomial degree).");
   args.AddOption(&ref_levels, "-r", "--refine",
                  "Number of times to refine the mesh uniformly.");
   args.AddOption(&amr, "-amr", "--refine-locally",
                  "Additional local (non-conforming) refinement:"
                  " 1 = refine around north pole, 2 = refine randomly.");
   args.AddOption(&visualization, "-vis", "--visualization", "-no-vis",
                  "--no-visualization",
                  "Enable or disable GLVis visualization.");
   args.AddOption(&always_snap, "-snap", "--always-snap", "-no-snap",
                  "--snap-at-the-end",
                  "If true, snap nodes to the sphere initially and after each refinement "
                  "otherwise, snap only after the last refinement");
   args.Parse();
   if (!args.Good())
   {
      if (myid == 0)
      {
         args.PrintUsage(cout);
      }
      MPI_Finalize();
      return 1;
   }
   if (myid == 0)
   {
      args.PrintOptions(cout);
   }

   // 3. Generate an initial high-order (surface) mesh on the unit sphere. The
   //    Mesh object represents a 2D mesh in 3 spatial dimensions. We first add
   //    the elements and the vertices of the mesh, and then make it high-order
   //    by specifying a finite element space for its nodes.
   int Nvert = 8, Nelem = 6;
   if (elem_type == 0)
   {
      Nvert = 6;
      Nelem = 8;
   }
   Mesh *mesh = new Mesh(2, Nvert, Nelem, 0, 3);

   if (elem_type == 0) // inscribed octahedron
   {
      const double tri_v[6][3] =
      {
         { 1,  0,  0}, { 0,  1,  0}, {-1,  0,  0},
         { 0, -1,  0}, { 0,  0,  1}, { 0,  0, -1}
      };
      const int tri_e[8][3] =
      {
         {0, 1, 4}, {1, 2, 4}, {2, 3, 4}, {3, 0, 4},
         {1, 0, 5}, {2, 1, 5}, {3, 2, 5}, {0, 3, 5}
      };

      for (int j = 0; j < Nvert; j++)
      {
         mesh->AddVertex(tri_v[j]);
      }
      for (int j = 0; j < Nelem; j++)
      {
         int attribute = j + 1;
         mesh->AddTriangle(tri_e[j], attribute);
      }
      mesh->FinalizeTriMesh(1, 1, true);
   }
   else // inscribed cube
   {
      const double quad_v[8][3] =
      {
         {-1, -1, -1}, {+1, -1, -1}, {+1, +1, -1}, {-1, +1, -1},
         {-1, -1, +1}, {+1, -1, +1}, {+1, +1, +1}, {-1, +1, +1}
      };
      const int quad_e[6][4] =
      {
         {3, 2, 1, 0}, {0, 1, 5, 4}, {1, 2, 6, 5},
         {2, 3, 7, 6}, {3, 0, 4, 7}, {4, 5, 6, 7}
      };

      for (int j = 0; j < Nvert; j++)
      {
         mesh->AddVertex(quad_v[j]);
//.........这里部分代码省略.........

int main(int argc, char *argv[])
{
   // 1. Parse command-line options.
   int elem_type = 1;
   int ref_levels = 2;
   int amr = 0;
   int order = 2;
   bool always_snap = false;
   bool visualization = 1;

   OptionsParser args(argc, argv);
   args.AddOption(&elem_type, "-e", "--elem",
                  "Type of elements to use: 0 - triangles, 1 - quads.");
   args.AddOption(&order, "-o", "--order",
                  "Finite element order (polynomial degree).");
   args.AddOption(&ref_levels, "-r", "--refine",
                  "Number of times to refine the mesh uniformly.");
   args.AddOption(&amr, "-amr", "--refine-locally",
                  "Additional local (non-conforming) refinement:"
                  " 1 = refine around north pole, 2 = refine randomly.");
   args.AddOption(&visualization, "-vis", "--visualization", "-no-vis",
                  "--no-visualization",
                  "Enable or disable GLVis visualization.");
   args.AddOption(&always_snap, "-snap", "--always-snap", "-no-snap",
                  "--snap-at-the-end",
                  "If true, snap nodes to the sphere initially and after each refinement "
                  "otherwise, snap only after the last refinement");
   args.Parse();
   if (!args.Good())
   {
      args.PrintUsage(cout);
      return 1;
   }
   args.PrintOptions(cout);

   // 2. Generate an initial high-order (surface) mesh on the unit sphere. The
   //    Mesh object represents a 2D mesh in 3 spatial dimensions. We first add
   //    the elements and the vertices of the mesh, and then make it high-order
   //    by specifying a finite element space for its nodes.
   int Nvert = 8, Nelem = 6;
   if (elem_type == 0)
   {
      Nvert = 6;
      Nelem = 8;
   }
   Mesh *mesh = new Mesh(2, Nvert, Nelem, 0, 3);

   if (elem_type == 0) // inscribed octahedron
   {
      const double tri_v[6][3] =
      {
         { 1,  0,  0}, { 0,  1,  0}, {-1,  0,  0},
         { 0, -1,  0}, { 0,  0,  1}, { 0,  0, -1}
      };
      const int tri_e[8][3] =
      {
         {0, 1, 4}, {1, 2, 4}, {2, 3, 4}, {3, 0, 4},
         {1, 0, 5}, {2, 1, 5}, {3, 2, 5}, {0, 3, 5}
      };

      for (int j = 0; j < Nvert; j++)
      {
         mesh->AddVertex(tri_v[j]);
      }
      for (int j = 0; j < Nelem; j++)
      {
         int attribute = j + 1;
         mesh->AddTriangle(tri_e[j], attribute);
      }
      mesh->FinalizeTriMesh(1, 1, true);
   }
   else // inscribed cube
   {
      const double quad_v[8][3] =
      {
         {-1, -1, -1}, {+1, -1, -1}, {+1, +1, -1}, {-1, +1, -1},
         {-1, -1, +1}, {+1, -1, +1}, {+1, +1, +1}, {-1, +1, +1}
      };
      const int quad_e[6][4] =
      {
         {3, 2, 1, 0}, {0, 1, 5, 4}, {1, 2, 6, 5},
         {2, 3, 7, 6}, {3, 0, 4, 7}, {4, 5, 6, 7}
      };

      for (int j = 0; j < Nvert; j++)
      {
         mesh->AddVertex(quad_v[j]);
      }
      for (int j = 0; j < Nelem; j++)
      {
         int attribute = j + 1;
         mesh->AddQuad(quad_e[j], attribute);
      }
      mesh->FinalizeQuadMesh(1, 1, true);
   }

   // Set the space for the high-order mesh nodes.
   H1_FECollection fec(order, mesh->Dimension());
   FiniteElementSpace nodal_fes(mesh, &fec, mesh->SpaceDimension());
   mesh->SetNodalFESpace(&nodal_fes);
//.........这里部分代码省略.........