UE5 三维图元源码 - Box，运行时动态创建自己的三维图元。

已于 2022-09-06 16:40:30 修改
阅读量834 收藏 2
点赞数
分类专栏： Gis UE5 文章标签： ue5
于 2022-09-06 16:35:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/usdnfo/article/details/126727998
版权
Gis 同时被 2 个专栏收录
6 篇文章 3 订阅
订阅专栏
UE5
1 篇文章 0 订阅
订阅专栏

首先是进入蓝图接口代码：

UDynamicMesh* UMyMeshPrimitiveFunctions::AppendBox(
	UDynamicMesh* TargetMesh,//添加到哪个UDynamicMesh中去
	FGeometryScriptPrimitiveOptions PrimitiveOptions,
	FTransform Transform,//坐标，旋转，缩放。注意：UE5中心点位置：x:x/2,y:y/2,z:0
	float DimensionX,//X长度
	float DimensionY,//y长度
	float DimensionZ,//z长度
	int32 StepsX,//X方向的顶点数
	int32 StepsY,//y方向的顶点数
	int32 StepsZ,//z方向的顶点数
	EGeometryScriptPrimitiveOriginMode Origin,
	UGeometryScriptDebug* Debug){
	if (TargetMesh == nullptr)
	{
		UE::Geometry::AppendError(Debug, EGeometryScriptErrorType::InvalidInputs, LOCTEXT("PrimitiveFunctions_AppendBox", "AppendBox: TargetMesh is Null"));
		return TargetMesh;
	}
    
//创建包围盒
	UE::Geometry::FAxisAlignedBox3d ConvertBox(
		FVector3d(-DimensionX / 2, -DimensionY / 2, 0),
		FVector3d(DimensionX / 2, DimensionY / 2, DimensionZ));

	FGridBoxMeshGenerator2 GridBoxGenerator;
//通过包围盒创建盒子
	GridBoxGenerator.Box = UE::Geometry::FOrientedBox3d(ConvertBox);
//各个方向的边缘顶点的数量，这里默认为0，创建的时候最小会修正为2。
	GridBoxGenerator.EdgeVertices = FIndex3i(FMath::Max(0, StepsX), FMath::Max(0, StepsY), FMath::Max(0, StepsZ));
	GridBoxGenerator.bPolygroupPerQuad = (PrimitiveOptions.PolygroupMode == EGeometryScriptPrimitivePolygroupMode::PerQuad);
	GridBoxGenerator.Generate();

	FVector3d OriginShift = (Origin == EGeometryScriptPrimitiveOriginMode::Center) ? FVector3d(0, 0, -DimensionZ / 2) : FVector3d::Zero();
	AppendPrimitive(TargetMesh, &GridBoxGenerator, Transform, PrimitiveOptions, OriginShift);

	return TargetMesh;
}

然后是Generate代码

virtual FMeshShapeGenerator& Generate() override
			{
                //边缘顶点，修正数量最低为2
				FIndex3i N = EdgeVertices;
				N.A = FMath::Max(2, N.A);
				N.B = FMath::Max(2, N.B);
				N.C = FMath::Max(2, N.C);
                //缩放
				FVector3d Nscale(1.0 / (N.A - 1), 1.0 / (N.B - 1), 1.0 / (N.C - 1));
                //内部，最低为0
				FIndex3i NInternal = N;
				NInternal.A -= 2; NInternal.B -= 2; NInternal.C -= 2;
                
				FIndex3i NTri = N;
				NTri.A--; NTri.B--; NTri.C--;
				//24个 UV 和 法线，法线与UV相同数量
				int NumUVsAndNormals = 2 * (N.A * N.B + N.B * N.C + N.C * N.A);
				//正方形的8 顶点
				int NumVertices = 8 + (NInternal.A + NInternal.B + NInternal.C) * 4 + (NInternal.A * NInternal.B + NInternal.B * NInternal.C + NInternal.C * NInternal.A) * 2;
				//12个三角形，6个面，一个面2个三角形
				int NumTriangles = 4 * (NTri.A * NTri.B + NTri.B * NTri.C + NTri.C * NTri.A);
                //设置UE缓冲
				SetBufferSizes(NumVertices, NumTriangles, NumUVsAndNormals, NumUVsAndNormals);

				int FaceDimOrder[3]{ 1, 2, 0 }; // ordering from IndexUtil.cpp
				int D[2][3]{ { 1,2,0 }, { 2,0,1 } }; // helper mapping to go from major dimension to the two canonical sub-dimensions in order; is just D[i][j] -> (j+i+1)%3 (TODO: replace with the modulus version?)

				// allocate a big mapping from faces to vertices, to make life easier when creating triangles later
				FIndex3i VerticesPerFace(N.B * N.C, N.A * N.C, N.A * N.B);
				//顶点索引
				TArray<TArray<int>> FaceVertIndices;
				FaceVertIndices.SetNum(6);
				for (int Dim = 0; Dim < 3; Dim++)
				{
					int FaceIdxForDim = FaceDimOrder[Dim] * 2;
					int VertexNum = VerticesPerFace[Dim];
					FaceVertIndices[FaceIdxForDim].SetNum(VertexNum);
					FaceVertIndices[FaceIdxForDim + 1].SetNum(VertexNum);
				}

				auto ToFaceV = [&N, &D](int Dim, int D0, int D1)
				{
					return D0 + N[D[0][Dim]] * D1;
				};

				// create the corners and distribute them into the face mapping
				for (int i = 0; i < 8; ++i)
				{
					Vertices[i] = Box.GetCorner(i);
					FIndex3i CornerSides = FOrientedBox3d::GetCornerSide(i);
					for (int Dim = 0; Dim < 3; Dim++)
					{
						int FaceIdx = FaceDimOrder[Dim] * 2 + CornerSides[Dim];
						int D0Ind = CornerSides[D[0][Dim]] * (N[D[0][Dim]] - 1);
						int D1Ind = CornerSides[D[1][Dim]] * (N[D[1][Dim]] - 1);
						int CornerVInd = ToFaceV(Dim, D0Ind, D1Ind);
						FaceVertIndices[FaceIdx][CornerVInd] = i;
					}
				}

				// create the internal (non-corner) edge vertices and distribute them into the face mapping
				int CurrentVertIndex = 8;
				for (int Dim = 0; Dim < 3; Dim++)
				{
					int EdgeLen = N[Dim];
					if (EdgeLen <= 2)
					{
						continue; // no internal edge vertices on this dimension
					}
					int MajorFaceInd = FaceDimOrder[Dim] * 2;
					int FaceInds[2]{ -1,-1 };
					int DSides[2]{ 0,0 };
					for (DSides[0] = 0; DSides[0] < 2; DSides[0]++)
					{
						FaceInds[0] = FaceDimOrder[D[0][Dim]] * 2 + DSides[0];
						for (DSides[1] = 0; DSides[1] < 2; DSides[1]++)
						{
							FaceInds[1] = FaceDimOrder[D[1][Dim]] * 2 + DSides[1];
							int MajorCornerInd = ToFaceV(Dim, DSides[0] * (N[D[0][Dim]] - 1), DSides[1] * (N[D[1][Dim]] - 1));
							FVector3d Corners[2]
							{
								Vertices[FaceVertIndices[MajorFaceInd][MajorCornerInd]],
								Vertices[FaceVertIndices[MajorFaceInd + 1][MajorCornerInd]]
							};

							for (int EdgeVert = 1; EdgeVert + 1 < EdgeLen; EdgeVert++)
							{
								Vertices[CurrentVertIndex] = Lerp(Corners[0], Corners[1], EdgeVert * Nscale[Dim]);
								for (int WhichFace = 0; WhichFace < 2; WhichFace++) // each edge is shared by two faces (w/ major axes of subdim 0 and subdim 1 respectively)
								{
									int FaceInd = FaceInds[WhichFace];

									int FaceDim = D[WhichFace][Dim];
									int SubDims[2];
									SubDims[1 - WhichFace] = EdgeVert;
									SubDims[WhichFace] = NTri[D[WhichFace][FaceDim]] * DSides[1 - WhichFace];
									int FaceV = ToFaceV(FaceDim, SubDims[0], SubDims[1]);
									FaceVertIndices[FaceInds[WhichFace]][FaceV] = CurrentVertIndex;
								}
								CurrentVertIndex++;
							}
						}
					}
				}

				// create the internal (non-corner, non-edge) face vertices and distribute them into the face mapping
				for (int Dim = 0; Dim < 3; Dim++)
				{
					int FaceIdxBase = FaceDimOrder[Dim] * 2;
					int FaceInternalVNum = NInternal[D[0][Dim]] * NInternal[D[1][Dim]];
					if (FaceInternalVNum <= 0)
					{
						continue;
					}

					for (int Side = 0; Side < 2; Side++)
					{
						int MajorFaceInd = FaceIdxBase + Side;
						for (int D0 = 1; D0 + 1 < N[D[0][Dim]]; D0++)
						{
							int BotInd = ToFaceV(Dim, D0, 0);
							int TopInd = ToFaceV(Dim, D0, N[D[1][Dim]] - 1);

							FVector3d Edges[2]
							{
								Vertices[FaceVertIndices[MajorFaceInd][BotInd]],
								Vertices[FaceVertIndices[MajorFaceInd][TopInd]]
							};
							for (int D1 = 1; D1 + 1 < N[D[1][Dim]]; D1++)
							{
								Vertices[CurrentVertIndex] = Lerp(Edges[0], Edges[1], D1 * Nscale[D[1][Dim]]);
								FaceVertIndices[MajorFaceInd][ToFaceV(Dim, D0, D1)] = CurrentVertIndex;
								CurrentVertIndex++;
							}
						}
					}
				}

				double MaxDimension = MaxAbsElement(2.0 * Box.Extents);
				float UVScale = (bScaleUVByAspectRatio) ? (1.0f / (float)MaxDimension) : 1.0f;

				// create the face triangles and UVs+normals
				int CurrentTriIdx = 0;
				int CurrentUVIdx = 0;
				int CurrentQuadIdx = 0;
				for (int Dim = 0; Dim < 3; Dim++)
				{
					int FaceIdxBase = FaceDimOrder[Dim] * 2;

					// UV-specific minor axes + flips; manually set to match default UnrealEngine cube texture arrangement
					int Minor1Flip[3] = { -1, 1, 1 };
					int Minor2Flip[3] = { -1, -1, 1 };

					// UV scales for D0, D1
					double FaceWidth = FMathd::Abs(Box.Extents[D[0][Dim]]) * 2.0;
					double FaceHeight = FMathd::Abs(Box.Extents[D[1][Dim]]) * 2.0;
					double WidthUVScale = FaceWidth * UVScale;
					double HeightUVScale = FaceHeight * UVScale;


					for (int Side = 0; Side < 2; Side++)
					{
						int SideOpp = 1 - Side;
						float SideSign = Side * 2 - 1;

						FVector3f Normal(0, 0, 0);
						Normal[Dim] = (2 * Side - 1);
						Normal = (FVector3f)Box.Frame.FromFrameVector((FVector3d)Normal);

						int MajorFaceInd = FaceIdxBase + Side;

						int FaceUVStartInd = CurrentUVIdx;
						// set all the UVs and normals
						FVector2f UV;
						int UVXDim = Dim == 1 ? 1 : 0;	// which dim (of D0,D1) follows the horizontal UV coordinate
						int UVYDim = 1 - UVXDim;		// which dim (of D0,D1) follows the vertical UV coordinate
						for (int D0 = 0; D0 < N[D[0][Dim]]; D0++)
						{
							for (int D1 = 0; D1 < N[D[1][Dim]]; D1++)
							{
								// put the grid coordinates (centered at 0,0) into the UVs
								UV[UVXDim] = D0 * Nscale[D[0][Dim]] - .5;
								UV[UVYDim] = D1 * Nscale[D[1][Dim]] - .5;
								// invert axes to match the desired UV patterns & so the opp faces are not backwards
								UV.X *= SideSign * Minor1Flip[Dim];
								UV.Y *= Minor2Flip[Dim];
								// recenter and scale up
								UV[UVXDim] = (UV[UVXDim] + .5) * WidthUVScale;
								UV[UVYDim] = (UV[UVYDim] + .5) * HeightUVScale;
								UVs[CurrentUVIdx] = UV;
								Normals[CurrentUVIdx] = Normal;
								UVParentVertex[CurrentUVIdx] = FaceVertIndices[MajorFaceInd][ToFaceV(Dim, D0, D1)];
								NormalParentVertex[CurrentUVIdx] = FaceVertIndices[MajorFaceInd][ToFaceV(Dim, D0, D1)];
								CurrentUVIdx++;
							}
						}

						// set all the triangles
						for (int D0 = 0; D0 + 1 < N[D[0][Dim]]; D0++)
						{
							for (int D1 = 0; D1 + 1 < N[D[1][Dim]]; D1++)
							{
								SetTriangle(CurrentTriIdx,
									FaceVertIndices[MajorFaceInd][ToFaceV(Dim, D0, D1)],
									FaceVertIndices[MajorFaceInd][ToFaceV(Dim, D0 + SideOpp, D1 + Side)],
									FaceVertIndices[MajorFaceInd][ToFaceV(Dim, D0 + 1, D1 + 1)]
								);

								SetTriangleUVs(CurrentTriIdx,
									FaceUVStartInd + D1 + (D0)*N[D[1][Dim]],
									FaceUVStartInd + D1 + Side + (D0 + SideOpp) * N[D[1][Dim]],
									FaceUVStartInd + D1 + 1 + (D0 + 1) * N[D[1][Dim]]
								);
								SetTriangleNormals(CurrentTriIdx,
									FaceUVStartInd + D1 + (D0)*N[D[1][Dim]],
									FaceUVStartInd + D1 + Side + (D0 + SideOpp) * N[D[1][Dim]],
									FaceUVStartInd + D1 + 1 + (D0 + 1) * N[D[1][Dim]]
								);
								SetTrianglePolygon(CurrentTriIdx, (bPolygroupPerQuad) ? CurrentQuadIdx : MajorFaceInd);
								CurrentTriIdx++;

								SetTriangle(CurrentTriIdx,
									FaceVertIndices[MajorFaceInd][ToFaceV(Dim, D0, D1)],
									FaceVertIndices[MajorFaceInd][ToFaceV(Dim, D0 + 1, D1 + 1)],
									FaceVertIndices[MajorFaceInd][ToFaceV(Dim, D0 + Side, D1 + SideOpp)]
								);
								SetTriangleUVs(CurrentTriIdx,
									FaceUVStartInd + D1 + (D0)*N[D[1][Dim]],
									FaceUVStartInd + D1 + 1 + (D0 + 1) * N[D[1][Dim]],
									FaceUVStartInd + D1 + SideOpp + (D0 + Side) * N[D[1][Dim]]
								);
								SetTriangleNormals(CurrentTriIdx,
									FaceUVStartInd + D1 + (D0)*N[D[1][Dim]],
									FaceUVStartInd + D1 + 1 + (D0 + 1) * N[D[1][Dim]],
									FaceUVStartInd + D1 + SideOpp + (D0 + Side) * N[D[1][Dim]]
								);
								SetTrianglePolygon(CurrentTriIdx, (bPolygroupPerQuad) ? CurrentQuadIdx : MajorFaceInd);
								CurrentTriIdx++;
								CurrentQuadIdx++;
							}
						}
					}
				}


				return *this;
			}

可以复用这些代码创建自己的三维图元

天道酬勤~
关注
专栏目录
UE5 Geometry Script
qq_34437757的博客
07-02 263
UE5 Geometry Script
ue5 小知识点 geometry script modeling
opk8848的专栏
06-09 1428
geometry script
开源项目《Geometry Script》安装与使用教程
最新发布
gitblog_00195的博客
08-24 350
开源项目《Geometry Script》安装与使用教程 geometry-scriptA scripting API for Blender's Geometry Nodes项目地址:https://gitcode.com/gh_mirrors/ge/geometry-script 一、项目目录结构及介绍 └── geometry-script ├── src ...
【UE5】Cesium for Unreal —— 测量面积
ChaoChao66666的博客
07-15 1993
1. 启用插件“Geometry Script”插件2. 新建一个actor蓝图，这里就命名为“BP_Sphere”，用于创建面积测量的点打开“BP_Sphere”，添加一个球形组件和一个“CesiumGlobeAnchor”组件（添加“CesiumGlobeAnchor”组件主要是怕Cesium GeoReference原点位置变了后，“BP_Sphere”的位置会改变）球体能根据DynamicPawn的远近动态调整自身大小蓝图库函数“ChangeActorSizeByDistance”逻辑如下。
UE5 新特性 DynamicMesh
qqQQqsadfj的博客
11-06 922
[UE5] Dynamic Mesh使用教程_哔哩哔哩_bilibili
使用编辑器动态调整C++创建的BoxComponent【UE4】【C++】
weixin_41946900的博客
11-28 920
方法一 .h文件 // Fill out your copyright notice in the Description page of Project Settings. #pragma once #include "CoreMinimal.h" #include "GameFramework/Actor.h" #include "Components\BoxComponent.h"...
三维产品设计ProE-几何图元的约束.pptx
11-24
三维产品设计ProE是一款强大的计算机辅助设计（CAD）软件，专用于进行三维数字化产品建模。ProE（现称为Creo Parametric）由美国PTC公司开发，它提供了丰富的工具和功能，帮助工程师和设计师创建、修改和优化复杂的...
三维产品设计ProE-几何图元的编辑.pptx
11-24
在三维产品设计领域，ProE（也称为Creo Parametric）是一款广泛应用的软件，它提供了强大的几何图元编辑功能，使得设计师能够精确地构建复杂的3D模型。本篇内容主要聚焦于通过ProE进行二维草绘，从而为三维建模奠定...
三维产品设计ProE-几何图元的绘制.pptx
11-24
在三维产品设计中，ProE（也称为Creo Parametric）是一款强大的软件工具，它提供了丰富的功能来创建、编辑和管理复杂的产品模型。本讲座主要关注的是如何利用ProE进行几何图元的绘制，这是构建三维模型的基础。下面...
VC++下三维图形及其三视图显示算法实现-C++文档类资源
12-05
在VC++环境下，开发三维图形及其三视图显示算法是一项重要的技术任务，广泛应用于计算机...通过深入研究源码，可以了解图形渲染的基本流程，提升对三维图形显示原理的理解，并可能启发自己在项目中实现更多复杂效果。
三维产品设计ProE-几何图元的镜像、旋转和复制.pptx
11-24
在三维产品设计中，ProE是一款强大的工具，用于创建、编辑和管理复杂的产品几何模型。本讲座主要聚焦于几何图元的三种基本操作：镜像、旋转和复制，这些都是产品设计过程中不可或缺的功能。 1. **几何图元的镜像**...
UE4使用RuntimeTransformer实现的对模型编辑功能
03-26
UE4使用RuntimeTransformer实现的对模型编辑功能 实现编辑器的第一步
UE5--我要成为建模大师
09-26 4196
Part1前言UE5中建模模式可以辅助做一些基本的模型操作，省去了简单修改一下模型都要导到其他DCC软件中的麻烦。如果修改ue5中的模型，请先关闭ninateue将所有模型以三角形计算，尤其建模模块中，没有四边形和多边形的概念，三角形是ue内建模基础，因此，最低层次的编辑工具围绕三角形和顶点开展但是引擎支持划分和编辑多边形组，从而方便对一组三角形集合进行编辑。Part2分类类别说明形状（Shape...
ue5 小知识点 random point in Bounding Boxf From Stream
opk8848的专栏
06-09 386
random point in Bounding Boxf From Stream
UE5 真实的进度条加载（记录一下）
weixin_42318094的博客
05-05 1787
ue5 c++类的真实进度条加载，怕忘了，记录一下。
UE5 TArry＜FVector3f＞转＜FVector3d＞
qq_45246052的博客
04-02 1191
TArry<FVector3d>vd=static_cast<TArray<FVector3d>>(vf);
ue5 小知识点 transform vector rotator 运算
opk8848的专栏
03-30 927
把局部坐标Location转换成世界坐标系下的location。
UE4爬坑记
Hello Mingo
12-19 5143
从Unity转Unreal，心里很是忐忑。不知道为什么，总感觉Unreal是个很高大上的东西，也总感觉C++是一门逼格很高的艺术... 然而，在学习过程中，感受到的与unity最大的不同，就是从网络上查资料的差别。unity基础的设置或者组件的用法，等等不牵涉到具体功能思路的问题，基本都可以搜索到。简单的问题很快就可以解决，但是Unreal不行，至少中文结果很少很少很少的。虽然自以为将来
UE TransformVector 学习笔记
qqQQqsadfj的博客
11-20 540
假如算现在枪的位置，那么就是先拿人的位置再拿枪在本地的相对位置相加，就是枪的位置，也就是枪在场景中的位置，那么这里还可以写成Actor的变化和枪的相对位置连在TransformVector上，返回的就是枪的场景位置。这样写就可以了，1，0，0是在本地的方向，换算出来的就是世界场景的方向。这里做反算，就是通过枪的场景位置来反算人在场景的位置。这个和反转变化位置效果一样。算箭头方向在世界场景的方向。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天道酬勤~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值