izzy/UnrealEngineUWP
0
0
Fork 0
mirror of https://github.com/izzy2lost/UnrealEngineUWP.git synced 2026-03-26 18:15:20 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
cbb856a117e8ecfb66067adecf3fc62861ecd8f1
UnrealEngineUWP/Engine/Source/Developer/MeshUtilities/Private/MeshUtilities.cpp
Ori Cohen 368bd22e6b Copying //UE4/Dev-Framework to //UE4/Dev-Main (Source: //UE4/Dev-Framework @ 3153514) 
#lockdown Nick.Penwarden
#rb none

==========================
MAJOR FEATURES + CHANGES
==========================

Change 3050254 on 2016/07/14 by Marc.Audy

	Merging //UE4/Dev-Main to Dev-Framework (//UE4/Dev-Framework) @ 3049614

Change 3136629 on 2016/09/22 by Marc.Audy

	bye bye auto

Change 3136631 on 2016/09/22 by Marc.Audy

	Allow objects to be marked as duplicate transient or non PIE duplicate transient
	ChildActors are not marked consistent with the property that references them as text export transient and non PIE duplicate transient
	#jira UE-35680

Change 3136636 on 2016/09/22 by Marc.Audy

	ParticleSystem and Audio Components now  route Activate/Deactivate events to blueprints
	Component Activate/Deactivate events now provide component as a property
	#jira UE-35191

Change 3136640 on 2016/09/22 by Marc.Audy

	Expose bReplicates to blueprint component properties
	#jira UE-34433

Change 3136709 on 2016/09/22 by Ori.Cohen

	Fix GetBodyInstance returning incorrect bodies when welded kinematics are attached.

	#JIRA UE-36234

Change 3136710 on 2016/09/22 by Ori.Cohen

	Fix defer actors not working when the physics scene is simulating. We now flush when the scene is not simulating, as well as a lazy flush that goes through the slow path when needed. This allows us to batch multiple components together.

	#JIRA UE-35899

Change 3136770 on 2016/09/22 by Marc.Audy

	Fix compile error

Change 3136854 on 2016/09/22 by Marc.Audy

	Sprite components need to be text export transient
	#jira UE-36064

Change 3136926 on 2016/09/22 by Ori.Cohen

	Fix ensure when skeletal mesh bodies have no collision.

Change 3137054 on 2016/09/22 by Aaron.McLeran

	PR #2628: Fix UAudioComponent SubtitlePriority not being initialised (Contributed by alanedwardes)

Change 3137058 on 2016/09/22 by Aaron.McLeran

	PR #2562: ReadCompressedInfo calculates duration for ADPCM audio (Contributed by derekvanvliet)

Change 3137060 on 2016/09/22 by Aaron.McLeran

	UE-36336 Fixing A3D for mono/2D sounds

	- Making it so if A3D is being loaded but not enabled, we can not have reverb on 2D sounds
	- Fixing A3D mono sources from failing after a time

Change 3137066 on 2016/09/22 by Aaron.McLeran

	Checking in Ngs2.Build.cs with A3D and USING_A3D set to 0

Change 3137098 on 2016/09/22 by dan.reynolds

	AEOverview Update: EQ Map, Reverb Map plus improvements on Main array cleanup process.

Change 3137132 on 2016/09/22 by Aaron.McLeran

	PR #2789: Fixed signature of FActiveSound::GetIntParameter (Contributed by Laurie-Hedge)

Change 3137175 on 2016/09/22 by Aaron.McLeran

	Fixing compile error with PhysXCollision.cpp from CL 3136710

Change 3137540 on 2016/09/23 by Thomas.Sarkanen

	Fixed crash when generating LODs automatically for skeletal meshes

	Quadric error reduction does not support skeletal meshes, so fails. Client code assumes that it cannot fail so crashed. This guards against immediatly assuming that LODs are valid after simplification.

	#jira UE-36253 - Crash applying LOD changes in Persona

Change 3137720 on 2016/09/23 by Thomas.Sarkanen

	Changed asset shortcut bar to display asset names & reworked padding

	#jira UE-36347 - Anim asset shortcut bar has difficult to read/cut-off text

Change 3137761 on 2016/09/23 by Martin.Wilson

	Fix typo in root motion from everything accumulation code

Change 3137877 on 2016/09/23 by Thomas.Sarkanen

	Fixed undo/redo forcing skeletal meshes into t-pose

	Re-populated AnimationData in InitAnim for UDebugSkelMeshComponent.

	#jira UE-35579 - If you undo an animation change to any animation asset (for single preview), the playback controls will no longer function

Change 3137885 on 2016/09/23 by Benn.Gallagher

	Fixed APEX clothing disappearing when time dilation results in a dt of 0. After simulating an actor with 0 APEX will fill positions and normals with NaNs, causing the disappearance. The fix in this case is to not schedule the evaluation task if we're not wanting to do any work. The simulation then freezes as we would expect.
	#jira UE-35151

Change 3137888 on 2016/09/23 by Benn.Gallagher

	Fixed transition nodes being able to be pasted or duplicated without 2 valid pin links
	#jira UE-24860

Change 3137889 on 2016/09/23 by Benn.Gallagher

	Fixed transform and widget inconsistencies in IK edit mode
	#jira UE-20628

Change 3137890 on 2016/09/23 by Jurre.deBaare

	Alembic Cached Geometry Does Not Display in Stand Alone Game
	#fix required to force load the GeometryCache module during runtime
	#jira UE-36187

Change 3137892 on 2016/09/23 by Jurre.deBaare

	Geometry cache playback should work in sequencer
	#fix add Interp UProperty tag to specific properties used for playing back the cache, future fix is having same approach as skeletal mesh animation for sequencer (depends on needs, -> skeletal mesh import has better compression anyway)
	#jira UE-35447

Change 3137893 on 2016/09/23 by Jurre.deBaare

	Alembic Cache Importer option for Hard Edge Angle Threshold does not work for objects with no normals
	#fix adhere to the assumed 'standard' no normals in ABC file means completely smooth normals throughout the sequence
	#jira UE-35091

Change 3137894 on 2016/09/23 by Jurre.deBaare

	Importing an Alembic File While mesh Distance Fields are Enabled Crashes Editor
	#fix Needed to save the raw mesh before building the mesh to ensure a LOD resource was created
	#misc added a new check + message in case this occurs again
	#jira UE-36059

Change 3137938 on 2016/09/23 by Jurre.deBaare

	Alembic Importing with Incorrect UV's
	#fix adding option for flipping UVs on import
	#jira UE-36190

	Alembic import axis not aligned correctly
	#fix also added option to specify scale and rotation to be applied during import (with preset for Maya and Max)
	#jira UE-35510

Change 3137949 on 2016/09/23 by Jurre.deBaare

	Frame range importing causes confusion during Alembic importing
	#fix this required storing information per Alembic object at which frame index it actual has stored frames, using this data we can determine which frames are empty, and at which frame there is data. This allows us to skip empty frames if we want to import data-only frames, or to import all frames in the sequence including empty (pre-roll) frames.
	#misc changed settings UI listview layout (extra columns and resized old ones)
	#jira UE-35498

Change 3137994 on 2016/09/23 by Martin.Wilson

	Fix for creating an empty state when dragging a montage into a state machine graph

	#jira UE-33371

Change 3138103 on 2016/09/23 by Aaron.McLeran

	UE-36312 Fixing sound node distance cross fade for case of looping sounds

Change 3138104 on 2016/09/23 by Aaron.McLeran

	UE-35392 Copy pasting local node into separate project crashes the engine

Change 3138224 on 2016/09/23 by Aaron.McLeran

	UE-36312 Fixing sound node distance cross fade for case of looping sounds

	- Adding a check for wave instance count to account for virtualized sounds (one-shots)

Change 3138666 on 2016/09/23 by Ben.Zeigler

	#UEFW-204 Add more comprehensive gameplay tag tests
	Fix issue with HasTag(Tag, IncludeParent, IncludeParent) revealed by tests, this was not returning true correctly in some cases. This use case is weird and will be deprecated soon

Change 3138779 on 2016/09/23 by Marc.Audy

	Get rid of pointless casts

Change 3138782 on 2016/09/23 by Marc.Audy

	remove some GWorlds

Change 3139701 on 2016/09/26 by Jurre.deBaare

	Assert failed on GemetryCache for PS4 package
	#fix add GeometryCache reference in engine build.cs and fix the serialization of geometry cache files
	#jira UE-36392

Change 3139704 on 2016/09/26 by Jurre.deBaare

	Fix for -1 begin frame
	#fix do the max as an signed int, to make sure we don't wrap around

Change 3139748 on 2016/09/26 by Benn.Gallagher

	PR #2784: Make sure that SceneScratchBufferSize is a multiple of 16K as requested by PhysX (Contributed by DenizPiri)

	Moved the definition of the boundary to a FPhysScene class static
	Changed comments on original user settings property to communicate the fact that the value is now rounded to the next 16K boundary

	#jira UE-35736

Change 3139903 on 2016/09/26 by Benn.Gallagher

	Fixed exposing subinstance pins stomping over class defaults and setting to uninitialized values
	#jira UE-34366

Change 3140409 on 2016/09/26 by Lukasz.Furman

	fixed uninitialized configs of gameplay debugger
	copy of CL# 3140399

Change 3140516 on 2016/09/26 by dan.reynolds

	AEOverview Map Update - Ambient Zone + Focus Test

Change 3140526 on 2016/09/26 by Jon.Nabozny

	#rn Fixed CanJump inconsistencies with previous versions.

	Deferred JumpCurrentCount increment until after jump, made bWasJumping a member variable, and updated how
	jump count and hold time were compared in CanJump.

	#jira UE-35524, UE-35582

Change 3140745 on 2016/09/26 by dan.reynolds

	AEOverview Test Map Update + Occlusion Test

Change 3140839 on 2016/09/26 by dan.reynolds

	AEOverview - minor updates

Change 3141101 on 2016/09/27 by Thomas.Sarkanen

	Preview scene worlds now render correctly

	Split "Preview" type into "EditorPreview" (the default) and "GamePreview". Deprecated the old "Preview" world type (but kept its index).
	In-game hidden flags now apply to GamePreview, but not EditorPreview worlds.
	Deprecated old bHack_Force_UsesGameHiddenFlags_True boolean. GamePReview now serves this purpose.
	Fixed up UT cases where this was being used.
	FPreviewScenes now use the editor mode by default, but can be set to non-editor if needed (as is the case with the still-experimental UViewport).
	Custom depth pass is not enabled for EditorPreview (as before) but is for GamePreview.
	Fixed erroneous use of TEnumAsByte for non-uproperty WorldType.

	#jira UE-22883 - Using FPreviewScenes in-game for scene captures

Change 3141106 on 2016/09/27 by Thomas.Sarkanen

	Column toggling improvements

	Column toggle menu now does not close when items are selected.
	This requries some Slate changes to how submenus are built to allow for sumbenus to specify whether they close after selection.
	Also allowed columns to be hidden by default for specific use cases (like the sequence browser).

	#jira UE-35818 - Anim asset browser column picker should stay up

Change 3141131 on 2016/09/27 by Thomas.Sarkanen

	Fix CIS warnings

	Fallout from preview world changes

Change 3141143 on 2016/09/27 by Jurre.deBaare

	Fix for CIS errors

Change 3141235 on 2016/09/27 by Thomas.Sarkanen

	Fix offset of Persona floor mesh when auto-alignment is enabled

	When auto alignment was disabled, the offset wasnt getting taken into account.

	#jira UE-35544 - In Persona, Floor Height Offset does nothing with Auto Align Floor to Mesh disabled

Change 3141327 on 2016/09/27 by Marc.Audy

	Ensure that the client side AttachChildren array remains accurate
	#jira UE-26025

Change 3141474 on 2016/09/27 by mason.seay

	Updating test map name and moving PlayerStart

Change 3141501 on 2016/09/27 by Benn.Gallagher

	Loading time improvements for destructibles from Nvidia
	Updated to use new framework custom version instead of global object version
	Fixed usage of TArray to enable correct loading and saving of the cached data.
	#jira UE-29680

Change 3141889 on 2016/09/27 by Marc.Audy

	Fix DestructibleMesh when WITH_APEX is 0
	#jira UE-36484

Change 3142034 on 2016/09/27 by Marc.Audy

	Merging //UE4/Dev-Main to Dev-Framework (//UE4/Dev-Framework) @ 3141971

Change 3142131 on 2016/09/27 by Ori.Cohen

	Make sure we return eTouch to physx during an overlap query. Fixes bad behavior when multiple objects blocked in an overlap query.

	#JIRA UE-36381

Change 3142154 on 2016/09/27 by Ori.Cohen

	Fix build, ModuleCachedData instead of NxApexModuleCachedData

Change 3142159 on 2016/09/27 by mason.seay

	Blueprint for testing Child Actor Templates

Change 3142255 on 2016/09/27 by Jon.Nabozny

	Fix crashes in QAMeshMerge component by making it a UObject, exposing it's method statically, and taking QASkeletalMeshMergeParams as an argument.

	#jira UE-35199, UE-35197, UE-35201

Change 3142717 on 2016/09/27 by dan.reynolds

	AEOverview Update + Sound Class Test

Change 3142764 on 2016/09/27 by Marc.Audy

	Fix Ocean deprecation warnings

Change 3142962 on 2016/09/28 by Thomas.Sarkanen

	Fixed bounds calculations for local camera animations

	Correctly calculated bounds as local to the initial transform in the track.
	Implemented suggested fixes from UDN user chhaddon (The Coalition).

	#jira UE-29594 - CameraAnim bounds are incorrect when bRelativeToInitialTransform == true

Change 3143007 on 2016/09/28 by Martin.Wilson

	Added virtual bones to USkeleton

	API Breaking change:
	-Added USkeleton pointer to RemoveBonesByName
	-FReferenceSkeleton::UpdateRefPoseTransform & FReferenceSkeleton::Add made private. Must use FReferenceSkeletonModifier instead

	#jira UEFW-81

Change 3143040 on 2016/09/28 by James.Golding

	Strip DrawDebug.. functions from Shipping and Test builds, controlled by new define ENABLE_DRAW_DEBUG
	Fix up game projects to compile in Shipping/Test after this change

	PR #2757: (Contributed by projectgheist)
	#jira UE-35488

Change 3143046 on 2016/09/28 by James.Golding

	Fix OrionEnvironmentPerfTest.cpp compiling in Shipping (optimizations were not being re-enabled at end of file)

Change 3143047 on 2016/09/28 by James.Golding

	PR #2731: Capsule primitive drawing fix (Contributed by kamrann)
	#jira UE-35142

Change 3143050 on 2016/09/28 by Martin.Wilson

	Update DDC key as some animation have stale data

Change 3143088 on 2016/09/28 by Martin.Wilson

	CIS Fixes for Ocean after FReferenceSkeleton changes

Change 3143090 on 2016/09/28 by Benn.Gallagher

	Fixed split pins in animation blueprints losing their pin links on editor restart. The anim nodes had opted out of the Super version of reconstruct, but that's where split pin restoration was added so we were skipping it.
	#jira UE-36482

Change 3143091 on 2016/09/28 by Thomas.Sarkanen

	Fix play/pause keyboard shortcut toggle in Persona based editors

	Correctly handled widget mode switching in the skeleton selection edit mode (previously it was manually handling this rather than hooking into the correct level viewport callbacks).
	Added the ability for FEdModes to specify whether they can use a widget mode.
	Added a common set of commands that all Persona-based editors can opt into (only contains TogglePlay for now).

	#jira UE-35163 - Cannot use Play/Pause shortcut in Persona if viewport is focused

Change 3143100 on 2016/09/28 by James.Golding

	UE-32275  Fix Anim Curve entries losing Auto state when hidden/reshown

Change 3143107 on 2016/09/28 by Martin.Wilson

	Add check to IsRunningParallelEvaluation to verify that the skeletal mesh component in question still references us

	#jira UE-34431

Change 3143125 on 2016/09/28 by Jurre.deBaare

	PR #2749: Fix blend space triangulation (Contributed by tmiv)

Change 3143225 on 2016/09/28 by Jurre.deBaare

	Mesh/material merging basic test files

Change 3143235 on 2016/09/28 by Martin.Wilson

	Fix issue where montage wrong section was updated with changes from details panel when clicking on a new section

	#jira UE-35929

Change 3143312 on 2016/09/28 by Marc.Audy

	Don't globally reregister components, globally recreate render state instead when force deleting assets
	Fixes crash force deleting a blueprint with a child actor component in it from the content browser

Change 3143340 on 2016/09/28 by Mieszko.Zielinski

	Improved consistency of loudness usage in AISense_Hearing #UE4

Change 3143359 on 2016/09/28 by Marc.Audy

	Fix spelling error in comment

Change 3143372 on 2016/09/28 by Jurre.deBaare

	HLOD meshes are causing degenerate triangles
	#fix Setting flag to ignore degenerate triangles when building the meshes vertex/index buffers
	#jira UE-34336

Change 3143420 on 2016/09/28 by Mieszko.Zielinski

	Fix to BlackboardData initialization's dependency on parent asset's initialization #UE4

Change 3143421 on 2016/09/28 by Martin.Wilson

	Allow reading on animation sequence length in blueprints

	#jira UE-34168

Change 3143455 on 2016/09/28 by James.Golding

	Add 'noop' versions of DrawDebug function, so you will not get compile errors by default for calling them in Shipping/Test builds.
	Added optional SHIPPING_DRAW_DEBUG_ERROR define, which will give compile errors in Shipping/Test if still calling DrawDebug functions

Change 3143518 on 2016/09/28 by Jurre.deBaare

	Meshes with no UV Coordinates will break the UVs of other meshes contained in the same HLOD if they share a material
	#fix calculate UV bounds and check whether they occupy any space (if not do not use them for baking out the material)
	#misc set texture sampling for HLOD proxy base material to clamp
	#jira UE-35221

Change 3143542 on 2016/09/28 by James.Golding

	Change SHIPPING_DRAW_DEBUG_ERROR define from ifdef to if
	Fix comment
	Enable by default for FN

Change 3143543 on 2016/09/28 by Benn.Gallagher

	Changed branch + early return into an ensure during FPxQueryFilterCallback::preFilter. We were checking for invalid shapes in preFilter but that shouldn't happen. More likely to get some information as an ensure instead of earlying out on the funciton.

Change 3143556 on 2016/09/28 by Aaron.McLeran

	UE-36540 Editor Preferences 'Enable Sound' option causes Real Time Audio to Stop Working after PIE

Change 3143566 on 2016/09/28 by Benn.Gallagher

	Readded early out alongside new ensure for catching bad preFilter shapes

Change 3143568 on 2016/09/28 by Marc.Audy

	Fix deprecation warnings in UT

Change 3143572 on 2016/09/28 by Jurre.deBaare

	More test content for mesh/material merging

Change 3143581 on 2016/09/28 by Jurre.deBaare

	More content :D

Change 3143585 on 2016/09/28 by Jurre.deBaare

	Geometry cache cleaning
	#misc fix for missing materials, not serialized (facepalm) as they were added later on (required custom version bump)
	#misc cleaning out unecessary code

Change 3143594 on 2016/09/28 by Marc.Audy

	Creating a child actor component by dragging an actor blueprint in to another blueprint now properly creates the template
	#jira UE-36511

Change 3143658 on 2016/09/28 by Marc.Audy

	RootComponent can be null by the time we hit PostUnregisterAllComponents so need to protect against the dereference
	#jira UE-36553

Change 3143776 on 2016/09/28 by Marc.Audy

	Properly reinstance child actor templates when using the fast reinstancing path
	#jira UE-36516

Change 3143896 on 2016/09/28 by Ori.Cohen

	Remove UPROPERTY on aggregate threshold which is always read from the physics settings.

Change 3144022 on 2016/09/28 by Ben.Zeigler

	Move AIMoveTo node from BlueprintGraph to AIGraph and remove BlueprintGraph->AIModule dependency in build system

Change 3144252 on 2016/09/28 by mason.seay

	More blueprints for child actor template testing

Change 3144262 on 2016/09/28 by Mason.Seay

	Deleting assets

Change 3144283 on 2016/09/28 by dan.reynolds

	AEOverview update + Sound Priority Test

Change 3144411 on 2016/09/28 by dan.reynolds

	AEOverview end of day update and tweaks

Change 3144679 on 2016/09/29 by Benn.Gallagher

	Changed skeletal bounds calculation to not consider clothing assets that aren't simulating in the current LOD. In this case we're not rendering the clothing, we're only rendering the skeletal geometry for that section in that LOD which isn't bound to cloth.

Change 3144856 on 2016/09/29 by Jurre.deBaare

	HLOD Outliner scrolls back to the top when generating proxy meshes
	#fix OnLevelActorsAdded was getting called for actors in the thumbnail worlds, which forced a refresh on the listview
	#jira UE-30384

Change 3144864 on 2016/09/29 by Thomas.Sarkanen

	Preview mesh fixes

	Animation preview meshes are now respected (and saved). Mesh is displayed as empty if none is set (but a default is chosen).
	Skeleton preview meshes are now shown as empty if none is set (but a default is chosen).

	#jira UE-36582 - Cannot set preview mesh per-animation

Change 3144865 on 2016/09/29 by Jurre.deBaare

	More test content

Change 3144885 on 2016/09/29 by James.Golding

	UE-35307  Move 'invalid scale' warning to Message Log to be more visible in editor
	Change scale clamping in UpdateBodyScale to catch cases like (1,0,1)

Change 3144903 on 2016/09/29 by Thomas.Sarkanen

	Deprecating StaticMesh in UStaticMeshComponent

	Added GetStaticMesh to access the value as read-only.
	SetStaticMesh is now called in all locations that used to call "StaticMesh =".
	Lots of fixups.

	#jira UE-24859 - Deprecate public access to StaticMesh property in UStaticMeshComponent

Change 3145020 on 2016/09/29 by Thomas.Sarkanen

	Fix bounds calculations that include bones to respect LOD (and other requried bones)

	Sometimes bones would not be updated if we LOD switched, extending the bounds.

	#jira UE-36525 - UDebugSkelMeshComponent::CalcBounds should filter by LOD

Change 3145041 on 2016/09/29 by Jurre.deBaare

	Setting the Target Lightmap UV Channel to an incorrect value leads to inconsistent results
	#fix removed target light map channel, we now determine according to the UV channels which are unused in the final mesh
	#misc ignore the source lightmap uv channels to reduce data
	#jira UE-36595

Change 3145219 on 2016/09/29 by Benn.Gallagher

	Fixed clothing actors not casting shadows in editor, after the material editing change the copy of the shadow flag was missed from the clothing association code, which runs on again on older clothing assets to use the new render data skinning. Also added some fix up for assets that have be saved in the mean time.
	#jira UE-36552

Change 3145222 on 2016/09/29 by Jurre.deBaare

	Exporting Alembic Skeletal mesh from UE4 to FBX causes a crash
	#fix on import set _all_ bone influence to 0
	#jira UE-36602

Change 3145267 on 2016/09/29 by Ori.Cohen

	Move OnConstraintBreak delegate so that it fires outside of fetchResults. Fixes crash from user doing unsafe things during fetchResults.

	#JIRA UE-36483

Change 3145306 on 2016/09/29 by Jon.Nabozny

	Fixed PhAT so multiple constraints can be selected and edited properly at the same time.

	#JIRA: UE-31493

Change 3145342 on 2016/09/29 by Marc.Audy

	Do not update cull distance volumes whenever any property changes
	* Any movement or property change of a cull distance volume still does a global update
	* Any movement of a component belong to any other Actor updates only the components of that Actor
	* Any property change of a primitive component only updates that component
	#jira UE-36399

Change 3145958 on 2016/09/29 by Marc.Audy

	In game worlds don't auto activate components until the actor is ready to process them
	#jira UE-35189

Change 3146110 on 2016/09/29 by dan.reynolds

	AEOverview update + Soundwave Procedural Test Map

Change 3146375 on 2016/09/30 by Benn.Gallagher

	Fixed crash saving newly created destructible mesh after material refactor.
	#jira UE-36619

Change 3146378 on 2016/09/30 by James.Golding

	UE-35908 Line trace against a BodyInstance now returns closest hit for trimesh (was any hit before)
	Also add stat for FBodyInstance::LineTrace

Change 3146379 on 2016/09/30 by James.Golding

	Add test assets for creating procmesh collision in non-editor builds

Change 3146386 on 2016/09/30 by Thomas.Sarkanen

	Fixed ensures (and functionality) of 'show uncompressed animation' option in Persona viewports

	Made sure that PreEvaluateAnimation is called for th einstance in use, rather than only the preview instance.
	This unearthed another issuye where each of the calls to GenSpaceBAses was causing the animation to run faster. Fixed this by resetting the update flag in the update context after it is used.

	#jira UE-36251 - Ensures showing uncompressed animations in anim blueprints

Change 3146464 on 2016/09/30 by Thomas.Sarkanen

	Fix layered blend per bone odd/even connection counts alternately working/not working

	Older hacky fix for multi-property to array copies flip-flipped between using fast path and not, when it really should have disabled fast path after the first array pin. Now it disables fast path based on whether this is a new handler or not, rather than looking at the SimpleCopyPropertyName.

	#jira UE-35648 - Layered Blend Per Bone doesn't work correctly with 3+ inputs

Change 3146652 on 2016/09/30 by Benn.Gallagher

	Fixed subinstance properties appearing in the caller's details panel as oddly named properties.
	#jira UE-34141

Change 3146673 on 2016/09/30 by Martin.Wilson

	Make RawAnimationData (and associated anim sequence data) private

	#jira ue-25869

Change 3146680 on 2016/09/30 by Benn.Gallagher

	Fixed errant asterisks in tooltips for source and target bone on rotation multiplier controller node
	#jira UE-29847

Change 3146681 on 2016/09/30 by Benn.Gallagher

	Fixed incorrect tooltip on left hand IK bone in hand ik retargetting node
	#jira UE-30885

Change 3146711 on 2016/09/30 by Jon.Nabozny

	Fix PhAT SnapConstraintToBone.

	#jira UE-31491

Change 3146717 on 2016/09/30 by Danny.Bouimad

	Adding Jurres really useful merge actor test assets to somewhere QA can get em.

Change 3146738 on 2016/09/30 by Martin.Wilson

	Fix pose blending for on non-additive pose blending + remove normalising of weights for weights less than 1

	#tests Editor tests with mambo pose asset
	#jira UE-36189

Change 3146750 on 2016/09/30 by Jurre.deBaare

	Material baking issue
	#misc Removed the renderer initialization which causes issue the first time you would render out a material (gradient from top left to bottom right over the texture)
	#misc Replaced incorrect masks with _way_  better approach thanks to Martin

Change 3146755 on 2016/09/30 by Jurre.deBaare

	Need better progress bar for HLOD
	#fix replaced the progress updates with new more 'correct' ones according to the actual workload and fixed up the Simplygon progress callback
	#jira UE-34334

Change 3147085 on 2016/09/30 by Marc.Audy

	PR #2815: GetNextViewablePlayer now checking and returning correct PlayerState. (Contributed by joshkay)
	#jira UE-36632

Change 3147224 on 2016/09/30 by Martin.Wilson

	CIS Fix

Change 3147280 on 2016/09/30 by Marc.Audy

	Mouse smoothing should use application frame rate, not the dilated game frame rate
	#jira UE-31040

Change 3147446 on 2016/09/30 by Aaron.McLeran

	UE-36682 SoundCue Delay Not Consuming Input StartTime Correctly

Change 3147693 on 2016/09/30 by Ben.Zeigler

	#jira UE-36657
	If a player has an existing Pawn during RestartPlayer, use that pawn's rotation instead of the start spot, because we were already keeping the pawn's location

Change 3147697 on 2016/09/30 by Jon.Nabozny

	Add rotation parameter to FBodyInstance::Sweep and FBodyInstance::InternalSweepPhysX

	#jira UE-30486

Change 3147761 on 2016/09/30 by Jon.Nabozny

	Fix AUTRepulsorBubble UPrimitiveComponent::SweepComponent usage.

Change 3148533 on 2016/10/03 by Thomas.Sarkanen

	Fix new deprecation warnings introduced by the pull from main

Change 3148567 on 2016/10/03 by Marc.Audy

	Fix crash when exiting PIE while a panoramic screenshot is being taken
	Make stereo panorama tick with the world it is operating on
	#jira UE-36492

Change 3148571 on 2016/10/03 by Marc.Audy

	Allow modification of components that are EditAnywhere but don't exist in the CDO
	#jira UE-36694

Change 3148607 on 2016/10/03 by Martin.Wilson

	Properly end notify states when we clear the anim instance on a skeletal mesh.

	#jira UE-32488

Change 3148711 on 2016/10/03 by Martin.Wilson

	Fix type in virtual bone tooltip

	#jira UE-36703

Change 3148746 on 2016/10/03 by Benn.Gallagher

	Fixed a few cases where post process and sub instance anim calls weren't being made correctly.
	#jira UE-36529

Change 3148807 on 2016/10/03 by Martin.Wilson

	Fix mismatch skeleton error when undoing virtual bone changes

	#jira UE-36705

Change 3148812 on 2016/10/03 by Martin.Wilson

	Add undo support to removing virtual bones

	#jira UE-36706

Change 3148975 on 2016/10/03 by Jurre.deBaare

	Issue with combining meshes both with/without normal maps
	#fix make sure we always output atleast the default normal value when baking out materials, this to ensure we output non-black values for meshes without normal maps (this would cause the normal to be incorrect)
	#misc fixed issue in function to set texture rectangle to a single colour
	#misc spotted comparison error

Change 3148976 on 2016/10/03 by Ori.Cohen

	Make sure that shape queries that we pass into physx are never size 0. Fixes some NaNs

	#JIRA UE-36639

Change 3148991 on 2016/10/03 by Jurre.deBaare

	Changing LOD materials on Merged Actors Crashes Editor
	#fix take into account LOD that is using the material when remapping (removing duplicate) materials
	#jira UE-35883

Change 3148997 on 2016/10/03 by Jurre.deBaare

	Make sure we remove matrix samples that fall outside of the import range and remap those that are in range

Change 3149002 on 2016/10/03 by Jurre.deBaare

	Issues with importing Alembic caches using  matrix transformations
	#fix Apply conversion matrix to imported matrix samples to make them match the DCC package they were exported from

Change 3149030 on 2016/10/03 by Martin.Wilson

	Dont show save warning on animations when we have curve data

	#jira UE-34145

Change 3149115 on 2016/10/03 by Mieszko.Zielinski

	Made PathfollowingComponent distinct between patrial and full paths in terms of acceptance radius used, when trying to determin if pathing agent is at goal location #UE4

	#jira UE-35153

Change 3149186 on 2016/10/03 by Ben.Zeigler

	#UE-36722 Fix failure to spawn when trying to spawn 4 capsules in the exact same location
	There's no "Correct" direction to move out of a penetrating capsule, but old PhysX appeared to be consistent. New PhysX is not, so now we save and restore the adjustment instead of letting previous iterations modify it.
	This code is weird but this solution is better than the old version and handles inconsistent results

Change 3149235 on 2016/10/03 by Martin.Wilson

	Change inline curve name editing to only change the name of that specific curve, instead of renaming the smart name itself.

	#jira UE-20005

Change 3149245 on 2016/10/03 by Marc.Audy

	Remove duplicate entries from AttachChildren caused by lack of atomic cross-object updates.

Change 3149397 on 2016/10/03 by Ori.Cohen

	Fix collision profile writing out response values to channels that don't exist.

	#JIRA UE-36359

Change 3149679 on 2016/10/03 by Zak.Middleton

	#ue4 -  Don't mark CharacterMovementComponent::bUseControllerDesiredRotation as an advanced property. Consolidate rotation settings (RotationRate, bUseControllerDesiredRotation, bOrientRotationToMovement) in a new "Rotation Settings" category.

Change 3149929 on 2016/10/04 by Jurre.deBaare

	Fix for CIS errors
	#fix Mac didn't like undefined struct

Change 3149977 on 2016/10/04 by danny.bouimad

	Massive update to Merge Actor test files

Change 3150014 on 2016/10/04 by James.Golding

	UE-36686 Fix crash when slicing and not creating other section

Change 3150016 on 2016/10/04 by James.Golding

	UE-35335 MergeActors now converts box collision to convex, so collision scales correctly after merging

Change 3150019 on 2016/10/04 by James.Golding

	UE-36737 Fix LineTraceComponent not returning face index

Change 3150020 on 2016/10/04 by James.Golding

	UE-36672 Export PhysicsContstraintComponent class so it can be subclassed outside Engine module

Change 3150027 on 2016/10/04 by Ben.Marsh

	Add PhysX build option into Dev-Framework.

Change 3150042 on 2016/10/04 by Benn.Gallagher

	Fixed clothing example 1.3 collision glitches

Change 3150172 on 2016/10/04 by Benn.Gallagher

	Made Skeletal Mesh LOD reimports clear any existing simplification flag so we don't show "generated" next to LOD entries for them.
	#jira UE-36589

Change 3150319 on 2016/10/04 by Ori.Cohen

	Go back to only deferring body creation per component. This can now use the slow path when needed. Can't support deferring of multiple components without changing locking API so we'll do that in the future.

	#JIRA UE-36535, UE-36504

Change 3150355 on 2016/10/04 by Zak.Middleton

	#ue4 - Change checkSlow() to check() in GetDefaultObject<> because this is potentially an unsafe static cast.

Change 3150370 on 2016/10/04 by Ori.Cohen

	Fix deferred actors not getting flushed.

Change 3150386 on 2016/10/04 by Martin.Wilson

	Fix additive animation check failing in cooked builds when using virtual bones

	#jira UE-36743

Change 3150424 on 2016/10/04 by Ori.Cohen

	Exclude kinematic actors from active transforms generation.

Change 3150613 on 2016/10/04 by Zak.Middleton

	#ue4 - Fix bad GetDefaultObject<> in AbilitySystemGlobals. Turned up since changing checkSlow() to check() in GetDefaultObject.

	(Mirror CL 3138304  in Orion-DevGeneral)

	#jira UE-36810
	#tests compiled

Change 3150679 on 2016/10/04 by Ben.Zeigler

	Crash fix with no async scene

Change 3150765 on 2016/10/04 by Ben.Zeigler

	Deprecate UStructProperty::ExportTextItem_Static and ImportItem_Static, and add ExportText and ImportText directly to UScriptStruct
	Add bAllowNativeOverride to specify rather to call the native override. For unclear reasons the static export skipped the native override while the static import included it
	This allows calling the generic ImportText from inside a native ImportTextItem and then doing some post processing

Change 3150796 on 2016/10/04 by Marc.Audy

	Fix LOCTEXT warnings related to blueprint class menu options

Change 3150806 on 2016/10/04 by Ben.Zeigler

	Fix bad text format in import error message, lead to double error

Change 3150891 on 2016/10/04 by Ben.Zeigler

	#jira UE-36170 Fix duplicate GUID spam when async loading levels during PIE by checking the package flag instead of the runtime global

Change 3150914 on 2016/10/04 by Marc.Audy

	Don't try to recreate render state if it has already been recreated while the recreate context was active
	#jira UE-36590

Change 3151195 on 2016/10/04 by Dan.Reynolds

	Updates to QASoundWaveProcedural

	QASoundWaveProcedural edited to be a GameplayStatic which spawns an Audio Component Handler as well as a Procedural Sound Wave.  Support for envelope shaping (Attack, Sustain, Release) as well as multiple waveforms (Sine, Triangle, Sawtooth, Square).  Blueprint API expanded to include separate functions for setting QASoundWaveProcedural settings and Playing.

Change 3151233 on 2016/10/04 by Ben.Zeigler

	#jira UE-36836 Fix variable shadowing warnings

Change 3151328 on 2016/10/04 by dan.reynolds

	AEOverview Update - Added Sound Wave Procedural test map and added support for mobile (tested on Android) menu selection - Still a WIP

Change 3151461 on 2016/10/05 by Thomas.Sarkanen

	Fix localization warnings

	#jira UE-36720 - //UE4/Main: Step 'Build Engine Localization' - 2 Warnings

Change 3151546 on 2016/10/05 by Martin.Wilson

	Fix pose watch regression due to persona refactor changes.

	#jira UE-36851

Change 3151587 on 2016/10/05 by Jurre.deBaare

	Updating Simplygon to SDK version 8.0
	#misc removed redundant files
	#misc fixed landscape culling in merge actor path
	#misc added support for volume culling using simplygon
	#misc fixed when or not to use mesh data for material baking

	#notes
	Change: 3137650
	Date: 23/09/2016 07:57
	Client: Mustafa.Tungekar_Dev-Partner-Simplygon
	User: Mustafa.Tungekar
	Status: submitted
	Type: restricted
	ImportedBy:
	Identity:
	Description:
	-Renamed commandline variables for ZipUtils AutomationScript
	-Implemented Execute instead of ExecuteBuild
	-Updated commandline arguments in SimplygonSwarm
	JobStatus:
	Jobs:
	Files:
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonSwarm/Private/SimplygonSwarm.cpp#4
	//UE4/Dev-Partner-Simplygon/Engine/Source/Programs/AutomationTool/Scripts/ZipUtils.Automation.cs#2
	Change: 3137649
	Date: 23/09/2016 07:56
	Client: Mustafa.Tungekar_Dev-Partner-Simplygon
	User: Mustafa.Tungekar
	Status: submitted
	Type: restricted
	ImportedBy:
	Identity:
	Description:
	Moved file hash computation to ImportObject
	JobStatus:
	Jobs:
	Files:
	//UE4/Dev-Partner-Simplygon/Engine/Source/Editor/UnrealEd/Classes/Factories/Factory.h#4
	//UE4/Dev-Partner-Simplygon/Engine/Source/Editor/UnrealEd/Private/Factories/Factory.cpp#4
	Change: 3137646
	Date: 23/09/2016 07:55
	Client: Mustafa.Tungekar_Dev-Partner-Simplygon
	User: Mustafa.Tungekar
	Status: submitted
	Type: restricted
	ImportedBy:
	Identity:
	Description:
	Fixes CL3099204
	EditorPerProjectUserSetting
	Removed ConfigRestartRequired attribute from properties where it was not required
	MeshUtilities
	-Added FProxyFailedDelegate
	-Extended IMeshMerging to include FProxyFailed delegate
	-Added ProxyGenerationFailed method to FProxyGenerationProcessor class
	-Setup FailedDelegate for both MeshMerging and DistributedMeshMerging
	SimplygonMeshReduction
	-Added check for invalid texture id
	-Updated notes and removed commented code that is not required.
	-Setup failed delegate
	-Fixed issue where image data was never hooked into the texture.
	-Fixed issue where texture table was never passed into casters
	SimplygonSwarm
	-Setup failed delegate
	-Fixed RawMesh pointer usage.
	-Move helper method into SimplygonSwarmHelpers.h.
	-Added SimplygonSwarmHelpers
	-Removed redundant constant path to 7-zip
	-Removed GetSimplygonDirectory instead using inplace.
	-Removed commented code that is currently not required.
	-Fixed Typos
	JobStatus:
	Jobs:
	Files:
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/MeshUtilities/Private/MeshUtilities.cpp#3
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/MeshUtilities/Public/MeshUtilities.h#3
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonMeshReduction/Private/SimplygonMeshReduction.cpp#4
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonSwarm/Private/SimplygonSwarm.cpp#3
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonSwarm/Public/SimplygonSwarmHelpers.h#1
	//UE4/Dev-Partner-Simplygon/Engine/Source/Editor/UnrealEd/Classes/Editor/EditorPerProjectUserSettings.h#3
	Change: 3099204
	Date: 24/08/2016 07:56
	Client: Mustafa.Tungekar_Dev-Partner-Simplygon
	User: Mustafa.Tungekar
	Status: submitted
	Type: restricted
	ImportedBy:
	Identity:
	Description:
	Simplygon 8.0 Updates
	Deprecated support for 7.0 and updated SimplygonSwarm and SimplygonMeshReduction to use 8.0
	EditorPerProjectSettings
	*SwarmMaxUploadChunkSizeInMB for limiting the max upload size for swarm. Note the Simplygon Grid has a limitation of 2GB
	*SwarmNumOfConcurrentJobs for executing number of concurrent jobs
	*Fixed issue where SG_MATERIAL_CHANNEL_METALLIC to SG_MATERIAL_CHANNEL_METALNESS (Chage in 8.0 SDK)
	SPL, SimplygonSwarm, RESTClient
	*Bumped up SPL Version to 8
	*Fixed code paths to use ZipUtils UAT script for zipping and unzipping CL3094374
	*Removed SPL Templates for version 7.0
	*Added conditional logging to REST methods
	*Added multi part upload. The RESTClient automatically decided if large files need to be split up before uploading to simplygon grid.
	*Updated method to take in texturepath
	SimplygonMeshReduction
	*Removed minimum version requirement.
	*Bumped up minimum version
	*Chagned license file name to refelect 8.0 changes
	*MaterialBaking related method now take in TextureTable as an extra parameter. This is due to 8.0 move away from old way of setting up materials and using SimplygonShadingNetowrk based appraoch.
	JobStatus:
	Jobs:
	Files:
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonMeshReduction/Private/SimplygonMeshReduction.cpp#3
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonMeshReduction/Public/SimplygonTypes.h#2
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonSwarm/Private/SimplygonRESTClient.cpp#3
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonSwarm/Private/SimplygonSwarm.cpp#2
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonSwarm/Public/SimplygonRESTClient.h#2
	//UE4/Dev-Partner-Simplygon/Engine/Source/Developer/SimplygonSwarm/Public/SimplygonSwarmPrivatePCH.h#2
	//UE4/Dev-Partner-Simplygon/Engine/Source/Editor/UnrealEd/Classes/Editor/EditorPerProjectUserSettings.h#2
	//UE4/Dev-Partner-Simplygon/Engine/Source/Editor/UnrealEd/Private/Settings/EditorPerProjectUserSettings.cpp#2
	Change: 3099200
	Date: 24/08/2016 07:48
	Client: Mustafa.Tungekar_Dev-Partner-Simplygon
	User: Mustafa.Tungekar
	Status: submitted
	Type: restricted
	ImportedBy:
	Identity:
	Description:
	#fix Copy constructor for FMeshReduciton mapped ShadingImportance to SilhouetteImportance
	JobStatus:
	Jobs:
	Files:
	//UE4/Dev-Partner-Simplygon/Engine/Source/Runtime/Engine/Classes/Engine/MeshMerging.h#2
	Change: 3099199
	Date: 24/08/2016 07:47
	Client: Mustafa.Tungekar_Dev-Partner-Simplygon
	User: Mustafa.Tungekar
	Status: submitted
	Type: restricted
	ImportedBy:
	Identity:
	Description:
	Added Automation Script ZipUtils to zip file and unzip files from SimplygonSwarm.
	This will remove any dependency on external zip program and should work across platforms
	JobStatus:
	Jobs:
	Files:
	//UE4/Dev-Partner-Simplygon/Engine/Source/Programs/AutomationTool/Scripts/AutomationScripts.Automation.csproj#2
	//UE4/Dev-Partner-Simplygon/Engine/Source/Programs/AutomationTool/Scripts/ZipUtils.Automation.cs#1
	Change: 3099197
	Date: 24/08/2016 07:40
	Client: Mustafa.Tungekar_Dev-Partner-Simplygon
	User: Mustafa.Tungekar
	Status: submitted
	Type: restricted
	ImportedBy:
	Identity:
	Description:
	*Speed improvements for FBX Scene Importer
	*Added a static method to compute Hash.
	JobStatus:
	Jobs:
	Files:
	//UE4/Dev-Partner-Simplygon/Engine/Source/Editor/UnrealEd/Classes/Factories/Factory.h#3
	//UE4/Dev-Partner-Simplygon/Engine/Source/Editor/UnrealEd/Private/Factories/Factory.cpp#3
	//UE4/Dev-Partner-Simplygon/Engine/Source/Editor/UnrealEd/Private/Fbx/FbxStaticMeshImport.cpp#2
	//UE4/Dev-Partner-Simplygon/Engine/Source/Runtime/Engine/Classes/EditorFramework/AssetImportData.h#2
	//UE4/Dev-Partner-Simplygon/Engine/Source/Runtime/Engine/Private/EditorFramework/AssetImportData.cpp#2

Change 3151664 on 2016/10/05 by Richard.Hinckley

	Fixing ACharacter template for "New C++ Class" feature. Avoiding naming a function parameter the same as an existing class member.

Change 3151729 on 2016/10/05 by Thomas.Sarkanen

	Audit of remaining NaN checks

	Some checks remain on in shipping (generally those called from blueprint):

	- AActor::TeleportTo
	- AActor::SetActorRelativeScale3D

	#jira UE-30999 - Optimize ⌠ContainsNaN÷ and ⌠ContainsNaNOrInfinite÷, audit those still in shipping/test

Change 3151742 on 2016/10/05 by Ori.Cohen

	Make sure that if physical animation component doesn't find a body and bone it doesn't crash.

	#JIRA UE-36839

Change 3151756 on 2016/10/05 by Jurre.deBaare

	Fixing d3dcompiler_47.dll missing issue
	#fix added runtime dependency and dll name to build.cs file
	#fix now load the d3dcompiler_47.dll from the Binaries/ThirdParty/Windows folder before loading the simplygon DLL

Change 3151761 on 2016/10/05 by Thomas.Sarkanen

	Fix deprecation warning from last integration

	Moved Preview to EditorPreview in FEditorWorldManager::OnWorldContextAdd.

	#jira UE-36858 - Compile UE4Editor* completed with 1 warning

Change 3151782 on 2016/10/05 by Jurre.deBaare

	Simplygon patch up
	#misc linker errors popping up from JSONCPP
	#misc incorporated emissive material property fix from other shelve
	#misc static analysis fix

Change 3151804 on 2016/10/05 by Marc.Audy

	Clear need end of frame update when unregistering a component

Change 3151928 on 2016/10/05 by Ori.Cohen

	Fix runtime DLLs not including all delay loaded physx dll files.

	#JIRA UE-36816

Change 3151977 on 2016/10/05 by Martin.Wilson

	Notifies can no longer occupy the same time on the same track.

	#jira UE-30658

Change 3151989 on 2016/10/05 by Jon.Nabozny

	Fix ArchVis character rotation pitch when looking up/down.

	#jira UE-35706

Change 3152083 on 2016/10/05 by Marc.Audy

	Ensure that pending kill components get their marked for end of frame state cleared.

Change 3152086 on 2016/10/05 by Ben.Zeigler

	#jira UE-36169 Fix it so missing linker errors that point to Blueprint CDOs are skipped, the same way it skips linker errors going to the actual class. Fixes a lot of spurious warnings from deleting components from blueprints or native classes
	Clean up the VerifyImport error handling so it also displays in -game and cook, and fix the missing class warning to work properly, previously it would happen 0% in development 100% in debug even if the class was valid

Change 3152093 on 2016/10/05 by Marc.Audy

	Change logic for when location cannot be changed for a static component to be independent of has begun play and have to do with whether construction script is running or the level is in the process of loading (mostly for backwards compatibility adjustments in post load).
	#jira UE-36146
	#jira UE-24647

Change 3152100 on 2016/10/05 by Ben.Zeigler

	Remove pragma optmize

Change 3152112 on 2016/10/05 by Marc.Audy

	Merging //UE4/Dev-Main to Dev-Framework (//UE4/Dev-Framework) @ 3152072

Change 3152134 on 2016/10/05 by Jurre.deBaare

	Simplygon/Merge actor issues
	#fix for emissive output on meshes that do not have emissive properties
	#fix for texture binning, not removing invalid split area causing overlapped textures

Change 3152136 on 2016/10/05 by James.Golding

	UE-36859 Fix tooltip saying you can click to stop recording

Change 3152169 on 2016/10/05 by James.Golding

	UE-31209 UE-30935 : Expose bDeformableMesh and bFastCook options in FTriMeshCollisionData
	ProceduralMeshComponent will now cook using 'fast' and 'deformable' options, so updating collision on sections should work correctly
	Change ERuntimePhysxCookOptimizationFlags to EPhysXMeshCookFlags and use that to pass options to CookConvex and CookTriMesh

Change 3152202 on 2016/10/05 by Jurre.deBaare

	Mac/Linux fix

Change 3152303 on 2016/10/05 by Marc.Audy

	Fix deprecation warning post merge from main

Change 3152320 on 2016/10/05 by Martin.Wilson

	Fix root motion from everything calculating incorrect root motion when animations haven't been ticking

	#jira UE-35364

Change 3152354 on 2016/10/05 by James.Golding

	PoseDriver should pass through if no poses activated

Change 3152357 on 2016/10/05 by James.Golding

	UE-36844 Remove unused OnAssetModifiedNotifier delegate from PoseAsset, ensure OnPoseListChanged is called when updating PoseAsset from anim.

Change 3152556 on 2016/10/05 by Marc.Audy

	Remove autos

Change 3152560 on 2016/10/05 by Marc.Audy

	Don't allow child actor references to be dragged from the outliner to a level script
	#jira UE-16700

Change 3152568 on 2016/10/05 by Marc.Audy

	Don't allow non-networking code to set bRemoteOwned in the actor spawn parameters
	Remove deprecated bNoCollisionFail
	#jira UE-35928

Change 3152575 on 2016/10/05 by Marc.Audy

	Allow construction script to run post move for native classes. Actor can determine whether it should only occur on finish or every call to post edit move

Change 3153101 on 2016/10/06 by Thomas.Sarkanen

	Fix crash re-opening the viewport in Persona-based editors

	#jira UE-36775 - Editor crashes when re-opening viewport in Persona

Change 3153139 on 2016/10/06 by James.Golding

	UE-36908 Remove GetRuntimeOnlyCookOptimizationFlags if cooking is not supported

Change 3153160 on 2016/10/06 by Thomas.Sarkanen

	Fix for crash when deleting additive layer track

	Code had not been updated to use the new delgate system (was still using reciprocal FPersona ptr).

	#jira UE-36740 - Crash when removing or disabling an additive layer track in Persona

Change 3153175 on 2016/10/06 by Benn.Gallagher

	Fixed crashes when using subinstances in non-default states. we previously initialized the anim instances in the node initialize, but in states that haven't been hit by an initialize this will happen off the game thread which is not allowed.
	#jira UE-36900

Change 3153223 on 2016/10/06 by Thomas.Sarkanen

	Fixed crash when opening an asset from the blend space editor

	Code was still trying to open 'old' Persona when it was disabled.
	Also fix other call sites where this was being done outside of asset type actions.

	#jira UE-36766 - Crash attempting to open an asset from Aim Offset graph in Persona

Change 3153324 on 2016/10/06 by Thomas.Sarkanen

	Prevented invalid GUIDs from being saved into smart name containers

	AddOrFindName now checks to see if existing GUIDs are valid before using them.
	AddName now requires a valid GUID to be passed in.
	Also added Modify() call to the skeleton when FindOrAddSmartName is called from VerifySmartNameInternal, as without  this the skeleton might not get saved.
	Also add Laurent's fix for fixing up already-saved invalid GUIDs (CL 3138068).

	#jira UE-36367 - It is possible for curves with an invalid GUID to be saved into the USkeleton asset

Change 3153348 on 2016/10/06 by Martin.Wilson

	Re add ticking code so all Persona editors viewports tick during drag events (went missing in Persona refactor)

	#jira UE-36751

Change 3153426 on 2016/10/06 by Mieszko.Zielinski

	Added missing elements of block comments support in BT editor #UE4

Change 3153454 on 2016/10/06 by Benn.Gallagher

	Fixed crash using anim debug with subinstances that are preceded by branching nodes.
	#jira UE-36935

[CL 3153517 by Ori Cohen in Main branch]
2016-10-06 12:11:11 -04:00

8710 lines
297 KiB
C++
Raw Blame History

// Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.
#include "MeshUtilitiesPrivate.h"
#include "StaticMeshResources.h"
#include "SkeletalMeshTypes.h"
#include "MeshBuild.h"
#include "TessellationRendering.h"
#include "NvTriStrip.h"
#include "forsythtriangleorderoptimizer.h"
#include "nvtess.h"
#include "SkeletalMeshTools.h"
#include "ImageUtils.h"
#include "Textures/TextureAtlas.h"
#include "LayoutUV.h"
#include "mikktspace.h"
#include "DistanceFieldAtlas.h"
#include "FbxErrors.h"
#include "Components/SplineMeshComponent.h"
#include "PhysicsEngine/BodySetup.h"
#include "MaterialUtilities.h"
#include "HierarchicalLODUtilities.h"
#include "HierarchicalLODUtilitiesModule.h"
#include "MeshBoneReduction.h"
#include "MeshMergeData.h"
#include "Editor/EditorPerProjectUserSettings.h"
#include "GPUSkinVertexFactory.h"
#include "Landscape.h"
#include "LandscapeProxy.h"
#include "LandscapeHeightfieldCollisionComponent.h"
#include "Engine/MeshMergeCullingVolume.h"
#include "ProxyMaterialUtilities.h"
#include "LevelEditor.h"
#include "IAnimationBlueprintEditorModule.h"
#include "IAnimationEditorModule.h"
#include "ISkeletalMeshEditorModule.h"
#include "ISkeletonEditorModule.h"
#include "IPersonaToolkit.h"
#include "Dialogs/DlgPickAssetPath.h"
#include "SkeletalRenderPublic.h"
#include "AssetRegistryModule.h"
#include "SNotificationList.h"
#include "NotificationManager.h"
#include "Toolkits/AssetEditorManager.h"
#include "StaticMeshResources.h"
//@todo - implement required vector intrinsics for other implementations
#if PLATFORM_ENABLE_VECTORINTRINSICS
#include "kDOP.h"
#endif
#if WITH_EDITOR
#include "Editor.h"
#endif
/*------------------------------------------------------------------------------
MeshUtilities module.
------------------------------------------------------------------------------*/
// The version string is a GUID. If you make a change to mesh utilities that
// causes meshes to be rebuilt you MUST generate a new GUID and replace this
// string with it.
#define MESH_UTILITIES_VER TEXT("8C68575CEF434CA8A9E1DA4AED8A47BB")
DEFINE_LOG_CATEGORY_STATIC(LogMeshUtilities, Verbose, All);
#define LOCTEXT_NAMESPACE "MeshUtils"
// CVars
static TAutoConsoleVariable<int32> CVarTriangleOrderOptimization(
TEXT("r.TriangleOrderOptimization"),
1,
TEXT("Controls the algorithm to use when optimizing the triangle order for the post-transform cache.\n")
TEXT("0: Use NVTriStrip (slower)\n")
TEXT("1: Use Forsyth algorithm (fastest)(default)")
TEXT("2: No triangle order optimization. (least efficient, debugging purposes only)"),
ECVF_Default);
static TAutoConsoleVariable<int32> CVarUseSimplygon(
TEXT("r.UseSimplygon"),
1,
TEXT("Whether to use Simplygon.\n")
TEXT("0: Don't use Simplygon for anything\n")
TEXT("1: Use Simplygon where necessary (not for static mesh reduction)")
TEXT("2: Use Simplygon for everything (including static mesh reduction)"),
ECVF_Default);
class FMeshUtilities : public IMeshUtilities
{
public:
/** Default constructor. */
FMeshUtilities()
: MeshReduction(NULL)
, MeshMerging(NULL)
, DistributedMeshMerging(NULL)
, Processor(NULL)
{
}
private:
/** Cached pointer to the mesh reduction interface. */
IMeshReduction* MeshReduction;
/** Cached pointer to the mesh merging interface. */
IMeshMerging* MeshMerging;
/** Cached pointer to the distributed mesh merging interface. */
IMeshMerging* DistributedMeshMerging;
/** Cached version string. */
FString VersionString;
/** True if Simplygon is being used for mesh reduction. */
bool bUsingSimplygon;
/** True if NvTriStrip is being used for tri order optimization. */
bool bUsingNvTriStrip;
/** True if we disable triangle order optimization. For debugging purposes only */
bool bDisableTriangleOrderOptimization;
class FProxyGenerationProcessor* Processor;
// IMeshUtilities interface.
virtual const FString& GetVersionString() const override
{
return VersionString;
}
virtual bool BuildStaticMesh(
FStaticMeshRenderData& OutRenderData,
TArray<FStaticMeshSourceModel>& SourceModels,
const FStaticMeshLODGroup& LODGroup
) override;
virtual void BuildStaticMeshVertexAndIndexBuffers(
TArray<FStaticMeshBuildVertex>& OutVertices,
TArray<TArray<uint32> >& OutPerSectionIndices,
TArray<int32>& OutWedgeMap,
const FRawMesh& RawMesh,
const TMultiMap<int32, int32>& OverlappingCorners,
const TMap<uint32, uint32>& MaterialToSectionMapping,
float ComparisonThreshold,
FVector BuildScale
) override;
virtual bool GenerateStaticMeshLODs(TArray<FStaticMeshSourceModel>& Models, const FStaticMeshLODGroup& LODGroup) override;
virtual void GenerateSignedDistanceFieldVolumeData(
const FStaticMeshLODResources& LODModel,
class FQueuedThreadPool& ThreadPool,
const TArray<EBlendMode>& MaterialBlendModes,
const FBoxSphereBounds& Bounds,
float DistanceFieldResolutionScale,
float DistanceFieldBias,
bool bGenerateAsIfTwoSided,
FDistanceFieldVolumeData& OutData) override;
virtual bool BuildSkeletalMesh(FStaticLODModel& LODModel, const FReferenceSkeleton& RefSkeleton, const TArray<FVertInfluence>& Influences, const TArray<FMeshWedge>& Wedges, const TArray<FMeshFace>& Faces, const TArray<FVector>& Points, const TArray<int32>& PointToOriginalMap, const MeshBuildOptions& BuildOptions = MeshBuildOptions(), TArray<FText> * OutWarningMessages = NULL, TArray<FName> * OutWarningNames = NULL) override;
bool BuildSkeletalMesh_Legacy(FStaticLODModel& LODModel, const FReferenceSkeleton& RefSkeleton, const TArray<FVertInfluence>& Influences, const TArray<FMeshWedge>& Wedges, const TArray<FMeshFace>& Faces, const TArray<FVector>& Points, const TArray<int32>& PointToOriginalMap, bool bKeepOverlappingVertices = false, bool bComputeNormals = true, bool bComputeTangents = true, TArray<FText> * OutWarningMessages = NULL, TArray<FName> * OutWarningNames = NULL);
virtual IMeshReduction* GetMeshReductionInterface() override;
virtual IMeshMerging* GetMeshMergingInterface() override;
virtual void CacheOptimizeIndexBuffer(TArray<uint16>& Indices) override;
virtual void CacheOptimizeIndexBuffer(TArray<uint32>& Indices) override;
void CacheOptimizeVertexAndIndexBuffer(TArray<FStaticMeshBuildVertex>& Vertices, TArray<TArray<uint32> >& PerSectionIndices, TArray<int32>& WedgeMap);
virtual void BuildSkeletalAdjacencyIndexBuffer(
const TArray<FSoftSkinVertex>& VertexBuffer,
const uint32 TexCoordCount,
const TArray<uint32>& Indices,
TArray<uint32>& OutPnAenIndices
) override;
virtual void RechunkSkeletalMeshModels(USkeletalMesh* SrcMesh, int32 MaxBonesPerChunk) override;
virtual void CalcBoneVertInfos(USkeletalMesh* SkeletalMesh, TArray<FBoneVertInfo>& Infos, bool bOnlyDominant) override;
/**
* Convert a set of mesh components in their current pose to a static mesh.
* @param InMeshComponents The mesh components we want to convert
* @param InRootTransform The transform of the root of the mesh we want to output
* @param InPackageName The package name to create the static mesh in. If this is empty then a dialog will be displayed to pick the mesh.
* @return a new static mesh (specified by the user)
*/
virtual UStaticMesh* ConvertMeshesToStaticMesh(const TArray<UMeshComponent*>& InMeshComponents, const FTransform& InRootTransform = FTransform::Identity, const FString& InPackageName = FString()) override;
/**
* Builds a renderable skeletal mesh LOD model. Note that the array of chunks
* will be destroyed during this process!
* @param LODModel Upon return contains a renderable skeletal mesh LOD model.
* @param RefSkeleton The reference skeleton associated with the model.
* @param Chunks Skinned mesh chunks from which to build the renderable model.
* @param PointToOriginalMap Maps a vertex's RawPointIdx to its index at import time.
*/
void BuildSkeletalModelFromChunks(FStaticLODModel& LODModel, const FReferenceSkeleton& RefSkeleton, TArray<FSkinnedMeshChunk*>& Chunks, const TArray<int32>& PointToOriginalMap);
// IModuleInterface interface.
virtual void StartupModule() override;
virtual void ShutdownModule() override;
DEPRECATED(4.12, "Please use MergeActor with new signature instead")
virtual void MergeActors(
const TArray<AActor*>& SourceActors,
const FMeshMergingSettings& InSettings,
UPackage* InOuter,
const FString& InBasePackageName,
int32 UseLOD, // does not build all LODs but only use this LOD to create base mesh
TArray<UObject*>& OutAssetsToSync,
FVector& OutMergedActorLocation,
bool bSilent = false) const override;
virtual void MergeActors(
const TArray<AActor*>& SourceActors,
const FMeshMergingSettings& InSettings,
UPackage* InOuter,
const FString& InBasePackageName,
TArray<UObject*>& OutAssetsToSync,
FVector& OutMergedActorLocation,
bool bSilent = false) const override;
DEPRECATED(4.12, "Please use MergeStaticMeshComponents with new signature instead")
virtual void MergeStaticMeshComponents(
const TArray<UStaticMeshComponent*>& ComponentsToMerge,
UWorld* World,
const FMeshMergingSettings& InSettings,
UPackage* InOuter,
const FString& InBasePackageName,
int32 UseLOD, // does not build all LODs but only use this LOD to create base mesh
TArray<UObject*>& OutAssetsToSync,
FVector& OutMergedActorLocation,
const float ScreenAreaSize,
bool bSilent = false) const override;
virtual void MergeStaticMeshComponents(
const TArray<UStaticMeshComponent*>& ComponentsToMerge,
UWorld* World,
const FMeshMergingSettings& InSettings,
UPackage* InOuter,
const FString& InBasePackageName,
TArray<UObject*>& OutAssetsToSync,
FVector& OutMergedActorLocation,
const float ScreenAreaSize,
bool bSilent = false) const override;
virtual void CreateProxyMesh(const TArray<AActor*>& InActors, const struct FMeshProxySettings& InMeshProxySettings, UPackage* InOuter, const FString& InProxyBasePackageName, const FGuid InGuid, FCreateProxyDelegate InProxyCreatedDelegate, const bool bAllowAsync,
const float ScreenAreaSize = 1.0f) override;
DEPRECATED(4.11, "Please use CreateProxyMesh with new signature")
virtual void CreateProxyMesh(
const TArray<AActor*>& Actors,
const struct FMeshProxySettings& InProxySettings,
UPackage* InOuter,
const FString& ProxyBasePackageName,
TArray<UObject*>& OutAssetsToSync,
FVector& OutProxyLocation
) override;
virtual void CreateProxyMesh(
const TArray<AActor*>& Actors,
const struct FMeshProxySettings& InProxySettings,
UPackage* InOuter,
const FString& ProxyBasePackageName,
TArray<UObject*>& OutAssetsToSync,
const float ScreenAreaSize = 1.0f) override;
virtual void FlattenMaterialsWithMeshData(TArray<UMaterialInterface*>& InMaterials, TArray<FRawMeshExt>& InSourceMeshes, TMap<FMeshIdAndLOD, TArray<int32>>& InMaterialIndexMap, TArray<bool>& InMeshShouldBakeVertexData, const FMaterialProxySettings &InMaterialProxySettings, TArray<FFlattenMaterial> &OutFlattenedMaterials) const override;
bool ConstructRawMesh(
const UStaticMeshComponent* InMeshComponent,
int32 InLODIndex,
const bool bPropagateVertexColours,
FRawMesh& OutRawMesh,
TArray<FSectionInfo>& OutUniqueSections,
TArray<int32>& OutGlobalMaterialIndices
) const;
virtual void ExtractMeshDataForGeometryCache(FRawMesh& RawMesh, const FMeshBuildSettings& BuildSettings, TArray<FStaticMeshBuildVertex>& OutVertices, TArray<TArray<uint32> >& OutPerSectionIndices);
virtual bool PropagatePaintedColorsToRawMesh(const UStaticMeshComponent* StaticMeshComponent, int32 LODIndex, FRawMesh& RawMesh) const override;
virtual void CalculateTextureCoordinateBoundsForRawMesh(const FRawMesh& InRawMesh, TArray<FBox2D>& OutBounds) const override;
virtual void CalculateTextureCoordinateBoundsForSkeletalMesh(const FStaticLODModel& LODModel, TArray<FBox2D>& OutBounds) const override;
virtual bool GenerateUniqueUVsForStaticMesh(const FRawMesh& RawMesh, int32 TextureResolution, TArray<FVector2D>& OutTexCoords) const override;
virtual bool GenerateUniqueUVsForSkeletalMesh(const FStaticLODModel& LODModel, int32 TextureResolution, TArray<FVector2D>& OutTexCoords) const override;
virtual bool RemoveBonesFromMesh(USkeletalMesh* SkeletalMesh, int32 LODIndex, const TArray<FName>* BoneNamesToRemove) const override;
virtual void CalculateTangents(const TArray<FVector>& InVertices, const TArray<uint32>& InIndices, const TArray<FVector2D>& InUVs, const TArray<uint32>& InSmoothingGroupIndices, const uint32 InTangentOptions, TArray<FVector>& OutTangentX, TArray<FVector>& OutTangentY, TArray<FVector>& OutNormals) const override;
// Need to call some members from this class, (which is internal to this module)
friend class FStaticMeshUtilityBuilder;
protected:
void AddAnimationBlueprintEditorToolbarExtender();
void RemoveAnimationBlueprintEditorToolbarExtender();
TSharedRef<FExtender> GetAnimationBlueprintEditorToolbarExtender(const TSharedRef<FUICommandList> CommandList, TSharedRef<IAnimationBlueprintEditor> InAnimationBlueprintEditor);
void AddAnimationEditorToolbarExtender();
void RemoveAnimationEditorToolbarExtender();
TSharedRef<FExtender> GetAnimationEditorToolbarExtender(const TSharedRef<FUICommandList> CommandList, TSharedRef<IAnimationEditor> InAnimationEditor);
void AddSkeletalMeshEditorToolbarExtender();
void RemoveSkeletalMeshEditorToolbarExtender();
TSharedRef<FExtender> GetSkeletalMeshEditorToolbarExtender(const TSharedRef<FUICommandList> CommandList, TSharedRef<ISkeletalMeshEditor> InSkeletalMeshEditor);
void AddSkeletonEditorToolbarExtender();
void RemoveSkeletonEditorToolbarExtender();
TSharedRef<FExtender> GetSkeletonEditorToolbarExtender(const TSharedRef<FUICommandList> CommandList, TSharedRef<ISkeletonEditor> InSkeletonEditor);
void HandleAddConvertComponentToStaticMeshToToolbar(FToolBarBuilder& ParentToolbarBuilder, UMeshComponent* MeshComponent);
void AddLevelViewportMenuExtender();
void RemoveLevelViewportMenuExtender();
TSharedRef<FExtender> GetLevelViewportContextMenuExtender(const TSharedRef<FUICommandList> CommandList, const TArray<AActor*> InActors);
void ConvertActorMeshesToStaticMesh(const TArray<AActor*> InActors);
FDelegateHandle ModuleLoadedDelegateHandle;
FDelegateHandle LevelViewportExtenderHandle;
FDelegateHandle AnimationBlueprintEditorExtenderHandle;
FDelegateHandle AnimationEditorExtenderHandle;
FDelegateHandle SkeletalMeshEditorExtenderHandle;
FDelegateHandle SkeletonEditorExtenderHandle;
};
IMPLEMENT_MODULE(FMeshUtilities, MeshUtilities);
class FProxyGenerationProcessor : FTickerObjectBase
{
public:
FProxyGenerationProcessor()
{
#if WITH_EDITOR
FEditorDelegates::MapChange.AddRaw(this, &FProxyGenerationProcessor::OnMapChange);
FEditorDelegates::NewCurrentLevel.AddRaw(this, &FProxyGenerationProcessor::OnNewCurrentLevel);
#endif // WITH_EDITOR
}
~FProxyGenerationProcessor()
{
#if WITH_EDITOR
FEditorDelegates::MapChange.RemoveAll(this);
FEditorDelegates::NewCurrentLevel.RemoveAll(this);
#endif // WITH_EDITOR
}
void AddProxyJob(FGuid InJobGuid, FMergeCompleteData* InCompleteData)
{
FScopeLock Lock(&StateLock);
ProxyMeshJobs.Add(InJobGuid, InCompleteData);
}
virtual bool Tick(float DeltaTime) override
{
FScopeLock Lock(&StateLock);
for (const auto& Entry : ToProcessJobDataMap)
{
FGuid JobGuid = Entry.Key;
FProxyGenerationData* Data = Entry.Value;
// Process the job
ProcessJob(JobGuid, Data);
// Data retrieved so can now remove the job from the map
ProxyMeshJobs.Remove(JobGuid);
delete Data->MergeData;
delete Data;
}
ToProcessJobDataMap.Reset();
return true;
}
void ProxyGenerationComplete(FRawMesh& OutProxyMesh, struct FFlattenMaterial& OutMaterial, const FGuid OutJobGUID)
{
FScopeLock Lock(&StateLock);
FMergeCompleteData** FindData = ProxyMeshJobs.Find(OutJobGUID);
if (FindData && *FindData)
{
FMergeCompleteData* Data = *FindData;
FProxyGenerationData* GenerationData = new FProxyGenerationData();
GenerationData->Material = OutMaterial;
GenerationData->RawMesh = OutProxyMesh;
GenerationData->MergeData = Data;
ToProcessJobDataMap.Add(OutJobGUID, GenerationData);
}
}
//@third party BEGIN SIMPLYGON
void ProxyGenerationFailed(const FGuid OutJobGUID, const FString& ErrorMessage)
{
FScopeLock Lock(&StateLock);
FMergeCompleteData** FindData = ProxyMeshJobs.Find(OutJobGUID);
if (FindData && *FindData)
{
UE_LOG(LogMeshUtilities, Log, TEXT("Failed to generate proxy mesh for cluster %s, %s"), *(*FindData)->ProxyBasePackageName, *ErrorMessage);
ProxyMeshJobs.Remove(OutJobGUID);
}
}
//@third party END SIMPLYGON
protected:
/** Called when the map has changed*/
void OnMapChange(uint32 MapFlags)
{
ClearProcessingData();
}
/** Called when the current level has changed */
void OnNewCurrentLevel()
{
ClearProcessingData();
}
/** Clears the processing data array/map */
void ClearProcessingData()
{
FScopeLock Lock(&StateLock);
ProxyMeshJobs.Empty();
ToProcessJobDataMap.Empty();
}
protected:
/** Structure storing the data required during processing */
struct FProxyGenerationData
{
FRawMesh RawMesh;
FFlattenMaterial Material;
FMergeCompleteData* MergeData;
};
void ProcessJob(const FGuid& JobGuid, FProxyGenerationData* Data)
{
TArray<UObject*> OutAssetsToSync;
const FString AssetBaseName = FPackageName::GetShortName(Data->MergeData->ProxyBasePackageName);
const FString AssetBasePath = Data->MergeData->InOuter ? TEXT("") : FPackageName::GetLongPackagePath(Data->MergeData->ProxyBasePackageName) + TEXT("/");
// Retrieve flattened material data
FFlattenMaterial& FlattenMaterial = Data->Material;
// Resize flattened material
FMaterialUtilities::ResizeFlattenMaterial(FlattenMaterial, Data->MergeData->InProxySettings);
// Optimize flattened material
FMaterialUtilities::OptimizeFlattenMaterial(FlattenMaterial);
// Create a new proxy material instance
UMaterialInstanceConstant* ProxyMaterial = ProxyMaterialUtilities::CreateProxyMaterialInstance(Data->MergeData->InOuter, Data->MergeData->InProxySettings.MaterialSettings, FlattenMaterial, AssetBasePath, AssetBaseName);
// Set material static lighting usage flag if project has static lighting enabled
static const auto AllowStaticLightingVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.AllowStaticLighting"));
const bool bAllowStaticLighting = (!AllowStaticLightingVar || AllowStaticLightingVar->GetValueOnGameThread() != 0);
if (bAllowStaticLighting)
{
ProxyMaterial->CheckMaterialUsage(MATUSAGE_StaticLighting);
}
// Construct proxy static mesh
UPackage* MeshPackage = Data->MergeData->InOuter;
FString MeshAssetName = TEXT("SM_") + AssetBaseName;
if (MeshPackage == nullptr)
{
MeshPackage = CreatePackage(NULL, *(AssetBasePath + MeshAssetName));
MeshPackage->FullyLoad();
MeshPackage->Modify();
}
UStaticMesh* StaticMesh = NewObject<UStaticMesh>(MeshPackage, FName(*MeshAssetName), RF_Public | RF_Standalone);
StaticMesh->InitResources();
FString OutputPath = StaticMesh->GetPathName();
// make sure it has a new lighting guid
StaticMesh->LightingGuid = FGuid::NewGuid();
// Set it to use textured lightmaps. Note that Build Lighting will do the error-checking (texcoordindex exists for all LODs, etc).
StaticMesh->LightMapResolution = Data->MergeData->InProxySettings.LightMapResolution;
StaticMesh->LightMapCoordinateIndex = 1;
FStaticMeshSourceModel* SrcModel = new (StaticMesh->SourceModels) FStaticMeshSourceModel();
/*Don't allow the engine to recalculate normals*/
SrcModel->BuildSettings.bRecomputeNormals = false;
SrcModel->BuildSettings.bRecomputeTangents = false;
SrcModel->BuildSettings.bRemoveDegenerates = true;
SrcModel->BuildSettings.bUseHighPrecisionTangentBasis = false;
SrcModel->BuildSettings.bUseFullPrecisionUVs = false;
SrcModel->RawMeshBulkData->SaveRawMesh(Data->RawMesh);
//Assign the proxy material to the static mesh
StaticMesh->StaticMaterials.Add(FStaticMaterial(ProxyMaterial));
StaticMesh->Build();
StaticMesh->PostEditChange();
OutAssetsToSync.Add(StaticMesh);
// Execute the delegate received from the user
Data->MergeData->CallbackDelegate.ExecuteIfBound(JobGuid, OutAssetsToSync);
}
protected:
/** Holds Proxy mesh job data together with the job Guid */
TMap<FGuid, FMergeCompleteData*> ProxyMeshJobs;
/** Holds Proxy generation data together with the job Guid */
TMap<FGuid, FProxyGenerationData*> ToProcessJobDataMap;
/** Critical section to keep ProxyMeshJobs/ToProcessJobDataMap access thread-safe */
FCriticalSection StateLock;
};
//@todo - implement required vector intrinsics for other implementations
#if PLATFORM_ENABLE_VECTORINTRINSICS
class FMeshBuildDataProvider
{
public:
/** Initialization constructor. */
FMeshBuildDataProvider(
const TkDOPTree<const FMeshBuildDataProvider, uint32>& InkDopTree) :
kDopTree(InkDopTree)
{}
// kDOP data provider interface.
FORCEINLINE const TkDOPTree<const FMeshBuildDataProvider, uint32>& GetkDOPTree(void) const
{
return kDopTree;
}
FORCEINLINE const FMatrix& GetLocalToWorld(void) const
{
return FMatrix::Identity;
}
FORCEINLINE const FMatrix& GetWorldToLocal(void) const
{
return FMatrix::Identity;
}
FORCEINLINE FMatrix GetLocalToWorldTransposeAdjoint(void) const
{
return FMatrix::Identity;
}
FORCEINLINE float GetDeterminant(void) const
{
return 1.0f;
}
private:
const TkDOPTree<const FMeshBuildDataProvider, uint32>& kDopTree;
};
/** Generates unit length, stratified and uniformly distributed direction samples in a hemisphere. */
void GenerateStratifiedUniformHemisphereSamples(int32 NumThetaSteps, int32 NumPhiSteps, FRandomStream& RandomStream, TArray<FVector4>& Samples)
{
Samples.Empty(NumThetaSteps * NumPhiSteps);
for (int32 ThetaIndex = 0; ThetaIndex < NumThetaSteps; ThetaIndex++)
{
for (int32 PhiIndex = 0; PhiIndex < NumPhiSteps; PhiIndex++)
{
const float U1 = RandomStream.GetFraction();
const float U2 = RandomStream.GetFraction();
const float Fraction1 = (ThetaIndex + U1) / (float)NumThetaSteps;
const float Fraction2 = (PhiIndex + U2) / (float)NumPhiSteps;
const float R = FMath::Sqrt(1.0f - Fraction1 * Fraction1);
const float Phi = 2.0f * (float)PI * Fraction2;
// Convert to Cartesian
Samples.Add(FVector4(FMath::Cos(Phi) * R, FMath::Sin(Phi) * R, Fraction1));
}
}
}
class FMeshDistanceFieldAsyncTask : public FNonAbandonableTask
{
public:
FMeshDistanceFieldAsyncTask(TkDOPTree<const FMeshBuildDataProvider, uint32>* InkDopTree,
const TArray<FVector4>* InSampleDirections,
FBox InVolumeBounds,
FIntVector InVolumeDimensions,
float InVolumeMaxDistance,
float InDistanceFieldBias,
int32 InZIndex,
TArray<FFloat16>* DistanceFieldVolume)
:
kDopTree(InkDopTree),
SampleDirections(InSampleDirections),
VolumeBounds(InVolumeBounds),
VolumeDimensions(InVolumeDimensions),
VolumeMaxDistance(InVolumeMaxDistance),
DistanceFieldBias(InDistanceFieldBias),
ZIndex(InZIndex),
OutDistanceFieldVolume(DistanceFieldVolume),
bNegativeAtBorder(false)
{}
void DoWork();
FORCEINLINE TStatId GetStatId() const
{
RETURN_QUICK_DECLARE_CYCLE_STAT(FMeshDistanceFieldAsyncTask, STATGROUP_ThreadPoolAsyncTasks);
}
bool WasNegativeAtBorder() const
{
return bNegativeAtBorder;
}
private:
// Readonly inputs
TkDOPTree<const FMeshBuildDataProvider, uint32>* kDopTree;
const TArray<FVector4>* SampleDirections;
FBox VolumeBounds;
FIntVector VolumeDimensions;
float VolumeMaxDistance;
float DistanceFieldBias;
int32 ZIndex;
// Output
TArray<FFloat16>* OutDistanceFieldVolume;
bool bNegativeAtBorder;
};
void FMeshDistanceFieldAsyncTask::DoWork()
{
FMeshBuildDataProvider kDOPDataProvider(*kDopTree);
const FVector DistanceFieldVoxelSize(VolumeBounds.GetSize() / FVector(VolumeDimensions.X, VolumeDimensions.Y, VolumeDimensions.Z));
const float VoxelDiameterSqr = DistanceFieldVoxelSize.SizeSquared();
for (int32 YIndex = 0; YIndex < VolumeDimensions.Y; YIndex++)
{
for (int32 XIndex = 0; XIndex < VolumeDimensions.X; XIndex++)
{
const FVector VoxelPosition = FVector(XIndex + .5f, YIndex + .5f, ZIndex + .5f) * DistanceFieldVoxelSize + VolumeBounds.Min;
const int32 Index = (ZIndex * VolumeDimensions.Y * VolumeDimensions.X + YIndex * VolumeDimensions.X + XIndex);
float MinDistance = VolumeMaxDistance;
int32 Hit = 0;
int32 HitBack = 0;
for (int32 SampleIndex = 0; SampleIndex < SampleDirections->Num(); SampleIndex++)
{
const FVector RayDirection = (*SampleDirections)[SampleIndex];
if (FMath::LineBoxIntersection(VolumeBounds, VoxelPosition, VoxelPosition + RayDirection * VolumeMaxDistance, RayDirection))
{
FkHitResult Result;
TkDOPLineCollisionCheck<const FMeshBuildDataProvider, uint32> kDOPCheck(
VoxelPosition,
VoxelPosition + RayDirection * VolumeMaxDistance,
true,
kDOPDataProvider,
&Result);
bool bHit = kDopTree->LineCheck(kDOPCheck);
if (bHit)
{
Hit++;
const FVector HitNormal = kDOPCheck.GetHitNormal();
if (FVector::DotProduct(RayDirection, HitNormal) > 0
// MaterialIndex on the build triangles was set to 1 if two-sided, or 0 if one-sided
&& kDOPCheck.Result->Item == 0)
{
HitBack++;
}
const float CurrentDistance = VolumeMaxDistance * Result.Time;
if (CurrentDistance < MinDistance)
{
MinDistance = CurrentDistance;
}
}
}
}
const float UnsignedDistance = MinDistance;
// Consider this voxel 'inside' an object if more than 50% of the rays hit back faces
MinDistance *= (Hit == 0 || HitBack < SampleDirections->Num() * .5f) ? 1 : -1;
// If we are very close to a surface and nearly all of our rays hit backfaces, treat as inside
// This is important for one sided planes
if (FMath::Square(UnsignedDistance) < VoxelDiameterSqr && HitBack > .95f * Hit)
{
MinDistance = -UnsignedDistance;
}
MinDistance = FMath::Min(MinDistance + DistanceFieldBias, VolumeMaxDistance);
const float VolumeSpaceDistance = MinDistance / VolumeBounds.GetExtent().GetMax();
if (MinDistance < 0 &&
(XIndex == 0 || XIndex == VolumeDimensions.X - 1 ||
YIndex == 0 || YIndex == VolumeDimensions.Y - 1 ||
ZIndex == 0 || ZIndex == VolumeDimensions.Z - 1))
{
bNegativeAtBorder = true;
}
(*OutDistanceFieldVolume)[Index] = FFloat16(VolumeSpaceDistance);
}
}
}
void FMeshUtilities::GenerateSignedDistanceFieldVolumeData(
const FStaticMeshLODResources& LODModel,
class FQueuedThreadPool& ThreadPool,
const TArray<EBlendMode>& MaterialBlendModes,
const FBoxSphereBounds& Bounds,
float DistanceFieldResolutionScale,
float DistanceFieldBias,
bool bGenerateAsIfTwoSided,
FDistanceFieldVolumeData& OutData)
{
if (DistanceFieldResolutionScale > 0)
{
const double StartTime = FPlatformTime::Seconds();
const FPositionVertexBuffer& PositionVertexBuffer = LODModel.PositionVertexBuffer;
FIndexArrayView Indices = LODModel.IndexBuffer.GetArrayView();
TArray<FkDOPBuildCollisionTriangle<uint32> > BuildTriangles;
FVector BoundsSize = Bounds.GetBox().GetExtent() * 2;
float MaxDimension = FMath::Max(FMath::Max(BoundsSize.X, BoundsSize.Y), BoundsSize.Z);
// Consider the mesh a plane if it is very flat
const bool bMeshWasPlane = BoundsSize.Z * 100 < MaxDimension
// And it lies mostly on the origin
&& Bounds.Origin.Z - Bounds.BoxExtent.Z < KINDA_SMALL_NUMBER
&& Bounds.Origin.Z + Bounds.BoxExtent.Z > -KINDA_SMALL_NUMBER;
for (int32 i = 0; i < Indices.Num(); i += 3)
{
FVector V0 = PositionVertexBuffer.VertexPosition(Indices[i + 0]);
FVector V1 = PositionVertexBuffer.VertexPosition(Indices[i + 1]);
FVector V2 = PositionVertexBuffer.VertexPosition(Indices[i + 2]);
if (bMeshWasPlane)
{
// Flatten out the mesh into an actual plane, this will allow us to manipulate the component's Z scale at runtime without artifacts
V0.Z = 0;
V1.Z = 0;
V2.Z = 0;
}
const FVector LocalNormal = ((V1 - V2) ^ (V0 - V2)).GetSafeNormal();
// No degenerates
if (LocalNormal.IsUnit())
{
bool bTriangleIsOpaqueOrMasked = false;
for (int32 SectionIndex = 0; SectionIndex < LODModel.Sections.Num(); SectionIndex++)
{
const FStaticMeshSection& Section = LODModel.Sections[SectionIndex];
if ((uint32)i >= Section.FirstIndex && (uint32)i < Section.FirstIndex + Section.NumTriangles * 3)
{
if (MaterialBlendModes.IsValidIndex(Section.MaterialIndex))
{
bTriangleIsOpaqueOrMasked = !IsTranslucentBlendMode(MaterialBlendModes[Section.MaterialIndex]);
}
break;
}
}
if (bTriangleIsOpaqueOrMasked)
{
BuildTriangles.Add(FkDOPBuildCollisionTriangle<uint32>(
bGenerateAsIfTwoSided,
V0,
V1,
V2));
}
}
}
TkDOPTree<const FMeshBuildDataProvider, uint32> kDopTree;
kDopTree.Build(BuildTriangles);
//@todo - project setting
const int32 NumVoxelDistanceSamples = 1200;
TArray<FVector4> SampleDirections;
const int32 NumThetaSteps = FMath::TruncToInt(FMath::Sqrt(NumVoxelDistanceSamples / (2.0f * (float)PI)));
const int32 NumPhiSteps = FMath::TruncToInt(NumThetaSteps * (float)PI);
FRandomStream RandomStream(0);
GenerateStratifiedUniformHemisphereSamples(NumThetaSteps, NumPhiSteps, RandomStream, SampleDirections);
TArray<FVector4> OtherHemisphereSamples;
GenerateStratifiedUniformHemisphereSamples(NumThetaSteps, NumPhiSteps, RandomStream, OtherHemisphereSamples);
for (int32 i = 0; i < OtherHemisphereSamples.Num(); i++)
{
FVector4 Sample = OtherHemisphereSamples[i];
Sample.Z *= -1;
SampleDirections.Add(Sample);
}
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.DistanceFields.MaxPerMeshResolution"));
const int32 PerMeshMax = CVar->GetValueOnAnyThread();
// Meshes with explicit artist-specified scale can go higher
const int32 MaxNumVoxelsOneDim = DistanceFieldResolutionScale <= 1 ? PerMeshMax / 2 : PerMeshMax;
const int32 MinNumVoxelsOneDim = 8;
static const auto CVarDensity = IConsoleManager::Get().FindTConsoleVariableDataFloat(TEXT("r.DistanceFields.DefaultVoxelDensity"));
const float VoxelDensity = CVarDensity->GetValueOnAnyThread();
const float NumVoxelsPerLocalSpaceUnit = VoxelDensity * DistanceFieldResolutionScale;
FBox MeshBounds(Bounds.GetBox());
{
const float MaxOriginalExtent = MeshBounds.GetExtent().GetMax();
// Expand so that the edges of the volume are guaranteed to be outside of the mesh
// Any samples outside the bounds will be clamped to the border, so they must be outside
const FVector NewExtent(MeshBounds.GetExtent() + FVector(.2f * MaxOriginalExtent).ComponentMax(4 * MeshBounds.GetExtent() / MinNumVoxelsOneDim));
FBox DistanceFieldVolumeBounds = FBox(MeshBounds.GetCenter() - NewExtent, MeshBounds.GetCenter() + NewExtent);
const float DistanceFieldVolumeMaxDistance = DistanceFieldVolumeBounds.GetExtent().Size();
const FVector DesiredDimensions(DistanceFieldVolumeBounds.GetSize() * FVector(NumVoxelsPerLocalSpaceUnit));
const FIntVector VolumeDimensions(
FMath::Clamp(FMath::TruncToInt(DesiredDimensions.X), MinNumVoxelsOneDim, MaxNumVoxelsOneDim),
FMath::Clamp(FMath::TruncToInt(DesiredDimensions.Y), MinNumVoxelsOneDim, MaxNumVoxelsOneDim),
FMath::Clamp(FMath::TruncToInt(DesiredDimensions.Z), MinNumVoxelsOneDim, MaxNumVoxelsOneDim));
OutData.Size = VolumeDimensions;
OutData.LocalBoundingBox = DistanceFieldVolumeBounds;
OutData.DistanceFieldVolume.AddZeroed(VolumeDimensions.X * VolumeDimensions.Y * VolumeDimensions.Z);
TIndirectArray<FAsyncTask<FMeshDistanceFieldAsyncTask>> AsyncTasks;
for (int32 ZIndex = 0; ZIndex < VolumeDimensions.Z; ZIndex++)
{
FAsyncTask<FMeshDistanceFieldAsyncTask>* Task = new FAsyncTask<class FMeshDistanceFieldAsyncTask>(
&kDopTree,
&SampleDirections,
DistanceFieldVolumeBounds,
VolumeDimensions,
DistanceFieldVolumeMaxDistance,
DistanceFieldBias,
ZIndex,
&OutData.DistanceFieldVolume);
Task->StartBackgroundTask(&ThreadPool);
AsyncTasks.Add(Task);
}
bool bNegativeAtBorder = false;
for (int32 TaskIndex = 0; TaskIndex < AsyncTasks.Num(); TaskIndex++)
{
FAsyncTask<FMeshDistanceFieldAsyncTask>& Task = AsyncTasks[TaskIndex];
Task.EnsureCompletion(false);
bNegativeAtBorder = bNegativeAtBorder || Task.GetTask().WasNegativeAtBorder();
}
OutData.bMeshWasClosed = !bNegativeAtBorder;
OutData.bBuiltAsIfTwoSided = bGenerateAsIfTwoSided;
OutData.bMeshWasPlane = bMeshWasPlane;
UE_LOG(LogMeshUtilities, Log, TEXT("Finished distance field build in %.1fs - %ux%ux%u distance field, %u triangles"),
(float)(FPlatformTime::Seconds() - StartTime),
VolumeDimensions.X,
VolumeDimensions.Y,
VolumeDimensions.Z,
Indices.Num() / 3);
// Toss distance field if mesh was not closed
if (bNegativeAtBorder)
{
OutData.Size = FIntVector(0, 0, 0);
OutData.DistanceFieldVolume.Empty();
UE_LOG(LogMeshUtilities, Log, TEXT("Discarded distance field as mesh was not closed! Assign a two-sided material to fix."));
}
}
}
}
#else
void FMeshUtilities::GenerateSignedDistanceFieldVolumeData(
const FStaticMeshLODResources& LODModel,
class FQueuedThreadPool& ThreadPool,
const TArray<EBlendMode>& MaterialBlendModes,
const FBoxSphereBounds& Bounds,
float DistanceFieldResolutionScale,
float DistanceFieldBias,
bool bGenerateAsIfTwoSided,
FDistanceFieldVolumeData& OutData)
{
if (DistanceFieldResolutionScale > 0)
{
UE_LOG(LogMeshUtilities, Error, TEXT("Couldn't generate distance field for mesh, platform is missing required Vector intrinsics."));
}
}
#endif
/*------------------------------------------------------------------------------
NVTriStrip for cache optimizing index buffers.
------------------------------------------------------------------------------*/
namespace NvTriStrip
{
/**
* Converts 16 bit indices to 32 bit prior to passing them into the real GenerateStrips util method
*/
void GenerateStrips(
const uint8* Indices,
bool Is32Bit,
const uint32 NumIndices,
PrimitiveGroup** PrimGroups,
uint32* NumGroups
)
{
if (Is32Bit)
{
GenerateStrips((uint32*)Indices, NumIndices, PrimGroups, NumGroups);
}
else
{
// convert to 32 bit
uint32 Idx;
TArray<uint32> NewIndices;
NewIndices.AddUninitialized(NumIndices);
for (Idx = 0; Idx < NumIndices; ++Idx)
{
NewIndices[Idx] = ((uint16*)Indices)[Idx];
}
GenerateStrips(NewIndices.GetData(), NumIndices, PrimGroups, NumGroups);
}
}
/**
* Orders a triangle list for better vertex cache coherency.
*
* *** WARNING: This is safe to call for multiple threads IF AND ONLY IF all
* threads call SetListsOnly(true) and SetCacheSize(CACHESIZE_GEFORCE3). If
* NvTriStrip is ever used with different settings the library will need
* some modifications to be thread-safe. ***
*/
template<typename IndexDataType, typename Allocator>
void CacheOptimizeIndexBuffer(TArray<IndexDataType, Allocator>& Indices)
{
static_assert(sizeof(IndexDataType) == 2 || sizeof(IndexDataType) == 4, "Indices must be short or int.");
PrimitiveGroup* PrimitiveGroups = NULL;
uint32 NumPrimitiveGroups = 0;
bool Is32Bit = sizeof(IndexDataType) == 4;
SetListsOnly(true);
SetCacheSize(CACHESIZE_GEFORCE3);
GenerateStrips((uint8*)Indices.GetData(), Is32Bit, Indices.Num(), &PrimitiveGroups, &NumPrimitiveGroups);
Indices.Empty();
Indices.AddUninitialized(PrimitiveGroups->numIndices);
if (Is32Bit)
{
FMemory::Memcpy(Indices.GetData(), PrimitiveGroups->indices, Indices.Num() * sizeof(IndexDataType));
}
else
{
for (uint32 I = 0; I < PrimitiveGroups->numIndices; ++I)
{
Indices[I] = (uint16)PrimitiveGroups->indices[I];
}
}
delete[] PrimitiveGroups;
}
}
/*------------------------------------------------------------------------------
Forsyth algorithm for cache optimizing index buffers.
------------------------------------------------------------------------------*/
namespace Forsyth
{
/**
* Converts 16 bit indices to 32 bit prior to passing them into the real OptimizeFaces util method
*/
void OptimizeFaces(
const uint8* Indices,
bool Is32Bit,
const uint32 NumIndices,
uint32 NumVertices,
uint32* OutIndices,
uint16 CacheSize
)
{
if (Is32Bit)
{
OptimizeFaces((uint32*)Indices, NumIndices, NumVertices, OutIndices, CacheSize);
}
else
{
// convert to 32 bit
uint32 Idx;
TArray<uint32> NewIndices;
NewIndices.AddUninitialized(NumIndices);
for (Idx = 0; Idx < NumIndices; ++Idx)
{
NewIndices[Idx] = ((uint16*)Indices)[Idx];
}
OptimizeFaces(NewIndices.GetData(), NumIndices, NumVertices, OutIndices, CacheSize);
}
}
/**
* Orders a triangle list for better vertex cache coherency.
*/
template<typename IndexDataType, typename Allocator>
void CacheOptimizeIndexBuffer(TArray<IndexDataType, Allocator>& Indices)
{
static_assert(sizeof(IndexDataType) == 2 || sizeof(IndexDataType) == 4, "Indices must be short or int.");
bool Is32Bit = sizeof(IndexDataType) == 4;
// Count the number of vertices
uint32 NumVertices = 0;
for (int32 Index = 0; Index < Indices.Num(); ++Index)
{
if (Indices[Index] > NumVertices)
{
NumVertices = Indices[Index];
}
}
NumVertices += 1;
TArray<uint32> OptimizedIndices;
OptimizedIndices.AddUninitialized(Indices.Num());
uint16 CacheSize = 32;
OptimizeFaces((uint8*)Indices.GetData(), Is32Bit, Indices.Num(), NumVertices, OptimizedIndices.GetData(), CacheSize);
if (Is32Bit)
{
FMemory::Memcpy(Indices.GetData(), OptimizedIndices.GetData(), Indices.Num() * sizeof(IndexDataType));
}
else
{
for (int32 I = 0; I < OptimizedIndices.Num(); ++I)
{
Indices[I] = (uint16)OptimizedIndices[I];
}
}
}
}
void FMeshUtilities::CacheOptimizeIndexBuffer(TArray<uint16>& Indices)
{
if (bUsingNvTriStrip)
{
NvTriStrip::CacheOptimizeIndexBuffer(Indices);
}
else if (!bDisableTriangleOrderOptimization)
{
Forsyth::CacheOptimizeIndexBuffer(Indices);
}
}
void FMeshUtilities::CacheOptimizeIndexBuffer(TArray<uint32>& Indices)
{
if (bUsingNvTriStrip)
{
NvTriStrip::CacheOptimizeIndexBuffer(Indices);
}
else if (!bDisableTriangleOrderOptimization)
{
Forsyth::CacheOptimizeIndexBuffer(Indices);
}
}
/*------------------------------------------------------------------------------
NVTessLib for computing adjacency used for tessellation.
------------------------------------------------------------------------------*/
/**
* Provides static mesh render data to the NVIDIA tessellation library.
*/
class FStaticMeshNvRenderBuffer : public nv::RenderBuffer
{
public:
/** Construct from static mesh render buffers. */
FStaticMeshNvRenderBuffer(
const FPositionVertexBuffer& InPositionVertexBuffer,
const FStaticMeshVertexBuffer& InVertexBuffer,
const TArray<uint32>& Indices)
: PositionVertexBuffer(InPositionVertexBuffer)
, VertexBuffer(InVertexBuffer)
{
check(PositionVertexBuffer.GetNumVertices() == VertexBuffer.GetNumVertices());
mIb = new nv::IndexBuffer((void*)Indices.GetData(), nv::IBT_U32, Indices.Num(), false);
}
/** Retrieve the position and first texture coordinate of the specified index. */
virtual nv::Vertex getVertex(unsigned int Index) const
{
nv::Vertex Vertex;
check(Index < PositionVertexBuffer.GetNumVertices());
const FVector& Position = PositionVertexBuffer.VertexPosition(Index);
Vertex.pos.x = Position.X;
Vertex.pos.y = Position.Y;
Vertex.pos.z = Position.Z;
if (VertexBuffer.GetNumTexCoords())
{
const FVector2D UV = VertexBuffer.GetVertexUV(Index, 0);
Vertex.uv.x = UV.X;
Vertex.uv.y = UV.Y;
}
else
{
Vertex.uv.x = 0.0f;
Vertex.uv.y = 0.0f;
}
return Vertex;
}
private:
/** The position vertex buffer for the static mesh. */
const FPositionVertexBuffer& PositionVertexBuffer;
/** The vertex buffer for the static mesh. */
const FStaticMeshVertexBuffer& VertexBuffer;
/** Copying is forbidden. */
FStaticMeshNvRenderBuffer(const FStaticMeshNvRenderBuffer&);
FStaticMeshNvRenderBuffer& operator=(const FStaticMeshNvRenderBuffer&);
};
/**
* Provides skeletal mesh render data to the NVIDIA tessellation library.
*/
class FSkeletalMeshNvRenderBuffer : public nv::RenderBuffer
{
public:
/** Construct from static mesh render buffers. */
FSkeletalMeshNvRenderBuffer(
const TArray<FSoftSkinVertex>& InVertexBuffer,
const uint32 InTexCoordCount,
const TArray<uint32>& Indices)
: VertexBuffer(InVertexBuffer)
, TexCoordCount(InTexCoordCount)
{
mIb = new nv::IndexBuffer((void*)Indices.GetData(), nv::IBT_U32, Indices.Num(), false);
}
/** Retrieve the position and first texture coordinate of the specified index. */
virtual nv::Vertex getVertex(unsigned int Index) const
{
nv::Vertex Vertex;
check(Index < (unsigned int)VertexBuffer.Num());
const FSoftSkinVertex& SrcVertex = VertexBuffer[Index];
Vertex.pos.x = SrcVertex.Position.X;
Vertex.pos.y = SrcVertex.Position.Y;
Vertex.pos.z = SrcVertex.Position.Z;
if (TexCoordCount > 0)
{
Vertex.uv.x = SrcVertex.UVs[0].X;
Vertex.uv.y = SrcVertex.UVs[0].Y;
}
else
{
Vertex.uv.x = 0.0f;
Vertex.uv.y = 0.0f;
}
return Vertex;
}
private:
/** The vertex buffer for the skeletal mesh. */
const TArray<FSoftSkinVertex>& VertexBuffer;
const uint32 TexCoordCount;
/** Copying is forbidden. */
FSkeletalMeshNvRenderBuffer(const FSkeletalMeshNvRenderBuffer&);
FSkeletalMeshNvRenderBuffer& operator=(const FSkeletalMeshNvRenderBuffer&);
};
static void BuildStaticAdjacencyIndexBuffer(
const FPositionVertexBuffer& PositionVertexBuffer,
const FStaticMeshVertexBuffer& VertexBuffer,
const TArray<uint32>& Indices,
TArray<uint32>& OutPnAenIndices
)
{
if (Indices.Num())
{
FStaticMeshNvRenderBuffer StaticMeshRenderBuffer(PositionVertexBuffer, VertexBuffer, Indices);
nv::IndexBuffer* PnAENIndexBuffer = nv::tess::buildTessellationBuffer(&StaticMeshRenderBuffer, nv::DBM_PnAenDominantCorner, true);
check(PnAENIndexBuffer);
const int32 IndexCount = (int32)PnAENIndexBuffer->getLength();
OutPnAenIndices.Empty(IndexCount);
OutPnAenIndices.AddUninitialized(IndexCount);
for (int32 Index = 0; Index < IndexCount; ++Index)
{
OutPnAenIndices[Index] = (*PnAENIndexBuffer)[Index];
}
delete PnAENIndexBuffer;
}
else
{
OutPnAenIndices.Empty();
}
}
void FMeshUtilities::BuildSkeletalAdjacencyIndexBuffer(
const TArray<FSoftSkinVertex>& VertexBuffer,
const uint32 TexCoordCount,
const TArray<uint32>& Indices,
TArray<uint32>& OutPnAenIndices
)
{
if (Indices.Num())
{
FSkeletalMeshNvRenderBuffer SkeletalMeshRenderBuffer(VertexBuffer, TexCoordCount, Indices);
nv::IndexBuffer* PnAENIndexBuffer = nv::tess::buildTessellationBuffer(&SkeletalMeshRenderBuffer, nv::DBM_PnAenDominantCorner, true);
check(PnAENIndexBuffer);
const int32 IndexCount = (int32)PnAENIndexBuffer->getLength();
OutPnAenIndices.Empty(IndexCount);
OutPnAenIndices.AddUninitialized(IndexCount);
for (int32 Index = 0; Index < IndexCount; ++Index)
{
OutPnAenIndices[Index] = (*PnAENIndexBuffer)[Index];
}
delete PnAENIndexBuffer;
}
else
{
OutPnAenIndices.Empty();
}
}
void FMeshUtilities::RechunkSkeletalMeshModels(USkeletalMesh* SrcMesh, int32 MaxBonesPerChunk)
{
#if WITH_EDITORONLY_DATA
TIndirectArray<FStaticLODModel> DestModels;
TIndirectArray<FSkinnedModelData> ModelData;
FReferenceSkeleton RefSkeleton = SrcMesh->RefSkeleton;
uint32 VertexBufferBuildFlags = SrcMesh->GetVertexBufferFlags();
FSkeletalMeshResource* SrcMeshResource = SrcMesh->GetImportedResource();
FVector TriangleSortCenter;
bool bHaveTriangleSortCenter = SrcMesh->GetSortCenterPoint(TriangleSortCenter);
for (int32 ModelIndex = 0; ModelIndex < SrcMeshResource->LODModels.Num(); ++ModelIndex)
{
FSkinnedModelData& TmpModelData = *new(ModelData)FSkinnedModelData();
SkeletalMeshTools::CopySkinnedModelData(TmpModelData, SrcMeshResource->LODModels[ModelIndex]);
}
for (int32 ModelIndex = 0; ModelIndex < ModelData.Num(); ++ModelIndex)
{
TArray<FSkinnedMeshChunk*> Chunks;
TArray<int32> PointToOriginalMap;
TArray<ETriangleSortOption> SectionSortOptions;
const FSkinnedModelData& SrcModel = ModelData[ModelIndex];
FStaticLODModel& DestModel = *new(DestModels)FStaticLODModel();
SkeletalMeshTools::UnchunkSkeletalModel(Chunks, PointToOriginalMap, SrcModel);
SkeletalMeshTools::ChunkSkinnedVertices(Chunks, MaxBonesPerChunk);
for (int32 ChunkIndex = 0; ChunkIndex < Chunks.Num(); ++ChunkIndex)
{
int32 SectionIndex = Chunks[ChunkIndex]->OriginalSectionIndex;
SectionSortOptions.Add(SrcModel.Sections[SectionIndex].TriangleSorting);
}
check(SectionSortOptions.Num() == Chunks.Num());
BuildSkeletalModelFromChunks(DestModel, RefSkeleton, Chunks, PointToOriginalMap);
check(DestModel.Sections.Num() == SectionSortOptions.Num());
DestModel.NumTexCoords = SrcModel.NumTexCoords;
DestModel.BuildVertexBuffers(VertexBufferBuildFlags);
for (int32 SectionIndex = 0; SectionIndex < DestModel.Sections.Num(); ++SectionIndex)
{
DestModel.SortTriangles(TriangleSortCenter, bHaveTriangleSortCenter, SectionIndex, SectionSortOptions[SectionIndex]);
}
}
//@todo-rco: Swap() doesn't seem to work
Exchange(SrcMeshResource->LODModels, DestModels);
// TODO: Also need to patch bEnableShadowCasting in the LODInfo struct.
#endif // #if WITH_EDITORONLY_DATA
}
void FMeshUtilities::CalcBoneVertInfos(USkeletalMesh* SkeletalMesh, TArray<FBoneVertInfo>& Infos, bool bOnlyDominant)
{
SkeletalMeshTools::CalcBoneVertInfos(SkeletalMesh, Infos, bOnlyDominant);
}
// Helper function for ConvertMeshesToStaticMesh
static void AddOrDuplicateMaterial(UMaterialInterface* InMaterialInterface, const FString& InPackageName, TArray<UMaterialInterface*>& OutMaterials)
{
if (InMaterialInterface && !InMaterialInterface->GetOuter()->IsA<UPackage>())
{
// Convert runtime material instances to new concrete material instances
// Create new package
FString OriginalMaterialName = InMaterialInterface->GetName();
FString MaterialPath = FPackageName::GetLongPackagePath(InPackageName) / OriginalMaterialName;
FString MaterialName;
FAssetToolsModule& AssetToolsModule = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools");
AssetToolsModule.Get().CreateUniqueAssetName(MaterialPath, TEXT(""), MaterialPath, MaterialName);
UPackage* MaterialPackage = CreatePackage(NULL, *MaterialPath);
// Duplicate the object into the new package
UMaterialInterface* NewMaterialInterface = DuplicateObject<UMaterialInterface>(InMaterialInterface, MaterialPackage, *MaterialName);
NewMaterialInterface->SetFlags(RF_Public | RF_Standalone);
if (UMaterialInstanceDynamic* MaterialInstanceDynamic = Cast<UMaterialInstanceDynamic>(NewMaterialInterface))
{
UMaterialInstanceDynamic* OldMaterialInstanceDynamic = CastChecked<UMaterialInstanceDynamic>(InMaterialInterface);
MaterialInstanceDynamic->K2_CopyMaterialInstanceParameters(OldMaterialInstanceDynamic);
}
NewMaterialInterface->MarkPackageDirty();
FAssetRegistryModule::AssetCreated(NewMaterialInterface);
InMaterialInterface = NewMaterialInterface;
}
OutMaterials.Add(InMaterialInterface);
}
// Helper function for ConvertMeshesToStaticMesh
template <typename ComponentType>
static void ProcessMaterials(ComponentType* InComponent, const FString& InPackageName, TArray<UMaterialInterface*>& OutMaterials)
{
const int32 NumMaterials = InComponent->GetNumMaterials();
for (int32 MaterialIndex = 0; MaterialIndex < NumMaterials; MaterialIndex++)
{
UMaterialInterface* MaterialInterface = InComponent->GetMaterial(MaterialIndex);
AddOrDuplicateMaterial(MaterialInterface, InPackageName, OutMaterials);
}
}
// Helper function for ConvertMeshesToStaticMesh
static bool IsValidSkinnedMeshComponent(USkinnedMeshComponent* InComponent)
{
return InComponent && InComponent->MeshObject && InComponent->IsVisible();
}
/** Helper struct for tracking validity of optional buffers */
struct FRawMeshTracker
{
FRawMeshTracker()
: bValidColors(false)
{
FMemory::Memset(bValidTexCoords, 0);
}
bool bValidTexCoords[MAX_MESH_TEXTURE_COORDS];
bool bValidColors;
};
// Helper function for ConvertMeshesToStaticMesh
static void SkinnedMeshToRawMeshes(USkinnedMeshComponent* InSkinnedMeshComponent, int32 InOverallMaxLODs, const FMatrix& InComponentToWorld, const FString& InPackageName, TArray<FRawMeshTracker>& OutRawMeshTrackers, TArray<FRawMesh>& OutRawMeshes, TArray<UMaterialInterface*>& OutMaterials)
{
const int32 BaseMaterialIndex = OutMaterials.Num();
// Export all LODs to raw meshes
const int32 NumLODs = InSkinnedMeshComponent->MeshObject->GetSkeletalMeshResource().LODModels.Num();
for (int32 OverallLODIndex = 0; OverallLODIndex < InOverallMaxLODs; OverallLODIndex++)
{
int32 LODIndexRead = FMath::Min(OverallLODIndex, NumLODs - 1);
FRawMesh& RawMesh = OutRawMeshes[OverallLODIndex];
FRawMeshTracker& RawMeshTracker = OutRawMeshTrackers[OverallLODIndex];
const int32 BaseVertexIndex = RawMesh.VertexPositions.Num();
// Get the CPU skinned verts for this LOD
TArray<FFinalSkinVertex> FinalVertices;
InSkinnedMeshComponent->GetCPUSkinnedVertices(FinalVertices, LODIndexRead);
FSkeletalMeshResource& SkeletalMeshResource = InSkinnedMeshComponent->MeshObject->GetSkeletalMeshResource();
FStaticLODModel& StaticLODModel = SkeletalMeshResource.LODModels[LODIndexRead];
// Copy skinned vertex positions
for (int32 VertIndex = 0; VertIndex < FinalVertices.Num(); ++VertIndex)
{
RawMesh.VertexPositions.Add(InComponentToWorld.TransformPosition(FinalVertices[VertIndex].Position));
}
const uint32 NumTexCoords = FMath::Min(StaticLODModel.VertexBufferGPUSkin.GetNumTexCoords(), (uint32)MAX_MESH_TEXTURE_COORDS);
const int32 NumSections = StaticLODModel.Sections.Num();
FRawStaticIndexBuffer16or32Interface& IndexBuffer = *StaticLODModel.MultiSizeIndexContainer.GetIndexBuffer();
for (int32 SectionIndex = 0; SectionIndex < NumSections; SectionIndex++)
{
const FSkelMeshSection& SkelMeshSection = StaticLODModel.Sections[SectionIndex];
if (!SkelMeshSection.bDisabled)
{
// Build 'wedge' info
const int32 NumIndices = SkelMeshSection.NumTriangles * 3;
for (int32 IndexIndex = 0; IndexIndex < NumIndices; IndexIndex++)
{
int32 Index = IndexBuffer.Get(SkelMeshSection.BaseIndex + IndexIndex);
RawMesh.WedgeIndices.Add(BaseVertexIndex + Index);
const FFinalSkinVertex& SkinnedVertex = FinalVertices[Index];
const FVector TangentX = InComponentToWorld.TransformVector(SkinnedVertex.TangentX);
const FVector4 TangentZ = InComponentToWorld.TransformVector(SkinnedVertex.TangentZ);
const FVector TangentY = (TangentX ^ TangentZ).GetSafeNormal() * TangentZ.W;
RawMesh.WedgeTangentX.Add(TangentX);
RawMesh.WedgeTangentY.Add(TangentY);
RawMesh.WedgeTangentZ.Add(TangentZ);
for (uint32 TexCoordIndex = 0; TexCoordIndex < MAX_MESH_TEXTURE_COORDS; TexCoordIndex++)
{
if (TexCoordIndex >= NumTexCoords)
{
RawMesh.WedgeTexCoords[TexCoordIndex].AddDefaulted();
}
else
{
RawMesh.WedgeTexCoords[TexCoordIndex].Add(StaticLODModel.VertexBufferGPUSkin.GetVertexUV(Index, TexCoordIndex));
RawMeshTracker.bValidTexCoords[TexCoordIndex] = true;
}
}
if (StaticLODModel.ColorVertexBuffer.IsInitialized())
{
RawMesh.WedgeColors.Add(StaticLODModel.ColorVertexBuffer.VertexColor(Index));
RawMeshTracker.bValidColors = true;
}
else
{
RawMesh.WedgeColors.Add(FColor::White);
}
}
// copy face info
for (uint32 TriIndex = 0; TriIndex < SkelMeshSection.NumTriangles; TriIndex++)
{
RawMesh.FaceMaterialIndices.Add(BaseMaterialIndex + SkelMeshSection.MaterialIndex);
RawMesh.FaceSmoothingMasks.Add(0); // Assume this is ignored as bRecomputeNormals is false
}
}
}
}
ProcessMaterials<USkinnedMeshComponent>(InSkinnedMeshComponent, InPackageName, OutMaterials);
}
// Helper function for ConvertMeshesToStaticMesh
static bool IsValidStaticMeshComponent(UStaticMeshComponent* InComponent)
{
return InComponent && InComponent->GetStaticMesh() && InComponent->GetStaticMesh()->RenderData && InComponent->IsVisible();
}
// Helper function for ConvertMeshesToStaticMesh
static void StaticMeshToRawMeshes(UStaticMeshComponent* InStaticMeshComponent, int32 InOverallMaxLODs, const FMatrix& InComponentToWorld, const FString& InPackageName, TArray<FRawMeshTracker>& OutRawMeshTrackers, TArray<FRawMesh>& OutRawMeshes, TArray<UMaterialInterface*>& OutMaterials)
{
const int32 BaseMaterialIndex = OutMaterials.Num();
const int32 NumLODs = InStaticMeshComponent->GetStaticMesh()->RenderData->LODResources.Num();
for (int32 OverallLODIndex = 0; OverallLODIndex < InOverallMaxLODs; OverallLODIndex++)
{
int32 LODIndexRead = FMath::Min(OverallLODIndex, NumLODs - 1);
FRawMesh& RawMesh = OutRawMeshes[OverallLODIndex];
FRawMeshTracker& RawMeshTracker = OutRawMeshTrackers[OverallLODIndex];
const FStaticMeshLODResources& LODResource = InStaticMeshComponent->GetStaticMesh()->RenderData->LODResources[LODIndexRead];
const int32 BaseVertexIndex = RawMesh.VertexPositions.Num();
for (int32 VertIndex = 0; VertIndex < LODResource.GetNumVertices(); ++VertIndex)
{
RawMesh.VertexPositions.Add(InComponentToWorld.TransformPosition(LODResource.PositionVertexBuffer.VertexPosition((uint32)VertIndex)));
}
const FIndexArrayView IndexArrayView = LODResource.IndexBuffer.GetArrayView();
const FStaticMeshVertexBuffer& StaticMeshVertexBuffer = LODResource.VertexBuffer;
const int32 NumTexCoords = FMath::Min(StaticMeshVertexBuffer.GetNumTexCoords(), (uint32)MAX_MESH_TEXTURE_COORDS);
const int32 NumSections = LODResource.Sections.Num();
for (int32 SectionIndex = 0; SectionIndex < NumSections; SectionIndex++)
{
const FStaticMeshSection& StaticMeshSection = LODResource.Sections[SectionIndex];
const int32 NumIndices = StaticMeshSection.NumTriangles * 3;
for (int32 IndexIndex = 0; IndexIndex < NumIndices; IndexIndex++)
{
int32 Index = IndexArrayView[StaticMeshSection.FirstIndex + IndexIndex];
RawMesh.WedgeIndices.Add(BaseVertexIndex + Index);
RawMesh.WedgeTangentX.Add(InComponentToWorld.TransformVector(StaticMeshVertexBuffer.VertexTangentX(Index)));
RawMesh.WedgeTangentY.Add(InComponentToWorld.TransformVector(StaticMeshVertexBuffer.VertexTangentY(Index)));
RawMesh.WedgeTangentZ.Add(InComponentToWorld.TransformVector(StaticMeshVertexBuffer.VertexTangentZ(Index)));
for (int32 TexCoordIndex = 0; TexCoordIndex < MAX_MESH_TEXTURE_COORDS; TexCoordIndex++)
{
if (TexCoordIndex >= NumTexCoords)
{
RawMesh.WedgeTexCoords[TexCoordIndex].AddDefaulted();
}
else
{
RawMesh.WedgeTexCoords[TexCoordIndex].Add(StaticMeshVertexBuffer.GetVertexUV(Index, TexCoordIndex));
RawMeshTracker.bValidTexCoords[TexCoordIndex] = true;
}
}
if (LODResource.ColorVertexBuffer.IsInitialized())
{
RawMesh.WedgeColors.Add(LODResource.ColorVertexBuffer.VertexColor(Index));
RawMeshTracker.bValidColors = true;
}
else
{
RawMesh.WedgeColors.Add(FColor::White);
}
}
// copy face info
for (uint32 TriIndex = 0; TriIndex < StaticMeshSection.NumTriangles; TriIndex++)
{
RawMesh.FaceMaterialIndices.Add(BaseMaterialIndex + StaticMeshSection.MaterialIndex);
RawMesh.FaceSmoothingMasks.Add(0); // Assume this is ignored as bRecomputeNormals is false
}
}
}
ProcessMaterials<UStaticMeshComponent>(InStaticMeshComponent, InPackageName, OutMaterials);
}
UStaticMesh* FMeshUtilities::ConvertMeshesToStaticMesh(const TArray<UMeshComponent*>& InMeshComponents, const FTransform& InRootTransform, const FString& InPackageName)
{
// Build a package name to use
FString MeshName;
FString PackageName;
if (InPackageName.IsEmpty())
{
FString NewNameSuggestion = FString(TEXT("StaticMesh"));
FString PackageNameSuggestion = FString(TEXT("/Game/Meshes/")) + NewNameSuggestion;
FString Name;
FAssetToolsModule& AssetToolsModule = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools");
AssetToolsModule.Get().CreateUniqueAssetName(PackageNameSuggestion, TEXT(""), PackageNameSuggestion, Name);
TSharedPtr<SDlgPickAssetPath> PickAssetPathWidget =
SNew(SDlgPickAssetPath)
.Title(LOCTEXT("ConvertToStaticMeshPickName", "Choose New StaticMesh Location"))
.DefaultAssetPath(FText::FromString(PackageNameSuggestion));
if (PickAssetPathWidget->ShowModal() == EAppReturnType::Ok)
{
// Get the full name of where we want to create the mesh asset.
PackageName = PickAssetPathWidget->GetFullAssetPath().ToString();
MeshName = FPackageName::GetLongPackageAssetName(PackageName);
// Check if the user inputed a valid asset name, if they did not, give it the generated default name
if (MeshName.IsEmpty())
{
// Use the defaults that were already generated.
PackageName = PackageNameSuggestion;
MeshName = *Name;
}
}
}
else
{
PackageName = InPackageName;
MeshName = *FPackageName::GetLongPackageAssetName(PackageName);
}
if(!PackageName.IsEmpty() && !MeshName.IsEmpty())
{
TArray<FRawMesh> RawMeshes;
TArray<UMaterialInterface*> Materials;
TArray<FRawMeshTracker> RawMeshTrackers;
FMatrix WorldToRoot = InRootTransform.ToMatrixWithScale().Inverse();
// first do a pass to determine the max LOD level we will be combining meshes into
int32 OverallMaxLODs = 0;
for (UMeshComponent* MeshComponent : InMeshComponents)
{
USkinnedMeshComponent* SkinnedMeshComponent = Cast<USkinnedMeshComponent>(MeshComponent);
UStaticMeshComponent* StaticMeshComponent = Cast<UStaticMeshComponent>(MeshComponent);
if (IsValidSkinnedMeshComponent(SkinnedMeshComponent))
{
OverallMaxLODs = FMath::Max(SkinnedMeshComponent->MeshObject->GetSkeletalMeshResource().LODModels.Num(), OverallMaxLODs);
}
else if(IsValidStaticMeshComponent(StaticMeshComponent))
{
OverallMaxLODs = FMath::Max(StaticMeshComponent->GetStaticMesh()->RenderData->LODResources.Num(), OverallMaxLODs);
}
}
// Resize raw meshes to accommodate the number of LODs we will need
RawMeshes.SetNum(OverallMaxLODs);
RawMeshTrackers.SetNum(OverallMaxLODs);
// Export all visible components
for (UMeshComponent* MeshComponent : InMeshComponents)
{
FMatrix ComponentToWorld = MeshComponent->GetComponentTransform().ToMatrixWithScale() * WorldToRoot;
USkinnedMeshComponent* SkinnedMeshComponent = Cast<USkinnedMeshComponent>(MeshComponent);
UStaticMeshComponent* StaticMeshComponent = Cast<UStaticMeshComponent>(MeshComponent);
if (IsValidSkinnedMeshComponent(SkinnedMeshComponent))
{
SkinnedMeshToRawMeshes(SkinnedMeshComponent, OverallMaxLODs, ComponentToWorld, PackageName, RawMeshTrackers, RawMeshes, Materials);
}
else if (IsValidStaticMeshComponent(StaticMeshComponent))
{
StaticMeshToRawMeshes(StaticMeshComponent, OverallMaxLODs, ComponentToWorld, PackageName, RawMeshTrackers, RawMeshes, Materials);
}
}
// scrub invalid vert color & tex coord data
check(RawMeshes.Num() == RawMeshTrackers.Num());
for (int32 RawMeshIndex = 0; RawMeshIndex < RawMeshes.Num(); RawMeshIndex++)
{
if (!RawMeshTrackers[RawMeshIndex].bValidColors)
{
RawMeshes[RawMeshIndex].WedgeColors.Empty();
}
for (uint32 TexCoordIndex = 0; TexCoordIndex < MAX_MESH_TEXTURE_COORDS; TexCoordIndex++)
{
if (!RawMeshTrackers[RawMeshIndex].bValidTexCoords[TexCoordIndex])
{
RawMeshes[RawMeshIndex].WedgeTexCoords[TexCoordIndex].Empty();
}
}
}
// Check if we got some valid data.
bool bValidData = false;
for (FRawMesh& RawMesh : RawMeshes)
{
if (RawMesh.IsValidOrFixable())
{
bValidData = true;
break;
}
}
if (bValidData)
{
// Then find/create it.
UPackage* Package = CreatePackage(NULL, *PackageName);
check(Package);
// Create StaticMesh object
UStaticMesh* StaticMesh = NewObject<UStaticMesh>(Package, *MeshName, RF_Public | RF_Standalone);
StaticMesh->InitResources();
StaticMesh->LightingGuid = FGuid::NewGuid();
// Add source to new StaticMesh
for (FRawMesh& RawMesh : RawMeshes)
{
if (RawMesh.IsValidOrFixable())
{
FStaticMeshSourceModel* SrcModel = new (StaticMesh->SourceModels) FStaticMeshSourceModel();
SrcModel->BuildSettings.bRecomputeNormals = false;
SrcModel->BuildSettings.bRecomputeTangents = false;
SrcModel->BuildSettings.bRemoveDegenerates = false;
SrcModel->BuildSettings.bUseHighPrecisionTangentBasis = false;
SrcModel->BuildSettings.bUseFullPrecisionUVs = false;
SrcModel->BuildSettings.bGenerateLightmapUVs = true;
SrcModel->BuildSettings.SrcLightmapIndex = 0;
SrcModel->BuildSettings.DstLightmapIndex = 1;
SrcModel->RawMeshBulkData->SaveRawMesh(RawMesh);
}
}
// Copy materials to new mesh
for(UMaterialInterface* Material : Materials)
{
StaticMesh->StaticMaterials.Add(FStaticMaterial(Material));
}
// Build mesh from source
StaticMesh->Build(false);
StaticMesh->PostEditChange();
StaticMesh->MarkPackageDirty();
// Notify asset registry of new asset
FAssetRegistryModule::AssetCreated(StaticMesh);
// Display notification so users can quickly access the mesh
if (GIsEditor)
{
FNotificationInfo Info(FText::Format(LOCTEXT("SkeletalMeshConverted", "Successfully Converted Mesh"), FText::FromString(StaticMesh->GetName())));
Info.ExpireDuration = 8.0f;
Info.bUseLargeFont = false;
Info.Hyperlink = FSimpleDelegate::CreateLambda([=]() { FAssetEditorManager::Get().OpenEditorForAssets(TArray<UObject*>({ StaticMesh })); });
Info.HyperlinkText = FText::Format(LOCTEXT("OpenNewAnimationHyperlink", "Open {0}"), FText::FromString(StaticMesh->GetName()));
TSharedPtr<SNotificationItem> Notification = FSlateNotificationManager::Get().AddNotification(Info);
if ( Notification.IsValid() )
{
Notification->SetCompletionState( SNotificationItem::CS_Success );
}
}
}
}
return nullptr;
}
/**
* Builds a renderable skeletal mesh LOD model. Note that the array of chunks
* will be destroyed during this process!
* @param LODModel Upon return contains a renderable skeletal mesh LOD model.
* @param RefSkeleton The reference skeleton associated with the model.
* @param Chunks Skinned mesh chunks from which to build the renderable model.
* @param PointToOriginalMap Maps a vertex's RawPointIdx to its index at import time.
*/
void FMeshUtilities::BuildSkeletalModelFromChunks(FStaticLODModel& LODModel, const FReferenceSkeleton& RefSkeleton, TArray<FSkinnedMeshChunk*>& Chunks, const TArray<int32>& PointToOriginalMap)
{
#if WITH_EDITORONLY_DATA
// Clear out any data currently held in the LOD model.
LODModel.Sections.Empty();
LODModel.NumVertices = 0;
if (LODModel.MultiSizeIndexContainer.IsIndexBufferValid())
{
LODModel.MultiSizeIndexContainer.GetIndexBuffer()->Empty();
}
// Setup the section and chunk arrays on the model.
for (int32 ChunkIndex = 0; ChunkIndex < Chunks.Num(); ++ChunkIndex)
{
FSkinnedMeshChunk* SrcChunk = Chunks[ChunkIndex];
FSkelMeshSection& Section = *new(LODModel.Sections) FSkelMeshSection();
Section.MaterialIndex = SrcChunk->MaterialIndex;
Exchange(Section.BoneMap, SrcChunk->BoneMap);
// Update the active bone indices on the LOD model.
for (int32 BoneIndex = 0; BoneIndex < Section.BoneMap.Num(); ++BoneIndex)
{
LODModel.ActiveBoneIndices.AddUnique(Section.BoneMap[BoneIndex]);
}
}
LODModel.ActiveBoneIndices.Sort();
// Reset 'final vertex to import vertex' map info
LODModel.MeshToImportVertexMap.Empty();
LODModel.MaxImportVertex = 0;
// Keep track of index mapping to chunk vertex offsets
TArray< TArray<uint32> > VertexIndexRemap;
VertexIndexRemap.Empty(LODModel.Sections.Num());
// Pack the chunk vertices into a single vertex buffer.
TArray<uint32> RawPointIndices;
LODModel.NumVertices = 0;
int32 PrevMaterialIndex = -1;
int32 CurrentChunkBaseVertexIndex = -1; // base vertex index for all chunks of the same material
int32 CurrentChunkVertexCount = -1; // total vertex count for all chunks of the same material
int32 CurrentVertexIndex = 0; // current vertex index added to the index buffer for all chunks of the same material
// rearrange the vert order to minimize the data fetched by the GPU
for (int32 SectionIndex = 0; SectionIndex < LODModel.Sections.Num(); SectionIndex++)
{
if (IsInGameThread())
{
GWarn->StatusUpdate(SectionIndex, LODModel.Sections.Num(), NSLOCTEXT("UnrealEd", "ProcessingSections", "Processing Sections"));
}
FSkinnedMeshChunk* SrcChunk = Chunks[SectionIndex];
FSkelMeshSection& Section = LODModel.Sections[SectionIndex];
TArray<FSoftSkinBuildVertex>& ChunkVertices = SrcChunk->Vertices;
TArray<uint32>& ChunkIndices = SrcChunk->Indices;
// Reorder the section index buffer for better vertex cache efficiency.
CacheOptimizeIndexBuffer(ChunkIndices);
// Calculate the number of triangles in the section. Note that CacheOptimize may change the number of triangles in the index buffer!
Section.NumTriangles = ChunkIndices.Num() / 3;
TArray<FSoftSkinBuildVertex> OriginalVertices;
Exchange(ChunkVertices, OriginalVertices);
ChunkVertices.AddUninitialized(OriginalVertices.Num());
TArray<int32> IndexCache;
IndexCache.AddUninitialized(ChunkVertices.Num());
FMemory::Memset(IndexCache.GetData(), INDEX_NONE, IndexCache.Num() * IndexCache.GetTypeSize());
int32 NextAvailableIndex = 0;
// Go through the indices and assign them new values that are coherent where possible
for (int32 Index = 0; Index < ChunkIndices.Num(); Index++)
{
const int32 OriginalIndex = ChunkIndices[Index];
const int32 CachedIndex = IndexCache[OriginalIndex];
if (CachedIndex == INDEX_NONE)
{
// No new index has been allocated for this existing index, assign a new one
ChunkIndices[Index] = NextAvailableIndex;
// Mark what this index has been assigned to
IndexCache[OriginalIndex] = NextAvailableIndex;
NextAvailableIndex++;
}
else
{
// Reuse an existing index assignment
ChunkIndices[Index] = CachedIndex;
}
// Reorder the vertices based on the new index assignment
ChunkVertices[ChunkIndices[Index]] = OriginalVertices[OriginalIndex];
}
}
// Build the arrays of rigid and soft vertices on the model's chunks.
for (int32 SectionIndex = 0; SectionIndex < LODModel.Sections.Num(); SectionIndex++)
{
FSkelMeshSection& Section = LODModel.Sections[SectionIndex];
TArray<FSoftSkinBuildVertex>& ChunkVertices = Chunks[SectionIndex]->Vertices;
if (IsInGameThread())
{
// Only update status if in the game thread. When importing morph targets, this function can run in another thread
GWarn->StatusUpdate(SectionIndex, LODModel.Sections.Num(), NSLOCTEXT("UnrealEd", "ProcessingChunks", "Processing Chunks"));
}
CurrentVertexIndex = 0;
CurrentChunkVertexCount = 0;
PrevMaterialIndex = Section.MaterialIndex;
// Calculate the offset to this chunk's vertices in the vertex buffer.
Section.BaseVertexIndex = CurrentChunkBaseVertexIndex = LODModel.NumVertices;
// Update the size of the vertex buffer.
LODModel.NumVertices += ChunkVertices.Num();
// Separate the section's vertices into rigid and soft vertices.
TArray<uint32>& ChunkVertexIndexRemap = *new(VertexIndexRemap)TArray<uint32>();
ChunkVertexIndexRemap.AddUninitialized(ChunkVertices.Num());
for (int32 VertexIndex = 0; VertexIndex < ChunkVertices.Num(); VertexIndex++)
{
const FSoftSkinBuildVertex& SoftVertex = ChunkVertices[VertexIndex];
FSoftSkinVertex NewVertex;
NewVertex.Position = SoftVertex.Position;
NewVertex.TangentX = SoftVertex.TangentX;
NewVertex.TangentY = SoftVertex.TangentY;
NewVertex.TangentZ = SoftVertex.TangentZ;
FMemory::Memcpy(NewVertex.UVs, SoftVertex.UVs, sizeof(FVector2D)*MAX_TEXCOORDS);
NewVertex.Color = SoftVertex.Color;
for (int32 i = 0; i < MAX_TOTAL_INFLUENCES; ++i)
{
// it only adds to the bone map if it has weight on it
// BoneMap contains only the bones that has influence with weight of >0.f
// so here, just make sure it is included before setting the data
if (Section.BoneMap.IsValidIndex(SoftVertex.InfluenceBones[i]))
{
NewVertex.InfluenceBones[i] = SoftVertex.InfluenceBones[i];
NewVertex.InfluenceWeights[i] = SoftVertex.InfluenceWeights[i];
}
}
Section.SoftVertices.Add(NewVertex);
ChunkVertexIndexRemap[VertexIndex] = (uint32)(Section.BaseVertexIndex + CurrentVertexIndex);
CurrentVertexIndex++;
// add the index to the original wedge point source of this vertex
RawPointIndices.Add(SoftVertex.PointWedgeIdx);
// Also remember import index
const int32 RawVertIndex = PointToOriginalMap[SoftVertex.PointWedgeIdx];
LODModel.MeshToImportVertexMap.Add(RawVertIndex);
LODModel.MaxImportVertex = FMath::Max<float>(LODModel.MaxImportVertex, RawVertIndex);
}
// update NumVertices
Section.NumVertices = Section.SoftVertices.Num();
// update max bone influences
Section.CalcMaxBoneInfluences();
// Log info about the chunk.
UE_LOG(LogSkeletalMesh, Log, TEXT("Section %u: %u vertices, %u active bones"),
SectionIndex,
Section.GetNumVertices(),
Section.BoneMap.Num()
);
}
// Copy raw point indices to LOD model.
LODModel.RawPointIndices.RemoveBulkData();
if (RawPointIndices.Num())
{
LODModel.RawPointIndices.Lock(LOCK_READ_WRITE);
void* Dest = LODModel.RawPointIndices.Realloc(RawPointIndices.Num());
FMemory::Memcpy(Dest, RawPointIndices.GetData(), LODModel.RawPointIndices.GetBulkDataSize());
LODModel.RawPointIndices.Unlock();
}
#if DISALLOW_32BIT_INDICES
LODModel.MultiSizeIndexContainer.CreateIndexBuffer(sizeof(uint16));
#else
LODModel.MultiSizeIndexContainer.CreateIndexBuffer((LODModel.NumVertices < MAX_uint16) ? sizeof(uint16) : sizeof(uint32));
#endif
// Finish building the sections.
for (int32 SectionIndex = 0; SectionIndex < LODModel.Sections.Num(); SectionIndex++)
{
FSkelMeshSection& Section = LODModel.Sections[SectionIndex];
const TArray<uint32>& SectionIndices = Chunks[SectionIndex]->Indices;
FRawStaticIndexBuffer16or32Interface* IndexBuffer = LODModel.MultiSizeIndexContainer.GetIndexBuffer();
Section.BaseIndex = IndexBuffer->Num();
const int32 NumIndices = SectionIndices.Num();
const TArray<uint32>& SectionVertexIndexRemap = VertexIndexRemap[SectionIndex];
for (int32 Index = 0; Index < NumIndices; Index++)
{
uint32 VertexIndex = SectionVertexIndexRemap[SectionIndices[Index]];
IndexBuffer->AddItem(VertexIndex);
}
}
// Free the skinned mesh chunks which are no longer needed.
for (int32 i = 0; i < Chunks.Num(); ++i)
{
delete Chunks[i];
Chunks[i] = NULL;
}
Chunks.Empty();
// Build the adjacency index buffer used for tessellation.
{
TArray<FSoftSkinVertex> Vertices;
LODModel.GetVertices(Vertices);
FMultiSizeIndexContainerData IndexData;
LODModel.MultiSizeIndexContainer.GetIndexBufferData(IndexData);
FMultiSizeIndexContainerData AdjacencyIndexData;
AdjacencyIndexData.DataTypeSize = IndexData.DataTypeSize;
BuildSkeletalAdjacencyIndexBuffer(Vertices, LODModel.NumTexCoords, IndexData.Indices, AdjacencyIndexData.Indices);
LODModel.AdjacencyMultiSizeIndexContainer.RebuildIndexBuffer(AdjacencyIndexData);
}
// Compute the required bones for this model.
USkeletalMesh::CalculateRequiredBones(LODModel, RefSkeleton, NULL);
#endif // #if WITH_EDITORONLY_DATA
}
/*------------------------------------------------------------------------------
Common functionality.
------------------------------------------------------------------------------*/
/** Helper struct for building acceleration structures. */
struct FIndexAndZ
{
float Z;
int32 Index;
/** Default constructor. */
FIndexAndZ() {}
/** Initialization constructor. */
FIndexAndZ(int32 InIndex, FVector V)
{
Z = 0.30f * V.X + 0.33f * V.Y + 0.37f * V.Z;
Index = InIndex;
}
};
/** Sorting function for vertex Z/index pairs. */
struct FCompareIndexAndZ
{
FORCEINLINE bool operator()(FIndexAndZ const& A, FIndexAndZ const& B) const { return A.Z < B.Z; }
};
static int32 ComputeNumTexCoords(FRawMesh const& RawMesh, int32 MaxSupportedTexCoords)
{
int32 NumWedges = RawMesh.WedgeIndices.Num();
int32 NumTexCoords = 0;
for (int32 TexCoordIndex = 0; TexCoordIndex < MAX_MESH_TEXTURE_COORDS; ++TexCoordIndex)
{
if (RawMesh.WedgeTexCoords[TexCoordIndex].Num() != NumWedges)
{
break;
}
NumTexCoords++;
}
return FMath::Min(NumTexCoords, MaxSupportedTexCoords);
}
/**
* Returns true if the specified points are about equal
*/
inline bool PointsEqual(const FVector& V1, const FVector& V2, float ComparisonThreshold)
{
if (FMath::Abs(V1.X - V2.X) > ComparisonThreshold
|| FMath::Abs(V1.Y - V2.Y) > ComparisonThreshold
|| FMath::Abs(V1.Z - V2.Z) > ComparisonThreshold)
{
return false;
}
return true;
}
static inline FVector GetPositionForWedge(FRawMesh const& Mesh, int32 WedgeIndex)
{
int32 VertexIndex = Mesh.WedgeIndices[WedgeIndex];
return Mesh.VertexPositions[VertexIndex];
}
struct FMeshEdge
{
int32 Vertices[2];
int32 Faces[2];
};
/**
* This helper class builds the edge list for a mesh. It uses a hash of vertex
* positions to edges sharing that vertex to remove the n^2 searching of all
* previously added edges. This class is templatized so it can be used with
* either static mesh or skeletal mesh vertices
*/
template <class VertexClass> class TEdgeBuilder
{
protected:
/**
* The list of indices to build the edge data from
*/
const TArray<uint32>& Indices;
/**
* The array of verts for vertex position comparison
*/
const TArray<VertexClass>& Vertices;
/**
* The array of edges to create
*/
TArray<FMeshEdge>& Edges;
/**
* List of edges that start with a given vertex
*/
TMultiMap<FVector, FMeshEdge*> VertexToEdgeList;
/**
* This function determines whether a given edge matches or not. It must be
* provided by derived classes since they have the specific information that
* this class doesn't know about (vertex info, influences, etc)
*
* @param Index1 The first index of the edge being checked
* @param Index2 The second index of the edge
* @param OtherEdge The edge to compare. Was found via the map
*
* @return true if the edge is a match, false otherwise
*/
virtual bool DoesEdgeMatch(int32 Index1, int32 Index2, FMeshEdge* OtherEdge) = 0;
/**
* Searches the list of edges to see if this one matches an existing and
* returns a pointer to it if it does
*
* @param Index1 the first index to check for
* @param Index2 the second index to check for
*
* @return NULL if no edge was found, otherwise the edge that was found
*/
inline FMeshEdge* FindOppositeEdge(int32 Index1, int32 Index2)
{
FMeshEdge* Edge = NULL;
TArray<FMeshEdge*> EdgeList;
// Search the hash for a corresponding vertex
VertexToEdgeList.MultiFind(Vertices[Index2].Position, EdgeList);
// Now search through the array for a match or not
for (int32 EdgeIndex = 0; EdgeIndex < EdgeList.Num() && Edge == NULL;
EdgeIndex++)
{
FMeshEdge* OtherEdge = EdgeList[EdgeIndex];
// See if this edge matches the passed in edge
if (OtherEdge != NULL && DoesEdgeMatch(Index1, Index2, OtherEdge))
{
// We have a match
Edge = OtherEdge;
}
}
return Edge;
}
/**
* Updates an existing edge if found or adds the new edge to the list
*
* @param Index1 the first index in the edge
* @param Index2 the second index in the edge
* @param Triangle the triangle that this edge was found in
*/
inline void AddEdge(int32 Index1, int32 Index2, int32 Triangle)
{
// If this edge matches another then just fill the other triangle
// otherwise add it
FMeshEdge* OtherEdge = FindOppositeEdge(Index1, Index2);
if (OtherEdge == NULL)
{
// Add a new edge to the array
int32 EdgeIndex = Edges.AddZeroed();
Edges[EdgeIndex].Vertices[0] = Index1;
Edges[EdgeIndex].Vertices[1] = Index2;
Edges[EdgeIndex].Faces[0] = Triangle;
Edges[EdgeIndex].Faces[1] = -1;
// Also add this edge to the hash for faster searches
// NOTE: This relies on the array never being realloced!
VertexToEdgeList.Add(Vertices[Index1].Position, &Edges[EdgeIndex]);
}
else
{
OtherEdge->Faces[1] = Triangle;
}
}
public:
/**
* Initializes the values for the code that will build the mesh edge list
*/
TEdgeBuilder(const TArray<uint32>& InIndices,
const TArray<VertexClass>& InVertices,
TArray<FMeshEdge>& OutEdges) :
Indices(InIndices), Vertices(InVertices), Edges(OutEdges)
{
// Presize the array so that there are no extra copies being done
// when adding edges to it
Edges.Empty(Indices.Num());
}
/**
* Virtual dtor
*/
virtual ~TEdgeBuilder(){}
/**
* Uses a hash of indices to edge lists so that it can avoid the n^2 search
* through the full edge list
*/
void FindEdges(void)
{
// @todo Handle something other than trilists when building edges
int32 TriangleCount = Indices.Num() / 3;
int32 EdgeCount = 0;
// Work through all triangles building the edges
for (int32 Triangle = 0; Triangle < TriangleCount; Triangle++)
{
// Determine the starting index
int32 TriangleIndex = Triangle * 3;
// Get the indices for the triangle
int32 Index1 = Indices[TriangleIndex];
int32 Index2 = Indices[TriangleIndex + 1];
int32 Index3 = Indices[TriangleIndex + 2];
// Add the first to second edge
AddEdge(Index1, Index2, Triangle);
// Now add the second to third
AddEdge(Index2, Index3, Triangle);
// Add the third to first edge
AddEdge(Index3, Index1, Triangle);
}
}
};
/**
* This is the static mesh specific version for finding edges
*/
class FStaticMeshEdgeBuilder : public TEdgeBuilder<FStaticMeshBuildVertex>
{
public:
/**
* Constructor that passes all work to the parent class
*/
FStaticMeshEdgeBuilder(const TArray<uint32>& InIndices,
const TArray<FStaticMeshBuildVertex>& InVertices,
TArray<FMeshEdge>& OutEdges) :
TEdgeBuilder<FStaticMeshBuildVertex>(InIndices, InVertices, OutEdges)
{
}
/**
* This function determines whether a given edge matches or not for a static mesh
*
* @param Index1 The first index of the edge being checked
* @param Index2 The second index of the edge
* @param OtherEdge The edge to compare. Was found via the map
*
* @return true if the edge is a match, false otherwise
*/
bool DoesEdgeMatch(int32 Index1, int32 Index2, FMeshEdge* OtherEdge)
{
return Vertices[OtherEdge->Vertices[1]].Position == Vertices[Index1].Position &&
OtherEdge->Faces[1] == -1;
}
};
static void ComputeTriangleTangents(
const TArray<FVector>& InVertices,
const TArray<uint32>& InIndices,
const TArray<FVector2D>& InUVs,
TArray<FVector>& OutTangentX,
TArray<FVector>& OutTangentY,
TArray<FVector>& OutTangentZ,
float ComparisonThreshold
)
{
const int32 NumTriangles = InIndices.Num() / 3;
OutTangentX.Empty(NumTriangles);
OutTangentY.Empty(NumTriangles);
OutTangentZ.Empty(NumTriangles);
for (int32 TriangleIndex = 0; TriangleIndex < NumTriangles; TriangleIndex++)
{
int32 UVIndex = 0;
FVector P[3];
for (int32 i = 0; i < 3; ++i)
{
P[i] = InVertices[InIndices[TriangleIndex * 3 + i]];
}
const FVector Normal = ((P[1] - P[2]) ^ (P[0] - P[2])).GetSafeNormal(ComparisonThreshold);
FMatrix ParameterToLocal(
FPlane(P[1].X - P[0].X, P[1].Y - P[0].Y, P[1].Z - P[0].Z, 0),
FPlane(P[2].X - P[0].X, P[2].Y - P[0].Y, P[2].Z - P[0].Z, 0),
FPlane(P[0].X, P[0].Y, P[0].Z, 0),
FPlane(0, 0, 0, 1)
);
const FVector2D T1 = InUVs[TriangleIndex * 3 + 0];
const FVector2D T2 = InUVs[TriangleIndex * 3 + 1];
const FVector2D T3 = InUVs[TriangleIndex * 3 + 2];
FMatrix ParameterToTexture(
FPlane(T2.X - T1.X, T2.Y - T1.Y, 0, 0),
FPlane(T3.X - T1.X, T3.Y - T1.Y, 0, 0),
FPlane(T1.X, T1.Y, 1, 0),
FPlane(0, 0, 0, 1)
);
// Use InverseSlow to catch singular matrices. Inverse can miss this sometimes.
const FMatrix TextureToLocal = ParameterToTexture.Inverse() * ParameterToLocal;
OutTangentX.Add(TextureToLocal.TransformVector(FVector(1, 0, 0)).GetSafeNormal());
OutTangentY.Add(TextureToLocal.TransformVector(FVector(0, 1, 0)).GetSafeNormal());
OutTangentZ.Add(Normal);
FVector::CreateOrthonormalBasis(
OutTangentX[TriangleIndex],
OutTangentY[TriangleIndex],
OutTangentZ[TriangleIndex]
);
}
check(OutTangentX.Num() == NumTriangles);
check(OutTangentY.Num() == NumTriangles);
check(OutTangentZ.Num() == NumTriangles);
}
static void ComputeTriangleTangents(
TArray<FVector>& OutTangentX,
TArray<FVector>& OutTangentY,
TArray<FVector>& OutTangentZ,
FRawMesh const& RawMesh,
float ComparisonThreshold
)
{
ComputeTriangleTangents(RawMesh.VertexPositions, RawMesh.WedgeIndices, RawMesh.WedgeTexCoords[0], OutTangentX, OutTangentY, OutTangentZ, ComparisonThreshold);
/*int32 NumTriangles = RawMesh.WedgeIndices.Num() / 3;
TriangleTangentX.Empty(NumTriangles);
TriangleTangentY.Empty(NumTriangles);
TriangleTangentZ.Empty(NumTriangles);
for (int32 TriangleIndex = 0; TriangleIndex < NumTriangles; TriangleIndex++)
{
int32 UVIndex = 0;
FVector P[3];
for (int32 i = 0; i < 3; ++i)
{
P[i] = GetPositionForWedge(RawMesh, TriangleIndex * 3 + i);
}
const FVector Normal = ((P[1] - P[2]) ^ (P[0] - P[2])).GetSafeNormal(ComparisonThreshold);
FMatrix ParameterToLocal(
FPlane(P[1].X - P[0].X, P[1].Y - P[0].Y, P[1].Z - P[0].Z, 0),
FPlane(P[2].X - P[0].X, P[2].Y - P[0].Y, P[2].Z - P[0].Z, 0),
FPlane(P[0].X, P[0].Y, P[0].Z, 0),
FPlane(0, 0, 0, 1)
);
FVector2D T1 = RawMesh.WedgeTexCoords[UVIndex][TriangleIndex * 3 + 0];
FVector2D T2 = RawMesh.WedgeTexCoords[UVIndex][TriangleIndex * 3 + 1];
FVector2D T3 = RawMesh.WedgeTexCoords[UVIndex][TriangleIndex * 3 + 2];
FMatrix ParameterToTexture(
FPlane(T2.X - T1.X, T2.Y - T1.Y, 0, 0),
FPlane(T3.X - T1.X, T3.Y - T1.Y, 0, 0),
FPlane(T1.X, T1.Y, 1, 0),
FPlane(0, 0, 0, 1)
);
// Use InverseSlow to catch singular matrices. Inverse can miss this sometimes.
const FMatrix TextureToLocal = ParameterToTexture.Inverse() * ParameterToLocal;
TriangleTangentX.Add(TextureToLocal.TransformVector(FVector(1, 0, 0)).GetSafeNormal());
TriangleTangentY.Add(TextureToLocal.TransformVector(FVector(0, 1, 0)).GetSafeNormal());
TriangleTangentZ.Add(Normal);
FVector::CreateOrthonormalBasis(
TriangleTangentX[TriangleIndex],
TriangleTangentY[TriangleIndex],
TriangleTangentZ[TriangleIndex]
);
}
check(TriangleTangentX.Num() == NumTriangles);
check(TriangleTangentY.Num() == NumTriangles);
check(TriangleTangentZ.Num() == NumTriangles);*/
}
/**
* Create a table that maps the corner of each face to its overlapping corners.
* @param OutOverlappingCorners - Maps a corner index to the indices of all overlapping corners.
* @param RawMesh - The mesh for which to compute overlapping corners.
*/
static void FindOverlappingCorners(
TMultiMap<int32, int32>& OutOverlappingCorners,
const TArray<FVector>& InVertices,
const TArray<uint32>& InIndices,
float ComparisonThreshold
)
{
const int32 NumWedges = InIndices.Num();
// Create a list of vertex Z/index pairs
TArray<FIndexAndZ> VertIndexAndZ;
VertIndexAndZ.Reserve(NumWedges);
for (int32 WedgeIndex = 0; WedgeIndex < NumWedges; WedgeIndex++)
{
new(VertIndexAndZ)FIndexAndZ(WedgeIndex, InVertices[InIndices[WedgeIndex]]);
}
// Sort the vertices by z value
VertIndexAndZ.Sort(FCompareIndexAndZ());
// Search for duplicates, quickly!
for (int32 i = 0; i < VertIndexAndZ.Num(); i++)
{
// only need to search forward, since we add pairs both ways
for (int32 j = i + 1; j < VertIndexAndZ.Num(); j++)
{
if (FMath::Abs(VertIndexAndZ[j].Z - VertIndexAndZ[i].Z) > ComparisonThreshold)
break; // can't be any more dups
const FVector& PositionA = InVertices[InIndices[VertIndexAndZ[i].Index]];
const FVector& PositionB = InVertices[InIndices[VertIndexAndZ[j].Index]];
if (PointsEqual(PositionA, PositionB, ComparisonThreshold))
{
OutOverlappingCorners.Add(VertIndexAndZ[i].Index, VertIndexAndZ[j].Index);
OutOverlappingCorners.Add(VertIndexAndZ[j].Index, VertIndexAndZ[i].Index);
}
}
}
}
/**
* Create a table that maps the corner of each face to its overlapping corners.
* @param OutOverlappingCorners - Maps a corner index to the indices of all overlapping corners.
* @param RawMesh - The mesh for which to compute overlapping corners.
*/
static void FindOverlappingCorners(
TMultiMap<int32, int32>& OutOverlappingCorners,
FRawMesh const& RawMesh,
float ComparisonThreshold
)
{
FindOverlappingCorners(OutOverlappingCorners, RawMesh.VertexPositions, RawMesh.WedgeIndices, ComparisonThreshold);
}
/**
* Smoothing group interpretation helper structure.
*/
struct FFanFace
{
int32 FaceIndex;
int32 LinkedVertexIndex;
bool bFilled;
bool bBlendTangents;
bool bBlendNormals;
};
static void ComputeTangents(
const TArray<FVector>& InVertices,
const TArray<uint32>& InIndices,
const TArray<FVector2D>& InUVs,
const TArray<uint32>& SmoothingGroupIndices,
TMultiMap<int32, int32> const& OverlappingCorners,
TArray<FVector>& OutTangentX,
TArray<FVector>& OutTangentY,
TArray<FVector>& OutTangentZ,
const uint32 TangentOptions
)
{
bool bBlendOverlappingNormals = (TangentOptions & ETangentOptions::BlendOverlappingNormals) != 0;
bool bIgnoreDegenerateTriangles = (TangentOptions & ETangentOptions::IgnoreDegenerateTriangles) != 0;
float ComparisonThreshold = bIgnoreDegenerateTriangles ? THRESH_POINTS_ARE_SAME : 0.0f;
// Compute per-triangle tangents.
TArray<FVector> TriangleTangentX;
TArray<FVector> TriangleTangentY;
TArray<FVector> TriangleTangentZ;
ComputeTriangleTangents(
InVertices,
InIndices,
InUVs,
TriangleTangentX,
TriangleTangentY,
TriangleTangentZ,
bIgnoreDegenerateTriangles ? SMALL_NUMBER : 0.0f
);
// Declare these out here to avoid reallocations.
TArray<FFanFace> RelevantFacesForCorner[3];
TArray<int32> AdjacentFaces;
TArray<int32> DupVerts;
int32 NumWedges = InIndices.Num();
int32 NumFaces = NumWedges / 3;
// Allocate storage for tangents if none were provided.
if (OutTangentX.Num() != NumWedges)
{
OutTangentX.Empty(NumWedges);
OutTangentX.AddZeroed(NumWedges);
}
if (OutTangentY.Num() != NumWedges)
{
OutTangentY.Empty(NumWedges);
OutTangentY.AddZeroed(NumWedges);
}
if (OutTangentZ.Num() != NumWedges)
{
OutTangentZ.Empty(NumWedges);
OutTangentZ.AddZeroed(NumWedges);
}
for (int32 FaceIndex = 0; FaceIndex < NumFaces; FaceIndex++)
{
int32 WedgeOffset = FaceIndex * 3;
FVector CornerPositions[3];
FVector CornerTangentX[3];
FVector CornerTangentY[3];
FVector CornerTangentZ[3];
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
CornerTangentX[CornerIndex] = FVector::ZeroVector;
CornerTangentY[CornerIndex] = FVector::ZeroVector;
CornerTangentZ[CornerIndex] = FVector::ZeroVector;
CornerPositions[CornerIndex] = InVertices[InIndices[WedgeOffset + CornerIndex]];
RelevantFacesForCorner[CornerIndex].Reset();
}
// Don't process degenerate triangles.
if (PointsEqual(CornerPositions[0], CornerPositions[1], ComparisonThreshold)
|| PointsEqual(CornerPositions[0], CornerPositions[2], ComparisonThreshold)
|| PointsEqual(CornerPositions[1], CornerPositions[2], ComparisonThreshold))
{
continue;
}
// No need to process triangles if tangents already exist.
bool bCornerHasTangents[3] = { 0 };
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
bCornerHasTangents[CornerIndex] = !OutTangentX[WedgeOffset + CornerIndex].IsZero()
&& !OutTangentY[WedgeOffset + CornerIndex].IsZero()
&& !OutTangentZ[WedgeOffset + CornerIndex].IsZero();
}
if (bCornerHasTangents[0] && bCornerHasTangents[1] && bCornerHasTangents[2])
{
continue;
}
// Calculate smooth vertex normals.
float Determinant = FVector::Triple(
TriangleTangentX[FaceIndex],
TriangleTangentY[FaceIndex],
TriangleTangentZ[FaceIndex]
);
// Start building a list of faces adjacent to this face.
AdjacentFaces.Reset();
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
int32 ThisCornerIndex = WedgeOffset + CornerIndex;
DupVerts.Reset();
OverlappingCorners.MultiFind(ThisCornerIndex, DupVerts);
DupVerts.Add(ThisCornerIndex); // I am a "dup" of myself
for (int32 k = 0; k < DupVerts.Num(); k++)
{
AdjacentFaces.AddUnique(DupVerts[k] / 3);
}
}
// We need to sort these here because the criteria for point equality is
// exact, so we must ensure the exact same order for all dups.
AdjacentFaces.Sort();
// Process adjacent faces
for (int32 AdjacentFaceIndex = 0; AdjacentFaceIndex < AdjacentFaces.Num(); AdjacentFaceIndex++)
{
int32 OtherFaceIndex = AdjacentFaces[AdjacentFaceIndex];
for (int32 OurCornerIndex = 0; OurCornerIndex < 3; OurCornerIndex++)
{
if (bCornerHasTangents[OurCornerIndex])
continue;
FFanFace NewFanFace;
int32 CommonIndexCount = 0;
// Check for vertices in common.
if (FaceIndex == OtherFaceIndex)
{
CommonIndexCount = 3;
NewFanFace.LinkedVertexIndex = OurCornerIndex;
}
else
{
// Check matching vertices against main vertex .
for (int32 OtherCornerIndex = 0; OtherCornerIndex < 3; OtherCornerIndex++)
{
if (PointsEqual(
CornerPositions[OurCornerIndex],
InVertices[InIndices[OtherFaceIndex * 3 + OtherCornerIndex]],
ComparisonThreshold
))
{
CommonIndexCount++;
NewFanFace.LinkedVertexIndex = OtherCornerIndex;
}
}
}
// Add if connected by at least one point. Smoothing matches are considered later.
if (CommonIndexCount > 0)
{
NewFanFace.FaceIndex = OtherFaceIndex;
NewFanFace.bFilled = (OtherFaceIndex == FaceIndex); // Starter face for smoothing floodfill.
NewFanFace.bBlendTangents = NewFanFace.bFilled;
NewFanFace.bBlendNormals = NewFanFace.bFilled;
RelevantFacesForCorner[OurCornerIndex].Add(NewFanFace);
}
}
}
// Find true relevance of faces for a vertex normal by traversing
// smoothing-group-compatible connected triangle fans around common vertices.
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
if (bCornerHasTangents[CornerIndex])
continue;
int32 NewConnections;
do
{
NewConnections = 0;
for (int32 OtherFaceIdx = 0; OtherFaceIdx < RelevantFacesForCorner[CornerIndex].Num(); OtherFaceIdx++)
{
FFanFace& OtherFace = RelevantFacesForCorner[CornerIndex][OtherFaceIdx];
// The vertex' own face is initially the only face with bFilled == true.
if (OtherFace.bFilled)
{
for (int32 NextFaceIndex = 0; NextFaceIndex < RelevantFacesForCorner[CornerIndex].Num(); NextFaceIndex++)
{
FFanFace& NextFace = RelevantFacesForCorner[CornerIndex][NextFaceIndex];
if (!NextFace.bFilled) // && !NextFace.bBlendTangents)
{
if ((NextFaceIndex != OtherFaceIdx)
&& (SmoothingGroupIndices[NextFace.FaceIndex] & SmoothingGroupIndices[OtherFace.FaceIndex]))
{
int32 CommonVertices = 0;
int32 CommonTangentVertices = 0;
int32 CommonNormalVertices = 0;
for (int32 OtherCornerIndex = 0; OtherCornerIndex < 3; OtherCornerIndex++)
{
for (int32 NextCornerIndex = 0; NextCornerIndex < 3; NextCornerIndex++)
{
int32 NextVertexIndex = InIndices[NextFace.FaceIndex * 3 + NextCornerIndex];
int32 OtherVertexIndex = InIndices[OtherFace.FaceIndex * 3 + OtherCornerIndex];
if (PointsEqual(
InVertices[NextVertexIndex],
InVertices[OtherVertexIndex],
ComparisonThreshold))
{
CommonVertices++;
const FVector2D& UVOne = InUVs[NextFace.FaceIndex * 3 + NextCornerIndex];
const FVector2D& UVTwo = InUVs[OtherFace.FaceIndex * 3 + OtherCornerIndex];
if (UVsEqual(UVOne, UVTwo))
{
CommonTangentVertices++;
}
if (bBlendOverlappingNormals
|| NextVertexIndex == OtherVertexIndex)
{
CommonNormalVertices++;
}
}
}
}
// Flood fill faces with more than one common vertices which must be touching edges.
if (CommonVertices > 1)
{
NextFace.bFilled = true;
NextFace.bBlendNormals = (CommonNormalVertices > 1);
NewConnections++;
// Only blend tangents if there is no UV seam along the edge with this face.
if (OtherFace.bBlendTangents && CommonTangentVertices > 1)
{
float OtherDeterminant = FVector::Triple(
TriangleTangentX[NextFace.FaceIndex],
TriangleTangentY[NextFace.FaceIndex],
TriangleTangentZ[NextFace.FaceIndex]
);
if ((Determinant * OtherDeterminant) > 0.0f)
{
NextFace.bBlendTangents = true;
}
}
}
}
}
}
}
}
} while (NewConnections > 0);
}
// Vertex normal construction.
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
if (bCornerHasTangents[CornerIndex])
{
CornerTangentX[CornerIndex] = OutTangentX[WedgeOffset + CornerIndex];
CornerTangentY[CornerIndex] = OutTangentY[WedgeOffset + CornerIndex];
CornerTangentZ[CornerIndex] = OutTangentZ[WedgeOffset + CornerIndex];
}
else
{
for (int32 RelevantFaceIdx = 0; RelevantFaceIdx < RelevantFacesForCorner[CornerIndex].Num(); RelevantFaceIdx++)
{
FFanFace const& RelevantFace = RelevantFacesForCorner[CornerIndex][RelevantFaceIdx];
if (RelevantFace.bFilled)
{
int32 OtherFaceIndex = RelevantFace.FaceIndex;
if (RelevantFace.bBlendTangents)
{
CornerTangentX[CornerIndex] += TriangleTangentX[OtherFaceIndex];
CornerTangentY[CornerIndex] += TriangleTangentY[OtherFaceIndex];
}
if (RelevantFace.bBlendNormals)
{
CornerTangentZ[CornerIndex] += TriangleTangentZ[OtherFaceIndex];
}
}
}
if (!OutTangentX[WedgeOffset + CornerIndex].IsZero())
{
CornerTangentX[CornerIndex] = OutTangentX[WedgeOffset + CornerIndex];
}
if (!OutTangentY[WedgeOffset + CornerIndex].IsZero())
{
CornerTangentY[CornerIndex] = OutTangentY[WedgeOffset + CornerIndex];
}
if (!OutTangentZ[WedgeOffset + CornerIndex].IsZero())
{
CornerTangentZ[CornerIndex] = OutTangentZ[WedgeOffset + CornerIndex];
}
}
}
// Normalization.
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
CornerTangentX[CornerIndex].Normalize();
CornerTangentY[CornerIndex].Normalize();
CornerTangentZ[CornerIndex].Normalize();
// Gram-Schmidt orthogonalization
CornerTangentY[CornerIndex] -= CornerTangentX[CornerIndex] * (CornerTangentX[CornerIndex] | CornerTangentY[CornerIndex]);
CornerTangentY[CornerIndex].Normalize();
CornerTangentX[CornerIndex] -= CornerTangentZ[CornerIndex] * (CornerTangentZ[CornerIndex] | CornerTangentX[CornerIndex]);
CornerTangentX[CornerIndex].Normalize();
CornerTangentY[CornerIndex] -= CornerTangentZ[CornerIndex] * (CornerTangentZ[CornerIndex] | CornerTangentY[CornerIndex]);
CornerTangentY[CornerIndex].Normalize();
}
// Copy back to the mesh.
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
OutTangentX[WedgeOffset + CornerIndex] = CornerTangentX[CornerIndex];
OutTangentY[WedgeOffset + CornerIndex] = CornerTangentY[CornerIndex];
OutTangentZ[WedgeOffset + CornerIndex] = CornerTangentZ[CornerIndex];
}
}
check(OutTangentX.Num() == NumWedges);
check(OutTangentY.Num() == NumWedges);
check(OutTangentZ.Num() == NumWedges);
}
static void ComputeTangents(
FRawMesh& RawMesh,
TMultiMap<int32, int32> const& OverlappingCorners,
uint32 TangentOptions
)
{
const float ComparisonThreshold = (TangentOptions & ETangentOptions::IgnoreDegenerateTriangles) ? THRESH_POINTS_ARE_SAME : 0.0f;
ComputeTangents(RawMesh.VertexPositions, RawMesh.WedgeIndices, RawMesh.WedgeTexCoords[0], RawMesh.FaceSmoothingMasks, OverlappingCorners, RawMesh.WedgeTangentX, RawMesh.WedgeTangentY, RawMesh.WedgeTangentZ, TangentOptions);
}
/*------------------------------------------------------------------------------
MikkTSpace for computing tangents.
------------------------------------------------------------------------------*/
static int MikkGetNumFaces(const SMikkTSpaceContext* Context)
{
FRawMesh *UserData = (FRawMesh*)(Context->m_pUserData);
return UserData->WedgeIndices.Num() / 3;
}
static int MikkGetNumVertsOfFace(const SMikkTSpaceContext* Context, const int FaceIdx)
{
// All of our meshes are triangles.
return 3;
}
static void MikkGetPosition(const SMikkTSpaceContext* Context, float Position[3], const int FaceIdx, const int VertIdx)
{
FRawMesh *UserData = (FRawMesh*)(Context->m_pUserData);
FVector VertexPosition = UserData->GetWedgePosition(FaceIdx * 3 + VertIdx);
Position[0] = VertexPosition.X;
Position[1] = VertexPosition.Y;
Position[2] = VertexPosition.Z;
}
static void MikkGetNormal(const SMikkTSpaceContext* Context, float Normal[3], const int FaceIdx, const int VertIdx)
{
FRawMesh *UserData = (FRawMesh*)(Context->m_pUserData);
FVector &VertexNormal = UserData->WedgeTangentZ[FaceIdx * 3 + VertIdx];
for (int32 i = 0; i < 3; ++i)
{
Normal[i] = VertexNormal[i];
}
}
static void MikkSetTSpaceBasic(const SMikkTSpaceContext* Context, const float Tangent[3], const float BitangentSign, const int FaceIdx, const int VertIdx)
{
FRawMesh *UserData = (FRawMesh*)(Context->m_pUserData);
FVector &VertexTangent = UserData->WedgeTangentX[FaceIdx * 3 + VertIdx];
for (int32 i = 0; i < 3; ++i)
{
VertexTangent[i] = Tangent[i];
}
FVector Bitangent = BitangentSign * FVector::CrossProduct(UserData->WedgeTangentZ[FaceIdx * 3 + VertIdx], VertexTangent);
FVector &VertexBitangent = UserData->WedgeTangentY[FaceIdx * 3 + VertIdx];
for (int32 i = 0; i < 3; ++i)
{
VertexBitangent[i] = -Bitangent[i];
}
}
static void MikkGetTexCoord(const SMikkTSpaceContext* Context, float UV[2], const int FaceIdx, const int VertIdx)
{
FRawMesh *UserData = (FRawMesh*)(Context->m_pUserData);
FVector2D &TexCoord = UserData->WedgeTexCoords[0][FaceIdx * 3 + VertIdx];
UV[0] = TexCoord.X;
UV[1] = TexCoord.Y;
}
// MikkTSpace implementations for skeletal meshes, where tangents/bitangents are ultimately derived from lists of attributes.
// Holder for skeletal data to be passed to MikkTSpace.
// Holds references to the wedge, face and points vectors that BuildSkeletalMesh is given.
// Holds reference to the calculated normals array, which will be fleshed out if they've been calculated.
// Holds reference to the newly created tangent and bitangent arrays, which MikkTSpace will fleshed out if required.
class MikkTSpace_Skeletal_Mesh
{
public:
const TArray<FMeshWedge> &wedges; //Reference to wedge list.
const TArray<FMeshFace> &faces; //Reference to face list. Also contains normal/tangent/bitanget/UV coords for each vertex of the face.
const TArray<FVector> &points; //Reference to position list.
bool bComputeNormals; //Copy of bComputeNormals.
TArray<FVector> &TangentsX; //Reference to newly created tangents list.
TArray<FVector> &TangentsY; //Reference to newly created bitangents list.
TArray<FVector> &TangentsZ; //Reference to computed normals, will be empty otherwise.
MikkTSpace_Skeletal_Mesh(
const TArray<FMeshWedge> &Wedges,
const TArray<FMeshFace> &Faces,
const TArray<FVector> &Points,
bool bInComputeNormals,
TArray<FVector> &VertexTangentsX,
TArray<FVector> &VertexTangentsY,
TArray<FVector> &VertexTangentsZ
)
:
wedges(Wedges),
faces(Faces),
points(Points),
bComputeNormals(bInComputeNormals),
TangentsX(VertexTangentsX),
TangentsY(VertexTangentsY),
TangentsZ(VertexTangentsZ)
{
}
};
static int MikkGetNumFaces_Skeletal(const SMikkTSpaceContext* Context)
{
MikkTSpace_Skeletal_Mesh *UserData = (MikkTSpace_Skeletal_Mesh*)(Context->m_pUserData);
return UserData->faces.Num();
}
static int MikkGetNumVertsOfFace_Skeletal(const SMikkTSpaceContext* Context, const int FaceIdx)
{
// Confirmed?
return 3;
}
static void MikkGetPosition_Skeletal(const SMikkTSpaceContext* Context, float Position[3], const int FaceIdx, const int VertIdx)
{
MikkTSpace_Skeletal_Mesh *UserData = (MikkTSpace_Skeletal_Mesh*)(Context->m_pUserData);
const FVector &VertexPosition = UserData->points[UserData->wedges[UserData->faces[FaceIdx].iWedge[VertIdx]].iVertex];
Position[0] = VertexPosition.X;
Position[1] = VertexPosition.Y;
Position[2] = VertexPosition.Z;
}
static void MikkGetNormal_Skeletal(const SMikkTSpaceContext* Context, float Normal[3], const int FaceIdx, const int VertIdx)
{
MikkTSpace_Skeletal_Mesh *UserData = (MikkTSpace_Skeletal_Mesh*)(Context->m_pUserData);
// Get different normals depending on whether they've been calculated or not.
if (UserData->bComputeNormals) {
FVector &VertexNormal = UserData->TangentsZ[FaceIdx * 3 + VertIdx];
Normal[0] = VertexNormal.X;
Normal[1] = VertexNormal.Y;
Normal[2] = VertexNormal.Z;
}
else
{
const FVector &VertexNormal = UserData->faces[FaceIdx].TangentZ[VertIdx];
Normal[0] = VertexNormal.X;
Normal[1] = VertexNormal.Y;
Normal[2] = VertexNormal.Z;
}
}
static void MikkSetTSpaceBasic_Skeletal(const SMikkTSpaceContext* Context, const float Tangent[3], const float BitangentSign, const int FaceIdx, const int VertIdx)
{
MikkTSpace_Skeletal_Mesh *UserData = (MikkTSpace_Skeletal_Mesh*)(Context->m_pUserData);
FVector &VertexTangent = UserData->TangentsX[FaceIdx * 3 + VertIdx];
VertexTangent.X = Tangent[0];
VertexTangent.Y = Tangent[1];
VertexTangent.Z = Tangent[2];
FVector Bitangent;
// Get different normals depending on whether they've been calculated or not.
if (UserData->bComputeNormals) {
Bitangent = BitangentSign * FVector::CrossProduct(UserData->TangentsZ[FaceIdx * 3 + VertIdx], VertexTangent);
}
else
{
Bitangent = BitangentSign * FVector::CrossProduct(UserData->faces[FaceIdx].TangentZ[VertIdx], VertexTangent);
}
FVector &VertexBitangent = UserData->TangentsY[FaceIdx * 3 + VertIdx];
// Switch the tangent space swizzle to X+Y-Z+ for legacy reasons.
VertexBitangent.X = -Bitangent[0];
VertexBitangent.Y = -Bitangent[1];
VertexBitangent.Z = -Bitangent[2];
}
static void MikkGetTexCoord_Skeletal(const SMikkTSpaceContext* Context, float UV[2], const int FaceIdx, const int VertIdx)
{
MikkTSpace_Skeletal_Mesh *UserData = (MikkTSpace_Skeletal_Mesh*)(Context->m_pUserData);
const FVector2D &TexCoord = UserData->wedges[UserData->faces[FaceIdx].iWedge[VertIdx]].UVs[0];
UV[0] = TexCoord.X;
UV[1] = TexCoord.Y;
}
static void ComputeTangents_MikkTSpace(
FRawMesh& RawMesh,
TMultiMap<int32, int32> const& OverlappingCorners,
uint32 TangentOptions
)
{
bool bBlendOverlappingNormals = (TangentOptions & ETangentOptions::BlendOverlappingNormals) != 0;
bool bIgnoreDegenerateTriangles = (TangentOptions & ETangentOptions::IgnoreDegenerateTriangles) != 0;
float ComparisonThreshold = bIgnoreDegenerateTriangles ? THRESH_POINTS_ARE_SAME : 0.0f;
// Compute per-triangle tangents.
TArray<FVector> TriangleTangentX;
TArray<FVector> TriangleTangentY;
TArray<FVector> TriangleTangentZ;
ComputeTriangleTangents(
TriangleTangentX,
TriangleTangentY,
TriangleTangentZ,
RawMesh,
bIgnoreDegenerateTriangles ? SMALL_NUMBER : 0.0f
);
// Declare these out here to avoid reallocations.
TArray<FFanFace> RelevantFacesForCorner[3];
TArray<int32> AdjacentFaces;
TArray<int32> DupVerts;
int32 NumWedges = RawMesh.WedgeIndices.Num();
int32 NumFaces = NumWedges / 3;
bool bWedgeNormals = true;
bool bWedgeTSpace = false;
for (int32 WedgeIdx = 0; WedgeIdx < RawMesh.WedgeTangentZ.Num(); ++WedgeIdx)
{
bWedgeNormals = bWedgeNormals && (!RawMesh.WedgeTangentZ[WedgeIdx].IsNearlyZero());
}
if (RawMesh.WedgeTangentX.Num() > 0 && RawMesh.WedgeTangentY.Num() > 0)
{
bWedgeTSpace = true;
for (int32 WedgeIdx = 0; WedgeIdx < RawMesh.WedgeTangentX.Num()
&& WedgeIdx < RawMesh.WedgeTangentY.Num(); ++WedgeIdx)
{
bWedgeTSpace = bWedgeTSpace && (!RawMesh.WedgeTangentX[WedgeIdx].IsNearlyZero()) && (!RawMesh.WedgeTangentY[WedgeIdx].IsNearlyZero());
}
}
// Allocate storage for tangents if none were provided, and calculate normals for MikkTSpace.
if (RawMesh.WedgeTangentZ.Num() != NumWedges || !bWedgeNormals)
{
// normals are not included, so we should calculate them
RawMesh.WedgeTangentZ.Empty(NumWedges);
RawMesh.WedgeTangentZ.AddZeroed(NumWedges);
// we need to calculate normals for MikkTSpace
UE_LOG(LogMeshUtilities, Log, TEXT("Invalid vertex normals found for mesh. Forcing recomputation of vertex normals for MikkTSpace. Fix mesh or disable \"Use MikkTSpace Tangent Space\" to avoid forced recomputation of normals."));
for (int32 FaceIndex = 0; FaceIndex < NumFaces; FaceIndex++)
{
int32 WedgeOffset = FaceIndex * 3;
FVector CornerPositions[3];
FVector CornerNormal[3];
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
CornerNormal[CornerIndex] = FVector::ZeroVector;
CornerPositions[CornerIndex] = GetPositionForWedge(RawMesh, WedgeOffset + CornerIndex);
RelevantFacesForCorner[CornerIndex].Reset();
}
// Don't process degenerate triangles.
if (PointsEqual(CornerPositions[0], CornerPositions[1], ComparisonThreshold)
|| PointsEqual(CornerPositions[0], CornerPositions[2], ComparisonThreshold)
|| PointsEqual(CornerPositions[1], CornerPositions[2], ComparisonThreshold))
{
continue;
}
// No need to process triangles if tangents already exist.
bool bCornerHasNormal[3] = { 0 };
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
bCornerHasNormal[CornerIndex] = !RawMesh.WedgeTangentZ[WedgeOffset + CornerIndex].IsZero();
}
if (bCornerHasNormal[0] && bCornerHasNormal[1] && bCornerHasNormal[2])
{
continue;
}
// Start building a list of faces adjacent to this face.
AdjacentFaces.Reset();
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
int32 ThisCornerIndex = WedgeOffset + CornerIndex;
DupVerts.Reset();
OverlappingCorners.MultiFind(ThisCornerIndex, DupVerts);
DupVerts.Add(ThisCornerIndex); // I am a "dup" of myself
for (int32 k = 0; k < DupVerts.Num(); k++)
{
AdjacentFaces.AddUnique(DupVerts[k] / 3);
}
}
// We need to sort these here because the criteria for point equality is
// exact, so we must ensure the exact same order for all dups.
AdjacentFaces.Sort();
// Process adjacent faces
for (int32 AdjacentFaceIndex = 0; AdjacentFaceIndex < AdjacentFaces.Num(); AdjacentFaceIndex++)
{
int32 OtherFaceIndex = AdjacentFaces[AdjacentFaceIndex];
for (int32 OurCornerIndex = 0; OurCornerIndex < 3; OurCornerIndex++)
{
if (bCornerHasNormal[OurCornerIndex])
continue;
FFanFace NewFanFace;
int32 CommonIndexCount = 0;
// Check for vertices in common.
if (FaceIndex == OtherFaceIndex)
{
CommonIndexCount = 3;
NewFanFace.LinkedVertexIndex = OurCornerIndex;
}
else
{
// Check matching vertices against main vertex .
for (int32 OtherCornerIndex = 0; OtherCornerIndex < 3; OtherCornerIndex++)
{
if (PointsEqual(
CornerPositions[OurCornerIndex],
GetPositionForWedge(RawMesh, OtherFaceIndex * 3 + OtherCornerIndex),
ComparisonThreshold
))
{
CommonIndexCount++;
NewFanFace.LinkedVertexIndex = OtherCornerIndex;
}
}
}
// Add if connected by at least one point. Smoothing matches are considered later.
if (CommonIndexCount > 0)
{
NewFanFace.FaceIndex = OtherFaceIndex;
NewFanFace.bFilled = (OtherFaceIndex == FaceIndex); // Starter face for smoothing floodfill.
NewFanFace.bBlendTangents = NewFanFace.bFilled;
NewFanFace.bBlendNormals = NewFanFace.bFilled;
RelevantFacesForCorner[OurCornerIndex].Add(NewFanFace);
}
}
}
// Find true relevance of faces for a vertex normal by traversing
// smoothing-group-compatible connected triangle fans around common vertices.
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
if (bCornerHasNormal[CornerIndex])
continue;
int32 NewConnections;
do
{
NewConnections = 0;
for (int32 OtherFaceIdx = 0; OtherFaceIdx < RelevantFacesForCorner[CornerIndex].Num(); OtherFaceIdx++)
{
FFanFace& OtherFace = RelevantFacesForCorner[CornerIndex][OtherFaceIdx];
// The vertex' own face is initially the only face with bFilled == true.
if (OtherFace.bFilled)
{
for (int32 NextFaceIndex = 0; NextFaceIndex < RelevantFacesForCorner[CornerIndex].Num(); NextFaceIndex++)
{
FFanFace& NextFace = RelevantFacesForCorner[CornerIndex][NextFaceIndex];
if (!NextFace.bFilled) // && !NextFace.bBlendTangents)
{
if ((NextFaceIndex != OtherFaceIdx)
&& (RawMesh.FaceSmoothingMasks[NextFace.FaceIndex] & RawMesh.FaceSmoothingMasks[OtherFace.FaceIndex]))
{
int32 CommonVertices = 0;
int32 CommonNormalVertices = 0;
for (int32 OtherCornerIndex = 0; OtherCornerIndex < 3; OtherCornerIndex++)
{
for (int32 NextCornerIndex = 0; NextCornerIndex < 3; NextCornerIndex++)
{
int32 NextVertexIndex = RawMesh.WedgeIndices[NextFace.FaceIndex * 3 + NextCornerIndex];
int32 OtherVertexIndex = RawMesh.WedgeIndices[OtherFace.FaceIndex * 3 + OtherCornerIndex];
if (PointsEqual(
RawMesh.VertexPositions[NextVertexIndex],
RawMesh.VertexPositions[OtherVertexIndex],
ComparisonThreshold))
{
CommonVertices++;
if (bBlendOverlappingNormals
|| NextVertexIndex == OtherVertexIndex)
{
CommonNormalVertices++;
}
}
}
}
// Flood fill faces with more than one common vertices which must be touching edges.
if (CommonVertices > 1)
{
NextFace.bFilled = true;
NextFace.bBlendNormals = (CommonNormalVertices > 1);
NewConnections++;
}
}
}
}
}
}
}
while (NewConnections > 0);
}
// Vertex normal construction.
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
if (bCornerHasNormal[CornerIndex])
{
CornerNormal[CornerIndex] = RawMesh.WedgeTangentZ[WedgeOffset + CornerIndex];
}
else
{
for (int32 RelevantFaceIdx = 0; RelevantFaceIdx < RelevantFacesForCorner[CornerIndex].Num(); RelevantFaceIdx++)
{
FFanFace const& RelevantFace = RelevantFacesForCorner[CornerIndex][RelevantFaceIdx];
if (RelevantFace.bFilled)
{
int32 OtherFaceIndex = RelevantFace.FaceIndex;
if (RelevantFace.bBlendNormals)
{
CornerNormal[CornerIndex] += TriangleTangentZ[OtherFaceIndex];
}
}
}
if (!RawMesh.WedgeTangentZ[WedgeOffset + CornerIndex].IsZero())
{
CornerNormal[CornerIndex] = RawMesh.WedgeTangentZ[WedgeOffset + CornerIndex];
}
}
}
// Normalization.
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
CornerNormal[CornerIndex].Normalize();
}
// Copy back to the mesh.
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
RawMesh.WedgeTangentZ[WedgeOffset + CornerIndex] = CornerNormal[CornerIndex];
}
}
}
if (RawMesh.WedgeTangentX.Num() != NumWedges)
{
RawMesh.WedgeTangentX.Empty(NumWedges);
RawMesh.WedgeTangentX.AddZeroed(NumWedges);
}
if (RawMesh.WedgeTangentY.Num() != NumWedges)
{
RawMesh.WedgeTangentY.Empty(NumWedges);
RawMesh.WedgeTangentY.AddZeroed(NumWedges);
}
if (!bWedgeTSpace)
{
// we can use mikktspace to calculate the tangents
SMikkTSpaceInterface MikkTInterface;
MikkTInterface.m_getNormal = MikkGetNormal;
MikkTInterface.m_getNumFaces = MikkGetNumFaces;
MikkTInterface.m_getNumVerticesOfFace = MikkGetNumVertsOfFace;
MikkTInterface.m_getPosition = MikkGetPosition;
MikkTInterface.m_getTexCoord = MikkGetTexCoord;
MikkTInterface.m_setTSpaceBasic = MikkSetTSpaceBasic;
MikkTInterface.m_setTSpace = nullptr;
SMikkTSpaceContext MikkTContext;
MikkTContext.m_pInterface = &MikkTInterface;
MikkTContext.m_pUserData = (void*)(&RawMesh);
MikkTContext.m_bIgnoreDegenerates = bIgnoreDegenerateTriangles;
genTangSpaceDefault(&MikkTContext);
}
check(RawMesh.WedgeTangentX.Num() == NumWedges);
check(RawMesh.WedgeTangentY.Num() == NumWedges);
check(RawMesh.WedgeTangentZ.Num() == NumWedges);
}
static void ComputeStreamingTextureFactors(
float* OutStreamingTextureFactors,
float* OutMaxStreamingTextureFactor,
const FRawMesh& Mesh,
const FVector& BuildScale
)
{
int32 NumTexCoords = ComputeNumTexCoords(Mesh, MAX_STATIC_TEXCOORDS);
int32 NumFaces = Mesh.WedgeIndices.Num() / 3;
TArray<float> TexelRatios[MAX_STATIC_TEXCOORDS];
float MaxStreamingTextureFactor = 0.0f;
for (int32 FaceIndex = 0; FaceIndex < NumFaces; ++FaceIndex)
{
int32 Wedge0 = FaceIndex * 3 + 0;
int32 Wedge1 = FaceIndex * 3 + 1;
int32 Wedge2 = FaceIndex * 3 + 2;
const FVector& Pos0 = Mesh.GetWedgePosition(Wedge0) * BuildScale;
const FVector& Pos1 = Mesh.GetWedgePosition(Wedge1) * BuildScale;
const FVector& Pos2 = Mesh.GetWedgePosition(Wedge2) * BuildScale;
float L1 = (Pos0 - Pos1).Size(),
L2 = (Pos0 - Pos2).Size();
for (int32 UVIndex = 0; UVIndex < NumTexCoords; UVIndex++)
{
FVector2D UV0 = Mesh.WedgeTexCoords[UVIndex][Wedge0];
FVector2D UV1 = Mesh.WedgeTexCoords[UVIndex][Wedge1];
FVector2D UV2 = Mesh.WedgeTexCoords[UVIndex][Wedge2];
float T1 = (UV0 - UV1).Size(),
T2 = (UV0 - UV2).Size();
if (FMath::Abs(T1 * T2) > FMath::Square(SMALL_NUMBER))
{
const float TexelRatio = FMath::Max(L1 / T1, L2 / T2);
TexelRatios[UVIndex].Add(TexelRatio);
// Update max texel ratio
if (TexelRatio > MaxStreamingTextureFactor)
{
MaxStreamingTextureFactor = TexelRatio;
}
}
}
}
for (int32 UVIndex = 0; UVIndex < MAX_STATIC_TEXCOORDS; UVIndex++)
{
OutStreamingTextureFactors[UVIndex] = 0.0f;
if (TexelRatios[UVIndex].Num())
{
// Disregard upper 75% of texel ratios.
// This is to ignore backfacing surfaces or other non-visible surfaces that tend to map a small number of texels to a large surface.
TexelRatios[UVIndex].Sort(TGreater<float>());
float TexelRatio = TexelRatios[UVIndex][FMath::TruncToInt(TexelRatios[UVIndex].Num() * 0.75f)];
OutStreamingTextureFactors[UVIndex] = TexelRatio;
}
}
*OutMaxStreamingTextureFactor = MaxStreamingTextureFactor;
}
static void BuildDepthOnlyIndexBuffer(
TArray<uint32>& OutDepthIndices,
const TArray<FStaticMeshBuildVertex>& InVertices,
const TArray<uint32>& InIndices,
const TArray<FStaticMeshSection>& InSections
)
{
int32 NumVertices = InVertices.Num();
if (InIndices.Num() <= 0 || NumVertices <= 0)
{
OutDepthIndices.Empty();
return;
}
// Create a mapping of index -> first overlapping index to accelerate the construction of the shadow index buffer.
TArray<FIndexAndZ> VertIndexAndZ;
VertIndexAndZ.Empty(NumVertices);
for (int32 VertIndex = 0; VertIndex < NumVertices; VertIndex++)
{
new(VertIndexAndZ)FIndexAndZ(VertIndex, InVertices[VertIndex].Position);
}
VertIndexAndZ.Sort(FCompareIndexAndZ());
// Setup the index map. 0xFFFFFFFF == not set.
TArray<uint32> IndexMap;
IndexMap.AddUninitialized(NumVertices);
FMemory::Memset(IndexMap.GetData(), 0xFF, NumVertices * sizeof(uint32));
// Search for duplicates, quickly!
for (int32 i = 0; i < VertIndexAndZ.Num(); i++)
{
uint32 SrcIndex = VertIndexAndZ[i].Index;
float Z = VertIndexAndZ[i].Z;
IndexMap[SrcIndex] = FMath::Min(IndexMap[SrcIndex], SrcIndex);
// Search forward since we add pairs both ways.
for (int32 j = i + 1; j < VertIndexAndZ.Num(); j++)
{
if (FMath::Abs(VertIndexAndZ[j].Z - Z) > THRESH_POINTS_ARE_SAME * 4.01f)
break; // can't be any more dups
uint32 OtherIndex = VertIndexAndZ[j].Index;
if (PointsEqual(InVertices[SrcIndex].Position, InVertices[OtherIndex].Position,/*bUseEpsilonCompare=*/ true))
{
IndexMap[SrcIndex] = FMath::Min(IndexMap[SrcIndex], OtherIndex);
IndexMap[OtherIndex] = FMath::Min(IndexMap[OtherIndex], SrcIndex);
}
}
}
// Build the depth-only index buffer by remapping all indices to the first overlapping
// vertex in the vertex buffer.
OutDepthIndices.Empty();
for (int32 SectionIndex = 0; SectionIndex < InSections.Num(); ++SectionIndex)
{
const FStaticMeshSection& Section = InSections[SectionIndex];
int32 FirstIndex = Section.FirstIndex;
int32 LastIndex = FirstIndex + Section.NumTriangles * 3;
for (int32 SrcIndex = FirstIndex; SrcIndex < LastIndex; ++SrcIndex)
{
uint32 VertIndex = InIndices[SrcIndex];
OutDepthIndices.Add(IndexMap[VertIndex]);
}
}
}
static float GetComparisonThreshold(FMeshBuildSettings const& BuildSettings)
{
return BuildSettings.bRemoveDegenerates ? THRESH_POINTS_ARE_SAME : 0.0f;
}
/*------------------------------------------------------------------------------
Static mesh building.
------------------------------------------------------------------------------*/
static FStaticMeshBuildVertex BuildStaticMeshVertex(FRawMesh const& RawMesh, int32 WedgeIndex, FVector BuildScale)
{
FStaticMeshBuildVertex Vertex;
Vertex.Position = GetPositionForWedge(RawMesh, WedgeIndex) * BuildScale;
const FMatrix ScaleMatrix = FScaleMatrix(BuildScale).Inverse().GetTransposed();
Vertex.TangentX = ScaleMatrix.TransformVector(RawMesh.WedgeTangentX[WedgeIndex]).GetSafeNormal();
Vertex.TangentY = ScaleMatrix.TransformVector(RawMesh.WedgeTangentY[WedgeIndex]).GetSafeNormal();
Vertex.TangentZ = ScaleMatrix.TransformVector(RawMesh.WedgeTangentZ[WedgeIndex]).GetSafeNormal();
if (RawMesh.WedgeColors.IsValidIndex(WedgeIndex))
{
Vertex.Color = RawMesh.WedgeColors[WedgeIndex];
}
else
{
Vertex.Color = FColor::White;
}
int32 NumTexCoords = FMath::Min<int32>(MAX_MESH_TEXTURE_COORDS, MAX_STATIC_TEXCOORDS);
for (int32 i = 0; i < NumTexCoords; ++i)
{
if (RawMesh.WedgeTexCoords[i].IsValidIndex(WedgeIndex))
{
Vertex.UVs[i] = RawMesh.WedgeTexCoords[i][WedgeIndex];
}
else
{
Vertex.UVs[i] = FVector2D(0.0f, 0.0f);
}
}
return Vertex;
}
static bool AreVerticesEqual(
FStaticMeshBuildVertex const& A,
FStaticMeshBuildVertex const& B,
float ComparisonThreshold
)
{
if (!PointsEqual(A.Position, B.Position, ComparisonThreshold)
|| !NormalsEqual(A.TangentX, B.TangentX)
|| !NormalsEqual(A.TangentY, B.TangentY)
|| !NormalsEqual(A.TangentZ, B.TangentZ)
|| A.Color != B.Color)
{
return false;
}
// UVs
for (int32 UVIndex = 0; UVIndex < MAX_STATIC_TEXCOORDS; UVIndex++)
{
if (!UVsEqual(A.UVs[UVIndex], B.UVs[UVIndex]))
{
return false;
}
}
return true;
}
void FMeshUtilities::BuildStaticMeshVertexAndIndexBuffers(
TArray<FStaticMeshBuildVertex>& OutVertices,
TArray<TArray<uint32> >& OutPerSectionIndices,
TArray<int32>& OutWedgeMap,
const FRawMesh& RawMesh,
const TMultiMap<int32, int32>& OverlappingCorners,
const TMap<uint32, uint32>& MaterialToSectionMapping,
float ComparisonThreshold,
FVector BuildScale
)
{
TMap<int32, int32> FinalVerts;
TArray<int32> DupVerts;
int32 NumFaces = RawMesh.WedgeIndices.Num() / 3;
// Process each face, build vertex buffer and per-section index buffers.
for (int32 FaceIndex = 0; FaceIndex < NumFaces; FaceIndex++)
{
int32 VertexIndices[3];
FVector CornerPositions[3];
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
CornerPositions[CornerIndex] = GetPositionForWedge(RawMesh, FaceIndex * 3 + CornerIndex);
}
// Don't process degenerate triangles.
if (PointsEqual(CornerPositions[0], CornerPositions[1], ComparisonThreshold)
|| PointsEqual(CornerPositions[0], CornerPositions[2], ComparisonThreshold)
|| PointsEqual(CornerPositions[1], CornerPositions[2], ComparisonThreshold))
{
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
OutWedgeMap.Add(INDEX_NONE);
}
continue;
}
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
int32 WedgeIndex = FaceIndex * 3 + CornerIndex;
FStaticMeshBuildVertex ThisVertex = BuildStaticMeshVertex(RawMesh, WedgeIndex, BuildScale);
DupVerts.Reset();
OverlappingCorners.MultiFind(WedgeIndex, DupVerts);
DupVerts.Sort();
int32 Index = INDEX_NONE;
for (int32 k = 0; k < DupVerts.Num(); k++)
{
if (DupVerts[k] >= WedgeIndex)
{
// the verts beyond me haven't been placed yet, so these duplicates are not relevant
break;
}
int32 *Location = FinalVerts.Find(DupVerts[k]);
if (Location != NULL
&& AreVerticesEqual(ThisVertex, OutVertices[*Location], ComparisonThreshold))
{
Index = *Location;
break;
}
}
if (Index == INDEX_NONE)
{
Index = OutVertices.Add(ThisVertex);
FinalVerts.Add(WedgeIndex, Index);
}
VertexIndices[CornerIndex] = Index;
}
// Reject degenerate triangles.
if (VertexIndices[0] == VertexIndices[1]
|| VertexIndices[1] == VertexIndices[2]
|| VertexIndices[0] == VertexIndices[2])
{
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
OutWedgeMap.Add(INDEX_NONE);
}
continue;
}
// Put the indices in the material index buffer.
const uint32 SectionIndex = MaterialToSectionMapping.FindChecked(RawMesh.FaceMaterialIndices[FaceIndex]);
TArray<uint32>& SectionIndices = OutPerSectionIndices[SectionIndex];
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
SectionIndices.Add(VertexIndices[CornerIndex]);
OutWedgeMap.Add(VertexIndices[CornerIndex]);
}
}
}
void FMeshUtilities::CacheOptimizeVertexAndIndexBuffer(
TArray<FStaticMeshBuildVertex>& Vertices,
TArray<TArray<uint32> >& PerSectionIndices,
TArray<int32>& WedgeMap
)
{
// Copy the vertices since we will be reordering them
TArray<FStaticMeshBuildVertex> OriginalVertices = Vertices;
// Initialize a cache that stores which indices have been assigned
TArray<int32> IndexCache;
IndexCache.AddUninitialized(Vertices.Num());
FMemory::Memset(IndexCache.GetData(), INDEX_NONE, IndexCache.Num() * IndexCache.GetTypeSize());
int32 NextAvailableIndex = 0;
// Iterate through the section index buffers,
// Optimizing index order for the post transform cache (minimizes the number of vertices transformed),
// And vertex order for the pre transform cache (minimizes the amount of vertex data fetched by the GPU).
for (int32 SectionIndex = 0; SectionIndex < PerSectionIndices.Num(); SectionIndex++)
{
TArray<uint32>& Indices = PerSectionIndices[SectionIndex];
if (Indices.Num())
{
// Optimize the index buffer for the post transform cache with.
CacheOptimizeIndexBuffer(Indices);
// Copy the index buffer since we will be reordering it
TArray<uint32> OriginalIndices = Indices;
// Go through the indices and assign them new values that are coherent where possible
for (int32 Index = 0; Index < Indices.Num(); Index++)
{
const int32 CachedIndex = IndexCache[OriginalIndices[Index]];
if (CachedIndex == INDEX_NONE)
{
// No new index has been allocated for this existing index, assign a new one
Indices[Index] = NextAvailableIndex;
// Mark what this index has been assigned to
IndexCache[OriginalIndices[Index]] = NextAvailableIndex;
NextAvailableIndex++;
}
else
{
// Reuse an existing index assignment
Indices[Index] = CachedIndex;
}
// Reorder the vertices based on the new index assignment
Vertices[Indices[Index]] = OriginalVertices[OriginalIndices[Index]];
}
}
}
for (int32 i = 0; i < WedgeMap.Num(); i++)
{
int32 MappedIndex = WedgeMap[i];
if (MappedIndex != INDEX_NONE)
{
WedgeMap[i] = IndexCache[MappedIndex];
}
}
}
class FStaticMeshUtilityBuilder
{
public:
FStaticMeshUtilityBuilder() : Stage(EStage::Uninit), NumValidLODs(0) {}
bool GatherSourceMeshesPerLOD(TArray<FStaticMeshSourceModel>& SourceModels, IMeshReduction* MeshReduction)
{
check(Stage == EStage::Uninit);
// Gather source meshes for each LOD.
for (int32 LODIndex = 0; LODIndex < SourceModels.Num(); ++LODIndex)
{
FStaticMeshSourceModel& SrcModel = SourceModels[LODIndex];
FRawMesh& RawMesh = *new(LODMeshes)FRawMesh;
TMultiMap<int32, int32>& OverlappingCorners = *new(LODOverlappingCorners)TMultiMap<int32, int32>;
if (!SrcModel.RawMeshBulkData->IsEmpty())
{
SrcModel.RawMeshBulkData->LoadRawMesh(RawMesh);
// Make sure the raw mesh is not irreparably malformed.
if (!RawMesh.IsValidOrFixable())
{
UE_LOG(LogMeshUtilities, Error, TEXT("Raw mesh is corrupt for LOD%d."), LODIndex);
return false;
}
LODBuildSettings[LODIndex] = SrcModel.BuildSettings;
float ComparisonThreshold = GetComparisonThreshold(LODBuildSettings[LODIndex]);
int32 NumWedges = RawMesh.WedgeIndices.Num();
// Find overlapping corners to accelerate adjacency.
FindOverlappingCorners(OverlappingCorners, RawMesh, ComparisonThreshold);
// Figure out if we should recompute normals and tangents.
bool bRecomputeNormals = SrcModel.BuildSettings.bRecomputeNormals || RawMesh.WedgeTangentZ.Num() != NumWedges;
bool bRecomputeTangents = SrcModel.BuildSettings.bRecomputeTangents || RawMesh.WedgeTangentX.Num() != NumWedges || RawMesh.WedgeTangentY.Num() != NumWedges;
// Dump normals and tangents if we are recomputing them.
if (bRecomputeTangents)
{
RawMesh.WedgeTangentX.Empty(NumWedges);
RawMesh.WedgeTangentX.AddZeroed(NumWedges);
RawMesh.WedgeTangentY.Empty(NumWedges);
RawMesh.WedgeTangentY.AddZeroed(NumWedges);
}
if (bRecomputeNormals)
{
RawMesh.WedgeTangentZ.Empty(NumWedges);
RawMesh.WedgeTangentZ.AddZeroed(NumWedges);
}
// Compute any missing tangents.
{
// Static meshes always blend normals of overlapping corners.
uint32 TangentOptions = ETangentOptions::BlendOverlappingNormals;
if (SrcModel.BuildSettings.bRemoveDegenerates)
{
// If removing degenerate triangles, ignore them when computing tangents.
TangentOptions |= ETangentOptions::IgnoreDegenerateTriangles;
}
//MikkTSpace should be use only when the user want to recompute the normals or tangents otherwise should always fallback on builtin
if (SrcModel.BuildSettings.bUseMikkTSpace && (SrcModel.BuildSettings.bRecomputeNormals || SrcModel.BuildSettings.bRecomputeTangents))
{
ComputeTangents_MikkTSpace(RawMesh, OverlappingCorners, TangentOptions);
}
else
{
ComputeTangents(RawMesh, OverlappingCorners, TangentOptions);
}
}
// At this point the mesh will have valid tangents.
check(RawMesh.WedgeTangentX.Num() == NumWedges);
check(RawMesh.WedgeTangentY.Num() == NumWedges);
check(RawMesh.WedgeTangentZ.Num() == NumWedges);
// Generate lightmap UVs
if (SrcModel.BuildSettings.bGenerateLightmapUVs)
{
if (RawMesh.WedgeTexCoords[SrcModel.BuildSettings.SrcLightmapIndex].Num() == 0)
{
SrcModel.BuildSettings.SrcLightmapIndex = 0;
}
FLayoutUV Packer(&RawMesh, SrcModel.BuildSettings.SrcLightmapIndex, SrcModel.BuildSettings.DstLightmapIndex, SrcModel.BuildSettings.MinLightmapResolution);
Packer.FindCharts(OverlappingCorners);
bool bPackSuccess = Packer.FindBestPacking();
if (bPackSuccess)
{
Packer.CommitPackedUVs();
}
}
HasRawMesh[LODIndex] = true;
}
else if (LODIndex > 0 && MeshReduction)
{
// If a raw mesh is not explicitly provided, use the raw mesh of the
// next highest LOD.
RawMesh = LODMeshes[LODIndex - 1];
OverlappingCorners = LODOverlappingCorners[LODIndex - 1];
LODBuildSettings[LODIndex] = LODBuildSettings[LODIndex - 1];
HasRawMesh[LODIndex] = false;
}
}
check(LODMeshes.Num() == SourceModels.Num());
check(LODOverlappingCorners.Num() == SourceModels.Num());
// Bail if there is no raw mesh data from which to build a renderable mesh.
if (LODMeshes.Num() == 0 || LODMeshes[0].WedgeIndices.Num() == 0)
{
return false;
}
Stage = EStage::Gathered;
return true;
}
bool ReduceLODs(TArray<FStaticMeshSourceModel>& SourceModels, const FStaticMeshLODGroup& LODGroup, IMeshReduction* MeshReduction, bool& bOutWasReduced)
{
check(Stage == EStage::Gathered);
// Reduce each LOD mesh according to its reduction settings.
for (int32 LODIndex = 0; LODIndex < SourceModels.Num(); ++LODIndex)
{
const FStaticMeshSourceModel& SrcModel = SourceModels[LODIndex];
FMeshReductionSettings ReductionSettings = LODGroup.GetSettings(SrcModel.ReductionSettings, LODIndex);
LODMaxDeviation[NumValidLODs] = 0.0f;
if (LODIndex != NumValidLODs)
{
LODBuildSettings[NumValidLODs] = LODBuildSettings[LODIndex];
LODOverlappingCorners[NumValidLODs] = LODOverlappingCorners[LODIndex];
}
if (MeshReduction && (ReductionSettings.PercentTriangles < 1.0f || ReductionSettings.MaxDeviation > 0.0f))
{
FRawMesh& InMesh = LODMeshes[ReductionSettings.BaseLODModel];
FRawMesh& DestMesh = LODMeshes[NumValidLODs];
TMultiMap<int32, int32>& InOverlappingCorners = LODOverlappingCorners[ReductionSettings.BaseLODModel];
TMultiMap<int32, int32>& DestOverlappingCorners = LODOverlappingCorners[NumValidLODs];
MeshReduction->Reduce(DestMesh, LODMaxDeviation[NumValidLODs], InMesh, InOverlappingCorners, ReductionSettings);
if (DestMesh.WedgeIndices.Num() > 0 && !DestMesh.IsValid())
{
UE_LOG(LogMeshUtilities, Error, TEXT("Mesh reduction produced a corrupt mesh for LOD%d"), LODIndex);
return false;
}
bOutWasReduced = true;
// Recompute adjacency information.
DestOverlappingCorners.Reset();
float ComparisonThreshold = GetComparisonThreshold(LODBuildSettings[NumValidLODs]);
FindOverlappingCorners(DestOverlappingCorners, DestMesh, ComparisonThreshold);
}
if (LODMeshes[NumValidLODs].WedgeIndices.Num() > 0)
{
NumValidLODs++;
}
}
if (NumValidLODs < 1)
{
return false;
}
Stage = EStage::Reduce;
return true;
}
bool GenerateRenderingMeshes(FMeshUtilities& MeshUtilities, FStaticMeshRenderData& OutRenderData, TArray<FStaticMeshSourceModel>& InOutModels)
{
check(Stage == EStage::Reduce);
// Generate per-LOD rendering data.
OutRenderData.AllocateLODResources(NumValidLODs);
for (int32 LODIndex = 0; LODIndex < NumValidLODs; ++LODIndex)
{
FStaticMeshLODResources& LODModel = OutRenderData.LODResources[LODIndex];
FRawMesh& RawMesh = LODMeshes[LODIndex];
LODModel.MaxDeviation = LODMaxDeviation[LODIndex];
TArray<FStaticMeshBuildVertex> Vertices;
TArray<TArray<uint32> > PerSectionIndices;
TMap<uint32, uint32> MaterialToSectionMapping;
// Find out how many sections are in the mesh.
TArray<int32> MaterialIndices;
for ( const int32 MaterialIndex : RawMesh.FaceMaterialIndices )
{
// Find all unique material indices
MaterialIndices.AddUnique(MaterialIndex);
}
// Need X number of sections for X number of material indices
//for (const int32 MaterialIndex : MaterialIndices)
for ( int32 Index = 0; Index < MaterialIndices.Num(); ++Index)
{
const int32 MaterialIndex = MaterialIndices[Index];
FStaticMeshSection* Section = new(LODModel.Sections) FStaticMeshSection();
Section->MaterialIndex = MaterialIndex;
MaterialToSectionMapping.Add(MaterialIndex, Index);
new(PerSectionIndices)TArray<uint32>;
}
// Build and cache optimize vertex and index buffers.
{
// TODO_STATICMESH: The wedge map is only valid for LODIndex 0 if no reduction has been performed.
// We can compute an approximate one instead for other LODs.
TArray<int32> TempWedgeMap;
TArray<int32>& WedgeMap = (LODIndex == 0 && InOutModels[0].ReductionSettings.PercentTriangles >= 1.0f) ? OutRenderData.WedgeMap : TempWedgeMap;
float ComparisonThreshold = GetComparisonThreshold(LODBuildSettings[LODIndex]);
MeshUtilities.BuildStaticMeshVertexAndIndexBuffers(Vertices, PerSectionIndices, WedgeMap, RawMesh, LODOverlappingCorners[LODIndex], MaterialToSectionMapping, ComparisonThreshold, LODBuildSettings[LODIndex].BuildScale3D);
check(WedgeMap.Num() == RawMesh.WedgeIndices.Num());
if (RawMesh.WedgeIndices.Num() < 100000 * 3)
{
MeshUtilities.CacheOptimizeVertexAndIndexBuffer(Vertices, PerSectionIndices, WedgeMap);
check(WedgeMap.Num() == RawMesh.WedgeIndices.Num());
}
}
verifyf(Vertices.Num() != 0, TEXT("No valid vertices found for the mesh."));
// Initialize the vertex buffer.
int32 NumTexCoords = ComputeNumTexCoords(RawMesh, MAX_STATIC_TEXCOORDS);
LODModel.VertexBuffer.SetUseHighPrecisionTangentBasis(LODBuildSettings[LODIndex].bUseHighPrecisionTangentBasis);
LODModel.VertexBuffer.SetUseFullPrecisionUVs(LODBuildSettings[LODIndex].bUseFullPrecisionUVs);
LODModel.VertexBuffer.Init(Vertices, NumTexCoords);
LODModel.PositionVertexBuffer.Init(Vertices);
LODModel.ColorVertexBuffer.Init(Vertices);
// Concatenate the per-section index buffers.
TArray<uint32> CombinedIndices;
bool bNeeds32BitIndices = false;
for (int32 SectionIndex = 0; SectionIndex < LODModel.Sections.Num(); SectionIndex++)
{
FStaticMeshSection& Section = LODModel.Sections[SectionIndex];
TArray<uint32> const& SectionIndices = PerSectionIndices[SectionIndex];
Section.FirstIndex = 0;
Section.NumTriangles = 0;
Section.MinVertexIndex = 0;
Section.MaxVertexIndex = 0;
if (SectionIndices.Num())
{
Section.FirstIndex = CombinedIndices.Num();
Section.NumTriangles = SectionIndices.Num() / 3;
CombinedIndices.AddUninitialized(SectionIndices.Num());
uint32* DestPtr = &CombinedIndices[Section.FirstIndex];
uint32 const* SrcPtr = SectionIndices.GetData();
Section.MinVertexIndex = *SrcPtr;
Section.MaxVertexIndex = *SrcPtr;
for (int32 Index = 0; Index < SectionIndices.Num(); Index++)
{
uint32 VertIndex = *SrcPtr++;
bNeeds32BitIndices |= (VertIndex > MAX_uint16);
Section.MinVertexIndex = FMath::Min<uint32>(VertIndex, Section.MinVertexIndex);
Section.MaxVertexIndex = FMath::Max<uint32>(VertIndex, Section.MaxVertexIndex);
*DestPtr++ = VertIndex;
}
}
}
LODModel.IndexBuffer.SetIndices(CombinedIndices, bNeeds32BitIndices ? EIndexBufferStride::Force32Bit : EIndexBufferStride::Force16Bit);
if (LODIndex == 0)
{
ComputeStreamingTextureFactors(
OutRenderData.StreamingTextureFactors,
&OutRenderData.MaxStreamingTextureFactor,
RawMesh,
LODBuildSettings[LODIndex].BuildScale3D
);
}
// Build the reversed index buffer.
if (InOutModels[0].BuildSettings.bBuildReversedIndexBuffer)
{
TArray<uint32> InversedIndices;
const int32 IndexCount = CombinedIndices.Num();
InversedIndices.AddUninitialized(IndexCount);
for (int32 SectionIndex = 0; SectionIndex < LODModel.Sections.Num(); ++SectionIndex)
{
const FStaticMeshSection& SectionInfo = LODModel.Sections[SectionIndex];
const int32 SectionIndexCount = SectionInfo.NumTriangles * 3;
for (int32 i = 0; i < SectionIndexCount; ++i)
{
InversedIndices[SectionInfo.FirstIndex + i] = CombinedIndices[SectionInfo.FirstIndex + SectionIndexCount - 1 - i];
}
}
LODModel.ReversedIndexBuffer.SetIndices(InversedIndices, bNeeds32BitIndices ? EIndexBufferStride::Force32Bit : EIndexBufferStride::Force16Bit);
}
// Build the depth-only index buffer.
TArray<uint32> DepthOnlyIndices;
{
BuildDepthOnlyIndexBuffer(
DepthOnlyIndices,
Vertices,
CombinedIndices,
LODModel.Sections
);
if (DepthOnlyIndices.Num() < 50000 * 3)
{
MeshUtilities.CacheOptimizeIndexBuffer(DepthOnlyIndices);
}
LODModel.DepthOnlyIndexBuffer.SetIndices(DepthOnlyIndices, bNeeds32BitIndices ? EIndexBufferStride::Force32Bit : EIndexBufferStride::Force16Bit);
}
// Build the inversed depth only index buffer.
if (InOutModels[0].BuildSettings.bBuildReversedIndexBuffer)
{
TArray<uint32> ReversedDepthOnlyIndices;
const int32 IndexCount = DepthOnlyIndices.Num();
ReversedDepthOnlyIndices.AddUninitialized(IndexCount);
for (int32 i = 0; i < IndexCount; ++i)
{
ReversedDepthOnlyIndices[i] = DepthOnlyIndices[IndexCount - 1 - i];
}
LODModel.ReversedDepthOnlyIndexBuffer.SetIndices(ReversedDepthOnlyIndices, bNeeds32BitIndices ? EIndexBufferStride::Force32Bit : EIndexBufferStride::Force16Bit);
}
// Build a list of wireframe edges in the static mesh.
{
TArray<FMeshEdge> Edges;
TArray<uint32> WireframeIndices;
FStaticMeshEdgeBuilder(CombinedIndices, Vertices, Edges).FindEdges();
WireframeIndices.Empty(2 * Edges.Num());
for (int32 EdgeIndex = 0; EdgeIndex < Edges.Num(); EdgeIndex++)
{
FMeshEdge& Edge = Edges[EdgeIndex];
WireframeIndices.Add(Edge.Vertices[0]);
WireframeIndices.Add(Edge.Vertices[1]);
}
LODModel.WireframeIndexBuffer.SetIndices(WireframeIndices, bNeeds32BitIndices ? EIndexBufferStride::Force32Bit : EIndexBufferStride::Force16Bit);
}
// Build the adjacency index buffer used for tessellation.
if (InOutModels[0].BuildSettings.bBuildAdjacencyBuffer)
{
TArray<uint32> AdjacencyIndices;
BuildStaticAdjacencyIndexBuffer(
LODModel.PositionVertexBuffer,
LODModel.VertexBuffer,
CombinedIndices,
AdjacencyIndices
);
LODModel.AdjacencyIndexBuffer.SetIndices(AdjacencyIndices, bNeeds32BitIndices ? EIndexBufferStride::Force32Bit : EIndexBufferStride::Force16Bit);
}
}
// Copy the original material indices to fixup meshes before compacting of materials was done.
if (NumValidLODs > 0)
{
OutRenderData.MaterialIndexToImportIndex = LODMeshes[0].MaterialIndexToImportIndex;
}
// Calculate the bounding box.
FBox BoundingBox(0);
FPositionVertexBuffer& BasePositionVertexBuffer = OutRenderData.LODResources[0].PositionVertexBuffer;
for (uint32 VertexIndex = 0; VertexIndex < BasePositionVertexBuffer.GetNumVertices(); VertexIndex++)
{
BoundingBox += BasePositionVertexBuffer.VertexPosition(VertexIndex);
}
BoundingBox.GetCenterAndExtents(OutRenderData.Bounds.Origin, OutRenderData.Bounds.BoxExtent);
// Calculate the bounding sphere, using the center of the bounding box as the origin.
OutRenderData.Bounds.SphereRadius = 0.0f;
for (uint32 VertexIndex = 0; VertexIndex < BasePositionVertexBuffer.GetNumVertices(); VertexIndex++)
{
OutRenderData.Bounds.SphereRadius = FMath::Max(
(BasePositionVertexBuffer.VertexPosition(VertexIndex) - OutRenderData.Bounds.Origin).Size(),
OutRenderData.Bounds.SphereRadius
);
}
Stage = EStage::GenerateRendering;
return true;
}
bool ReplaceRawMeshModels(TArray<FStaticMeshSourceModel>& SourceModels)
{
check(Stage == EStage::Reduce);
check(HasRawMesh[0]);
check(SourceModels.Num() >= NumValidLODs);
bool bDirty = false;
for (int32 Index = 1; Index < NumValidLODs; ++Index)
{
if (!HasRawMesh[Index])
{
SourceModels[Index].RawMeshBulkData->SaveRawMesh(LODMeshes[Index]);
bDirty = true;
}
}
Stage = EStage::ReplaceRaw;
return true;
}
private:
enum class EStage
{
Uninit,
Gathered,
Reduce,
GenerateRendering,
ReplaceRaw,
};
EStage Stage;
int32 NumValidLODs;
TIndirectArray<FRawMesh> LODMeshes;
TIndirectArray<TMultiMap<int32, int32> > LODOverlappingCorners;
float LODMaxDeviation[MAX_STATIC_MESH_LODS];
FMeshBuildSettings LODBuildSettings[MAX_STATIC_MESH_LODS];
bool HasRawMesh[MAX_STATIC_MESH_LODS];
};
bool FMeshUtilities::BuildStaticMesh(FStaticMeshRenderData& OutRenderData, TArray<FStaticMeshSourceModel>& SourceModels, const FStaticMeshLODGroup& LODGroup)
{
FStaticMeshUtilityBuilder Builder;
if (!Builder.GatherSourceMeshesPerLOD(SourceModels, MeshReduction))
{
return false;
}
OutRenderData.bReducedBySimplygon = false;
bool bWasReduced = false;
if (!Builder.ReduceLODs(SourceModels, LODGroup, MeshReduction, bWasReduced))
{
return false;
}
OutRenderData.bReducedBySimplygon = (bWasReduced && bUsingSimplygon);
return Builder.GenerateRenderingMeshes(*this, OutRenderData, SourceModels);
}
bool FMeshUtilities::GenerateStaticMeshLODs(TArray<FStaticMeshSourceModel>& Models, const FStaticMeshLODGroup& LODGroup)
{
FStaticMeshUtilityBuilder Builder;
if (!Builder.GatherSourceMeshesPerLOD(Models, MeshReduction))
{
return false;
}
bool bWasReduced = false;
if (!Builder.ReduceLODs(Models, LODGroup, MeshReduction, bWasReduced))
{
return false;
}
if (bWasReduced)
{
return Builder.ReplaceRawMeshModels(Models);
}
return false;
}
class IMeshBuildData
{
public:
virtual uint32 GetWedgeIndex(uint32 FaceIndex, uint32 TriIndex) = 0;
virtual uint32 GetVertexIndex(uint32 WedgeIndex) = 0;
virtual uint32 GetVertexIndex(uint32 FaceIndex, uint32 TriIndex) = 0;
virtual FVector GetVertexPosition(uint32 WedgeIndex) = 0;
virtual FVector GetVertexPosition(uint32 FaceIndex, uint32 TriIndex) = 0;
virtual FVector2D GetVertexUV(uint32 FaceIndex, uint32 TriIndex, uint32 UVIndex) = 0;
virtual uint32 GetFaceSmoothingGroups(uint32 FaceIndex) = 0;
virtual uint32 GetNumFaces() = 0;
virtual uint32 GetNumWedges() = 0;
virtual TArray<FVector>& GetTangentArray(uint32 Axis) = 0;
virtual void ValidateTangentArraySize() = 0;
virtual SMikkTSpaceInterface* GetMikkTInterface() = 0;
virtual void* GetMikkTUserData() = 0;
const IMeshUtilities::MeshBuildOptions& BuildOptions;
TArray<FText>* OutWarningMessages;
TArray<FName>* OutWarningNames;
bool bTooManyVerts;
protected:
IMeshBuildData(
const IMeshUtilities::MeshBuildOptions& InBuildOptions,
TArray<FText>* InWarningMessages,
TArray<FName>* InWarningNames)
: BuildOptions(InBuildOptions)
, OutWarningMessages(InWarningMessages)
, OutWarningNames(InWarningNames)
, bTooManyVerts(false)
{
}
};
class SkeletalMeshBuildData : public IMeshBuildData
{
public:
SkeletalMeshBuildData(
FStaticLODModel& InLODModel,
const FReferenceSkeleton& InRefSkeleton,
const TArray<FVertInfluence>& InInfluences,
const TArray<FMeshWedge>& InWedges,
const TArray<FMeshFace>& InFaces,
const TArray<FVector>& InPoints,
const TArray<int32>& InPointToOriginalMap,
const IMeshUtilities::MeshBuildOptions& InBuildOptions,
TArray<FText>* InWarningMessages,
TArray<FName>* InWarningNames)
: IMeshBuildData(InBuildOptions, InWarningMessages, InWarningNames)
, MikkTUserData(InWedges, InFaces, InPoints, InBuildOptions.bComputeNormals, TangentX, TangentY, TangentZ)
, LODModel(InLODModel)
, RefSkeleton(InRefSkeleton)
, Influences(InInfluences)
, Wedges(InWedges)
, Faces(InFaces)
, Points(InPoints)
, PointToOriginalMap(InPointToOriginalMap)
{
MikkTInterface.m_getNormal = MikkGetNormal_Skeletal;
MikkTInterface.m_getNumFaces = MikkGetNumFaces_Skeletal;
MikkTInterface.m_getNumVerticesOfFace = MikkGetNumVertsOfFace_Skeletal;
MikkTInterface.m_getPosition = MikkGetPosition_Skeletal;
MikkTInterface.m_getTexCoord = MikkGetTexCoord_Skeletal;
MikkTInterface.m_setTSpaceBasic = MikkSetTSpaceBasic_Skeletal;
MikkTInterface.m_setTSpace = nullptr;
}
virtual uint32 GetWedgeIndex(uint32 FaceIndex, uint32 TriIndex) override
{
return Faces[FaceIndex].iWedge[TriIndex];
}
virtual uint32 GetVertexIndex(uint32 WedgeIndex) override
{
return Wedges[WedgeIndex].iVertex;
}
virtual uint32 GetVertexIndex(uint32 FaceIndex, uint32 TriIndex) override
{
return Wedges[Faces[FaceIndex].iWedge[TriIndex]].iVertex;
}
virtual FVector GetVertexPosition(uint32 WedgeIndex) override
{
return Points[Wedges[WedgeIndex].iVertex];
}
virtual FVector GetVertexPosition(uint32 FaceIndex, uint32 TriIndex) override
{
return Points[Wedges[Faces[FaceIndex].iWedge[TriIndex]].iVertex];
}
virtual FVector2D GetVertexUV(uint32 FaceIndex, uint32 TriIndex, uint32 UVIndex) override
{
return Wedges[Faces[FaceIndex].iWedge[TriIndex]].UVs[UVIndex];
}
virtual uint32 GetFaceSmoothingGroups(uint32 FaceIndex)
{
return Faces[FaceIndex].SmoothingGroups;
}
virtual uint32 GetNumFaces() override
{
return Faces.Num();
}
virtual uint32 GetNumWedges() override
{
return Wedges.Num();
}
virtual TArray<FVector>& GetTangentArray(uint32 Axis) override
{
if (Axis == 0)
{
return TangentX;
}
else if (Axis == 1)
{
return TangentY;
}
return TangentZ;
}
virtual void ValidateTangentArraySize() override
{
check(TangentX.Num() == Wedges.Num());
check(TangentY.Num() == Wedges.Num());
check(TangentZ.Num() == Wedges.Num());
}
virtual SMikkTSpaceInterface* GetMikkTInterface() override
{
return &MikkTInterface;
}
virtual void* GetMikkTUserData() override
{
return (void*)&MikkTUserData;
}
TArray<FVector> TangentX;
TArray<FVector> TangentY;
TArray<FVector> TangentZ;
TArray<FSkinnedMeshChunk*> Chunks;
SMikkTSpaceInterface MikkTInterface;
MikkTSpace_Skeletal_Mesh MikkTUserData;
FStaticLODModel& LODModel;
const FReferenceSkeleton& RefSkeleton;
const TArray<FVertInfluence>& Influences;
const TArray<FMeshWedge>& Wedges;
const TArray<FMeshFace>& Faces;
const TArray<FVector>& Points;
const TArray<int32>& PointToOriginalMap;
};
class FSkeletalMeshUtilityBuilder
{
public:
FSkeletalMeshUtilityBuilder()
: Stage(EStage::Uninit)
{
}
public:
void Skeletal_FindOverlappingCorners(
TMultiMap<int32, int32>& OutOverlappingCorners,
IMeshBuildData* BuildData,
float ComparisonThreshold
)
{
int32 NumFaces = BuildData->GetNumFaces();
int32 NumWedges = BuildData->GetNumWedges();
check(NumFaces * 3 <= NumWedges);
// Create a list of vertex Z/index pairs
TArray<FIndexAndZ> VertIndexAndZ;
VertIndexAndZ.Empty(NumWedges);
for (int32 FaceIndex = 0; FaceIndex < NumFaces; FaceIndex++)
{
for (int32 TriIndex = 0; TriIndex < 3; ++TriIndex)
{
uint32 Index = BuildData->GetWedgeIndex(FaceIndex, TriIndex);
new(VertIndexAndZ)FIndexAndZ(Index, BuildData->GetVertexPosition(Index));
}
}
// Sort the vertices by z value
VertIndexAndZ.Sort(FCompareIndexAndZ());
// Search for duplicates, quickly!
for (int32 i = 0; i < VertIndexAndZ.Num(); i++)
{
// only need to search forward, since we add pairs both ways
for (int32 j = i + 1; j < VertIndexAndZ.Num(); j++)
{
if (FMath::Abs(VertIndexAndZ[j].Z - VertIndexAndZ[i].Z) > ComparisonThreshold)
break; // can't be any more dups
FVector PositionA = BuildData->GetVertexPosition(VertIndexAndZ[i].Index);
FVector PositionB = BuildData->GetVertexPosition(VertIndexAndZ[j].Index);
if (PointsEqual(PositionA, PositionB, ComparisonThreshold))
{
OutOverlappingCorners.Add(VertIndexAndZ[i].Index, VertIndexAndZ[j].Index);
OutOverlappingCorners.Add(VertIndexAndZ[j].Index, VertIndexAndZ[i].Index);
}
}
}
}
void Skeletal_ComputeTriangleTangents(
TArray<FVector>& TriangleTangentX,
TArray<FVector>& TriangleTangentY,
TArray<FVector>& TriangleTangentZ,
IMeshBuildData* BuildData,
float ComparisonThreshold
)
{
int32 NumTriangles = BuildData->GetNumFaces();
TriangleTangentX.Empty(NumTriangles);
TriangleTangentY.Empty(NumTriangles);
TriangleTangentZ.Empty(NumTriangles);
for (int32 TriangleIndex = 0; TriangleIndex < NumTriangles; TriangleIndex++)
{
const int32 UVIndex = 0;
FVector P[3];
for (int32 i = 0; i < 3; ++i)
{
P[i] = BuildData->GetVertexPosition(TriangleIndex, i);
}
const FVector Normal = ((P[1] - P[2]) ^ (P[0] - P[2])).GetSafeNormal(ComparisonThreshold);
FMatrix ParameterToLocal(
FPlane(P[1].X - P[0].X, P[1].Y - P[0].Y, P[1].Z - P[0].Z, 0),
FPlane(P[2].X - P[0].X, P[2].Y - P[0].Y, P[2].Z - P[0].Z, 0),
FPlane(P[0].X, P[0].Y, P[0].Z, 0),
FPlane(0, 0, 0, 1)
);
FVector2D T1 = BuildData->GetVertexUV(TriangleIndex, 0, UVIndex);
FVector2D T2 = BuildData->GetVertexUV(TriangleIndex, 1, UVIndex);
FVector2D T3 = BuildData->GetVertexUV(TriangleIndex, 2, UVIndex);
FMatrix ParameterToTexture(
FPlane(T2.X - T1.X, T2.Y - T1.Y, 0, 0),
FPlane(T3.X - T1.X, T3.Y - T1.Y, 0, 0),
FPlane(T1.X, T1.Y, 1, 0),
FPlane(0, 0, 0, 1)
);
// Use InverseSlow to catch singular matrices. Inverse can miss this sometimes.
const FMatrix TextureToLocal = ParameterToTexture.Inverse() * ParameterToLocal;
TriangleTangentX.Add(TextureToLocal.TransformVector(FVector(1, 0, 0)).GetSafeNormal());
TriangleTangentY.Add(TextureToLocal.TransformVector(FVector(0, 1, 0)).GetSafeNormal());
TriangleTangentZ.Add(Normal);
FVector::CreateOrthonormalBasis(
TriangleTangentX[TriangleIndex],
TriangleTangentY[TriangleIndex],
TriangleTangentZ[TriangleIndex]
);
}
}
void Skeletal_ComputeTangents(
IMeshBuildData* BuildData,
TMultiMap<int32, int32> const& OverlappingCorners
)
{
bool bBlendOverlappingNormals = true;
bool bIgnoreDegenerateTriangles = BuildData->BuildOptions.bRemoveDegenerateTriangles;
float ComparisonThreshold = bIgnoreDegenerateTriangles ? THRESH_POINTS_ARE_SAME : 0.0f;
// Compute per-triangle tangents.
TArray<FVector> TriangleTangentX;
TArray<FVector> TriangleTangentY;
TArray<FVector> TriangleTangentZ;
Skeletal_ComputeTriangleTangents(
TriangleTangentX,
TriangleTangentY,
TriangleTangentZ,
BuildData,
bIgnoreDegenerateTriangles ? SMALL_NUMBER : 0.0f
);
TArray<FVector>& WedgeTangentX = BuildData->GetTangentArray(0);
TArray<FVector>& WedgeTangentY = BuildData->GetTangentArray(1);
TArray<FVector>& WedgeTangentZ = BuildData->GetTangentArray(2);
// Declare these out here to avoid reallocations.
TArray<FFanFace> RelevantFacesForCorner[3];
TArray<int32> AdjacentFaces;
TArray<int32> DupVerts;
int32 NumFaces = BuildData->GetNumFaces();
int32 NumWedges = BuildData->GetNumWedges();
check(NumFaces * 3 <= NumWedges);
// Allocate storage for tangents if none were provided.
if (WedgeTangentX.Num() != NumWedges)
{
WedgeTangentX.Empty(NumWedges);
WedgeTangentX.AddZeroed(NumWedges);
}
if (WedgeTangentY.Num() != NumWedges)
{
WedgeTangentY.Empty(NumWedges);
WedgeTangentY.AddZeroed(NumWedges);
}
if (WedgeTangentZ.Num() != NumWedges)
{
WedgeTangentZ.Empty(NumWedges);
WedgeTangentZ.AddZeroed(NumWedges);
}
for (int32 FaceIndex = 0; FaceIndex < NumFaces; FaceIndex++)
{
int32 WedgeOffset = FaceIndex * 3;
FVector CornerPositions[3];
FVector CornerTangentX[3];
FVector CornerTangentY[3];
FVector CornerTangentZ[3];
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
CornerTangentX[CornerIndex] = FVector::ZeroVector;
CornerTangentY[CornerIndex] = FVector::ZeroVector;
CornerTangentZ[CornerIndex] = FVector::ZeroVector;
CornerPositions[CornerIndex] = BuildData->GetVertexPosition(FaceIndex, CornerIndex);
RelevantFacesForCorner[CornerIndex].Reset();
}
// Don't process degenerate triangles.
if (PointsEqual(CornerPositions[0], CornerPositions[1], ComparisonThreshold)
|| PointsEqual(CornerPositions[0], CornerPositions[2], ComparisonThreshold)
|| PointsEqual(CornerPositions[1], CornerPositions[2], ComparisonThreshold))
{
continue;
}
// No need to process triangles if tangents already exist.
bool bCornerHasTangents[3] = { 0 };
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
bCornerHasTangents[CornerIndex] = !WedgeTangentX[WedgeOffset + CornerIndex].IsZero()
&& !WedgeTangentY[WedgeOffset + CornerIndex].IsZero()
&& !WedgeTangentZ[WedgeOffset + CornerIndex].IsZero();
}
if (bCornerHasTangents[0] && bCornerHasTangents[1] && bCornerHasTangents[2])
{
continue;
}
// Calculate smooth vertex normals.
float Determinant = FVector::Triple(
TriangleTangentX[FaceIndex],
TriangleTangentY[FaceIndex],
TriangleTangentZ[FaceIndex]
);
// Start building a list of faces adjacent to this face.
AdjacentFaces.Reset();
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
int32 ThisCornerIndex = WedgeOffset + CornerIndex;
DupVerts.Reset();
OverlappingCorners.MultiFind(ThisCornerIndex, DupVerts);
DupVerts.Add(ThisCornerIndex); // I am a "dup" of myself
for (int32 k = 0; k < DupVerts.Num(); k++)
{
AdjacentFaces.AddUnique(DupVerts[k] / 3);
}
}
// We need to sort these here because the criteria for point equality is
// exact, so we must ensure the exact same order for all dups.
AdjacentFaces.Sort();
// Process adjacent faces
for (int32 AdjacentFaceIndex = 0; AdjacentFaceIndex < AdjacentFaces.Num(); AdjacentFaceIndex++)
{
int32 OtherFaceIndex = AdjacentFaces[AdjacentFaceIndex];
for (int32 OurCornerIndex = 0; OurCornerIndex < 3; OurCornerIndex++)
{
if (bCornerHasTangents[OurCornerIndex])
continue;
FFanFace NewFanFace;
int32 CommonIndexCount = 0;
// Check for vertices in common.
if (FaceIndex == OtherFaceIndex)
{
CommonIndexCount = 3;
NewFanFace.LinkedVertexIndex = OurCornerIndex;
}
else
{
// Check matching vertices against main vertex .
for (int32 OtherCornerIndex = 0; OtherCornerIndex < 3; OtherCornerIndex++)
{
if (PointsEqual(
CornerPositions[OurCornerIndex],
BuildData->GetVertexPosition(OtherFaceIndex, OtherCornerIndex),
ComparisonThreshold
))
{
CommonIndexCount++;
NewFanFace.LinkedVertexIndex = OtherCornerIndex;
}
}
}
// Add if connected by at least one point. Smoothing matches are considered later.
if (CommonIndexCount > 0)
{
NewFanFace.FaceIndex = OtherFaceIndex;
NewFanFace.bFilled = (OtherFaceIndex == FaceIndex); // Starter face for smoothing floodfill.
NewFanFace.bBlendTangents = NewFanFace.bFilled;
NewFanFace.bBlendNormals = NewFanFace.bFilled;
RelevantFacesForCorner[OurCornerIndex].Add(NewFanFace);
}
}
}
// Find true relevance of faces for a vertex normal by traversing
// smoothing-group-compatible connected triangle fans around common vertices.
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
if (bCornerHasTangents[CornerIndex])
continue;
int32 NewConnections;
do
{
NewConnections = 0;
for (int32 OtherFaceIdx = 0; OtherFaceIdx < RelevantFacesForCorner[CornerIndex].Num(); OtherFaceIdx++)
{
FFanFace& OtherFace = RelevantFacesForCorner[CornerIndex][OtherFaceIdx];
// The vertex' own face is initially the only face with bFilled == true.
if (OtherFace.bFilled)
{
for (int32 NextFaceIndex = 0; NextFaceIndex < RelevantFacesForCorner[CornerIndex].Num(); NextFaceIndex++)
{
FFanFace& NextFace = RelevantFacesForCorner[CornerIndex][NextFaceIndex];
if (!NextFace.bFilled) // && !NextFace.bBlendTangents)
{
if (NextFaceIndex != OtherFaceIdx)
//&& (RawMesh.FaceSmoothingMasks[NextFace.FaceIndex] & RawMesh.FaceSmoothingMasks[OtherFace.FaceIndex]))
{
int32 CommonVertices = 0;
int32 CommonTangentVertices = 0;
int32 CommonNormalVertices = 0;
for (int32 OtherCornerIndex = 0; OtherCornerIndex < 3; OtherCornerIndex++)
{
for (int32 NextCornerIndex = 0; NextCornerIndex < 3; NextCornerIndex++)
{
int32 NextVertexIndex = BuildData->GetVertexIndex(NextFace.FaceIndex, NextCornerIndex);
int32 OtherVertexIndex = BuildData->GetVertexIndex(OtherFace.FaceIndex, OtherCornerIndex);
if (PointsEqual(
BuildData->GetVertexPosition(NextFace.FaceIndex, NextCornerIndex),
BuildData->GetVertexPosition(OtherFace.FaceIndex, OtherCornerIndex),
ComparisonThreshold))
{
CommonVertices++;
if (UVsEqual(
BuildData->GetVertexUV(NextFace.FaceIndex, NextCornerIndex, 0),
BuildData->GetVertexUV(OtherFace.FaceIndex, OtherCornerIndex, 0)))
{
CommonTangentVertices++;
}
if (bBlendOverlappingNormals
|| NextVertexIndex == OtherVertexIndex)
{
CommonNormalVertices++;
}
}
}
}
// Flood fill faces with more than one common vertices which must be touching edges.
if (CommonVertices > 1)
{
NextFace.bFilled = true;
NextFace.bBlendNormals = (CommonNormalVertices > 1);
NewConnections++;
// Only blend tangents if there is no UV seam along the edge with this face.
if (OtherFace.bBlendTangents && CommonTangentVertices > 1)
{
float OtherDeterminant = FVector::Triple(
TriangleTangentX[NextFace.FaceIndex],
TriangleTangentY[NextFace.FaceIndex],
TriangleTangentZ[NextFace.FaceIndex]
);
if ((Determinant * OtherDeterminant) > 0.0f)
{
NextFace.bBlendTangents = true;
}
}
}
}
}
}
}
}
}
while (NewConnections > 0);
}
// Vertex normal construction.
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
if (bCornerHasTangents[CornerIndex])
{
CornerTangentX[CornerIndex] = WedgeTangentX[WedgeOffset + CornerIndex];
CornerTangentY[CornerIndex] = WedgeTangentY[WedgeOffset + CornerIndex];
CornerTangentZ[CornerIndex] = WedgeTangentZ[WedgeOffset + CornerIndex];
}
else
{
for (int32 RelevantFaceIdx = 0; RelevantFaceIdx < RelevantFacesForCorner[CornerIndex].Num(); RelevantFaceIdx++)
{
FFanFace const& RelevantFace = RelevantFacesForCorner[CornerIndex][RelevantFaceIdx];
if (RelevantFace.bFilled)
{
int32 OtherFaceIndex = RelevantFace.FaceIndex;
if (RelevantFace.bBlendTangents)
{
CornerTangentX[CornerIndex] += TriangleTangentX[OtherFaceIndex];
CornerTangentY[CornerIndex] += TriangleTangentY[OtherFaceIndex];
}
if (RelevantFace.bBlendNormals)
{
CornerTangentZ[CornerIndex] += TriangleTangentZ[OtherFaceIndex];
}
}
}
if (!WedgeTangentX[WedgeOffset + CornerIndex].IsZero())
{
CornerTangentX[CornerIndex] = WedgeTangentX[WedgeOffset + CornerIndex];
}
if (!WedgeTangentY[WedgeOffset + CornerIndex].IsZero())
{
CornerTangentY[CornerIndex] = WedgeTangentY[WedgeOffset + CornerIndex];
}
if (!WedgeTangentZ[WedgeOffset + CornerIndex].IsZero())
{
CornerTangentZ[CornerIndex] = WedgeTangentZ[WedgeOffset + CornerIndex];
}
}
}
// Normalization.
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
CornerTangentX[CornerIndex].Normalize();
CornerTangentY[CornerIndex].Normalize();
CornerTangentZ[CornerIndex].Normalize();
// Gram-Schmidt orthogonalization
CornerTangentY[CornerIndex] -= CornerTangentX[CornerIndex] * (CornerTangentX[CornerIndex] | CornerTangentY[CornerIndex]);
CornerTangentY[CornerIndex].Normalize();
CornerTangentX[CornerIndex] -= CornerTangentZ[CornerIndex] * (CornerTangentZ[CornerIndex] | CornerTangentX[CornerIndex]);
CornerTangentX[CornerIndex].Normalize();
CornerTangentY[CornerIndex] -= CornerTangentZ[CornerIndex] * (CornerTangentZ[CornerIndex] | CornerTangentY[CornerIndex]);
CornerTangentY[CornerIndex].Normalize();
}
// Copy back to the mesh.
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
WedgeTangentX[WedgeOffset + CornerIndex] = CornerTangentX[CornerIndex];
WedgeTangentY[WedgeOffset + CornerIndex] = CornerTangentY[CornerIndex];
WedgeTangentZ[WedgeOffset + CornerIndex] = CornerTangentZ[CornerIndex];
}
}
check(WedgeTangentX.Num() == NumWedges);
check(WedgeTangentY.Num() == NumWedges);
check(WedgeTangentZ.Num() == NumWedges);
}
void Skeletal_ComputeTangents_MikkTSpace(
IMeshBuildData* BuildData,
TMultiMap<int32, int32> const& OverlappingCorners
)
{
bool bBlendOverlappingNormals = true;
bool bIgnoreDegenerateTriangles = BuildData->BuildOptions.bRemoveDegenerateTriangles;
float ComparisonThreshold = bIgnoreDegenerateTriangles ? THRESH_POINTS_ARE_SAME : 0.0f;
// Compute per-triangle tangents.
TArray<FVector> TriangleTangentX;
TArray<FVector> TriangleTangentY;
TArray<FVector> TriangleTangentZ;
Skeletal_ComputeTriangleTangents(
TriangleTangentX,
TriangleTangentY,
TriangleTangentZ,
BuildData,
bIgnoreDegenerateTriangles ? SMALL_NUMBER : 0.0f
);
TArray<FVector>& WedgeTangentX = BuildData->GetTangentArray(0);
TArray<FVector>& WedgeTangentY = BuildData->GetTangentArray(1);
TArray<FVector>& WedgeTangentZ = BuildData->GetTangentArray(2);
// Declare these out here to avoid reallocations.
TArray<FFanFace> RelevantFacesForCorner[3];
TArray<int32> AdjacentFaces;
TArray<int32> DupVerts;
int32 NumFaces = BuildData->GetNumFaces();
int32 NumWedges = BuildData->GetNumWedges();
check(NumFaces * 3 == NumWedges);
bool bWedgeNormals = true;
bool bWedgeTSpace = false;
for (int32 WedgeIdx = 0; WedgeIdx < WedgeTangentZ.Num(); ++WedgeIdx)
{
for (int32 VertexIndex = 0; VertexIndex < 3; VertexIndex++)
bWedgeNormals = bWedgeNormals && (!WedgeTangentZ[WedgeIdx].IsNearlyZero());
}
if (WedgeTangentX.Num() > 0 && WedgeTangentY.Num() > 0)
{
bWedgeTSpace = true;
for (int32 WedgeIdx = 0; WedgeIdx < WedgeTangentX.Num()
&& WedgeIdx < WedgeTangentY.Num(); ++WedgeIdx)
{
bWedgeTSpace = bWedgeTSpace && (!WedgeTangentX[WedgeIdx].IsNearlyZero()) && (!WedgeTangentY[WedgeIdx].IsNearlyZero());
}
}
// Allocate storage for tangents if none were provided, and calculate normals for MikkTSpace.
if (WedgeTangentZ.Num() != NumWedges || !bWedgeNormals)
{
// normals are not included, so we should calculate them
WedgeTangentZ.Empty(NumWedges);
WedgeTangentZ.AddZeroed(NumWedges);
// we need to calculate normals for MikkTSpace
for (int32 FaceIndex = 0; FaceIndex < NumFaces; FaceIndex++)
{
int32 WedgeOffset = FaceIndex * 3;
FVector CornerPositions[3];
FVector CornerNormal[3];
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
CornerNormal[CornerIndex] = FVector::ZeroVector;
CornerPositions[CornerIndex] = BuildData->GetVertexPosition(FaceIndex, CornerIndex);
RelevantFacesForCorner[CornerIndex].Reset();
}
// Don't process degenerate triangles.
if (PointsEqual(CornerPositions[0], CornerPositions[1], ComparisonThreshold)
|| PointsEqual(CornerPositions[0], CornerPositions[2], ComparisonThreshold)
|| PointsEqual(CornerPositions[1], CornerPositions[2], ComparisonThreshold))
{
continue;
}
// No need to process triangles if tangents already exist.
bool bCornerHasNormal[3] = { 0 };
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
bCornerHasNormal[CornerIndex] = !WedgeTangentZ[WedgeOffset + CornerIndex].IsZero();
}
if (bCornerHasNormal[0] && bCornerHasNormal[1] && bCornerHasNormal[2])
{
continue;
}
// Start building a list of faces adjacent to this face.
AdjacentFaces.Reset();
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
int32 ThisCornerIndex = WedgeOffset + CornerIndex;
DupVerts.Reset();
OverlappingCorners.MultiFind(ThisCornerIndex, DupVerts);
DupVerts.Add(ThisCornerIndex); // I am a "dup" of myself
for (int32 k = 0; k < DupVerts.Num(); k++)
{
AdjacentFaces.AddUnique(DupVerts[k] / 3);
}
}
// We need to sort these here because the criteria for point equality is
// exact, so we must ensure the exact same order for all dups.
AdjacentFaces.Sort();
// Process adjacent faces
for (int32 AdjacentFaceIndex = 0; AdjacentFaceIndex < AdjacentFaces.Num(); AdjacentFaceIndex++)
{
int32 OtherFaceIndex = AdjacentFaces[AdjacentFaceIndex];
for (int32 OurCornerIndex = 0; OurCornerIndex < 3; OurCornerIndex++)
{
if (bCornerHasNormal[OurCornerIndex])
continue;
FFanFace NewFanFace;
int32 CommonIndexCount = 0;
// Check for vertices in common.
if (FaceIndex == OtherFaceIndex)
{
CommonIndexCount = 3;
NewFanFace.LinkedVertexIndex = OurCornerIndex;
}
else
{
// Check matching vertices against main vertex .
for (int32 OtherCornerIndex = 0; OtherCornerIndex < 3; OtherCornerIndex++)
{
if (PointsEqual(
CornerPositions[OurCornerIndex],
BuildData->GetVertexPosition(OtherFaceIndex, OtherCornerIndex),
ComparisonThreshold
))
{
CommonIndexCount++;
NewFanFace.LinkedVertexIndex = OtherCornerIndex;
}
}
}
// Add if connected by at least one point. Smoothing matches are considered later.
if (CommonIndexCount > 0)
{
NewFanFace.FaceIndex = OtherFaceIndex;
NewFanFace.bFilled = (OtherFaceIndex == FaceIndex); // Starter face for smoothing floodfill.
NewFanFace.bBlendTangents = NewFanFace.bFilled;
NewFanFace.bBlendNormals = NewFanFace.bFilled;
RelevantFacesForCorner[OurCornerIndex].Add(NewFanFace);
}
}
}
// Find true relevance of faces for a vertex normal by traversing
// smoothing-group-compatible connected triangle fans around common vertices.
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
if (bCornerHasNormal[CornerIndex])
continue;
int32 NewConnections;
do
{
NewConnections = 0;
for (int32 OtherFaceIdx = 0; OtherFaceIdx < RelevantFacesForCorner[CornerIndex].Num(); OtherFaceIdx++)
{
FFanFace& OtherFace = RelevantFacesForCorner[CornerIndex][OtherFaceIdx];
// The vertex' own face is initially the only face with bFilled == true.
if (OtherFace.bFilled)
{
for (int32 NextFaceIndex = 0; NextFaceIndex < RelevantFacesForCorner[CornerIndex].Num(); NextFaceIndex++)
{
FFanFace& NextFace = RelevantFacesForCorner[CornerIndex][NextFaceIndex];
if (!NextFace.bFilled) // && !NextFace.bBlendTangents)
{
if ((NextFaceIndex != OtherFaceIdx)
&& (BuildData->GetFaceSmoothingGroups(NextFace.FaceIndex) & BuildData->GetFaceSmoothingGroups(OtherFace.FaceIndex)))
{
int32 CommonVertices = 0;
int32 CommonNormalVertices = 0;
for (int32 OtherCornerIndex = 0; OtherCornerIndex < 3; OtherCornerIndex++)
{
for (int32 NextCornerIndex = 0; NextCornerIndex < 3; NextCornerIndex++)
{
int32 NextVertexIndex = BuildData->GetVertexIndex(NextFace.FaceIndex, NextCornerIndex);
int32 OtherVertexIndex = BuildData->GetVertexIndex(OtherFace.FaceIndex, OtherCornerIndex);
if (PointsEqual(
BuildData->GetVertexPosition(NextFace.FaceIndex, NextCornerIndex),
BuildData->GetVertexPosition(OtherFace.FaceIndex, OtherCornerIndex),
ComparisonThreshold))
{
CommonVertices++;
if (bBlendOverlappingNormals
|| NextVertexIndex == OtherVertexIndex)
{
CommonNormalVertices++;
}
}
}
}
// Flood fill faces with more than one common vertices which must be touching edges.
if (CommonVertices > 1)
{
NextFace.bFilled = true;
NextFace.bBlendNormals = (CommonNormalVertices > 1);
NewConnections++;
}
}
}
}
}
}
}
while (NewConnections > 0);
}
// Vertex normal construction.
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
if (bCornerHasNormal[CornerIndex])
{
CornerNormal[CornerIndex] = WedgeTangentZ[WedgeOffset + CornerIndex];
}
else
{
for (int32 RelevantFaceIdx = 0; RelevantFaceIdx < RelevantFacesForCorner[CornerIndex].Num(); RelevantFaceIdx++)
{
FFanFace const& RelevantFace = RelevantFacesForCorner[CornerIndex][RelevantFaceIdx];
if (RelevantFace.bFilled)
{
int32 OtherFaceIndex = RelevantFace.FaceIndex;
if (RelevantFace.bBlendNormals)
{
CornerNormal[CornerIndex] += TriangleTangentZ[OtherFaceIndex];
}
}
}
if (!WedgeTangentZ[WedgeOffset + CornerIndex].IsZero())
{
CornerNormal[CornerIndex] = WedgeTangentZ[WedgeOffset + CornerIndex];
}
}
}
// Normalization.
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
CornerNormal[CornerIndex].Normalize();
}
// Copy back to the mesh.
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++)
{
WedgeTangentZ[WedgeOffset + CornerIndex] = CornerNormal[CornerIndex];
}
}
}
if (WedgeTangentX.Num() != NumWedges)
{
WedgeTangentX.Empty(NumWedges);
WedgeTangentX.AddZeroed(NumWedges);
}
if (WedgeTangentY.Num() != NumWedges)
{
WedgeTangentY.Empty(NumWedges);
WedgeTangentY.AddZeroed(NumWedges);
}
//if (!bWedgeTSpace)
{
// we can use mikktspace to calculate the tangents
SMikkTSpaceContext MikkTContext;
MikkTContext.m_pInterface = BuildData->GetMikkTInterface();
MikkTContext.m_pUserData = BuildData->GetMikkTUserData();
//MikkTContext.m_bIgnoreDegenerates = bIgnoreDegenerateTriangles;
genTangSpaceDefault(&MikkTContext);
}
check(WedgeTangentX.Num() == NumWedges);
check(WedgeTangentY.Num() == NumWedges);
check(WedgeTangentZ.Num() == NumWedges);
}
bool PrepareSourceMesh(IMeshBuildData* BuildData)
{
check(Stage == EStage::Uninit);
BeginSlowTask();
TMultiMap<int32, int32>& OverlappingCorners = *new(LODOverlappingCorners)TMultiMap<int32, int32>;
float ComparisonThreshold = THRESH_POINTS_ARE_SAME;//GetComparisonThreshold(LODBuildSettings[LODIndex]);
int32 NumWedges = BuildData->GetNumWedges();
// Find overlapping corners to accelerate adjacency.
Skeletal_FindOverlappingCorners(OverlappingCorners, BuildData, ComparisonThreshold);
// Figure out if we should recompute normals and tangents.
bool bRecomputeNormals = BuildData->BuildOptions.bComputeNormals;
bool bRecomputeTangents = BuildData->BuildOptions.bComputeTangents;
// Dump normals and tangents if we are recomputing them.
if (bRecomputeTangents)
{
TArray<FVector>& TangentX = BuildData->GetTangentArray(0);
TArray<FVector>& TangentY = BuildData->GetTangentArray(1);
TangentX.Empty(NumWedges);
TangentX.AddZeroed(NumWedges);
TangentY.Empty(NumWedges);
TangentY.AddZeroed(NumWedges);
}
if (bRecomputeNormals)
{
TArray<FVector>& TangentZ = BuildData->GetTangentArray(2);
TangentZ.Empty(NumWedges);
TangentZ.AddZeroed(NumWedges);
}
// Compute any missing tangents. MikkTSpace should be use only when the user want to recompute the normals or tangents otherwise should always fallback on builtin
if (BuildData->BuildOptions.bUseMikkTSpace && (BuildData->BuildOptions.bComputeNormals || BuildData->BuildOptions.bComputeTangents))
{
Skeletal_ComputeTangents_MikkTSpace(BuildData, OverlappingCorners);
}
else
{
Skeletal_ComputeTangents(BuildData, OverlappingCorners);
}
// At this point the mesh will have valid tangents.
BuildData->ValidateTangentArraySize();
check(LODOverlappingCorners.Num() == 1);
EndSlowTask();
Stage = EStage::Prepared;
return true;
}
bool GenerateSkeletalRenderMesh(IMeshBuildData* InBuildData)
{
check(Stage == EStage::Prepared);
SkeletalMeshBuildData& BuildData = *(SkeletalMeshBuildData*)InBuildData;
BeginSlowTask();
// Find wedge influences.
TArray<int32> WedgeInfluenceIndices;
TMap<uint32, uint32> VertexIndexToInfluenceIndexMap;
for (uint32 LookIdx = 0; LookIdx < (uint32)BuildData.Influences.Num(); LookIdx++)
{
// Order matters do not allow the map to overwrite an existing value.
if (!VertexIndexToInfluenceIndexMap.Find(BuildData.Influences[LookIdx].VertIndex))
{
VertexIndexToInfluenceIndexMap.Add(BuildData.Influences[LookIdx].VertIndex, LookIdx);
}
}
for (int32 WedgeIndex = 0; WedgeIndex < BuildData.Wedges.Num(); WedgeIndex++)
{
uint32* InfluenceIndex = VertexIndexToInfluenceIndexMap.Find(BuildData.Wedges[WedgeIndex].iVertex);
if (InfluenceIndex)
{
WedgeInfluenceIndices.Add(*InfluenceIndex);
}
else
{
// we have missing influence vert, we weight to root
WedgeInfluenceIndices.Add(0);
// add warning message
if (BuildData.OutWarningMessages)
{
BuildData.OutWarningMessages->Add(FText::Format(FText::FromString("Missing influence on vert {0}. Weighting it to root."), FText::FromString(FString::FromInt(BuildData.Wedges[WedgeIndex].iVertex))));
if (BuildData.OutWarningNames)
{
BuildData.OutWarningNames->Add(FFbxErrors::SkeletalMesh_VertMissingInfluences);
}
}
}
}
check(BuildData.Wedges.Num() == WedgeInfluenceIndices.Num());
TArray<FSkeletalMeshVertIndexAndZ> VertIndexAndZ;
TArray<FSoftSkinBuildVertex> RawVertices;
VertIndexAndZ.Empty(BuildData.Points.Num());
RawVertices.Reserve(BuildData.Points.Num());
for (int32 FaceIndex = 0; FaceIndex < BuildData.Faces.Num(); FaceIndex++)
{
// Only update the status progress bar if we are in the game thread and every thousand faces.
// Updating status is extremely slow
if (FaceIndex % 5000 == 0)
{
UpdateSlowTask(FaceIndex, BuildData.Faces.Num());
}
const FMeshFace& Face = BuildData.Faces[FaceIndex];
for (int32 VertexIndex = 0; VertexIndex < 3; VertexIndex++)
{
FSoftSkinBuildVertex Vertex;
const uint32 WedgeIndex = BuildData.GetWedgeIndex(FaceIndex, VertexIndex);
const FMeshWedge& Wedge = BuildData.Wedges[WedgeIndex];
Vertex.Position = BuildData.GetVertexPosition(FaceIndex, VertexIndex);
FVector TangentX, TangentY, TangentZ;
TangentX = BuildData.TangentX[WedgeIndex].GetSafeNormal();
TangentY = BuildData.TangentY[WedgeIndex].GetSafeNormal();
TangentZ = BuildData.TangentZ[WedgeIndex].GetSafeNormal();
/*if (BuildData.BuildOptions.bComputeNormals || BuildData.BuildOptions.bComputeTangents)
{
TangentX = BuildData.TangentX[VertexIndex].GetSafeNormal();
TangentY = BuildData.TangentY[VertexIndex].GetSafeNormal();
if( BuildData.BuildOptions.bComputeNormals )
{
TangentZ = BuildData.TangentZ[VertexIndex].GetSafeNormal();
}
else
{
//TangentZ = Face.TangentZ[VertexIndex];
}
TangentY -= TangentX * (TangentX | TangentY);
TangentY.Normalize();
TangentX -= TangentZ * (TangentZ | TangentX);
TangentY -= TangentZ * (TangentZ | TangentY);
TangentX.Normalize();
TangentY.Normalize();
}
else*/
{
//TangentX = Face.TangentX[VertexIndex];
//TangentY = Face.TangentY[VertexIndex];
//TangentZ = Face.TangentZ[VertexIndex];
// Normalize overridden tangents. Its possible for them to import un-normalized.
TangentX.Normalize();
TangentY.Normalize();
TangentZ.Normalize();
}
Vertex.TangentX = TangentX;
Vertex.TangentY = TangentY;
Vertex.TangentZ = TangentZ;
FMemory::Memcpy(Vertex.UVs, Wedge.UVs, sizeof(FVector2D)*MAX_TEXCOORDS);
Vertex.Color = Wedge.Color;
{
// Count the influences.
int32 InfIdx = WedgeInfluenceIndices[Face.iWedge[VertexIndex]];
int32 LookIdx = InfIdx;
uint32 InfluenceCount = 0;
while (BuildData.Influences.IsValidIndex(LookIdx) && (BuildData.Influences[LookIdx].VertIndex == Wedge.iVertex))
{
InfluenceCount++;
LookIdx++;
}
InfluenceCount = FMath::Min<uint32>(InfluenceCount, MAX_TOTAL_INFLUENCES);
// Setup the vertex influences.
Vertex.InfluenceBones[0] = 0;
Vertex.InfluenceWeights[0] = 255;
for (uint32 i = 1; i < MAX_TOTAL_INFLUENCES; i++)
{
Vertex.InfluenceBones[i] = 0;
Vertex.InfluenceWeights[i] = 0;
}
uint32 TotalInfluenceWeight = 0;
for (uint32 i = 0; i < InfluenceCount; i++)
{
FBoneIndexType BoneIndex = (FBoneIndexType)BuildData.Influences[InfIdx + i].BoneIndex;
if (BoneIndex >= BuildData.RefSkeleton.GetRawBoneNum())
continue;
Vertex.InfluenceBones[i] = BoneIndex;
Vertex.InfluenceWeights[i] = (uint8)(BuildData.Influences[InfIdx + i].Weight * 255.0f);
TotalInfluenceWeight += Vertex.InfluenceWeights[i];
}
Vertex.InfluenceWeights[0] += 255 - TotalInfluenceWeight;
}
// Add the vertex as well as its original index in the points array
Vertex.PointWedgeIdx = Wedge.iVertex;
int32 RawIndex = RawVertices.Add(Vertex);
// Add an efficient way to find dupes of this vertex later for fast combining of vertices
FSkeletalMeshVertIndexAndZ IAndZ;
IAndZ.Index = RawIndex;
IAndZ.Z = Vertex.Position.Z;
VertIndexAndZ.Add(IAndZ);
}
}
// Generate chunks and their vertices and indices
SkeletalMeshTools::BuildSkeletalMeshChunks(BuildData.Faces, RawVertices, VertIndexAndZ, BuildData.BuildOptions.bKeepOverlappingVertices, BuildData.Chunks, BuildData.bTooManyVerts);
// Chunk vertices to satisfy the requested limit.
const uint32 MaxGPUSkinBones = FGPUBaseSkinVertexFactory::GetMaxGPUSkinBones();
check(MaxGPUSkinBones <= FGPUBaseSkinVertexFactory::GHardwareMaxGPUSkinBones);
SkeletalMeshTools::ChunkSkinnedVertices(BuildData.Chunks, MaxGPUSkinBones);
EndSlowTask();
Stage = EStage::GenerateRendering;
return true;
}
void BeginSlowTask()
{
if (IsInGameThread())
{
GWarn->BeginSlowTask(NSLOCTEXT("UnrealEd", "ProcessingSkeletalTriangles", "Processing Mesh Triangles"), true);
}
}
void UpdateSlowTask(int32 Numerator, int32 Denominator)
{
if (IsInGameThread())
{
GWarn->StatusUpdate(Numerator, Denominator, NSLOCTEXT("UnrealEd", "ProcessingSkeletalTriangles", "Processing Mesh Triangles"));
}
}
void EndSlowTask()
{
if (IsInGameThread())
{
GWarn->EndSlowTask();
}
}
private:
enum class EStage
{
Uninit,
Prepared,
GenerateRendering,
};
TIndirectArray<TMultiMap<int32, int32> > LODOverlappingCorners;
EStage Stage;
};
bool FMeshUtilities::BuildSkeletalMesh(FStaticLODModel& LODModel, const FReferenceSkeleton& RefSkeleton, const TArray<FVertInfluence>& Influences, const TArray<FMeshWedge>& Wedges, const TArray<FMeshFace>& Faces, const TArray<FVector>& Points, const TArray<int32>& PointToOriginalMap, const MeshBuildOptions& BuildOptions, TArray<FText> * OutWarningMessages, TArray<FName> * OutWarningNames)
{
#if WITH_EDITORONLY_DATA
// Temporarily supporting both import paths
if (!BuildOptions.bUseMikkTSpace)
{
return BuildSkeletalMesh_Legacy(LODModel, RefSkeleton, Influences, Wedges, Faces, Points, PointToOriginalMap, BuildOptions.bKeepOverlappingVertices, BuildOptions.bComputeNormals, BuildOptions.bComputeTangents, OutWarningMessages, OutWarningNames);
}
SkeletalMeshBuildData BuildData(
LODModel,
RefSkeleton,
Influences,
Wedges,
Faces,
Points,
PointToOriginalMap,
BuildOptions,
OutWarningMessages,
OutWarningNames);
FSkeletalMeshUtilityBuilder Builder;
if (!Builder.PrepareSourceMesh(&BuildData))
{
return false;
}
if (!Builder.GenerateSkeletalRenderMesh(&BuildData))
{
return false;
}
// Build the skeletal model from chunks.
Builder.BeginSlowTask();
BuildSkeletalModelFromChunks(BuildData.LODModel, BuildData.RefSkeleton, BuildData.Chunks, BuildData.PointToOriginalMap);
Builder.EndSlowTask();
// Only show these warnings if in the game thread. When importing morph targets, this function can run in another thread and these warnings dont prevent the mesh from importing
if (IsInGameThread())
{
bool bHasBadSections = false;
for (int32 SectionIndex = 0; SectionIndex < BuildData.LODModel.Sections.Num(); SectionIndex++)
{
FSkelMeshSection& Section = BuildData.LODModel.Sections[SectionIndex];
bHasBadSections |= (Section.NumTriangles == 0);
// Log info about the section.
UE_LOG(LogSkeletalMesh, Log, TEXT("Section %u: Material=%u, %u triangles"),
SectionIndex,
Section.MaterialIndex,
Section.NumTriangles
);
}
if (bHasBadSections)
{
FText BadSectionMessage(NSLOCTEXT("UnrealEd", "Error_SkeletalMeshHasBadSections", "Input mesh has a section with no triangles. This mesh may not render properly."));
if (BuildData.OutWarningMessages)
{
BuildData.OutWarningMessages->Add(BadSectionMessage);
if (BuildData.OutWarningNames)
{
BuildData.OutWarningNames->Add(FFbxErrors::SkeletalMesh_SectionWithNoTriangle);
}
}
else
{
FMessageDialog::Open(EAppMsgType::Ok, BadSectionMessage);
}
}
if (BuildData.bTooManyVerts)
{
FText TooManyVertsMessage(NSLOCTEXT("UnrealEd", "Error_SkeletalMeshTooManyVertices", "Input mesh has too many vertices. The generated mesh will be corrupt! Consider adding extra materials to split up the source mesh into smaller chunks."));
if (BuildData.OutWarningMessages)
{
BuildData.OutWarningMessages->Add(TooManyVertsMessage);
if (BuildData.OutWarningNames)
{
BuildData.OutWarningNames->Add(FFbxErrors::SkeletalMesh_TooManyVertices);
}
}
else
{
FMessageDialog::Open(EAppMsgType::Ok, TooManyVertsMessage);
}
}
}
return true;
#else
if (OutWarningMessages)
{
OutWarningMessages->Add(FText::FromString(TEXT("Cannot call FMeshUtilities::BuildSkeletalMesh on a console!")));
}
else
{
UE_LOG(LogSkeletalMesh, Fatal, TEXT("Cannot call FMeshUtilities::BuildSkeletalMesh on a console!"));
}
return false;
#endif
}
//@TODO: The OutMessages has to be a struct that contains FText/FName, or make it Token and add that as error. Needs re-work. Temporary workaround for now.
bool FMeshUtilities::BuildSkeletalMesh_Legacy(FStaticLODModel& LODModel, const FReferenceSkeleton& RefSkeleton, const TArray<FVertInfluence>& Influences, const TArray<FMeshWedge>& Wedges, const TArray<FMeshFace>& Faces, const TArray<FVector>& Points, const TArray<int32>& PointToOriginalMap, bool bKeepOverlappingVertices, bool bComputeNormals, bool bComputeTangents, TArray<FText> * OutWarningMessages, TArray<FName> * OutWarningNames)
{
bool bTooManyVerts = false;
check(PointToOriginalMap.Num() == Points.Num());
// Calculate face tangent vectors.
TArray<FVector> FaceTangentX;
TArray<FVector> FaceTangentY;
FaceTangentX.AddUninitialized(Faces.Num());
FaceTangentY.AddUninitialized(Faces.Num());
if (bComputeNormals || bComputeTangents)
{
for (int32 FaceIndex = 0; FaceIndex < Faces.Num(); FaceIndex++)
{
FVector P1 = Points[Wedges[Faces[FaceIndex].iWedge[0]].iVertex],
P2 = Points[Wedges[Faces[FaceIndex].iWedge[1]].iVertex],
P3 = Points[Wedges[Faces[FaceIndex].iWedge[2]].iVertex];
FVector TriangleNormal = FPlane(P3, P2, P1);
FMatrix ParameterToLocal(
FPlane(P2.X - P1.X, P2.Y - P1.Y, P2.Z - P1.Z, 0),
FPlane(P3.X - P1.X, P3.Y - P1.Y, P3.Z - P1.Z, 0),
FPlane(P1.X, P1.Y, P1.Z, 0),
FPlane(0, 0, 0, 1)
);
float U1 = Wedges[Faces[FaceIndex].iWedge[0]].UVs[0].X,
U2 = Wedges[Faces[FaceIndex].iWedge[1]].UVs[0].X,
U3 = Wedges[Faces[FaceIndex].iWedge[2]].UVs[0].X,
V1 = Wedges[Faces[FaceIndex].iWedge[0]].UVs[0].Y,
V2 = Wedges[Faces[FaceIndex].iWedge[1]].UVs[0].Y,
V3 = Wedges[Faces[FaceIndex].iWedge[2]].UVs[0].Y;
FMatrix ParameterToTexture(
FPlane(U2 - U1, V2 - V1, 0, 0),
FPlane(U3 - U1, V3 - V1, 0, 0),
FPlane(U1, V1, 1, 0),
FPlane(0, 0, 0, 1)
);
FMatrix TextureToLocal = ParameterToTexture.Inverse() * ParameterToLocal;
FVector TangentX = TextureToLocal.TransformVector(FVector(1, 0, 0)).GetSafeNormal(),
TangentY = TextureToLocal.TransformVector(FVector(0, 1, 0)).GetSafeNormal(),
TangentZ;
TangentX = TangentX - TriangleNormal * (TangentX | TriangleNormal);
TangentY = TangentY - TriangleNormal * (TangentY | TriangleNormal);
FaceTangentX[FaceIndex] = TangentX.GetSafeNormal();
FaceTangentY[FaceIndex] = TangentY.GetSafeNormal();
}
}
TArray<int32> WedgeInfluenceIndices;
// Find wedge influences.
TMap<uint32, uint32> VertexIndexToInfluenceIndexMap;
for (uint32 LookIdx = 0; LookIdx < (uint32)Influences.Num(); LookIdx++)
{
// Order matters do not allow the map to overwrite an existing value.
if (!VertexIndexToInfluenceIndexMap.Find(Influences[LookIdx].VertIndex))
{
VertexIndexToInfluenceIndexMap.Add(Influences[LookIdx].VertIndex, LookIdx);
}
}
for (int32 WedgeIndex = 0; WedgeIndex < Wedges.Num(); WedgeIndex++)
{
uint32* InfluenceIndex = VertexIndexToInfluenceIndexMap.Find(Wedges[WedgeIndex].iVertex);
if (InfluenceIndex)
{
WedgeInfluenceIndices.Add(*InfluenceIndex);
}
else
{
// we have missing influence vert, we weight to root
WedgeInfluenceIndices.Add(0);
// add warning message
if (OutWarningMessages)
{
OutWarningMessages->Add(FText::Format(FText::FromString("Missing influence on vert {0}. Weighting it to root."), FText::FromString(FString::FromInt(Wedges[WedgeIndex].iVertex))));
if (OutWarningNames)
{
OutWarningNames->Add(FFbxErrors::SkeletalMesh_VertMissingInfluences);
}
}
}
}
check(Wedges.Num() == WedgeInfluenceIndices.Num());
// Calculate smooth wedge tangent vectors.
if (IsInGameThread())
{
// Only update status if in the game thread. When importing morph targets, this function can run in another thread
GWarn->BeginSlowTask(NSLOCTEXT("UnrealEd", "ProcessingSkeletalTriangles", "Processing Mesh Triangles"), true);
}
// To accelerate generation of adjacency, we'll create a table that maps each vertex index
// to its overlapping vertices, and a table that maps a vertex to the its influenced faces
TMultiMap<int32, int32> Vert2Duplicates;
TMultiMap<int32, int32> Vert2Faces;
TArray<FSkeletalMeshVertIndexAndZ> VertIndexAndZ;
{
// Create a list of vertex Z/index pairs
VertIndexAndZ.Empty(Points.Num());
for (int32 i = 0; i < Points.Num(); i++)
{
FSkeletalMeshVertIndexAndZ iandz;
iandz.Index = i;
iandz.Z = Points[i].Z;
VertIndexAndZ.Add(iandz);
}
// Sorting function for vertex Z/index pairs
struct FCompareFSkeletalMeshVertIndexAndZ
{
FORCEINLINE bool operator()(const FSkeletalMeshVertIndexAndZ& A, const FSkeletalMeshVertIndexAndZ& B) const
{
return A.Z < B.Z;
}
};
// Sort the vertices by z value
VertIndexAndZ.Sort(FCompareFSkeletalMeshVertIndexAndZ());
// Search for duplicates, quickly!
for (int32 i = 0; i < VertIndexAndZ.Num(); i++)
{
// only need to search forward, since we add pairs both ways
for (int32 j = i + 1; j < VertIndexAndZ.Num(); j++)
{
if (FMath::Abs(VertIndexAndZ[j].Z - VertIndexAndZ[i].Z) > THRESH_POINTS_ARE_SAME)
{
// our list is sorted, so there can't be any more dupes
break;
}
// check to see if the points are really overlapping
if (PointsEqual(
Points[VertIndexAndZ[i].Index],
Points[VertIndexAndZ[j].Index]))
{
Vert2Duplicates.Add(VertIndexAndZ[i].Index, VertIndexAndZ[j].Index);
Vert2Duplicates.Add(VertIndexAndZ[j].Index, VertIndexAndZ[i].Index);
}
}
}
// we are done with this
VertIndexAndZ.Reset();
// now create a map from vert indices to faces
for (int32 FaceIndex = 0; FaceIndex < Faces.Num(); FaceIndex++)
{
const FMeshFace& Face = Faces[FaceIndex];
for (int32 VertexIndex = 0; VertexIndex < 3; VertexIndex++)
{
Vert2Faces.AddUnique(Wedges[Face.iWedge[VertexIndex]].iVertex, FaceIndex);
}
}
}
TArray<FSkinnedMeshChunk*> Chunks;
TArray<int32> AdjacentFaces;
TArray<int32> DupVerts;
TArray<int32> DupFaces;
// List of raw calculated vertices that will be merged later
TArray<FSoftSkinBuildVertex> RawVertices;
RawVertices.Reserve(Points.Num());
// Create a list of vertex Z/index pairs
for (int32 FaceIndex = 0; FaceIndex < Faces.Num(); FaceIndex++)
{
// Only update the status progress bar if we are in the gamethread and every thousand faces.
// Updating status is extremely slow
if (FaceIndex % 5000 == 0 && IsInGameThread())
{
// Only update status if in the game thread. When importing morph targets, this function can run in another thread
GWarn->StatusUpdate(FaceIndex, Faces.Num(), NSLOCTEXT("UnrealEd", "ProcessingSkeletalTriangles", "Processing Mesh Triangles"));
}
const FMeshFace& Face = Faces[FaceIndex];
FVector VertexTangentX[3],
VertexTangentY[3],
VertexTangentZ[3];
if (bComputeNormals || bComputeTangents)
{
for (int32 VertexIndex = 0; VertexIndex < 3; VertexIndex++)
{
VertexTangentX[VertexIndex] = FVector::ZeroVector;
VertexTangentY[VertexIndex] = FVector::ZeroVector;
VertexTangentZ[VertexIndex] = FVector::ZeroVector;
}
FVector TriangleNormal = FPlane(
Points[Wedges[Face.iWedge[2]].iVertex],
Points[Wedges[Face.iWedge[1]].iVertex],
Points[Wedges[Face.iWedge[0]].iVertex]
);
float Determinant = FVector::Triple(FaceTangentX[FaceIndex], FaceTangentY[FaceIndex], TriangleNormal);
// Start building a list of faces adjacent to this triangle
AdjacentFaces.Reset();
for (int32 VertexIndex = 0; VertexIndex < 3; VertexIndex++)
{
int32 vert = Wedges[Face.iWedge[VertexIndex]].iVertex;
DupVerts.Reset();
Vert2Duplicates.MultiFind(vert, DupVerts);
DupVerts.Add(vert); // I am a "dupe" of myself
for (int32 k = 0; k < DupVerts.Num(); k++)
{
DupFaces.Reset();
Vert2Faces.MultiFind(DupVerts[k], DupFaces);
for (int32 l = 0; l < DupFaces.Num(); l++)
{
AdjacentFaces.AddUnique(DupFaces[l]);
}
}
}
// Process adjacent faces
for (int32 AdjacentFaceIndex = 0; AdjacentFaceIndex < AdjacentFaces.Num(); AdjacentFaceIndex++)
{
int32 OtherFaceIndex = AdjacentFaces[AdjacentFaceIndex];
const FMeshFace& OtherFace = Faces[OtherFaceIndex];
FVector OtherTriangleNormal = FPlane(
Points[Wedges[OtherFace.iWedge[2]].iVertex],
Points[Wedges[OtherFace.iWedge[1]].iVertex],
Points[Wedges[OtherFace.iWedge[0]].iVertex]
);
float OtherFaceDeterminant = FVector::Triple(FaceTangentX[OtherFaceIndex], FaceTangentY[OtherFaceIndex], OtherTriangleNormal);
for (int32 VertexIndex = 0; VertexIndex < 3; VertexIndex++)
{
for (int32 OtherVertexIndex = 0; OtherVertexIndex < 3; OtherVertexIndex++)
{
if (PointsEqual(
Points[Wedges[OtherFace.iWedge[OtherVertexIndex]].iVertex],
Points[Wedges[Face.iWedge[VertexIndex]].iVertex]
))
{
if (Determinant * OtherFaceDeterminant > 0.0f && SkeletalMeshTools::SkeletalMesh_UVsEqual(Wedges[OtherFace.iWedge[OtherVertexIndex]], Wedges[Face.iWedge[VertexIndex]]))
{
VertexTangentX[VertexIndex] += FaceTangentX[OtherFaceIndex];
VertexTangentY[VertexIndex] += FaceTangentY[OtherFaceIndex];
}
// Only contribute 'normal' if the vertices are truly one and the same to obey hard "smoothing" edges baked into
// the mesh by vertex duplication
if (Wedges[OtherFace.iWedge[OtherVertexIndex]].iVertex == Wedges[Face.iWedge[VertexIndex]].iVertex)
{
VertexTangentZ[VertexIndex] += OtherTriangleNormal;
}
}
}
}
}
}
for (int32 VertexIndex = 0; VertexIndex < 3; VertexIndex++)
{
FSoftSkinBuildVertex Vertex;
Vertex.Position = Points[Wedges[Face.iWedge[VertexIndex]].iVertex];
FVector TangentX, TangentY, TangentZ;
if (bComputeNormals || bComputeTangents)
{
TangentX = VertexTangentX[VertexIndex].GetSafeNormal();
TangentY = VertexTangentY[VertexIndex].GetSafeNormal();
if (bComputeNormals)
{
TangentZ = VertexTangentZ[VertexIndex].GetSafeNormal();
}
else
{
TangentZ = Face.TangentZ[VertexIndex];
}
TangentY -= TangentX * (TangentX | TangentY);
TangentY.Normalize();
TangentX -= TangentZ * (TangentZ | TangentX);
TangentY -= TangentZ * (TangentZ | TangentY);
TangentX.Normalize();
TangentY.Normalize();
}
else
{
TangentX = Face.TangentX[VertexIndex];
TangentY = Face.TangentY[VertexIndex];
TangentZ = Face.TangentZ[VertexIndex];
// Normalize overridden tangents. Its possible for them to import un-normalized.
TangentX.Normalize();
TangentY.Normalize();
TangentZ.Normalize();
}
Vertex.TangentX = TangentX;
Vertex.TangentY = TangentY;
Vertex.TangentZ = TangentZ;
FMemory::Memcpy(Vertex.UVs, Wedges[Face.iWedge[VertexIndex]].UVs, sizeof(FVector2D)*MAX_TEXCOORDS);
Vertex.Color = Wedges[Face.iWedge[VertexIndex]].Color;
{
// Count the influences.
int32 InfIdx = WedgeInfluenceIndices[Face.iWedge[VertexIndex]];
int32 LookIdx = InfIdx;
uint32 InfluenceCount = 0;
while (Influences.IsValidIndex(LookIdx) && (Influences[LookIdx].VertIndex == Wedges[Face.iWedge[VertexIndex]].iVertex))
{
InfluenceCount++;
LookIdx++;
}
InfluenceCount = FMath::Min<uint32>(InfluenceCount, MAX_TOTAL_INFLUENCES);
// Setup the vertex influences.
Vertex.InfluenceBones[0] = 0;
Vertex.InfluenceWeights[0] = 255;
for (uint32 i = 1; i < MAX_TOTAL_INFLUENCES; i++)
{
Vertex.InfluenceBones[i] = 0;
Vertex.InfluenceWeights[i] = 0;
}
uint32 TotalInfluenceWeight = 0;
for (uint32 i = 0; i < InfluenceCount; i++)
{
FBoneIndexType BoneIndex = (FBoneIndexType)Influences[InfIdx + i].BoneIndex;
if (BoneIndex >= RefSkeleton.GetRawBoneNum())
continue;
Vertex.InfluenceBones[i] = BoneIndex;
Vertex.InfluenceWeights[i] = (uint8)(Influences[InfIdx + i].Weight * 255.0f);
TotalInfluenceWeight += Vertex.InfluenceWeights[i];
}
Vertex.InfluenceWeights[0] += 255 - TotalInfluenceWeight;
}
// Add the vertex as well as its original index in the points array
Vertex.PointWedgeIdx = Wedges[Face.iWedge[VertexIndex]].iVertex;
int32 RawIndex = RawVertices.Add(Vertex);
// Add an efficient way to find dupes of this vertex later for fast combining of vertices
FSkeletalMeshVertIndexAndZ IAndZ;
IAndZ.Index = RawIndex;
IAndZ.Z = Vertex.Position.Z;
VertIndexAndZ.Add(IAndZ);
}
}
// Generate chunks and their vertices and indices
SkeletalMeshTools::BuildSkeletalMeshChunks(Faces, RawVertices, VertIndexAndZ, bKeepOverlappingVertices, Chunks, bTooManyVerts);
// Chunk vertices to satisfy the requested limit.
const uint32 MaxGPUSkinBones = FGPUBaseSkinVertexFactory::GetMaxGPUSkinBones();
check(MaxGPUSkinBones <= FGPUBaseSkinVertexFactory::GHardwareMaxGPUSkinBones);
SkeletalMeshTools::ChunkSkinnedVertices(Chunks, MaxGPUSkinBones);
// Build the skeletal model from chunks.
BuildSkeletalModelFromChunks(LODModel, RefSkeleton, Chunks, PointToOriginalMap);
if (IsInGameThread())
{
// Only update status if in the game thread. When importing morph targets, this function can run in another thread
GWarn->EndSlowTask();
}
// Only show these warnings if in the game thread. When importing morph targets, this function can run in another thread and these warnings dont prevent the mesh from importing
if (IsInGameThread())
{
bool bHasBadSections = false;
for (int32 SectionIndex = 0; SectionIndex < LODModel.Sections.Num(); SectionIndex++)
{
FSkelMeshSection& Section = LODModel.Sections[SectionIndex];
bHasBadSections |= (Section.NumTriangles == 0);
// Log info about the section.
UE_LOG(LogSkeletalMesh, Log, TEXT("Section %u: Material=%u, %u triangles"),
SectionIndex,
Section.MaterialIndex,
Section.NumTriangles
);
}
if (bHasBadSections)
{
FText BadSectionMessage(NSLOCTEXT("UnrealEd", "Error_SkeletalMeshHasBadSections", "Input mesh has a section with no triangles. This mesh may not render properly."));
if (OutWarningMessages)
{
OutWarningMessages->Add(BadSectionMessage);
if (OutWarningNames)
{
OutWarningNames->Add(FFbxErrors::SkeletalMesh_SectionWithNoTriangle);
}
}
else
{
FMessageDialog::Open(EAppMsgType::Ok, BadSectionMessage);
}
}
if (bTooManyVerts)
{
FText TooManyVertsMessage(NSLOCTEXT("UnrealEd", "Error_SkeletalMeshTooManyVertices", "Input mesh has too many vertices. The generated mesh will be corrupt! Consider adding extra materials to split up the source mesh into smaller chunks."));
if (OutWarningMessages)
{
OutWarningMessages->Add(TooManyVertsMessage);
if (OutWarningNames)
{
OutWarningNames->Add(FFbxErrors::SkeletalMesh_TooManyVertices);
}
}
else
{
FMessageDialog::Open(EAppMsgType::Ok, TooManyVertsMessage);
}
}
}
return true;
}
static bool NonOpaqueMaterialPredicate(UStaticMeshComponent* InMesh)
{
TArray<UMaterialInterface*> OutMaterials;
InMesh->GetUsedMaterials(OutMaterials);
for (auto Material : OutMaterials)
{
if (Material == nullptr || Material->GetBlendMode() != BLEND_Opaque)
{
return true;
}
}
return false;
}
static FIntPoint ConditionalImageResize(const FIntPoint& SrcSize, const FIntPoint& DesiredSize, TArray<FColor>& InOutImage, bool bLinearSpace)
{
const int32 NumDesiredSamples = DesiredSize.X*DesiredSize.Y;
if (InOutImage.Num() && InOutImage.Num() != NumDesiredSamples)
{
check(InOutImage.Num() == SrcSize.X*SrcSize.Y);
TArray<FColor> OutImage;
if (NumDesiredSamples > 0)
{
FImageUtils::ImageResize(SrcSize.X, SrcSize.Y, InOutImage, DesiredSize.X, DesiredSize.Y, OutImage, bLinearSpace);
}
Exchange(InOutImage, OutImage);
return DesiredSize;
}
return SrcSize;
}
static void RetrieveValidStaticMeshComponentsForMerging(AActor* InActor, TArray<UStaticMeshComponent*>& OutComponents)
{
TInlineComponentArray<UStaticMeshComponent*> Components;
InActor->GetComponents<UStaticMeshComponent>(Components);
// TODO: support derived classes from static component
Components.RemoveAll([](UStaticMeshComponent* Val){ return !(Val->GetClass() == UStaticMeshComponent::StaticClass() || Val->IsA(USplineMeshComponent::StaticClass())); });
// TODO: support non-opaque materials
//Components.RemoveAll(&NonOpaqueMaterialPredicate);
OutComponents.Append(Components);
}
static void CheckWrappingUVs(TArray<FRawMeshExt>& SourceMeshes, TArray<bool>& MeshShouldBakeVertexData)
{
const uint32 MeshCount = SourceMeshes.Num();
for (uint32 MeshIndex = 0; MeshIndex < MeshCount; ++MeshIndex)
{
FRawMeshExt& SourceMesh = SourceMeshes[MeshIndex];
const int32 LODIndex = SourceMeshes[MeshIndex].ExportLODIndex;
if (SourceMesh.bShouldExportLOD[LODIndex])
{
FRawMesh* RawMesh = SourceMesh.MeshLODData[LODIndex].RawMesh;
check(RawMesh);
for (uint32 ChannelIndex = 0; ChannelIndex < MAX_MESH_TEXTURE_COORDS; ++ChannelIndex)
{
bool bProcessed = false;
bool bHasCoordinates = (RawMesh->WedgeTexCoords[ChannelIndex].Num() != 0);
if (bHasCoordinates)
{
FVector2D Min(FLT_MAX, FLT_MAX);
FVector2D Max(-FLT_MAX, -FLT_MAX);
for (const FVector2D& Coordinate : RawMesh->WedgeTexCoords[ChannelIndex])
{
if ((FMath::IsNegativeFloat(Coordinate.X) || FMath::IsNegativeFloat(Coordinate.Y)) || (Coordinate.X > (1.0f + KINDA_SMALL_NUMBER) || Coordinate.Y > (1.0f + KINDA_SMALL_NUMBER)))
{
MeshShouldBakeVertexData[MeshIndex] = true;
bProcessed = true;
break;
}
}
}
if (bProcessed)
{
break;
}
}
}
}
}
void FMeshUtilities::CreateProxyMesh(const TArray<AActor*>& InActors, const struct FMeshProxySettings& InMeshProxySettings, UPackage* InOuter, const FString& InProxyBasePackageName, const FGuid InGuid, FCreateProxyDelegate InProxyCreatedDelegate, const bool bAllowAsync, const float ScreenAreaSize)
{
// Error/warning checking for input
if (MeshMerging == NULL)
{
UE_LOG(LogMeshUtilities, Log, TEXT("No automatic mesh merging module available"));
return;
}
// Check that the delegate has a func-ptr bound to it
if (!InProxyCreatedDelegate.IsBound())
{
UE_LOG(LogMeshUtilities, Log, TEXT("Invalid (unbound) delegate for returning generated proxy mesh"));
return;
}
// No actors given as input
if (InActors.Num() == 0)
{
UE_LOG(LogMeshUtilities, Log, TEXT("No actors specified to generate a proxy mesh for"));
return;
}
// Base asset name for a new assets
// In case outer is null ProxyBasePackageName has to be long package name
if (InOuter == nullptr && FPackageName::IsShortPackageName(InProxyBasePackageName))
{
UE_LOG(LogMeshUtilities, Warning, TEXT("Invalid long package name: '%s'."), *InProxyBasePackageName);
return;
}
FScopedSlowTask SlowTask(100.f, (LOCTEXT("CreateProxyMesh_CreateMesh", "Creating Mesh Proxy")));
SlowTask.MakeDialog();
// Retrieve static mesh components valid for merging from the given set of actors
TArray<UStaticMeshComponent*> ComponentsToMerge;
{
// Collect components to merge
for (AActor* Actor : InActors)
{
RetrieveValidStaticMeshComponentsForMerging(Actor, ComponentsToMerge);
}
}
// Check if there are actually any static mesh components to merge
if (ComponentsToMerge.Num() == 0)
{
UE_LOG(LogMeshUtilities, Log, TEXT("No valid static mesh components found in given set of Actors"));
return;
}
typedef FIntPoint FMeshIdAndLOD;
TArray<FRawMeshExt> SourceMeshes;
TArray<FSectionInfo> UniqueSections;
TMap<FMeshIdAndLOD, TArray<int32>> GlobalMaterialMap;
static const int32 ProxyMeshTargetLODLevel = 0;
FBoxSphereBounds EstimatedBounds(ForceInitToZero);
for (const UStaticMeshComponent* StaticMeshComponent : ComponentsToMerge)
{
EstimatedBounds = EstimatedBounds + StaticMeshComponent->Bounds;
}
static const float FOVRad = 90.0f * (float)PI / 360.0f;
static const FMatrix ProjectionMatrix = FPerspectiveMatrix(FOVRad, 1920, 1080, 0.01f);
FHierarchicalLODUtilitiesModule& Module = FModuleManager::LoadModuleChecked<FHierarchicalLODUtilitiesModule>("HierarchicalLODUtilities");
IHierarchicalLODUtilities* Utilities = Module.GetUtilities();
float EstimatedDistance = Utilities->CalculateDrawDistanceFromScreenSize(EstimatedBounds.SphereRadius, ScreenAreaSize, ProjectionMatrix);
SlowTask.EnterProgressFrame(5.0f, LOCTEXT("CreateProxyMesh_CollectingMeshes", "Collecting Input Static Meshes"));
// Retrieve mesh / material data
for (const UStaticMeshComponent* StaticMeshComponent : ComponentsToMerge)
{
TArray<int32> StaticMeshGlobalMaterialMap;
FRawMesh* RawMesh = new FRawMesh();
FMemory::Memzero(RawMesh, sizeof(FRawMesh));
const int32 ProxyMeshSourceLODLevel = InMeshProxySettings.bCalculateCorrectLODModel ? Utilities->GetLODLevelForScreenAreaSize(StaticMeshComponent, Utilities->CalculateScreenSizeFromDrawDistance(StaticMeshComponent->Bounds.SphereRadius, ProjectionMatrix, EstimatedDistance)) : 0;
// Proxy meshes should always propagate vertex colours for material baking
static const bool bPropagateVertexColours = true;
const bool bValidRawMesh = ConstructRawMesh(StaticMeshComponent, ProxyMeshSourceLODLevel, bPropagateVertexColours, *RawMesh, UniqueSections, StaticMeshGlobalMaterialMap);
if ( bValidRawMesh )
{
// Add constructed raw mesh to source mesh array
const int32 SourceMeshIndex = SourceMeshes.AddZeroed();
SourceMeshes[SourceMeshIndex].MeshLODData[ProxyMeshTargetLODLevel].RawMesh = RawMesh;
SourceMeshes[SourceMeshIndex].bShouldExportLOD[ProxyMeshTargetLODLevel] = true;
SourceMeshes[SourceMeshIndex].ExportLODIndex = ProxyMeshTargetLODLevel;
// Make sure we do now the bounds of our UVs
//CalculateTextureCoordinateBoundsForRawMesh(*SourceMeshes[SourceMeshIndex].MeshLODData[ProxyMeshTargetLODLevel].RawMesh, SourceMeshes[SourceMeshIndex].MeshLODData[ProxyMeshTargetLODLevel].TexCoordBounds);
// Append retrieved materials for this static mesh component to the global material map
GlobalMaterialMap.Add(FMeshIdAndLOD(SourceMeshIndex, ProxyMeshTargetLODLevel), StaticMeshGlobalMaterialMap);
}
}
if (SourceMeshes.Num() == 0)
{
UE_LOG(LogMeshUtilities, Log, TEXT("No valid (or completely culled) raw meshes constructed from static mesh components"));
return;
}
SlowTask.EnterProgressFrame(InMeshProxySettings.bUseLandscapeCulling ? 40.0f : 45.0f, LOCTEXT("CreateProxyMesh_RemapAndFlatten", "Remapping and Flattening Materials"));
TArray<bool> MeshShouldBakeVertexData;
MeshShouldBakeVertexData.AddZeroed(SourceMeshes.Num());
CheckWrappingUVs(SourceMeshes, MeshShouldBakeVertexData);
TMap<FMeshIdAndLOD, TArray<int32> > NewGlobalMaterialMap;
TArray<FSectionInfo> NewUniqueSections;
FMaterialUtilities::RemapUniqueMaterialIndices(
UniqueSections,
SourceMeshes,
GlobalMaterialMap,
InMeshProxySettings.MaterialSettings,
true, // Always need vertex data for baking materials
true, // Always want to merge materials
MeshShouldBakeVertexData,
NewGlobalMaterialMap,
NewUniqueSections);
// Use shared material data.
Exchange(GlobalMaterialMap, NewGlobalMaterialMap);
Exchange(UniqueSections, NewUniqueSections);
// Flatten Materials
TArray<FFlattenMaterial> FlattenedMaterials;
TArray<UMaterialInterface*> Materials;
for (const FSectionInfo& Section : UniqueSections)
{
Materials.Push(Section.Material);
}
FlattenMaterialsWithMeshData(Materials, SourceMeshes, GlobalMaterialMap, MeshShouldBakeVertexData, InMeshProxySettings.MaterialSettings, FlattenedMaterials);
for (FRawMeshExt& MeshData : SourceMeshes)
{
if (MeshData.MeshLODData[MeshData.ExportLODIndex].NewUVs.Num() == 0)
{
MeshData.MeshLODData[MeshData.ExportLODIndex].TexCoordBounds.Empty();
}
}
for (FFlattenMaterial& InMaterial : FlattenedMaterials)
{
FMaterialUtilities::OptimizeFlattenMaterial(InMaterial);
}
//For each raw mesh, re-map the material indices from Local to Global material indices space
for (int32 RawMeshIndex = 0; RawMeshIndex < SourceMeshes.Num(); ++RawMeshIndex)
{
const TArray<int32>& GlobalMaterialIndices = *GlobalMaterialMap.Find(FMeshIdAndLOD(RawMeshIndex, ProxyMeshTargetLODLevel));
TArray<int32>& MaterialIndices = SourceMeshes[RawMeshIndex].MeshLODData[ProxyMeshTargetLODLevel].RawMesh->FaceMaterialIndices;
int32 MaterialIndicesCount = MaterialIndices.Num();
for (int32 TriangleIndex = 0; TriangleIndex < MaterialIndicesCount; ++TriangleIndex)
{
int32 LocalMaterialIndex = MaterialIndices[TriangleIndex];
int32 GlobalMaterialIndex = GlobalMaterialIndices[LocalMaterialIndex];
//Assign the new material index to the raw mesh
MaterialIndices[TriangleIndex] = GlobalMaterialIndex;
}
}
// Build proxy mesh
// Landscape culling
TArray<FRawMesh*> CullingRawMeshes;
if (InMeshProxySettings.bUseLandscapeCulling)
{
SlowTask.EnterProgressFrame(5.0f, LOCTEXT("CreateProxyMesh_LandscapeCulling", "Applying Landscape Culling"));
// Extract landscape proxies and cull volumes from the world
TArray<ALandscapeProxy*> LandscapeActors;
TArray<AMeshMergeCullingVolume*> CullVolumes;
UWorld* InWorld = InActors[0]->GetWorld();
uint32 MaxLandscapeExportLOD = 0;
if (InWorld->IsValidLowLevel())
{
for (FConstLevelIterator Iterator = InWorld->GetLevelIterator(); Iterator; ++Iterator)
{
for (AActor* Actor : (*Iterator)->Actors)
{
if (Actor)
{
ALandscapeProxy* LandscapeProxy = Cast<ALandscapeProxy>(Actor);
if (LandscapeProxy && LandscapeProxy->bUseLandscapeForCullingInvisibleHLODVertices)
{
// Retrieve highest landscape LOD level possible
MaxLandscapeExportLOD = FMath::Max(MaxLandscapeExportLOD, FMath::CeilLogTwo(LandscapeProxy->SubsectionSizeQuads + 1) - 1);
LandscapeActors.Add(LandscapeProxy);
}
// Check for culling volumes
AMeshMergeCullingVolume* Volume = Cast<AMeshMergeCullingVolume>(Actor);
if (Volume)
{
// If the mesh's bounds intersect with the volume there is a possibility of culling
const bool bIntersecting = Volume->EncompassesPoint(EstimatedBounds.Origin, EstimatedBounds.SphereRadius, nullptr);
if (bIntersecting)
{
CullVolumes.Add(Volume);
}
}
}
}
}
}
// Setting determines the precision at which we should export the landscape for culling (highest, half or lowest)
const uint32 LandscapeExportLOD = ((float)MaxLandscapeExportLOD * (0.5f * (float)InMeshProxySettings.LandscapeCullingPrecision));
for (ALandscapeProxy* Landscape : LandscapeActors)
{
// Export the landscape to raw mesh format
FRawMesh* LandscapeRawMesh = new FRawMesh();
FBoxSphereBounds LandscapeBounds = EstimatedBounds;
Landscape->ExportToRawMesh(LandscapeExportLOD, *LandscapeRawMesh, LandscapeBounds);
if (LandscapeRawMesh->VertexPositions.Num())
{
CullingRawMeshes.Add(LandscapeRawMesh);
}
}
// Also add volume mesh data as culling meshes
for (AMeshMergeCullingVolume* Volume : CullVolumes)
{
// Export the landscape to raw mesh format
FRawMesh* VolumeMesh = new FRawMesh();
TArray<FStaticMaterial> VolumeMaterials;
GetBrushMesh(Volume, Volume->Brush, *VolumeMesh, VolumeMaterials);
// Offset vertices to correct world position;
FVector VolumeLocation = Volume->GetActorLocation();
for (FVector& Position : VolumeMesh->VertexPositions)
{
Position += VolumeLocation;
}
CullingRawMeshes.Add(VolumeMesh);
}
}
// Allocate merge complete data
FMergeCompleteData* Data = new FMergeCompleteData();
Data->InOuter = InOuter;
Data->InProxySettings = InMeshProxySettings;
Data->ProxyBasePackageName = InProxyBasePackageName;
Data->CallbackDelegate = InProxyCreatedDelegate;
// Add this proxy job to map
Processor->AddProxyJob(InGuid, Data);
// We are only using LOD level 0 (ProxyMeshTargetLODLevel)
TArray<FMeshMergeData> MergeData;
for (FRawMeshExt& SourceMesh : SourceMeshes)
{
MergeData.Add(SourceMesh.MeshLODData[ProxyMeshTargetLODLevel]);
}
// Populate landscape clipping geometry
for (FRawMesh* RawMesh : CullingRawMeshes)
{
FMeshMergeData ClipData;
ClipData.bIsClippingMesh = true;
ClipData.RawMesh = RawMesh;
MergeData.Add(ClipData);
}
SlowTask.EnterProgressFrame(50.0f, LOCTEXT("CreateProxyMesh_GenerateProxy", "Generating Proxy Mesh"));
// Choose Simplygon Swarm (if available) or local proxy lod method
if (DistributedMeshMerging != nullptr && GetDefault<UEditorPerProjectUserSettings>()->bUseSimplygonSwarm && bAllowAsync)
{
DistributedMeshMerging->ProxyLOD(MergeData, Data->InProxySettings, FlattenedMaterials, InGuid);
}
else
{
MeshMerging->ProxyLOD(MergeData, Data->InProxySettings, FlattenedMaterials, InGuid);
Processor->Tick(0); // make sure caller gets merging results
}
for (FMeshMergeData& DataToRelease : MergeData)
{
DataToRelease.ReleaseData();
}
}
void FMeshUtilities::CreateProxyMesh(const TArray<AActor*>& Actors, const struct FMeshProxySettings& InProxySettings, UPackage* InOuter, const FString& ProxyBasePackageName, TArray<UObject*>& OutAssetsToSync, FVector& OutProxyLocation)
{
CreateProxyMesh(Actors, InProxySettings, InOuter, ProxyBasePackageName, OutAssetsToSync);
}
void FMeshUtilities::CreateProxyMesh(const TArray<AActor*>& Actors, const struct FMeshProxySettings& InProxySettings, UPackage* InOuter, const FString& ProxyBasePackageName, TArray<UObject*>& OutAssetsToSync, const float ScreenAreaSize)
{
FCreateProxyDelegate Delegate;
FGuid JobGuid = FGuid::NewGuid();
Delegate.BindLambda(
[&](const FGuid Guid, TArray<UObject*>& InAssetsToSync)
{
if (JobGuid == Guid)
{
OutAssetsToSync.Append(InAssetsToSync);
}
}
);
CreateProxyMesh(Actors, InProxySettings, InOuter, ProxyBasePackageName, JobGuid, Delegate, false, ScreenAreaSize);
}
void FMeshUtilities::FlattenMaterialsWithMeshData(TArray<UMaterialInterface*>& InMaterials, TArray<FRawMeshExt>& InSourceMeshes, TMap<FMeshIdAndLOD, TArray<int32>>& InMaterialIndexMap, TArray<bool>& InMeshShouldBakeVertexData, const FMaterialProxySettings &InMaterialProxySettings, TArray<FFlattenMaterial> &OutFlattenedMaterials) const
{
FScopedSlowTask SlowTask(InMaterials.Num(), (LOCTEXT("FlattenMaterialsWithMeshData", "Flattening Materials With Mesh Data")));
SlowTask.MakeDialog();
// Prepare container for cached shaders.
TMap<UMaterialInterface*, FExportMaterialProxyCache> CachedShaders;
CachedShaders.Empty(InMaterials.Num());
bool bDitheredLODTransition = false;
for (int32 MaterialIndex = 0; MaterialIndex < InMaterials.Num(); MaterialIndex++)
{
UMaterialInterface* CurrentMaterial = InMaterials[MaterialIndex];
SlowTask.EnterProgressFrame(1.0f, FText::FromString(FString::Printf(TEXT("Flattening out %s"), *CurrentMaterial->GetName())));
// Store if any material uses dithered transitions
bDitheredLODTransition |= CurrentMaterial->IsDitheredLODTransition();
// Check if we already have cached compiled shader for this material.
FExportMaterialProxyCache* CachedShader = CachedShaders.Find(CurrentMaterial);
if (CachedShader == nullptr)
{
CachedShader = &CachedShaders.Add(CurrentMaterial);
}
FFlattenMaterial FlattenMaterial = FMaterialUtilities::CreateFlattenMaterialWithSettings(InMaterialProxySettings);
/* Find a mesh which uses the current material. Materials using vertex data are added for each individual mesh using it,
which is why baking down the materials like this works. :) */
int32 UsedMeshIndex = 0;
int32 LocalMaterialIndex = 0;
int32 LocalTextureBoundIndex = 0;
FMeshMergeData* MergeData = nullptr;
for (int32 MeshIndex = 0; MeshIndex < InSourceMeshes.Num() && MergeData == nullptr; MeshIndex++)
{
const int32 LODIndex = InSourceMeshes[MeshIndex].ExportLODIndex;
if (InSourceMeshes[MeshIndex].MeshLODData[LODIndex].RawMesh->VertexPositions.Num())
{
const TArray<int32>& GlobalMaterialIndices = *InMaterialIndexMap.Find(FMeshIdAndLOD(MeshIndex, LODIndex));
for (LocalMaterialIndex = 0; LocalMaterialIndex < GlobalMaterialIndices.Num(); LocalMaterialIndex++)
{
// Only need to set merge data if we need to bake out using vertex data for this specific mesh
if (InMeshShouldBakeVertexData[MeshIndex] && GlobalMaterialIndices[LocalMaterialIndex] == MaterialIndex)
{
UsedMeshIndex = MeshIndex;
MergeData = &InSourceMeshes[MeshIndex].MeshLODData[LODIndex];
LocalTextureBoundIndex = LocalMaterialIndex;
break;
}
}
}
else
{
break;
}
}
// If there is specific vertex data available and used in the material we should generate non-overlapping UVs
if (MergeData && InMeshShouldBakeVertexData[UsedMeshIndex])
{
// Generate new non-overlapping texture coordinates for mesh if needed
if (MergeData->TexCoordBounds.Num() == 0)
{
// Calculate the max bounds for this raw mesh
CalculateTextureCoordinateBoundsForRawMesh(*MergeData->RawMesh, MergeData->TexCoordBounds);
}
if (MergeData->NewUVs.Num() == 0)
{
// Generate unique UVs
GenerateUniqueUVsForStaticMesh(*MergeData->RawMesh, InMaterialProxySettings.TextureSize.GetMax(), MergeData->NewUVs);
}
// Export the material using mesh data to support vertex based material properties
FMaterialUtilities::ExportMaterial(
CurrentMaterial,
MergeData->RawMesh,
LocalMaterialIndex,
MergeData->TexCoordBounds[LocalTextureBoundIndex],
MergeData->NewUVs,
FlattenMaterial,
CachedShader);
}
else
{
// Export the material without vertex data
FMaterialUtilities::ExportMaterial(
CurrentMaterial,
FlattenMaterial,
CachedShader);
}
// Fill flatten material samples alpha values with 255 (for saving out textures correctly for Simplygon Swarm)
FlattenMaterial.FillAlphaValues(255);
// Add flattened material to outgoing array
OutFlattenedMaterials.Add(FlattenMaterial);
// Check if this material will be used later. If not - release shader.
bool bMaterialStillUsed = false;
for (int32 Index = MaterialIndex + 1; Index < InMaterials.Num(); Index++)
{
if (InMaterials[Index] == CurrentMaterial)
{
bMaterialStillUsed = true;
break;
}
}
if (!bMaterialStillUsed)
{
CachedShader->Release();
}
}
if (OutFlattenedMaterials.Num() > 1)
{
// Dither transition fix-up
for (FFlattenMaterial& FlatMaterial : OutFlattenedMaterials)
{
FlatMaterial.bDitheredLODTransition = bDitheredLODTransition;
}
// Start with determining maximum emissive scale
float MaxEmissiveScale = 0.0f;
for (FFlattenMaterial& FlatMaterial : OutFlattenedMaterials)
{
if (FlatMaterial.DoesPropertyContainData(EFlattenMaterialProperties::Emissive))
{
if (FlatMaterial.EmissiveScale > MaxEmissiveScale)
{
MaxEmissiveScale = FlatMaterial.EmissiveScale;
}
}
}
if (MaxEmissiveScale > 0.001f)
{
// Rescale all materials.
for (FFlattenMaterial& FlatMaterial : OutFlattenedMaterials)
{
const float Scale = FlatMaterial.EmissiveScale / MaxEmissiveScale;
if (FMath::Abs(Scale - 1.0f) < 0.01f)
{
// Difference is not noticeable for this material, or this material has maximal emissive level.
continue;
}
// Rescale emissive data.
TArray<FColor>& EmissiveSamples = FlatMaterial.GetPropertySamples(EFlattenMaterialProperties::Emissive);
for (int32 PixelIndex = 0; PixelIndex < EmissiveSamples.Num(); PixelIndex++)
{
FColor& C = EmissiveSamples[PixelIndex];
C.R = FMath::RoundToInt(C.R * Scale);
C.G = FMath::RoundToInt(C.G * Scale);
C.B = FMath::RoundToInt(C.B * Scale);
}
// Update emissive scale to maximum
FlatMaterial.EmissiveScale = MaxEmissiveScale;
}
}
}
}
// Exports static mesh LOD render data to a RawMesh
static void ExportStaticMeshLOD(const FStaticMeshLODResources& StaticMeshLOD, FRawMesh& OutRawMesh)
{
const int32 NumWedges = StaticMeshLOD.IndexBuffer.GetNumIndices();
const int32 NumVertexPositions = StaticMeshLOD.PositionVertexBuffer.GetNumVertices();
const int32 NumFaces = NumWedges / 3;
// Indices
StaticMeshLOD.IndexBuffer.GetCopy(OutRawMesh.WedgeIndices);
// Vertex positions
if (NumVertexPositions > 0)
{
OutRawMesh.VertexPositions.Empty(NumVertexPositions);
for (int32 PosIdx = 0; PosIdx < NumVertexPositions; ++PosIdx)
{
FVector Pos = StaticMeshLOD.PositionVertexBuffer.VertexPosition(PosIdx);
OutRawMesh.VertexPositions.Add(Pos);
}
}
// Vertex data
if (StaticMeshLOD.VertexBuffer.GetNumVertices() > 0)
{
OutRawMesh.WedgeTangentX.Empty(NumWedges);
OutRawMesh.WedgeTangentY.Empty(NumWedges);
OutRawMesh.WedgeTangentZ.Empty(NumWedges);
const int32 NumTexCoords = StaticMeshLOD.VertexBuffer.GetNumTexCoords();
for (int32 TexCoodIdx = 0; TexCoodIdx < NumTexCoords; ++TexCoodIdx)
{
OutRawMesh.WedgeTexCoords[TexCoodIdx].Empty(NumWedges);
}
for (int32 WedgeIndex : OutRawMesh.WedgeIndices)
{
FVector WedgeTangentX = StaticMeshLOD.VertexBuffer.VertexTangentX(WedgeIndex);
FVector WedgeTangentY = StaticMeshLOD.VertexBuffer.VertexTangentY(WedgeIndex);
FVector WedgeTangentZ = StaticMeshLOD.VertexBuffer.VertexTangentZ(WedgeIndex);
OutRawMesh.WedgeTangentX.Add(WedgeTangentX);
OutRawMesh.WedgeTangentY.Add(WedgeTangentY);
OutRawMesh.WedgeTangentZ.Add(WedgeTangentZ);
for (int32 TexCoodIdx = 0; TexCoodIdx < NumTexCoords; ++TexCoodIdx)
{
FVector2D WedgeTexCoord = StaticMeshLOD.VertexBuffer.GetVertexUV(WedgeIndex, TexCoodIdx);
OutRawMesh.WedgeTexCoords[TexCoodIdx].Add(WedgeTexCoord);
}
}
}
// Vertex colors
if (StaticMeshLOD.ColorVertexBuffer.GetNumVertices() > 0)
{
OutRawMesh.WedgeColors.Empty(NumWedges);
for (int32 WedgeIndex : OutRawMesh.WedgeIndices)
{
FColor VertexColor = StaticMeshLOD.ColorVertexBuffer.VertexColor(WedgeIndex);
OutRawMesh.WedgeColors.Add(VertexColor);
}
}
// Materials
{
OutRawMesh.FaceMaterialIndices.Empty(NumFaces);
OutRawMesh.FaceMaterialIndices.SetNumZeroed(NumFaces);
for (const FStaticMeshSection& Section : StaticMeshLOD.Sections)
{
uint32 FirstTriangle = Section.FirstIndex / 3;
for (uint32 TriangleIndex = 0; TriangleIndex < Section.NumTriangles; ++TriangleIndex)
{
OutRawMesh.FaceMaterialIndices[FirstTriangle + TriangleIndex] = Section.MaterialIndex;
}
}
}
// Smoothing masks
{
OutRawMesh.FaceSmoothingMasks.Empty(NumFaces);
OutRawMesh.FaceSmoothingMasks.SetNumUninitialized(NumFaces);
for (auto& SmoothingMask : OutRawMesh.FaceSmoothingMasks)
{
SmoothingMask = 1;
}
}
}
const bool IsLandscapeHit(const FVector& RayOrigin, const FVector& RayEndPoint, const UWorld* World, const TArray<ALandscapeProxy*>& LandscapeProxies, FVector& OutHitLocation)
{
static FName TraceTag = FName(TEXT("LandscapeTrace"));
TArray<FHitResult> Results;
// Each landscape component has 2 collision shapes, 1 of them is specific to landscape editor
// Trace only ECC_Visibility channel, so we do hit only Editor specific shape
World->LineTraceMultiByObjectType(Results, RayOrigin, RayEndPoint, FCollisionObjectQueryParams(ECollisionChannel::ECC_Visibility), FCollisionQueryParams(TraceTag, true));
bool bHitLandscape = false;
for (const FHitResult& HitResult : Results)
{
ULandscapeHeightfieldCollisionComponent* CollisionComponent = Cast<ULandscapeHeightfieldCollisionComponent>(HitResult.Component.Get());
if (CollisionComponent)
{
ALandscapeProxy* HitLandscape = CollisionComponent->GetLandscapeProxy();
if (HitLandscape && LandscapeProxies.Contains(HitLandscape))
{
// Could write a correct clipping algorithm, that clips the triangle to hit location
OutHitLocation = HitLandscape->LandscapeActorToWorld().InverseTransformPosition(HitResult.Location);
// Above landscape so visible
bHitLandscape = true;
}
}
}
return bHitLandscape;
}
void CullTrianglesFromVolumesAndUnderLandscapes(const UStaticMeshComponent* InMeshComponent, FRawMesh &OutRawMesh)
{
UWorld* World = InMeshComponent->GetWorld();
TArray<ALandscapeProxy*> Landscapes;
TArray<AMeshMergeCullingVolume*> CullVolumes;
FBox ComponentBox(InMeshComponent->Bounds.Origin - InMeshComponent->Bounds.BoxExtent, InMeshComponent->Bounds.Origin + InMeshComponent->Bounds.BoxExtent);
for (ULevel* Level : World->GetLevels())
{
for (AActor* Actor : Level->Actors)
{
ALandscape* Proxy = Cast<ALandscape>(Actor);
if (Proxy && Proxy->bUseLandscapeForCullingInvisibleHLODVertices)
{
FVector Origin, Extent;
Proxy->GetActorBounds(false, Origin, Extent);
FBox LandscapeBox(Origin - Extent, Origin + Extent);
// Ignore Z axis for 2d bounds check
if (LandscapeBox.IntersectXY(ComponentBox))
{
Landscapes.Add(Proxy->GetLandscapeActor());
}
}
// Check for culling volumes
AMeshMergeCullingVolume* Volume = Cast<AMeshMergeCullingVolume>(Actor);
if (Volume)
{
// If the mesh's bounds intersect with the volume there is a possibility of culling
const bool bIntersecting = Volume->EncompassesPoint(InMeshComponent->Bounds.Origin, InMeshComponent->Bounds.SphereRadius, nullptr);
if (bIntersecting)
{
CullVolumes.Add(Volume);
}
}
}
}
TArray<bool> VertexVisible;
VertexVisible.AddZeroed(OutRawMesh.VertexPositions.Num());
int32 Index = 0;
for (const FVector& Position : OutRawMesh.VertexPositions)
{
// Start with setting visibility to true on all vertices
VertexVisible[Index] = true;
// Check if this vertex is culled due to being underneath a landscape
if (Landscapes.Num() > 0)
{
bool bVertexWithinLandscapeBounds = false;
for (ALandscapeProxy* Proxy : Landscapes)
{
FVector Origin, Extent;
Proxy->GetActorBounds(false, Origin, Extent);
FBox LandscapeBox(Origin - Extent, Origin + Extent);
bVertexWithinLandscapeBounds |= LandscapeBox.IsInsideXY(Position);
}
if (bVertexWithinLandscapeBounds)
{
const FVector Start = Position;
FVector End = Position - (WORLD_MAX * FVector::UpVector);
FVector OutHit;
const bool IsAboveLandscape = IsLandscapeHit(Start, End, World, Landscapes, OutHit);
End = Position + (WORLD_MAX * FVector::UpVector);
const bool IsUnderneathLandscape = IsLandscapeHit(Start, End, World, Landscapes, OutHit);
// Vertex is visible when above landscape (with actual landscape underneath) or if there is no landscape beneath or above the vertex (falls outside of landscape bounds)
VertexVisible[Index] = (IsAboveLandscape && !IsUnderneathLandscape);// || (!IsAboveLandscape && !IsUnderneathLandscape);
}
}
// Volume culling
for (AMeshMergeCullingVolume* Volume : CullVolumes)
{
const bool bVertexIsInsideVolume = Volume->EncompassesPoint(Position, 0.0f, nullptr);
if (bVertexIsInsideVolume)
{
// Inside a culling volume so invisible
VertexVisible[Index] = false;
}
}
Index++;
}
// We now know which vertices are below the landscape
TArray<bool> TriangleVisible;
int32 NumTriangles = OutRawMesh.WedgeIndices.Num() / 3;
TriangleVisible.AddZeroed(NumTriangles);
bool bCreateNewMesh = false;
// Determine which triangles of the mesh are visible
for (int32 TriangleIndex = 0; TriangleIndex < NumTriangles; TriangleIndex++)
{
bool AboveLandscape = false;
for (int32 WedgeIndex = 0; WedgeIndex < 3; ++WedgeIndex)
{
AboveLandscape |= VertexVisible[OutRawMesh.WedgeIndices[(TriangleIndex * 3) + WedgeIndex]];
}
TriangleVisible[TriangleIndex] = AboveLandscape;
bCreateNewMesh |= !AboveLandscape;
}
// Check whether or not we have to create a new mesh
if (bCreateNewMesh)
{
FRawMesh NewRawMesh;
TMap<int32, int32> VertexRemapping;
// Fill new mesh with data only from visible triangles
for (int32 TriangleIndex = 0; TriangleIndex < NumTriangles; ++TriangleIndex)
{
if (!TriangleVisible[TriangleIndex])
continue;
for (int32 WedgeIndex = 0; WedgeIndex < 3; ++WedgeIndex)
{
int32 OldIndex = OutRawMesh.WedgeIndices[(TriangleIndex * 3) + WedgeIndex];
int32 NewIndex;
int32* RemappedIndex = VertexRemapping.Find(Index);
if (RemappedIndex)
{
NewIndex = *RemappedIndex;
}
else
{
NewIndex = NewRawMesh.VertexPositions.Add(OutRawMesh.VertexPositions[OldIndex]);
VertexRemapping.Add(OldIndex, NewIndex);
}
NewRawMesh.WedgeIndices.Add(NewIndex);
if (OutRawMesh.WedgeColors.Num()) NewRawMesh.WedgeColors.Add(OutRawMesh.WedgeColors[(TriangleIndex * 3) + WedgeIndex]);
if (OutRawMesh.WedgeTangentX.Num()) NewRawMesh.WedgeTangentX.Add(OutRawMesh.WedgeTangentX[(TriangleIndex * 3) + WedgeIndex]);
if (OutRawMesh.WedgeTangentY.Num()) NewRawMesh.WedgeTangentY.Add(OutRawMesh.WedgeTangentY[(TriangleIndex * 3) + WedgeIndex]);
if (OutRawMesh.WedgeTangentZ.Num()) NewRawMesh.WedgeTangentZ.Add(OutRawMesh.WedgeTangentZ[(TriangleIndex * 3) + WedgeIndex]);
for (int32 UVIndex = 0; UVIndex < MAX_MESH_TEXTURE_COORDS; ++UVIndex)
{
if (OutRawMesh.WedgeTexCoords[UVIndex].Num())
{
NewRawMesh.WedgeTexCoords[UVIndex].Add(OutRawMesh.WedgeTexCoords[UVIndex][(TriangleIndex * 3) + WedgeIndex]);
}
}
}
NewRawMesh.FaceMaterialIndices.Add(OutRawMesh.FaceMaterialIndices[TriangleIndex]);
NewRawMesh.FaceSmoothingMasks.Add(OutRawMesh.FaceSmoothingMasks[TriangleIndex]);
}
OutRawMesh = NewRawMesh;
}
}
void PropagateSplineDeformationToRawMesh(const USplineMeshComponent* InSplineMeshComponent, FRawMesh &OutRawMesh)
{
// Apply spline deformation for each vertex's tangents
for (int32 iVert = 0; iVert < OutRawMesh.WedgeIndices.Num(); ++iVert)
{
uint32 Index = OutRawMesh.WedgeIndices[iVert];
float& AxisValue = USplineMeshComponent::GetAxisValue(OutRawMesh.VertexPositions[Index], InSplineMeshComponent->ForwardAxis);
FTransform SliceTransform = InSplineMeshComponent->CalcSliceTransform(AxisValue);
// Transform tangents first
if (OutRawMesh.WedgeTangentX.Num())
{
OutRawMesh.WedgeTangentX[iVert] = SliceTransform.TransformVector(OutRawMesh.WedgeTangentX[iVert]);
}
if (OutRawMesh.WedgeTangentY.Num())
{
OutRawMesh.WedgeTangentY[iVert] = SliceTransform.TransformVector(OutRawMesh.WedgeTangentY[iVert]);
}
if (OutRawMesh.WedgeTangentZ.Num())
{
OutRawMesh.WedgeTangentZ[iVert] = SliceTransform.TransformVector(OutRawMesh.WedgeTangentZ[iVert]);
}
}
// Apply spline deformation for each vertex position
for (int32 iVert = 0; iVert < OutRawMesh.VertexPositions.Num(); ++iVert)
{
float& AxisValue = USplineMeshComponent::GetAxisValue(OutRawMesh.VertexPositions[iVert], InSplineMeshComponent->ForwardAxis);
FTransform SliceTransform = InSplineMeshComponent->CalcSliceTransform(AxisValue);
AxisValue = 0.0f;
OutRawMesh.VertexPositions[iVert] = SliceTransform.TransformPosition(OutRawMesh.VertexPositions[iVert]);
}
}
void TransformRawMeshVertexData(const FTransform& InTransform, FRawMesh &OutRawMesh )
{
for (FVector& Vertex : OutRawMesh.VertexPositions)
{
Vertex = InTransform.TransformPosition(Vertex);
}
for (FVector& TangentX : OutRawMesh.WedgeTangentX)
{
TangentX = InTransform.TransformVectorNoScale(TangentX);
}
for (FVector& TangentY : OutRawMesh.WedgeTangentY)
{
TangentY = InTransform.TransformVectorNoScale(TangentY);
}
for (FVector& TangentZ : OutRawMesh.WedgeTangentZ)
{
TangentZ = InTransform.TransformVectorNoScale(TangentZ);
}
const bool bIsMirrored = InTransform.GetDeterminant() < 0.f;
if (bIsMirrored)
{
// Flip faces
for (int32 FaceIdx = 0; FaceIdx < OutRawMesh.WedgeIndices.Num() / 3; FaceIdx++)
{
int32 I0 = FaceIdx * 3 + 0;
int32 I2 = FaceIdx * 3 + 2;
Swap(OutRawMesh.WedgeIndices[I0], OutRawMesh.WedgeIndices[I2]);
// seems like vertex colors and UVs are not indexed, so swap values instead
if (OutRawMesh.WedgeColors.Num())
{
Swap(OutRawMesh.WedgeColors[I0], OutRawMesh.WedgeColors[I2]);
}
for (int32 i = 0; i < MAX_MESH_TEXTURE_COORDS; ++i)
{
if (OutRawMesh.WedgeTexCoords[i].Num())
{
Swap(OutRawMesh.WedgeTexCoords[i][I0], OutRawMesh.WedgeTexCoords[i][I2]);
}
}
}
}
}
void RecomputeTangentsAndNormalsForRawMesh(bool bRecomputeTangents, bool bRecomputeNormals, const FMeshBuildSettings& InBuildSettings, FRawMesh &OutRawMesh )
{
const int32 NumWedges = OutRawMesh.WedgeIndices.Num();
// Dump normals and tangents if we are recomputing them.
if (bRecomputeTangents)
{
OutRawMesh.WedgeTangentX.Empty(NumWedges);
OutRawMesh.WedgeTangentX.AddZeroed(NumWedges);
OutRawMesh.WedgeTangentY.Empty(NumWedges);
OutRawMesh.WedgeTangentY.AddZeroed(NumWedges);
}
if (bRecomputeNormals)
{
OutRawMesh.WedgeTangentZ.Empty(NumWedges);
OutRawMesh.WedgeTangentZ.AddZeroed(NumWedges);
}
// Compute any missing tangents.
if (bRecomputeNormals || bRecomputeTangents)
{
float ComparisonThreshold = GetComparisonThreshold(InBuildSettings);
TMultiMap<int32, int32> OverlappingCorners;
FindOverlappingCorners(OverlappingCorners, OutRawMesh, ComparisonThreshold);
// Static meshes always blend normals of overlapping corners.
uint32 TangentOptions = ETangentOptions::BlendOverlappingNormals;
if (InBuildSettings.bRemoveDegenerates)
{
// If removing degenerate triangles, ignore them when computing tangents.
TangentOptions |= ETangentOptions::IgnoreDegenerateTriangles;
}
if (InBuildSettings.bUseMikkTSpace)
{
ComputeTangents_MikkTSpace(OutRawMesh, OverlappingCorners, TangentOptions);
}
else
{
ComputeTangents(OutRawMesh, OverlappingCorners, TangentOptions);
}
}
// At this point the mesh will have valid tangents.
check(OutRawMesh.WedgeTangentX.Num() == NumWedges);
check(OutRawMesh.WedgeTangentY.Num() == NumWedges);
check(OutRawMesh.WedgeTangentZ.Num() == NumWedges);
}
bool FMeshUtilities::ConstructRawMesh(
const UStaticMeshComponent* InMeshComponent,
int32 InLODIndex,
const bool bPropagateVertexColours,
FRawMesh& OutRawMesh,
TArray<FSectionInfo>& OutUniqueSections,
TArray<int32>& OutGlobalMaterialIndices) const
{
// Retrieve source static mesh
const UStaticMesh* SourceStaticMesh = InMeshComponent->GetStaticMesh();
if (SourceStaticMesh == NULL)
{
UE_LOG(LogMeshUtilities, Warning, TEXT("No static mesh actor found in component %s."), *InMeshComponent->GetName());
return false;
}
if (!SourceStaticMesh->SourceModels.IsValidIndex(InLODIndex))
{
UE_LOG(LogMeshUtilities, Log, TEXT("No mesh data found for LOD%d %s."), InLODIndex, *SourceStaticMesh->GetName());
return false;
}
if (!SourceStaticMesh->RenderData->LODResources.IsValidIndex(InLODIndex))
{
UE_LOG(LogMeshUtilities, Warning, TEXT("No mesh render data found for LOD%d %s."), InLODIndex, *SourceStaticMesh->GetName());
return false;
}
const FStaticMeshSourceModel& SourceStaticMeshModel = SourceStaticMesh->SourceModels[InLODIndex];
// Imported meshes will have a filled RawMeshBulkData set
const bool bImportedMesh = !SourceStaticMeshModel.RawMeshBulkData->IsEmpty();
// Check whether or not this mesh has been reduced in-engine
const bool bReducedMesh = (SourceStaticMeshModel.ReductionSettings.PercentTriangles < 1.0f);
// rying to retrieve rawmesh from SourceStaticMeshModel was giving issues, which causes a mismatch
const bool bRenderDataMismatch = (InLODIndex > 0);
// Determine whether we load the raw mesh data from (original) import data or from the generated render data resources
if (bImportedMesh && !InMeshComponent->IsA<USplineMeshComponent>() && !bReducedMesh && !bRenderDataMismatch)
{
SourceStaticMeshModel.RawMeshBulkData->LoadRawMesh(OutRawMesh);
}
else
{
ExportStaticMeshLOD(SourceStaticMesh->RenderData->LODResources[InLODIndex], OutRawMesh);
}
// Make sure the raw mesh is not irreparably malformed.
if (!OutRawMesh.IsValidOrFixable())
{
UE_LOG(LogMeshUtilities, Error, TEXT("Raw mesh (%s) is corrupt for LOD%d."), *SourceStaticMesh->GetName(), InLODIndex);
return false;
}
// Handle spline mesh deformation
if (InMeshComponent->IsA<USplineMeshComponent>())
{
const USplineMeshComponent* SplineMeshComponent = Cast<USplineMeshComponent>(InMeshComponent);
// Deform raw mesh data according to the Spline Mesh Component's data
PropagateSplineDeformationToRawMesh(SplineMeshComponent, OutRawMesh);
}
// Use build settings from base mesh for LOD entries that was generated inside Editor.
const FMeshBuildSettings& BuildSettings = bImportedMesh ? SourceStaticMeshModel.BuildSettings : SourceStaticMesh->SourceModels[0].BuildSettings;
// Transform raw mesh to world space
FTransform ComponentToWorldTransform = InMeshComponent->ComponentToWorld;
// Take into account build scale settings only for meshes imported from raw data
// meshes reconstructed from render data already have build scale applied
if (bImportedMesh)
{
ComponentToWorldTransform.SetScale3D(ComponentToWorldTransform.GetScale3D()*BuildSettings.BuildScale3D);
}
// If specified propagate painted vertex colors into our raw mesh
if (bPropagateVertexColours)
{
PropagatePaintedColorsToRawMesh(InMeshComponent, InLODIndex, OutRawMesh);
}
// Transform raw mesh vertex data by the Static Mesh Component's component to world transformation
TransformRawMeshVertexData(ComponentToWorldTransform, OutRawMesh);
// Culling triangles could lead to an entirely empty RawMesh (all vertices culled)
if (!OutRawMesh.IsValid())
{
return false;
}
// Figure out if we should recompute normals and tangents. By default generated LODs should not recompute normals
const bool bIsMirrored = ComponentToWorldTransform.GetDeterminant() < 0.f;
bool bRecomputeNormals = (bImportedMesh && BuildSettings.bRecomputeNormals) || OutRawMesh.WedgeTangentZ.Num() == 0 || bIsMirrored;
bool bRecomputeTangents = (bImportedMesh && BuildSettings.bRecomputeTangents) || OutRawMesh.WedgeTangentX.Num() == 0 || OutRawMesh.WedgeTangentY.Num() == 0 || bIsMirrored;
if (bRecomputeNormals || bRecomputeTangents)
{
RecomputeTangentsAndNormalsForRawMesh(bRecomputeTangents, bRecomputeNormals, BuildSettings, OutRawMesh);
}
// Retrieving materials
UMaterialInterface* DefaultMaterial = Cast<UMaterialInterface>(UMaterial::GetDefaultMaterial(MD_Surface));
//Need to store the unique material indices in order to re-map the material indices in each rawmesh
for (const FStaticMeshSection& Section : SourceStaticMesh->RenderData->LODResources[InLODIndex].Sections)
{
// Add material and store the material ID
UMaterialInterface* MaterialToAdd = InMeshComponent->GetMaterial(Section.MaterialIndex);
if (MaterialToAdd)
{
//Need to check if the resource exists
FMaterialResource* Resource = MaterialToAdd->GetMaterialResource(GMaxRHIFeatureLevel);
if (!Resource)
{
MaterialToAdd = DefaultMaterial;
}
}
else
{
MaterialToAdd = DefaultMaterial;
}
FSectionInfo SectionInfo;
SectionInfo.Material = MaterialToAdd;
SectionInfo.bCollisionEnabled = Section.bEnableCollision;
SectionInfo.bShadowCastingEnabled = Section.bCastShadow;
const int32 MaterialIdx = OutUniqueSections.Add(SectionInfo);
const int32 MaterialMapIdx = OutGlobalMaterialIndices.Add(MaterialIdx);
// Update face material indices?
if (OutRawMesh.FaceMaterialIndices.Num())
{
for (int32& MaterialIndex : OutRawMesh.FaceMaterialIndices)
{
if (MaterialIndex == Section.MaterialIndex)
{
MaterialIndex = MaterialMapIdx;
}
}
}
}
return true;
}
void FMeshUtilities::ExtractMeshDataForGeometryCache(FRawMesh& RawMesh, const FMeshBuildSettings& BuildSettings, TArray<FStaticMeshBuildVertex>& OutVertices, TArray<TArray<uint32> >& OutPerSectionIndices)
{
int32 NumWedges = RawMesh.WedgeIndices.Num();
// Figure out if we should recompute normals and tangents. By default generated LODs should not recompute normals
bool bRecomputeNormals = (BuildSettings.bRecomputeNormals) || RawMesh.WedgeTangentZ.Num() == 0;
bool bRecomputeTangents = (BuildSettings.bRecomputeTangents) || RawMesh.WedgeTangentX.Num() == 0 || RawMesh.WedgeTangentY.Num() == 0;
// Dump normals and tangents if we are recomputing them.
if (bRecomputeTangents)
{
RawMesh.WedgeTangentX.Empty(NumWedges);
RawMesh.WedgeTangentX.AddZeroed(NumWedges);
RawMesh.WedgeTangentY.Empty(NumWedges);
RawMesh.WedgeTangentY.AddZeroed(NumWedges);
}
if (bRecomputeNormals)
{
RawMesh.WedgeTangentZ.Empty(NumWedges);
RawMesh.WedgeTangentZ.AddZeroed(NumWedges);
}
// Compute any missing tangents.
TMultiMap<int32, int32> OverlappingCorners;
if (bRecomputeNormals || bRecomputeTangents)
{
float ComparisonThreshold = GetComparisonThreshold(BuildSettings);
FindOverlappingCorners(OverlappingCorners, RawMesh, ComparisonThreshold);
// Static meshes always blend normals of overlapping corners.
uint32 TangentOptions = ETangentOptions::BlendOverlappingNormals;
if (BuildSettings.bRemoveDegenerates)
{
// If removing degenerate triangles, ignore them when computing tangents.
TangentOptions |= ETangentOptions::IgnoreDegenerateTriangles;
}
if (BuildSettings.bUseMikkTSpace)
{
ComputeTangents_MikkTSpace(RawMesh, OverlappingCorners, TangentOptions);
}
else
{
ComputeTangents(RawMesh, OverlappingCorners, TangentOptions);
}
}
// At this point the mesh will have valid tangents.
check(RawMesh.WedgeTangentX.Num() == NumWedges);
check(RawMesh.WedgeTangentY.Num() == NumWedges);
check(RawMesh.WedgeTangentZ.Num() == NumWedges);
TArray<int32> OutWedgeMap;
int32 MaxMaterialIndex = 1;
for (int32 FaceIndex = 0; FaceIndex < RawMesh.FaceMaterialIndices.Num(); FaceIndex++)
{
MaxMaterialIndex = FMath::Max<int32>(RawMesh.FaceMaterialIndices[FaceIndex], MaxMaterialIndex);
}
TMap<uint32, uint32> MaterialToSectionMapping;
for (int32 i = 0; i <= MaxMaterialIndex; ++i)
{
OutPerSectionIndices.Push(TArray<uint32>());
MaterialToSectionMapping.Add(i, i);
}
BuildStaticMeshVertexAndIndexBuffers(OutVertices, OutPerSectionIndices, OutWedgeMap, RawMesh, OverlappingCorners, MaterialToSectionMapping, KINDA_SMALL_NUMBER, BuildSettings.BuildScale3D);
if (RawMesh.WedgeIndices.Num() < 100000 * 3)
{
CacheOptimizeVertexAndIndexBuffer(OutVertices, OutPerSectionIndices, OutWedgeMap);
check(OutWedgeMap.Num() == RawMesh.WedgeIndices.Num());
}
}
/*------------------------------------------------------------------------------
Mesh merging
------------------------------------------------------------------------------*/
bool FMeshUtilities::PropagatePaintedColorsToRawMesh(const UStaticMeshComponent* StaticMeshComponent, int32 LODIndex, FRawMesh& RawMesh) const
{
UStaticMesh* StaticMesh = StaticMeshComponent->GetStaticMesh();
if (StaticMesh->SourceModels.IsValidIndex(LODIndex) &&
StaticMeshComponent->LODData.IsValidIndex(LODIndex) &&
StaticMeshComponent->LODData[LODIndex].OverrideVertexColors != nullptr)
{
FColorVertexBuffer& ColorVertexBuffer = *StaticMeshComponent->LODData[LODIndex].OverrideVertexColors;
FStaticMeshSourceModel& SrcModel = StaticMesh->SourceModels[LODIndex];
FStaticMeshRenderData& RenderData = *StaticMesh->RenderData;
FStaticMeshLODResources& RenderModel = RenderData.LODResources[LODIndex];
if (ColorVertexBuffer.GetNumVertices() == RenderModel.GetNumVertices())
{
int32 NumWedges = RawMesh.WedgeIndices.Num();
const bool bUseWedgeMap = RenderData.WedgeMap.Num() > 0 && RenderData.WedgeMap.Num() == NumWedges;
// If we have a wedge map
if (bUseWedgeMap)
{
if (RenderData.WedgeMap.Num() == NumWedges)
{
int32 NumExistingColors = RawMesh.WedgeColors.Num();
if (NumExistingColors < NumWedges)
{
RawMesh.WedgeColors.AddUninitialized(NumWedges - NumExistingColors);
}
for (int32 i = 0; i < NumWedges; ++i)
{
FColor WedgeColor = FColor::White;
int32 Index = RenderData.WedgeMap[i];
if (Index != INDEX_NONE)
{
WedgeColor = ColorVertexBuffer.VertexColor(Index);
}
RawMesh.WedgeColors[i] = WedgeColor;
}
return true;
}
}
// No wedge map (this can happen when we poly reduce the LOD for example)
// Use index buffer directly
else
{
UE_LOG(LogMeshUtilities, Warning, TEXT("{%s} Wedge map size %d is wrong or empty. Expected %d. Falling back on using index buffer for propagating vertex painting"), *StaticMesh->GetName(), RenderData.WedgeMap.Num(), RawMesh.WedgeIndices.Num());
RawMesh.WedgeColors.SetNumUninitialized(NumWedges);
if (RawMesh.VertexPositions.Num() == ColorVertexBuffer.GetNumVertices())
{
for (int32 i = 0; i < NumWedges; ++i)
{
FColor WedgeColor = FColor::White;
uint32 VertIndex = RawMesh.WedgeIndices[i];
if (VertIndex < ColorVertexBuffer.GetNumVertices())
{
WedgeColor = ColorVertexBuffer.VertexColor(VertIndex);
}
RawMesh.WedgeColors[i] = WedgeColor;
}
return true;
}
}
}
}
return false;
}
static void TransformPhysicsGeometry(const FTransform& InTransform, FKAggregateGeom& AggGeom)
{
FTransform NoScaleInTransform = InTransform;
NoScaleInTransform.SetScale3D(FVector(1, 1, 1));
for (FKSphereElem& Elem : AggGeom.SphereElems)
{
FTransform ElemTM = Elem.GetTransform();
Elem.SetTransform(ElemTM*NoScaleInTransform);
}
for (FKBoxElem& Elem : AggGeom.BoxElems)
{
FTransform ElemTM = Elem.GetTransform();
Elem.SetTransform(ElemTM*NoScaleInTransform);
}
for (FKSphylElem& Elem : AggGeom.SphylElems)
{
FTransform ElemTM = Elem.GetTransform();
Elem.SetTransform(ElemTM*NoScaleInTransform);
}
for (FKConvexElem& Elem : AggGeom.ConvexElems)
{
FTransform ElemTM = Elem.GetTransform();
Elem.SetTransform(ElemTM*InTransform);
}
// seems like all primitives except Convex need separate scaling pass
const FVector Scale3D = InTransform.GetScale3D();
if (!Scale3D.Equals(FVector(1.f)))
{
const float MinPrimSize = KINDA_SMALL_NUMBER;
for (FKSphereElem& Elem : AggGeom.SphereElems)
{
Elem.ScaleElem(Scale3D, MinPrimSize);
}
for (FKBoxElem& Elem : AggGeom.BoxElems)
{
Elem.ScaleElem(Scale3D, MinPrimSize);
}
for (FKSphylElem& Elem : AggGeom.SphylElems)
{
Elem.ScaleElem(Scale3D, MinPrimSize);
}
}
}
static void ExtractPhysicsGeometry(UStaticMeshComponent* InMeshComponent, FKAggregateGeom& OutAggGeom)
{
UStaticMesh* SrcMesh = InMeshComponent->GetStaticMesh();
if (SrcMesh == nullptr)
{
return;
}
if (!SrcMesh->BodySetup)
{
return;
}
OutAggGeom = SrcMesh->BodySetup->AggGeom;
// Convert boxes to convex, so they can be sheared
for (int32 BoxIdx = 0; BoxIdx < OutAggGeom.BoxElems.Num(); BoxIdx++)
{
FKConvexElem* NewConvexColl = new(OutAggGeom.ConvexElems) FKConvexElem();
NewConvexColl->ConvexFromBoxElem(OutAggGeom.BoxElems[BoxIdx]);
}
OutAggGeom.BoxElems.Empty();
// we are not owner of this stuff
OutAggGeom.RenderInfo = nullptr;
for (FKConvexElem& Elem : OutAggGeom.ConvexElems)
{
Elem.ConvexMesh = nullptr;
Elem.ConvexMeshNegX = nullptr;
}
// Transform geometry to world space
FTransform CtoM = InMeshComponent->ComponentToWorld;
TransformPhysicsGeometry(CtoM, OutAggGeom);
}
void FMeshUtilities::CalculateTextureCoordinateBoundsForRawMesh(const FRawMesh& InRawMesh, TArray<FBox2D>& OutBounds) const
{
const int32 NumWedges = InRawMesh.WedgeIndices.Num();
const int32 NumTris = NumWedges / 3;
OutBounds.Empty();
int32 WedgeIndex = 0;
for (int32 TriIndex = 0; TriIndex < NumTris; TriIndex++)
{
int MaterialIndex = InRawMesh.FaceMaterialIndices[TriIndex];
if (OutBounds.Num() <= MaterialIndex)
OutBounds.SetNumZeroed(MaterialIndex + 1);
{
int32 CachedWedgeIndex = WedgeIndex;
for (int32 UVIndex = 0; UVIndex < MAX_MESH_TEXTURE_COORDS; ++UVIndex)
{
WedgeIndex = CachedWedgeIndex;
if (InRawMesh.WedgeTexCoords[UVIndex].Num())
{
for (int32 CornerIndex = 0; CornerIndex < 3; CornerIndex++, WedgeIndex++)
{
OutBounds[MaterialIndex] += InRawMesh.WedgeTexCoords[UVIndex][WedgeIndex];
}
}
}
}
}
}
void FMeshUtilities::CalculateTextureCoordinateBoundsForSkeletalMesh(const FStaticLODModel& LODModel, TArray<FBox2D>& OutBounds) const
{
TArray<FSoftSkinVertex> Vertices;
FMultiSizeIndexContainerData IndexData;
LODModel.GetVertices(Vertices);
LODModel.MultiSizeIndexContainer.GetIndexBufferData(IndexData);
#if WITH_APEX_CLOTHING
const uint32 SectionCount = (uint32)LODModel.NumNonClothingSections();
#else
const uint32 SectionCount = LODModel.Sections.Num();
#endif // #if WITH_APEX_CLOTHING
check(OutBounds.Num() != 0);
for (uint32 SectionIndex = 0; SectionIndex < SectionCount; ++SectionIndex)
{
const FSkelMeshSection& Section = LODModel.Sections[SectionIndex];
const uint32 FirstIndex = Section.BaseIndex;
const uint32 LastIndex = FirstIndex + Section.NumTriangles * 3;
const int32 MaterialIndex = Section.MaterialIndex;
if (OutBounds.Num() <= MaterialIndex)
{
OutBounds.SetNumZeroed(MaterialIndex + 1);
}
for (uint32 Index = FirstIndex; Index < LastIndex; ++Index)
{
uint32 VertexIndex = IndexData.Indices[Index];
FSoftSkinVertex& Vertex = Vertices[VertexIndex];
FVector2D TexCoord = Vertex.UVs[0];
OutBounds[MaterialIndex] += TexCoord;
}
}
}
static void CopyTextureRect(const FColor* Src, const FIntPoint& SrcSize, FColor* Dst, const FIntPoint& DstSize, const FIntPoint& DstPos)
{
int32 RowLength = SrcSize.X*sizeof(FColor);
FColor* RowDst = Dst + DstSize.X*DstPos.Y;
const FColor* RowSrc = Src;
for (int32 RowIdx = 0; RowIdx < SrcSize.Y; ++RowIdx)
{
FMemory::Memcpy(RowDst + DstPos.X, RowSrc, RowLength);
RowDst += DstSize.X;
RowSrc += SrcSize.X;
}
}
static void SetTextureRect(const FColor& ColorValue, const FIntPoint& SrcSize, FColor* Dst, const FIntPoint& DstSize, const FIntPoint& DstPos)
{
FColor* RowDst = Dst + DstSize.X*DstPos.Y;
for (int32 RowIdx = 0; RowIdx < SrcSize.Y; ++RowIdx)
{
for (int32 ColIdx = 0; ColIdx < SrcSize.X; ++ColIdx)
{
RowDst[DstPos.X + ColIdx] = ColorValue;
}
RowDst += DstSize.X;
}
}
struct FRawMeshUVTransform
{
FVector2D Offset;
FVector2D Scale;
bool IsValid() const
{
return (Scale != FVector2D::ZeroVector);
}
};
static FVector2D GetValidUV(const FVector2D& UV)
{
FVector2D NewUV = UV;
// first make sure they're positive
if (UV.X < 0.0f)
{
NewUV.X = UV.X + FMath::CeilToInt(FMath::Abs(UV.X));
}
if (UV.Y < 0.0f)
{
NewUV.Y = UV.Y + FMath::CeilToInt(FMath::Abs(UV.Y));
}
// now make sure they're within [0, 1]
if (UV.X > 1.0f)
{
NewUV.X = FMath::Fmod(NewUV.X, 1.0f);
}
if (UV.Y > 1.0f)
{
NewUV.Y = FMath::Fmod(NewUV.Y, 1.0f);
}
return NewUV;
}
static void MergeFlattenedMaterials(TArray<struct FFlattenMaterial>& InMaterialList, FFlattenMaterial& OutMergedMaterial, TArray<FRawMeshUVTransform>& OutUVTransforms)
{
OutUVTransforms.Reserve(InMaterialList.Num());
// Fill output UV transforms with invalid values
for (auto Material : InMaterialList)
{
// Invalid UV transform
FRawMeshUVTransform UVTransform;
UVTransform.Offset = FVector2D::ZeroVector;
UVTransform.Scale = FVector2D::ZeroVector;
OutUVTransforms.Add(UVTransform);
}
int32 AtlasGridSize = FMath::CeilToInt(FMath::Sqrt(InMaterialList.Num()));
FIntPoint AtlasTextureSize = OutMergedMaterial.GetPropertySize(EFlattenMaterialProperties::Diffuse);
FIntPoint ExportTextureSize = AtlasTextureSize / AtlasGridSize;
int32 AtlasNumSamples = AtlasTextureSize.X*AtlasTextureSize.Y;
for (int32 PropertyIndex = 0; PropertyIndex < (int32)EFlattenMaterialProperties::NumFlattenMaterialProperties; ++PropertyIndex)
{
EFlattenMaterialProperties Property = (EFlattenMaterialProperties)PropertyIndex;
if (OutMergedMaterial.ShouldGenerateDataForProperty(Property))
{
check(OutMergedMaterial.GetPropertySize(Property) == AtlasTextureSize);
TArray<FColor>& Samples = OutMergedMaterial.GetPropertySamples(Property);
Samples.SetNumZeroed(AtlasNumSamples);
}
}
int32 AtlasRowIdx = 0;
int32 AtlasColIdx = 0;
FIntPoint AtlasTargetPos = FIntPoint(0, 0);
bool bSamplesWritten[(uint32)EFlattenMaterialProperties::NumFlattenMaterialProperties];
FMemory::Memset(bSamplesWritten, 0);
// Flatten all materials and merge them into one material using texture atlases
for (int32 MatIdx = 0; MatIdx < InMaterialList.Num(); ++MatIdx)
{
FFlattenMaterial& FlatMaterial = InMaterialList[MatIdx];
for (int32 PropertyIndex = 0; PropertyIndex < (int32)EFlattenMaterialProperties::NumFlattenMaterialProperties; ++PropertyIndex)
{
EFlattenMaterialProperties Property = (EFlattenMaterialProperties)PropertyIndex;
if (OutMergedMaterial.ShouldGenerateDataForProperty(Property) && FlatMaterial.DoesPropertyContainData(Property))
{
TArray<FColor>& SourceSamples = FlatMaterial.GetPropertySamples(Property);
TArray<FColor>& TargetSamples = OutMergedMaterial.GetPropertySamples(Property);
if (FlatMaterial.IsPropertyConstant(Property))
{
SetTextureRect(SourceSamples[0], ExportTextureSize, TargetSamples.GetData(), AtlasTextureSize, AtlasTargetPos);
}
else
{
FIntPoint PropertySize = FlatMaterial.GetPropertySize(Property);
PropertySize = ConditionalImageResize(PropertySize, ExportTextureSize, SourceSamples, false);
CopyTextureRect(SourceSamples.GetData(), ExportTextureSize, TargetSamples.GetData(), AtlasTextureSize, AtlasTargetPos);
FlatMaterial.SetPropertySize(Property, PropertySize);
}
bSamplesWritten[PropertyIndex] |= true;
}
}
check(OutUVTransforms.IsValidIndex(MatIdx));
OutUVTransforms[MatIdx].Offset = FVector2D(
(float)AtlasTargetPos.X / AtlasTextureSize.X,
(float)AtlasTargetPos.Y / AtlasTextureSize.Y);
OutUVTransforms[MatIdx].Scale = FVector2D(
(float)ExportTextureSize.X / AtlasTextureSize.X,
(float)ExportTextureSize.Y / AtlasTextureSize.Y);
AtlasColIdx++;
if (AtlasColIdx >= AtlasGridSize)
{
AtlasColIdx = 0;
AtlasRowIdx++;
}
AtlasTargetPos = FIntPoint(AtlasColIdx*ExportTextureSize.X, AtlasRowIdx*ExportTextureSize.Y);
}
// Check if some properties weren't populated with data (which means we can empty them out)
for (int32 PropertyIndex = 0; PropertyIndex < (int32)EFlattenMaterialProperties::NumFlattenMaterialProperties; ++PropertyIndex)
{
if (!bSamplesWritten[PropertyIndex])
{
EFlattenMaterialProperties Property = (EFlattenMaterialProperties)PropertyIndex;
OutMergedMaterial.GetPropertySamples(Property).Empty();
OutMergedMaterial.SetPropertySize(Property, FIntPoint(0, 0));
}
}
}
static void FlattenBinnedMaterials(TArray<struct FFlattenMaterial>& InMaterialList, const TArray<FBox2D>& InMaterialBoxes, FFlattenMaterial& OutMergedMaterial, TArray<FRawMeshUVTransform>& OutUVTransforms)
{
OutUVTransforms.Reserve(InMaterialList.Num());
// We support merging only for opaque materials
// Fill output UV transforms with invalid values
for (auto Material : InMaterialList)
{
// Invalid UV transform
FRawMeshUVTransform UVTransform;
UVTransform.Offset = FVector2D::ZeroVector;
UVTransform.Scale = FVector2D::ZeroVector;
OutUVTransforms.Add(UVTransform);
}
// Merge all material properties
for (int32 Index = 0; Index < (int32)EFlattenMaterialProperties::NumFlattenMaterialProperties; ++Index)
{
const EFlattenMaterialProperties Property = (EFlattenMaterialProperties)Index;
const FIntPoint& OutTextureSize = OutMergedMaterial.GetPropertySize(Property);
if (OutTextureSize != FIntPoint::ZeroValue)
{
TArray<FColor>& OutSamples = OutMergedMaterial.GetPropertySamples(Property);
OutSamples.Reserve(OutTextureSize.X * OutTextureSize.Y);
OutSamples.SetNumZeroed(OutTextureSize.X * OutTextureSize.Y);
bool bMaterialsWritten = false;
for (int32 MaterialIndex = 0; MaterialIndex < InMaterialList.Num(); ++MaterialIndex)
{
// Determine output size and offset
FFlattenMaterial& FlatMaterial = InMaterialList[MaterialIndex];
if (FlatMaterial.DoesPropertyContainData(Property))
{
FBox2D MaterialBox = InMaterialBoxes[MaterialIndex];
const FIntPoint& InputSize = FlatMaterial.GetPropertySize(Property);
TArray<FColor>& InputSamples = FlatMaterial.GetPropertySamples(Property);
// Resize material to match output (area) size
FIntPoint OutputSize = FIntPoint(OutTextureSize.X * MaterialBox.GetSize().X, OutTextureSize.Y * MaterialBox.GetSize().Y);
ConditionalImageResize(InputSize, OutputSize, InputSamples, false);
// Copy material data to the merged 'atlas' texture
FIntPoint OutputPosition = FIntPoint(OutTextureSize.X * MaterialBox.Min.X, OutTextureSize.Y * MaterialBox.Min.Y);
CopyTextureRect(InputSamples.GetData(), OutputSize, OutSamples.GetData(), OutTextureSize, OutputPosition);
// Set the UV tranforms only once
if (Index == 0)
{
FRawMeshUVTransform& UVTransform = OutUVTransforms[MaterialIndex];
UVTransform.Offset = MaterialBox.Min;
UVTransform.Scale = MaterialBox.GetSize();
}
bMaterialsWritten = true;
}
}
if (!bMaterialsWritten)
{
OutSamples.Empty();
OutMergedMaterial.SetPropertySize(Property, FIntPoint(0, 0));
}
}
}
}
void FMeshUtilities::MergeActors(
const TArray<AActor*>& SourceActors,
const FMeshMergingSettings& InSettings,
UPackage* InOuter,
const FString& InBasePackageName,
int32 UseLOD, // does not build all LODs but only use this LOD to create base mesh
TArray<UObject*>& OutAssetsToSync,
FVector& OutMergedActorLocation,
bool bSilent) const
{
MergeActors(SourceActors, InSettings, InOuter, InBasePackageName, OutAssetsToSync, OutMergedActorLocation, bSilent);
}
void FMeshUtilities::MergeActors(
const TArray<AActor*>& SourceActors,
const FMeshMergingSettings& InSettings,
UPackage* InOuter,
const FString& InBasePackageName,
TArray<UObject*>& OutAssetsToSync,
FVector& OutMergedActorLocation,
bool bSilent) const
{
checkf(SourceActors.Num(), TEXT("No actors supplied for merging"));
TArray<UStaticMeshComponent*> ComponentsToMerge;
ComponentsToMerge.Reserve(SourceActors.Num());
// Collect static mesh components
for (AActor* Actor : SourceActors)
{
TInlineComponentArray<UStaticMeshComponent*> Components;
Actor->GetComponents<UStaticMeshComponent>(Components);
// Filter out bad components
for (UStaticMeshComponent* MeshComponent : Components)
{
if (MeshComponent->GetStaticMesh() != nullptr &&
MeshComponent->GetStaticMesh()->SourceModels.Num() > 0)
{
ComponentsToMerge.Add(MeshComponent);
}
}
}
checkf(SourceActors.Num(), TEXT("No valid components found in actors supplied for merging"));
UWorld* World = SourceActors[0]->GetWorld();
checkf(World != nullptr, TEXT("Invalid world retrieved from Actor"));
const float ScreenAreaSize = TNumericLimits<float>::Max();
MergeStaticMeshComponents(ComponentsToMerge, World, InSettings, InOuter, InBasePackageName, OutAssetsToSync, OutMergedActorLocation, ScreenAreaSize, bSilent);
}
void FMeshUtilities::MergeStaticMeshComponents(const TArray<UStaticMeshComponent*>& ComponentsToMerge, UWorld* World, const FMeshMergingSettings& InSettings, UPackage* InOuter, const FString& InBasePackageName, TArray<UObject*>& OutAssetsToSync, FVector& OutMergedActorLocation, const float ScreenAreaSize, bool bSilent /*= false*/) const
{
FScopedSlowTask SlowTask(100.f, (LOCTEXT("MergeStaticMeshComponents_BuildingMesh", "Merging Static Mesh Components")));
SlowTask.MakeDialog();
TArray<FSectionInfo> UniqueSections;
TMap<FMeshIdAndLOD, TArray<int32>> MaterialMap;
TArray<FRawMeshExt> SourceMeshes;
bool bWithVertexColors[MAX_STATIC_MESH_LODS] = {};
bool bOcuppiedUVChannels[MAX_STATIC_MESH_LODS][MAX_MESH_TEXTURE_COORDS] = {};
UBodySetup* BodySetupSource = nullptr;
checkf(ComponentsToMerge.Num(), TEXT("No valid components supplied for merging"));
SourceMeshes.AddZeroed(ComponentsToMerge.Num());
// Use first mesh for naming and pivot
FString MergedAssetPackageName;
FVector MergedAssetPivot;
int32 NumMaxLOD = 0;
for (int32 MeshId = 0; MeshId < ComponentsToMerge.Num(); ++MeshId)
{
UStaticMeshComponent* MeshComponent = ComponentsToMerge[MeshId];
// Determine the maximum number of LOD levels found in the source meshes
NumMaxLOD = FMath::Max(NumMaxLOD, MeshComponent->GetStaticMesh()->SourceModels.Num());
// Save the pivot and asset package name of the first mesh, will later be used for creating merged mesh asset
if (MeshId == 0)
{
// Mesh component pivot point
MergedAssetPivot = InSettings.bPivotPointAtZero ? FVector::ZeroVector : MeshComponent->ComponentToWorld.GetLocation();
// Source mesh asset package name
MergedAssetPackageName = MeshComponent->GetStaticMesh()->GetOutermost()->GetName();
}
}
// Cap the number of LOD levels to the max
NumMaxLOD = FMath::Min(NumMaxLOD, MAX_STATIC_MESH_LODS);
int32 BaseLODIndex = 0;
// Are we going to export a single LOD or not
if (InSettings.LODSelectionType == EMeshLODSelectionType::SpecificLOD && InSettings.SpecificLOD >= 0)
{
// Will export only one specified LOD as LOD0 for the merged mesh
BaseLODIndex = FMath::Max(0, FMath::Min(InSettings.SpecificLOD, MAX_STATIC_MESH_LODS));
}
const bool bMergeAllAvailableLODs = InSettings.LODSelectionType == EMeshLODSelectionType::AllLODs;
SlowTask.EnterProgressFrame(10.0f, LOCTEXT("MergeStaticMeshComponents_RetrievingStaticMeshes", "Collecting Source Static Meshes"));
for (int32 MeshId = 0; MeshId < ComponentsToMerge.Num(); ++MeshId)
{
UStaticMeshComponent* StaticMeshComponent = ComponentsToMerge[MeshId];
// LOD index will be overridden if the user has chosen to pick it according to the viewing distance
int32 CalculatedLODIndex = -1;
if (InSettings.LODSelectionType == EMeshLODSelectionType::CalculateLOD && ScreenAreaSize > 0.0f && ScreenAreaSize < 1.0f)
{
FHierarchicalLODUtilitiesModule& Module = FModuleManager::LoadModuleChecked<FHierarchicalLODUtilitiesModule>("HierarchicalLODUtilities");
IHierarchicalLODUtilities* Utilities = Module.GetUtilities();
CalculatedLODIndex = Utilities->GetLODLevelForScreenAreaSize(StaticMeshComponent, ScreenAreaSize);
}
SourceMeshes[MeshId].SourceStaticMesh = StaticMeshComponent->GetStaticMesh();
// Retrieve the lowest available LOD level from the mesh
int32 StartLODIndex = InSettings.LODSelectionType == EMeshLODSelectionType::CalculateLOD ? CalculatedLODIndex : FMath::Min(BaseLODIndex, StaticMeshComponent->GetStaticMesh()->SourceModels.Num() - 1);
int32 EndLODIndex = bMergeAllAvailableLODs ? FMath::Min(StaticMeshComponent->GetStaticMesh()->SourceModels.Num(), MAX_STATIC_MESH_LODS) : StartLODIndex + 1;
SourceMeshes[MeshId].MaxLODExport = EndLODIndex - 1;
// Set export LOD index if we are exporting one specifically
SourceMeshes[MeshId].ExportLODIndex = !bMergeAllAvailableLODs ? StartLODIndex : -1;
for (int32 LODIndex = StartLODIndex; LODIndex < EndLODIndex; ++LODIndex)
{
// Store source static mesh and set LOD export flag
SourceMeshes[MeshId].SourceStaticMesh = StaticMeshComponent->GetStaticMesh();
SourceMeshes[MeshId].bShouldExportLOD[LODIndex] = true;
TArray<int32> MeshMaterialMap;
// Retrieve and construct raw mesh from source meshes
SourceMeshes[MeshId].MeshLODData[LODIndex].RawMesh = new FRawMesh();
FRawMesh* RawMeshLOD = SourceMeshes[MeshId].MeshLODData[LODIndex].RawMesh;
if (ConstructRawMesh(StaticMeshComponent, LODIndex, InSettings.bBakeVertexDataToMesh || InSettings.bUseVertexDataForBakingMaterial, *RawMeshLOD, UniqueSections, MeshMaterialMap))
{
// Check if vertex colours should be propagated
if (InSettings.bBakeVertexDataToMesh)
{
// Whether at least one of the meshes has vertex colors
bWithVertexColors[LODIndex] |= (RawMeshLOD->WedgeColors.Num() != 0);
}
// Which UV channels has data at least in one mesh
for (int32 ChannelIdx = 0; ChannelIdx < MAX_MESH_TEXTURE_COORDS; ++ChannelIdx)
{
bOcuppiedUVChannels[LODIndex][ChannelIdx] |= (RawMeshLOD->WedgeTexCoords[ChannelIdx].Num() != 0) && StaticMeshComponent->GetStaticMesh()->LightMapCoordinateIndex != ChannelIdx;
}
if ( InSettings.bUseLandscapeCulling )
{
// Landscape / volume culling
CullTrianglesFromVolumesAndUnderLandscapes(StaticMeshComponent, *RawMeshLOD);
if ( !RawMeshLOD->IsValid())
{
RawMeshLOD = nullptr;
SourceMeshes[MeshId].bShouldExportLOD[LODIndex] = false;
}
}
if (SourceMeshes[MeshId].bShouldExportLOD[LODIndex])
{
MaterialMap.Add(FMeshIdAndLOD(MeshId, LODIndex), MeshMaterialMap);
//CalculateTextureCoordinateBoundsForRawMesh(*SourceMeshes[MeshId].MeshLODData[LODIndex].RawMesh, SourceMeshes[MeshId].MeshLODData[LODIndex].TexCoordBounds);
}
}
}
}
// Failed to retrieve static meshes/materials cannot merge anything
if (MaterialMap.Num() == 0)
{
return;
}
if (InSettings.bMergePhysicsData)
{
for (int32 MeshId = 0; MeshId < ComponentsToMerge.Num(); ++MeshId)
{
UStaticMeshComponent* MeshComponent = ComponentsToMerge[MeshId];
ExtractPhysicsGeometry(MeshComponent, SourceMeshes[MeshId].AggGeom);
// We will use first valid BodySetup as a source of physics settings
if (BodySetupSource == nullptr)
{
BodySetupSource = MeshComponent->GetStaticMesh()->BodySetup;
}
}
}
const bool bShouldBakeOutMaterials = InSettings.bMergeMaterials && !bMergeAllAvailableLODs;
SlowTask.EnterProgressFrame(bShouldBakeOutMaterials ? 10.0f : 40.0f, LOCTEXT("MergeStaticMeshComponents_RemapMaterials", "Remapping Duplicate Materials"));
// Remap material indices regardless of baking out materials or not (could give a draw call decrease)
TArray<bool> MeshShouldBakeVertexData;
MeshShouldBakeVertexData.AddZeroed(SourceMeshes.Num());
if (bShouldBakeOutMaterials)
{
// If we have UVs outside of the UV boundaries we should use unique UVs to render out the materials
CheckWrappingUVs(SourceMeshes, MeshShouldBakeVertexData);
}
TMap<FMeshIdAndLOD, TArray<int32> > NewMaterialMap;
TArray<FSectionInfo> NewSections;
FMaterialUtilities::RemapUniqueMaterialIndices(
UniqueSections,
SourceMeshes,
MaterialMap,
InSettings.MaterialSettings,
InSettings.bUseVertexDataForBakingMaterial,
InSettings.bMergeMaterials,
MeshShouldBakeVertexData,
NewMaterialMap,
NewSections);
// Use shared material data.
Exchange(MaterialMap, NewMaterialMap);
Exchange(UniqueSections, NewSections);
if (bShouldBakeOutMaterials)
{
// Should merge flattened materials into one texture
SlowTask.EnterProgressFrame(30.0f, LOCTEXT("MergeStaticMeshComponents_BakingDownMaterials", "Rendering out Materials"));
// Flatten Materials
TArray<FFlattenMaterial> FlattenedMaterials;
TArray<UMaterialInterface*> Materials;
for (const FSectionInfo& Section : UniqueSections)
{
Materials.Push(Section.Material);
}
FlattenMaterialsWithMeshData(Materials, SourceMeshes, MaterialMap, MeshShouldBakeVertexData, InSettings.MaterialSettings, FlattenedMaterials);
// Try to optimize materials where possible
for (FFlattenMaterial& InMaterial : FlattenedMaterials)
{
FMaterialUtilities::OptimizeFlattenMaterial(InMaterial);
}
FIntPoint AtlasTextureSize = InSettings.MaterialSettings.TextureSize;
FFlattenMaterial MergedFlatMaterial;
MergedFlatMaterial.SetPropertySize(EFlattenMaterialProperties::Diffuse, AtlasTextureSize);
MergedFlatMaterial.SetPropertySize(EFlattenMaterialProperties::Normal, InSettings.MaterialSettings.bNormalMap ? AtlasTextureSize : FIntPoint::ZeroValue);
MergedFlatMaterial.SetPropertySize(EFlattenMaterialProperties::Metallic, InSettings.MaterialSettings.bMetallicMap ? AtlasTextureSize : FIntPoint::ZeroValue);
MergedFlatMaterial.SetPropertySize(EFlattenMaterialProperties::Roughness, InSettings.MaterialSettings.bRoughnessMap ? AtlasTextureSize : FIntPoint::ZeroValue);
MergedFlatMaterial.SetPropertySize(EFlattenMaterialProperties::Specular, InSettings.MaterialSettings.bSpecularMap ? AtlasTextureSize : FIntPoint::ZeroValue);
MergedFlatMaterial.SetPropertySize(EFlattenMaterialProperties::Emissive, InSettings.MaterialSettings.bEmissiveMap ? AtlasTextureSize : FIntPoint::ZeroValue);
MergedFlatMaterial.SetPropertySize(EFlattenMaterialProperties::Opacity, InSettings.MaterialSettings.bOpacityMap ? AtlasTextureSize : FIntPoint::ZeroValue);
TArray<FRawMeshUVTransform> UVTransforms;
if (InSettings.bUseTextureBinning)
{
TArray<float> MaterialImportance;
FMaterialUtilities::DetermineMaterialImportance(Materials, MaterialImportance);
TArray<FBox2D> MaterialBoxes;
FMaterialUtilities::GeneratedBinnedTextureSquares(FVector2D(1.0f, 1.0f), MaterialImportance, MaterialBoxes);
FlattenBinnedMaterials(FlattenedMaterials, MaterialBoxes, MergedFlatMaterial, UVTransforms);
}
else
{
MergeFlattenedMaterials(FlattenedMaterials, MergedFlatMaterial, UVTransforms);
}
FMaterialUtilities::OptimizeFlattenMaterial(MergedFlatMaterial);
// Adjust UVs and remap material indices
for (int32 MeshIndex = 0; MeshIndex < SourceMeshes.Num(); ++MeshIndex)
{
const int32 LODIndex = SourceMeshes[MeshIndex].ExportLODIndex;
FRawMesh& RawMesh = *SourceMeshes[MeshIndex].MeshLODData[LODIndex].RawMesh;
if (RawMesh.VertexPositions.Num())
{
const TArray<int32> MaterialIndices = MaterialMap[FMeshIdAndLOD(MeshIndex, LODIndex)];
// If we end up in the situation where we have two of the same meshes which require baking vertex data (thus unique UVs), the first one to be found in the array will be used to bake out the material and generate new uvs for it. The other one however will not have the new UVs and thus the baked out material does not match up with its uvs which makes the mesh be UVed incorrectly with the new baked material.
if (!SourceMeshes[MeshIndex].MeshLODData[LODIndex].NewUVs.Num() && MeshShouldBakeVertexData[MeshIndex])
{
// Calculate the max bounds for this raw mesh
CalculateTextureCoordinateBoundsForRawMesh(*SourceMeshes[MeshIndex].MeshLODData[LODIndex].RawMesh, SourceMeshes[MeshIndex].MeshLODData[LODIndex].TexCoordBounds);
// Generate unique UVs
GenerateUniqueUVsForStaticMesh(*SourceMeshes[MeshIndex].MeshLODData[LODIndex].RawMesh, InSettings.MaterialSettings.TextureSize.GetMax(), SourceMeshes[MeshIndex].MeshLODData[LODIndex].NewUVs);
}
for (int32 UVChannelIdx = 0; UVChannelIdx < MAX_MESH_TEXTURE_COORDS; ++UVChannelIdx)
{
// Determine if we should use original or non-overlapping generated UVs
TArray<FVector2D>& UVs = SourceMeshes[MeshIndex].MeshLODData[LODIndex].NewUVs.Num() ? SourceMeshes[MeshIndex].MeshLODData[LODIndex].NewUVs : RawMesh.WedgeTexCoords[UVChannelIdx];
if (RawMesh.WedgeTexCoords[UVChannelIdx].Num() > 0)
{
int32 UVIdx = 0;
for (int32 FaceMaterialIndex : RawMesh.FaceMaterialIndices)
{
const FRawMeshUVTransform& UVTransform = UVTransforms[MaterialIndices[FaceMaterialIndex]];
if (UVTransform.IsValid())
{
FVector2D UV0 = GetValidUV(UVs[UVIdx + 0]);
FVector2D UV1 = GetValidUV(UVs[UVIdx + 1]);
FVector2D UV2 = GetValidUV(UVs[UVIdx + 2]);
RawMesh.WedgeTexCoords[UVChannelIdx][UVIdx + 0] = UV0 * UVTransform.Scale + UVTransform.Offset;
RawMesh.WedgeTexCoords[UVChannelIdx][UVIdx + 1] = UV1 * UVTransform.Scale + UVTransform.Offset;
RawMesh.WedgeTexCoords[UVChannelIdx][UVIdx + 2] = UV2 * UVTransform.Scale + UVTransform.Offset;
}
UVIdx += 3;
}
}
}
// Reset material indexes
for (int32& FaceMaterialIndex : RawMesh.FaceMaterialIndices)
{
FaceMaterialIndex = 0;
}
}
else
{
break;
}
}
// Create merged material asset
FString MaterialAssetName;
FString MaterialPackageName;
if (InBasePackageName.IsEmpty())
{
MaterialAssetName = TEXT("M_MERGED_") + FPackageName::GetShortName(MergedAssetPackageName);
MaterialPackageName = FPackageName::GetLongPackagePath(MergedAssetPackageName) + TEXT("/") + MaterialAssetName;
}
else
{
MaterialAssetName = TEXT("M_") + FPackageName::GetShortName(InBasePackageName);
MaterialPackageName = FPackageName::GetLongPackagePath(InBasePackageName) + TEXT("/") + MaterialAssetName;
}
UPackage* MaterialPackage = InOuter;
if (MaterialPackage == nullptr)
{
MaterialPackage = CreatePackage(nullptr, *MaterialPackageName);
check(MaterialPackage);
MaterialPackage->FullyLoad();
MaterialPackage->Modify();
}
UMaterialInstanceConstant* MergedMaterial = ProxyMaterialUtilities::CreateProxyMaterialInstance(MaterialPackage, InSettings.MaterialSettings, MergedFlatMaterial, MaterialAssetName, MaterialPackageName);
// Set material static lighting usage flag if project has static lighting enabled
static const auto AllowStaticLightingVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.AllowStaticLighting"));
const bool bAllowStaticLighting = (!AllowStaticLightingVar || AllowStaticLightingVar->GetValueOnGameThread() != 0);
if (bAllowStaticLighting)
{
MergedMaterial->CheckMaterialUsage(MATUSAGE_StaticLighting);
}
// Only end up with one material so clear array first
UniqueSections.Empty();
FSectionInfo NewSection;
NewSection.Material = MergedMaterial;
NewSection.bShadowCastingEnabled = true;
NewSection.bCollisionEnabled = false;
UniqueSections.Add(NewSection);
}
FRawMeshExt MergedMesh;
FMemory::Memset(&MergedMesh, 0, sizeof(MergedMesh));
// Flatten out the occupied UV channel flags, we need this to ensure the same amount of uv sets written out for each mesh
bool bFlattenedOcuppiedUVChannels[MAX_MESH_TEXTURE_COORDS];
FMemory::Memset(bFlattenedOcuppiedUVChannels, 0, sizeof(bool) * MAX_MESH_TEXTURE_COORDS);
for (int CoordinateIndex = 0; CoordinateIndex < MAX_MESH_TEXTURE_COORDS; ++CoordinateIndex)
{
for (int32 LODIndex = 0; LODIndex < MAX_STATIC_MESH_LODS; ++LODIndex)
{
bFlattenedOcuppiedUVChannels[CoordinateIndex] |= bOcuppiedUVChannels[LODIndex][CoordinateIndex];
}
}
SlowTask.EnterProgressFrame(40.0f, LOCTEXT("MergeStaticMeshComponents_MergingMeshesTogether", "Generating Output Static Mesh"));
FMeshSectionInfoMap SectionInfoMap;
int32 MaxExportLODs = bMergeAllAvailableLODs ? NumMaxLOD : 1;
// Merge meshes into single mesh
for (int32 SourceMeshIdx = 0; SourceMeshIdx < SourceMeshes.Num(); ++SourceMeshIdx)
{
for (int32 TargetLODIndex = 0; TargetLODIndex < MaxExportLODs; ++TargetLODIndex)
{
int32 SourceLODIndex = SourceMeshes[SourceMeshIdx].bShouldExportLOD[TargetLODIndex] ? TargetLODIndex : (SourceMeshes[SourceMeshIdx].MaxLODExport);
if (!bMergeAllAvailableLODs)
{
SourceLODIndex = SourceMeshes[SourceMeshIdx].ExportLODIndex;
}
// Allocate raw meshes where needed
if (MergedMesh.MeshLODData[TargetLODIndex].RawMesh == nullptr)
{
MergedMesh.MeshLODData[TargetLODIndex].RawMesh = new FRawMesh();
}
// Merge vertex data from source mesh list into single mesh
const FRawMesh& SourceRawMesh = *SourceMeshes[SourceMeshIdx].MeshLODData[SourceLODIndex].RawMesh;
if (SourceRawMesh.VertexPositions.Num() == 0)
{
continue;
}
const TArray<int32> MaterialIndices = MaterialMap[FMeshIdAndLOD(SourceMeshIdx, SourceLODIndex)];
check(MaterialIndices.Num() > 0);
FRawMesh& TargetRawMesh = *MergedMesh.MeshLODData[TargetLODIndex].RawMesh;
TargetRawMesh.FaceSmoothingMasks.Append(SourceRawMesh.FaceSmoothingMasks);
if (InSettings.bMergeMaterials && !bMergeAllAvailableLODs)
{
TargetRawMesh.FaceMaterialIndices.AddZeroed(SourceRawMesh.FaceMaterialIndices.Num());
}
else
{
for (const int32 Index : SourceRawMesh.FaceMaterialIndices)
{
TargetRawMesh.FaceMaterialIndices.Add(MaterialIndices[Index]);
}
}
int32 IndicesOffset = TargetRawMesh.VertexPositions.Num();
for (int32 Index : SourceRawMesh.WedgeIndices)
{
TargetRawMesh.WedgeIndices.Add(Index + IndicesOffset);
}
for (FVector VertexPos : SourceRawMesh.VertexPositions)
{
TargetRawMesh.VertexPositions.Add(VertexPos - MergedAssetPivot);
}
TargetRawMesh.WedgeTangentX.Append(SourceRawMesh.WedgeTangentX);
TargetRawMesh.WedgeTangentY.Append(SourceRawMesh.WedgeTangentY);
TargetRawMesh.WedgeTangentZ.Append(SourceRawMesh.WedgeTangentZ);
// Deal with vertex colors
// Some meshes may have it, in this case merged mesh will be forced to have vertex colors as well
if (InSettings.bBakeVertexDataToMesh)
{
if (bWithVertexColors[SourceLODIndex] && SourceRawMesh.WedgeColors.Num())
{
TargetRawMesh.WedgeColors.Append(SourceRawMesh.WedgeColors);
}
else
{
// In case this source mesh does not have vertex colors, fill target with 0xFF
int32 ColorsOffset = TargetRawMesh.WedgeColors.Num();
int32 ColorsNum = SourceRawMesh.WedgeIndices.Num();
TargetRawMesh.WedgeColors.AddUninitialized(ColorsNum);
FMemory::Memset(&TargetRawMesh.WedgeColors[ColorsOffset], 0xFF, ColorsNum*TargetRawMesh.WedgeColors.GetTypeSize());
}
}
// Merge all other UV channels
for (int32 ChannelIdx = 0; ChannelIdx < MAX_MESH_TEXTURE_COORDS; ++ChannelIdx)
{
// Whether this channel has data
if (bFlattenedOcuppiedUVChannels[ChannelIdx])
{
const TArray<FVector2D>& SourceChannel = SourceRawMesh.WedgeTexCoords[ChannelIdx];
TArray<FVector2D>& TargetChannel = TargetRawMesh.WedgeTexCoords[ChannelIdx];
// Whether source mesh has data in this channel
if (SourceChannel.Num())
{
TargetChannel.Append(SourceChannel);
}
else
{
// Fill with zero coordinates if source mesh has no data for this channel
const int32 TexCoordNum = SourceRawMesh.WedgeIndices.Num();
for (int32 CoordIdx = 0; CoordIdx < TexCoordNum; ++CoordIdx)
{
TargetChannel.Add(FVector2D::ZeroVector);
}
}
}
}
}
}
// Populate mesh section map
for (int32 TargetLODIndex = 0; TargetLODIndex < MaxExportLODs; ++TargetLODIndex)
{
TArray<uint32> UniqueMaterialIndices;
FRawMesh& TargetRawMesh = *MergedMesh.MeshLODData[TargetLODIndex].RawMesh;
for (uint32 MaterialIndex : TargetRawMesh.FaceMaterialIndices)
{
UniqueMaterialIndices.AddUnique(MaterialIndex);
}
for (int32 Index = 0; Index < UniqueMaterialIndices.Num(); ++Index)
{
const uint32 MaterialIndex = UniqueMaterialIndices[Index];
FSectionInfo StoredSectionInfo = UniqueSections[MaterialIndex];
FMeshSectionInfo SectionInfo;
SectionInfo.bCastShadow = StoredSectionInfo.bShadowCastingEnabled;
SectionInfo.bEnableCollision = StoredSectionInfo.bCollisionEnabled;
SectionInfo.MaterialIndex = MaterialIndex;
SectionInfoMap.Set(TargetLODIndex, Index, SectionInfo);
}
}
// Transform physics primitives to merged mesh pivot
if (InSettings.bMergePhysicsData && !MergedAssetPivot.IsZero())
{
FTransform PivotTM(-MergedAssetPivot);
for (auto& SourceMesh : SourceMeshes)
{
TransformPhysicsGeometry(PivotTM, SourceMesh.AggGeom);
}
}
// Compute target lightmap channel for each LOD, by looking at the first empty UV channel
int32 LightMapUVChannel = InSettings.bGenerateLightMapUV ? -1 : 0;
if (InSettings.bGenerateLightMapUV)
{
for (int32 ChannelIdx = 0; ChannelIdx < MAX_MESH_TEXTURE_COORDS; ++ChannelIdx)
{
bool bOccupied = false;
if (bFlattenedOcuppiedUVChannels[ChannelIdx])
{
continue;
}
else
{
LightMapUVChannel = ChannelIdx;
break;
}
}
if (LightMapUVChannel == -1)
{
// Output warning message
UE_LOG(LogMeshUtilities, Log, TEXT("Failed to find available lightmap uv channel"));
LightMapUVChannel = 0;
}
}
//
//Create merged mesh asset
//
SlowTask.EnterProgressFrame(10.0f, LOCTEXT("MergeStaticMeshComponents_CreatingAsset", "Creating Output Assets"));
{
FString AssetName;
FString PackageName;
if (InBasePackageName.IsEmpty())
{
AssetName = TEXT("SM_MERGED_") + FPackageName::GetShortName(MergedAssetPackageName);
PackageName = FPackageName::GetLongPackagePath(MergedAssetPackageName) + TEXT("/") + AssetName;
}
else
{
AssetName = FPackageName::GetShortName(InBasePackageName);
PackageName = InBasePackageName;
}
UPackage* Package = InOuter;
if (Package == nullptr)
{
Package = CreatePackage(NULL, *PackageName);
check(Package);
Package->FullyLoad();
Package->Modify();
}
UStaticMesh* StaticMesh = NewObject<UStaticMesh>(Package, *AssetName, RF_Public | RF_Standalone);
StaticMesh->InitResources();
FString OutputPath = StaticMesh->GetPathName();
// make sure it has a new lighting guid
StaticMesh->LightingGuid = FGuid::NewGuid();
if (InSettings.bGenerateLightMapUV)
{
StaticMesh->LightMapResolution = InSettings.TargetLightMapResolution;
StaticMesh->LightMapCoordinateIndex = LightMapUVChannel;
}
for (int32 LODIndex = 0; LODIndex < NumMaxLOD; ++LODIndex)
{
if (MergedMesh.MeshLODData[LODIndex].RawMesh != nullptr)
{
FRawMesh& MergedMeshLOD = *MergedMesh.MeshLODData[LODIndex].RawMesh;
if (MergedMeshLOD.VertexPositions.Num() > 0)
{
FStaticMeshSourceModel* SrcModel = new (StaticMesh->SourceModels) FStaticMeshSourceModel();
/*Don't allow the engine to recalculate normals*/
SrcModel->BuildSettings.bRecomputeNormals = false;
SrcModel->BuildSettings.bRecomputeTangents = false;
SrcModel->BuildSettings.bRemoveDegenerates = false;
SrcModel->BuildSettings.bUseHighPrecisionTangentBasis = false;
SrcModel->BuildSettings.bUseFullPrecisionUVs = false;
SrcModel->BuildSettings.bGenerateLightmapUVs = InSettings.bGenerateLightMapUV;
SrcModel->BuildSettings.MinLightmapResolution = InSettings.TargetLightMapResolution;
SrcModel->BuildSettings.SrcLightmapIndex = 0;
SrcModel->BuildSettings.DstLightmapIndex = LightMapUVChannel;
SrcModel->RawMeshBulkData->SaveRawMesh(MergedMeshLOD);
}
}
}
// Assign materials
for (const FSectionInfo& Section : UniqueSections)
{
UMaterialInterface* Material = Section.Material;
if (Material && !Material->IsAsset())
{
Material = nullptr; // do not save non-asset materials
}
StaticMesh->StaticMaterials.Add(FStaticMaterial(Material));
}
if (InSettings.bMergePhysicsData)
{
StaticMesh->CreateBodySetup();
if (BodySetupSource)
{
StaticMesh->BodySetup->CopyBodyPropertiesFrom(BodySetupSource);
}
StaticMesh->BodySetup->AggGeom = FKAggregateGeom();
// Copy collision from the source meshes
for (const FRawMeshExt& SourceMesh : SourceMeshes)
{
StaticMesh->BodySetup->AddCollisionFrom(SourceMesh.AggGeom);
}
// Bake rotation into verts of convex hulls, so they scale correctly after rotation
for (FKConvexElem& ConvexElem : StaticMesh->BodySetup->AggGeom.ConvexElems)
{
ConvexElem.BakeTransformToVerts();
}
}
StaticMesh->SectionInfoMap.CopyFrom(SectionInfoMap);
StaticMesh->Build(bSilent);
StaticMesh->PostEditChange();
OutAssetsToSync.Add(StaticMesh);
OutMergedActorLocation = MergedAssetPivot;
}
for (FRawMeshExt& SourceMesh : SourceMeshes)
{
for (FMeshMergeData& Mergedata : SourceMesh.MeshLODData)
{
Mergedata.ReleaseData();
}
}
for (FMeshMergeData& Mergedata : MergedMesh.MeshLODData)
{
Mergedata.ReleaseData();
}
}
void FMeshUtilities::MergeStaticMeshComponents(const TArray<UStaticMeshComponent*>& ComponentsToMerge, UWorld* World, const FMeshMergingSettings& InSettings, UPackage* InOuter, const FString& InBasePackageName, int32 UseLOD, /* does not build all LODs but only use this LOD to create base mesh */ TArray<UObject*>& OutAssetsToSync, FVector& OutMergedActorLocation, const float ScreenAreaSize, bool bSilent /*= false*/) const
{
MergeStaticMeshComponents(ComponentsToMerge, World, InSettings, InOuter, InBasePackageName, OutAssetsToSync, OutMergedActorLocation, ScreenAreaSize, bSilent);
}
bool FMeshUtilities::RemoveBonesFromMesh(USkeletalMesh* SkeletalMesh, int32 LODIndex, const TArray<FName>* BoneNamesToRemove) const
{
IMeshBoneReductionModule& MeshBoneReductionModule = FModuleManager::Get().LoadModuleChecked<IMeshBoneReductionModule>("MeshBoneReduction");
IMeshBoneReduction * MeshBoneReductionInterface = MeshBoneReductionModule.GetMeshBoneReductionInterface();
return MeshBoneReductionInterface->ReduceBoneCounts(SkeletalMesh, LODIndex, BoneNamesToRemove);
}
/*------------------------------------------------------------------------------
Mesh reduction.
------------------------------------------------------------------------------*/
IMeshReduction* FMeshUtilities::GetMeshReductionInterface()
{
return MeshReduction;
}
/*------------------------------------------------------------------------------
Mesh merging.
------------------------------------------------------------------------------*/
IMeshMerging* FMeshUtilities::GetMeshMergingInterface()
{
return MeshMerging;
}
/*------------------------------------------------------------------------------
Module initialization / teardown.
------------------------------------------------------------------------------*/
void FMeshUtilities::StartupModule()
{
check(MeshReduction == NULL);
check(MeshMerging == NULL);
Processor = new FProxyGenerationProcessor();
// Look for a mesh reduction module.
{
TArray<FName> ModuleNames;
FModuleManager::Get().FindModules(TEXT("*MeshReduction"), ModuleNames);
TArray<FName> SwarmModuleNames;
FModuleManager::Get().FindModules(TEXT("*SimplygonSwarm"), SwarmModuleNames);
for (int32 Index = 0; Index < ModuleNames.Num(); Index++)
{
bool bIsSimplygon = ModuleNames[Index].GetPlainNameString().Contains(TEXT("Simplygon"));
if( CVarUseSimplygon.GetValueOnAnyThread() == 0 && bIsSimplygon )
{
continue;
}
if( CVarUseSimplygon.GetValueOnAnyThread() == 2 && !bIsSimplygon )
{
continue;
}
IMeshReductionModule& MeshReductionModule = FModuleManager::LoadModuleChecked<IMeshReductionModule>(ModuleNames[Index]);
// Look for MeshReduction interface
if (MeshReduction == NULL)
{
MeshReduction = MeshReductionModule.GetMeshReductionInterface();
if (MeshReduction)
{
UE_LOG(LogMeshUtilities, Log, TEXT("Using %s for automatic mesh reduction"), *ModuleNames[Index].ToString());
}
}
// Look for MeshMerging interface
if (MeshMerging == NULL)
{
MeshMerging = MeshReductionModule.GetMeshMergingInterface();
if (MeshMerging)
{
UE_LOG(LogMeshUtilities, Log, TEXT("Using %s for automatic mesh merging"), *ModuleNames[Index].ToString());
}
}
// Break early if both interfaces were found
if (MeshReduction && MeshMerging)
{
break;
}
}
for (int32 Index = 0; Index < SwarmModuleNames.Num(); Index++)
{
IMeshReductionModule& MeshReductionModule = FModuleManager::LoadModuleChecked<IMeshReductionModule>(SwarmModuleNames[Index]);
// Look for distributed mesh merging interface
if (DistributedMeshMerging == NULL)
{
DistributedMeshMerging = MeshReductionModule.GetMeshMergingInterface();
if (DistributedMeshMerging)
{
UE_LOG(LogMeshUtilities, Log, TEXT("Using %s for distributed automatic mesh merging"), *SwarmModuleNames[Index].ToString());
}
}
}
if (!MeshReduction)
{
UE_LOG(LogMeshUtilities, Log, TEXT("No automatic mesh reduction module available"));
}
if (!MeshMerging)
{
UE_LOG(LogMeshUtilities, Log, TEXT("No automatic mesh merging module available"));
}
else
{
MeshMerging->CompleteDelegate.BindRaw(Processor, &FProxyGenerationProcessor::ProxyGenerationComplete);
MeshMerging->FailedDelegate.BindRaw(Processor, &FProxyGenerationProcessor::ProxyGenerationFailed);
}
if (!DistributedMeshMerging)
{
UE_LOG(LogMeshUtilities, Log, TEXT("No distributed automatic mesh merging module available"));
}
else
{
DistributedMeshMerging->CompleteDelegate.BindRaw(Processor, &FProxyGenerationProcessor::ProxyGenerationComplete);
DistributedMeshMerging->FailedDelegate.BindRaw(Processor, &FProxyGenerationProcessor::ProxyGenerationFailed);
}
}
bDisableTriangleOrderOptimization = (CVarTriangleOrderOptimization.GetValueOnGameThread() == 2);
bUsingNvTriStrip = !bDisableTriangleOrderOptimization && (CVarTriangleOrderOptimization.GetValueOnGameThread() == 0);
// Construct and cache the version string for the mesh utilities module.
VersionString = FString::Printf(
TEXT("%s%s%s"),
MESH_UTILITIES_VER,
MeshReduction ? *MeshReduction->GetVersionString() : TEXT(""),
bUsingNvTriStrip ? TEXT("_NvTriStrip") : TEXT("")
);
bUsingSimplygon = VersionString.Contains(TEXT("Simplygon"));
// hook up level editor extension for skeletal mesh conversion
ModuleLoadedDelegateHandle = FModuleManager::Get().OnModulesChanged().AddLambda([this](FName InModuleName, EModuleChangeReason InChangeReason)
{
if (InChangeReason == EModuleChangeReason::ModuleLoaded)
{
if (InModuleName == "LevelEditor")
{
AddLevelViewportMenuExtender();
}
else if (InModuleName == "AnimationBlueprintEditor")
{
AddAnimationBlueprintEditorToolbarExtender();
}
else if (InModuleName == "AnimationEditor")
{
AddAnimationEditorToolbarExtender();
}
else if (InModuleName == "SkeletalMeshEditor")
{
AddSkeletalMeshEditorToolbarExtender();
}
else if (InModuleName == "SkeletonEditor")
{
AddSkeletonEditorToolbarExtender();
}
}
});
}
void FMeshUtilities::ShutdownModule()
{
RemoveLevelViewportMenuExtender();
RemoveAnimationBlueprintEditorToolbarExtender();
RemoveAnimationEditorToolbarExtender();
RemoveSkeletalMeshEditorToolbarExtender();
RemoveSkeletonEditorToolbarExtender();
FModuleManager::Get().OnModulesChanged().Remove(ModuleLoadedDelegateHandle);
MeshReduction = NULL;
MeshMerging = NULL;
VersionString.Empty();
}
bool FMeshUtilities::GenerateUniqueUVsForStaticMesh(const FRawMesh& RawMesh, int32 TextureResolution, TArray<FVector2D>& OutTexCoords) const
{
// Create a copy of original mesh
FRawMesh TempMesh = RawMesh;
// Find overlapping corners for UV generator. Allow some threshold - this should not produce any error in a case if resulting
// mesh will not merge these vertices.
TMultiMap<int32, int32> OverlappingCorners;
FindOverlappingCorners(OverlappingCorners, RawMesh, THRESH_POINTS_ARE_SAME);
// Generate new UVs
FLayoutUV Packer(&TempMesh, 0, 1, FMath::Clamp(TextureResolution / 4, 32, 512));
Packer.FindCharts(OverlappingCorners);
bool bPackSuccess = Packer.FindBestPacking();
if (bPackSuccess)
{
Packer.CommitPackedUVs();
// Save generated UVs
OutTexCoords = TempMesh.WedgeTexCoords[1];
}
return bPackSuccess;
}
bool FMeshUtilities::GenerateUniqueUVsForSkeletalMesh(const FStaticLODModel& LODModel, int32 TextureResolution, TArray<FVector2D>& OutTexCoords) const
{
// Get easy to use SkeletalMesh data
TArray<FSoftSkinVertex> Vertices;
FMultiSizeIndexContainerData IndexData;
LODModel.GetVertices(Vertices);
LODModel.MultiSizeIndexContainer.GetIndexBufferData(IndexData);
int32 NumCorners = IndexData.Indices.Num();
// Generate FRawMesh from FStaticLODModel
FRawMesh TempMesh;
TempMesh.WedgeIndices.AddUninitialized(NumCorners);
TempMesh.WedgeTexCoords[0].AddUninitialized(NumCorners);
TempMesh.VertexPositions.AddUninitialized(NumCorners);
// Prepare vertex to wedge map
// PrevCorner[i] points to previous corner which shares the same wedge
TArray<int32> LastWedgeCorner;
LastWedgeCorner.AddUninitialized(Vertices.Num());
TArray<int32> PrevCorner;
PrevCorner.AddUninitialized(NumCorners);
for (int32 Index = 0; Index < Vertices.Num(); Index++)
{
LastWedgeCorner[Index] = -1;
}
for (int32 Index = 0; Index < NumCorners; Index++)
{
// Copy static vertex data
int32 VertexIndex = IndexData.Indices[Index];
FSoftSkinVertex& Vertex = Vertices[VertexIndex];
TempMesh.WedgeIndices[Index] = Index; // rudimental data, not really used by FLayoutUV - but array size matters
TempMesh.WedgeTexCoords[0][Index] = Vertex.UVs[0];
TempMesh.VertexPositions[Index] = Vertex.Position;
// Link all corners belonging to a single wedge into list
int32 PrevCornerIndex = LastWedgeCorner[VertexIndex];
LastWedgeCorner[VertexIndex] = Index;
PrevCorner[Index] = PrevCornerIndex;
}
// return GenerateUniqueUVsForStaticMesh(TempMesh, TextureResolution, OutTexCoords);
// Build overlapping corners map
TMultiMap<int32, int32> OverlappingCorners;
for (int32 Index = 0; Index < NumCorners; Index++)
{
int VertexIndex = IndexData.Indices[Index];
for (int32 CornerIndex = LastWedgeCorner[VertexIndex]; CornerIndex >= 0; CornerIndex = PrevCorner[CornerIndex])
{
if (CornerIndex != Index)
{
OverlappingCorners.Add(Index, CornerIndex);
}
}
}
// Generate new UVs
FLayoutUV Packer(&TempMesh, 0, 1, FMath::Clamp(TextureResolution / 4, 32, 512));
Packer.FindCharts(OverlappingCorners);
bool bPackSuccess = Packer.FindBestPacking();
if (bPackSuccess)
{
Packer.CommitPackedUVs();
// Save generated UVs
OutTexCoords = TempMesh.WedgeTexCoords[1];
}
return bPackSuccess;
}
void FMeshUtilities::CalculateTangents(const TArray<FVector>& InVertices, const TArray<uint32>& InIndices, const TArray<FVector2D>& InUVs, const TArray<uint32>& InSmoothingGroupIndices, const uint32 InTangentOptions, TArray<FVector>& OutTangentX, TArray<FVector>& OutTangentY, TArray<FVector>& OutNormals) const
{
const float ComparisonThreshold = (InTangentOptions & ETangentOptions::IgnoreDegenerateTriangles ) ? THRESH_POINTS_ARE_SAME : 0.0f;
TMultiMap<int32, int32> OverlappingCorners;
FindOverlappingCorners(OverlappingCorners, InVertices, InIndices, ComparisonThreshold);
ComputeTangents(InVertices, InIndices, InUVs, InSmoothingGroupIndices, OverlappingCorners, OutTangentX, OutTangentY, OutNormals, InTangentOptions);
}
void FMeshUtilities::AddAnimationBlueprintEditorToolbarExtender()
{
IAnimationBlueprintEditorModule& AnimationBlueprintEditorModule = FModuleManager::Get().LoadModuleChecked<IAnimationBlueprintEditorModule>("AnimationBlueprintEditor");
auto& ToolbarExtenders = AnimationBlueprintEditorModule.GetAllAnimationBlueprintEditorToolbarExtenders();
ToolbarExtenders.Add(IAnimationBlueprintEditorModule::FAnimationBlueprintEditorToolbarExtender::CreateRaw(this, &FMeshUtilities::GetAnimationBlueprintEditorToolbarExtender));
AnimationBlueprintEditorExtenderHandle = ToolbarExtenders.Last().GetHandle();
}
void FMeshUtilities::RemoveAnimationBlueprintEditorToolbarExtender()
{
IAnimationBlueprintEditorModule* AnimationBlueprintEditorModule = FModuleManager::Get().GetModulePtr<IAnimationBlueprintEditorModule>("AnimationBlueprintEditor");
if (AnimationBlueprintEditorModule)
{
typedef IAnimationBlueprintEditorModule::FAnimationBlueprintEditorToolbarExtender DelegateType;
AnimationBlueprintEditorModule->GetAllAnimationBlueprintEditorToolbarExtenders().RemoveAll([=](const DelegateType& In) { return In.GetHandle() == AnimationBlueprintEditorExtenderHandle; });
}
}
TSharedRef<FExtender> FMeshUtilities::GetAnimationBlueprintEditorToolbarExtender(const TSharedRef<FUICommandList> CommandList, TSharedRef<IAnimationBlueprintEditor> InAnimationBlueprintEditor)
{
TSharedRef<FExtender> Extender = MakeShareable(new FExtender);
UMeshComponent* MeshComponent = Cast<UMeshComponent>(InAnimationBlueprintEditor->GetPersonaToolkit()->GetPreviewMeshComponent());
Extender->AddToolBarExtension(
"Asset",
EExtensionHook::After,
CommandList,
FToolBarExtensionDelegate::CreateRaw(this, &FMeshUtilities::HandleAddConvertComponentToStaticMeshToToolbar, MeshComponent)
);
return Extender;
}
void FMeshUtilities::AddAnimationEditorToolbarExtender()
{
IAnimationEditorModule& AnimationEditorModule = FModuleManager::Get().LoadModuleChecked<IAnimationEditorModule>("AnimationEditor");
auto& ToolbarExtenders = AnimationEditorModule.GetAllAnimationEditorToolbarExtenders();
ToolbarExtenders.Add(IAnimationEditorModule::FAnimationEditorToolbarExtender::CreateRaw(this, &FMeshUtilities::GetAnimationEditorToolbarExtender));
AnimationEditorExtenderHandle = ToolbarExtenders.Last().GetHandle();
}
void FMeshUtilities::RemoveAnimationEditorToolbarExtender()
{
IAnimationEditorModule* AnimationEditorModule = FModuleManager::Get().GetModulePtr<IAnimationEditorModule>("AnimationEditor");
if (AnimationEditorModule)
{
typedef IAnimationEditorModule::FAnimationEditorToolbarExtender DelegateType;
AnimationEditorModule->GetAllAnimationEditorToolbarExtenders().RemoveAll([=](const DelegateType& In) { return In.GetHandle() == AnimationEditorExtenderHandle; });
}
}
TSharedRef<FExtender> FMeshUtilities::GetAnimationEditorToolbarExtender(const TSharedRef<FUICommandList> CommandList, TSharedRef<IAnimationEditor> InAnimationEditor)
{
TSharedRef<FExtender> Extender = MakeShareable(new FExtender);
UMeshComponent* MeshComponent = Cast<UMeshComponent>(InAnimationEditor->GetPersonaToolkit()->GetPreviewMeshComponent());
Extender->AddToolBarExtension(
"Asset",
EExtensionHook::After,
CommandList,
FToolBarExtensionDelegate::CreateRaw(this, &FMeshUtilities::HandleAddConvertComponentToStaticMeshToToolbar, MeshComponent)
);
return Extender;
}
void FMeshUtilities::AddSkeletalMeshEditorToolbarExtender()
{
ISkeletalMeshEditorModule& SkeletalMeshEditorModule = FModuleManager::Get().LoadModuleChecked<ISkeletalMeshEditorModule>("SkeletalMeshEditor");
auto& ToolbarExtenders = SkeletalMeshEditorModule.GetAllSkeletalMeshEditorToolbarExtenders();
ToolbarExtenders.Add(ISkeletalMeshEditorModule::FSkeletalMeshEditorToolbarExtender::CreateRaw(this, &FMeshUtilities::GetSkeletalMeshEditorToolbarExtender));
SkeletalMeshEditorExtenderHandle = ToolbarExtenders.Last().GetHandle();
}
void FMeshUtilities::RemoveSkeletalMeshEditorToolbarExtender()
{
ISkeletalMeshEditorModule* SkeletalMeshEditorModule = FModuleManager::Get().GetModulePtr<ISkeletalMeshEditorModule>("SkeletalMeshEditor");
if (SkeletalMeshEditorModule)
{
typedef ISkeletalMeshEditorModule::FSkeletalMeshEditorToolbarExtender DelegateType;
SkeletalMeshEditorModule->GetAllSkeletalMeshEditorToolbarExtenders().RemoveAll([=](const DelegateType& In) { return In.GetHandle() == SkeletalMeshEditorExtenderHandle; });
}
}
TSharedRef<FExtender> FMeshUtilities::GetSkeletalMeshEditorToolbarExtender(const TSharedRef<FUICommandList> CommandList, TSharedRef<ISkeletalMeshEditor> InSkeletalMeshEditor)
{
TSharedRef<FExtender> Extender = MakeShareable(new FExtender);
UMeshComponent* MeshComponent = Cast<UMeshComponent>(InSkeletalMeshEditor->GetPersonaToolkit()->GetPreviewMeshComponent());
Extender->AddToolBarExtension(
"Asset",
EExtensionHook::After,
CommandList,
FToolBarExtensionDelegate::CreateRaw(this, &FMeshUtilities::HandleAddConvertComponentToStaticMeshToToolbar, MeshComponent)
);
return Extender;
}
void FMeshUtilities::AddSkeletonEditorToolbarExtender()
{
ISkeletonEditorModule& SkeletonEditorModule = FModuleManager::Get().LoadModuleChecked<ISkeletonEditorModule>("SkeletonEditor");
auto& ToolbarExtenders = SkeletonEditorModule.GetAllSkeletonEditorToolbarExtenders();
ToolbarExtenders.Add(ISkeletonEditorModule::FSkeletonEditorToolbarExtender::CreateRaw(this, &FMeshUtilities::GetSkeletonEditorToolbarExtender));
SkeletonEditorExtenderHandle = ToolbarExtenders.Last().GetHandle();
}
void FMeshUtilities::RemoveSkeletonEditorToolbarExtender()
{
ISkeletonEditorModule* SkeletonEditorModule = FModuleManager::Get().GetModulePtr<ISkeletonEditorModule>("SkeletonEditor");
if (SkeletonEditorModule)
{
typedef ISkeletonEditorModule::FSkeletonEditorToolbarExtender DelegateType;
SkeletonEditorModule->GetAllSkeletonEditorToolbarExtenders().RemoveAll([=](const DelegateType& In) { return In.GetHandle() == SkeletonEditorExtenderHandle; });
}
}
TSharedRef<FExtender> FMeshUtilities::GetSkeletonEditorToolbarExtender(const TSharedRef<FUICommandList> CommandList, TSharedRef<ISkeletonEditor> InSkeletonEditor)
{
TSharedRef<FExtender> Extender = MakeShareable(new FExtender);
UMeshComponent* MeshComponent = Cast<UMeshComponent>(InSkeletonEditor->GetPersonaToolkit()->GetPreviewMeshComponent());
Extender->AddToolBarExtension(
"Asset",
EExtensionHook::After,
CommandList,
FToolBarExtensionDelegate::CreateRaw(this, &FMeshUtilities::HandleAddConvertComponentToStaticMeshToToolbar, MeshComponent)
);
return Extender;
}
void FMeshUtilities::HandleAddConvertComponentToStaticMeshToToolbar(FToolBarBuilder& ParentToolbarBuilder, UMeshComponent* InMeshComponent)
{
ParentToolbarBuilder.AddToolBarButton(
FUIAction(FExecuteAction::CreateLambda([this, InMeshComponent]()
{
ConvertMeshesToStaticMesh(TArray<UMeshComponent*>({ InMeshComponent }), InMeshComponent->GetComponentToWorld());
})),
NAME_None,
LOCTEXT("MakeStaticMesh", "Make Static Mesh"),
LOCTEXT("MakeStaticMeshTooltip", "Make a new static mesh out of the preview's current pose."),
FSlateIcon("EditorStyle", "Persona.ConvertToStaticMesh")
);
}
void FMeshUtilities::AddLevelViewportMenuExtender()
{
FLevelEditorModule& LevelEditorModule = FModuleManager::Get().LoadModuleChecked<FLevelEditorModule>("LevelEditor");
auto& MenuExtenders = LevelEditorModule.GetAllLevelViewportContextMenuExtenders();
MenuExtenders.Add(FLevelEditorModule::FLevelViewportMenuExtender_SelectedActors::CreateRaw(this, &FMeshUtilities::GetLevelViewportContextMenuExtender));
LevelViewportExtenderHandle = MenuExtenders.Last().GetHandle();
}
void FMeshUtilities::RemoveLevelViewportMenuExtender()
{
if (LevelViewportExtenderHandle.IsValid())
{
FLevelEditorModule* LevelEditorModule = FModuleManager::Get().GetModulePtr<FLevelEditorModule>("LevelEditor");
if (LevelEditorModule)
{
typedef FLevelEditorModule::FLevelViewportMenuExtender_SelectedActors DelegateType;
LevelEditorModule->GetAllLevelViewportContextMenuExtenders().RemoveAll([=](const DelegateType& In) { return In.GetHandle() == LevelViewportExtenderHandle; });
}
}
}
TSharedRef<FExtender> FMeshUtilities::GetLevelViewportContextMenuExtender(const TSharedRef<FUICommandList> CommandList, const TArray<AActor*> InActors)
{
TSharedRef<FExtender> Extender = MakeShareable(new FExtender);
if (InActors.Num() > 0)
{
bool bHasComponent = false;
for (AActor* Actor : InActors)
{
TInlineComponentArray<UMeshComponent*> Components(Actor);
if (Components.Num() > 0)
{
bHasComponent = true;
break;
}
}
if (bHasComponent)
{
FText ActorName = InActors.Num() == 1 ? FText::Format(LOCTEXT("ActorNameSingular", "\"{0}\""), FText::FromString(InActors[0]->GetActorLabel())) : LOCTEXT("ActorNamePlural", "Actors");
FLevelEditorModule& LevelEditor = FModuleManager::GetModuleChecked<FLevelEditorModule>(TEXT("LevelEditor"));
TSharedRef<FUICommandList> LevelEditorCommandBindings = LevelEditor.GetGlobalLevelEditorActions();
Extender->AddMenuExtension("ActorControl", EExtensionHook::After, LevelEditorCommandBindings, FMenuExtensionDelegate::CreateLambda(
[this, ActorName, InActors](FMenuBuilder& MenuBuilder) {
MenuBuilder.AddMenuEntry(
FText::Format(LOCTEXT("ConvertSelectedActorsToStaticMeshText", "Convert {0} To Static Mesh"), ActorName),
LOCTEXT("ConvertSelectedActorsToStaticMeshTooltip", "Convert the selected actor's meshes to a new Static Mesh asset. Supports static and skeletal meshes."),
FSlateIcon(),
FUIAction(FExecuteAction::CreateRaw(this, &FMeshUtilities::ConvertActorMeshesToStaticMesh, InActors))
);
})
);
}
}
return Extender;
}
void FMeshUtilities::ConvertActorMeshesToStaticMesh(const TArray<AActor*> InActors)
{
TArray<UMeshComponent*> MeshComponents;
for (AActor* Actor : InActors)
{
// add all components from this actor
TInlineComponentArray<UMeshComponent*> ActorComponents(Actor);
for (UMeshComponent* ActorComponent : ActorComponents)
{
MeshComponents.AddUnique(ActorComponent);
}
// add all attached actors
TArray<AActor*> AttachedActors;
Actor->GetAttachedActors(AttachedActors);
for (AActor* AttachedActor : AttachedActors)
{
TInlineComponentArray<UMeshComponent*> AttachedActorComponents(AttachedActor);
for (UMeshComponent* AttachedActorComponent : AttachedActorComponents)
{
MeshComponents.AddUnique(AttachedActorComponent);
}
}
}
auto GetActorRootTransform = [](AActor* InActor)
{
FTransform RootTransform(FTransform::Identity);
if (ACharacter* Character = Cast<ACharacter>(InActor))
{
RootTransform = Character->GetTransform();
RootTransform.SetLocation(RootTransform.GetLocation() - FVector(0.0f, 0.0f, Character->GetCapsuleComponent()->GetScaledCapsuleHalfHeight()));
}
else
{
// otherwise just use the actor's origin
RootTransform = InActor->GetTransform();
}
return RootTransform;
};
// now pick a root transform
FTransform RootTransform(FTransform::Identity);
if (InActors.Num() == 1)
{
RootTransform = GetActorRootTransform(InActors[0]);
}
else
{
// multiple actors use the average of their origins, with Z being the min of all origins. Rotation is identity for simplicity
FVector Location(FVector::ZeroVector);
float MinZ = FLT_MAX;
for (AActor* Actor : InActors)
{
FTransform ActorTransform(GetActorRootTransform(Actor));
Location += ActorTransform.GetLocation();
MinZ = FMath::Min(ActorTransform.GetLocation().Z, MinZ);
}
Location /= (float)InActors.Num();
Location.Z = MinZ;
RootTransform.SetLocation(Location);
}
ConvertMeshesToStaticMesh(MeshComponents, RootTransform);
}
#undef LOCTEXT_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink