/**
	 * Allows adjusting the desired streaming distance of streaming textures that uses UV 0.
	 * 1.0 is the default, whereas a higher value makes the textures stream in sooner from far away.
	 * A lower value (0.0-1.0) makes the textures stream in later (you have to be closer).
	 * Value can be < 0 (from legcay content, or code changes)
	 */
	UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=TextureStreaming, meta=(ClampMin = 0, ToolTip="Allows adjusting the desired resolution of streaming textures that uses UV 0.  1.0 is the default, whereas a higher value increases the streamed-in resolution."))
	float StreamingDistanceMultiplier;

	/** Used to forcefully disable pixel programmable rasterization of Nanite when the mesh is further than a given distance from the camera. */
	UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Rendering)
	float NanitePixelProgrammableDistance;

#if WITH_EDITORONLY_DATA
	UPROPERTY()
	TArray<FGuid> IrrelevantLights_DEPRECATED;
#endif

	/** Static mesh LOD data.  Contains static lighting data along with instanced mesh vertex colors. */
	UPROPERTY(transient)
	TArray<struct FStaticMeshComponentLODInfo> LODData;

	/** The list of texture, bounds and scales. As computed in the texture streaming build process. */
	UPROPERTY(NonTransactional)
	TArray<FStreamingTextureBuildInfo> StreamingTextureData;

#if WITH_EDITORONLY_DATA
	/** Derived data key of the static mesh, used to determine if an update from the source static mesh is required. */
	UPROPERTY()
	FString StaticMeshDerivedDataKey;

	/** Material Bounds used for texture streaming. */
	UPROPERTY(NonTransactional)
	TArray<uint32> MaterialStreamingRelativeBoxes;
#endif

	/** The Lightmass settings for this object. */
	UPROPERTY(EditAnywhere, Category=Lighting)
	struct FLightmassPrimitiveSettings LightmassSettings;

	ENGINE_API virtual ~UStaticMeshComponent();

	/** Change the StaticMesh used by this instance. */
	UFUNCTION(BlueprintCallable, Category="Components|StaticMesh")
	ENGINE_API virtual bool SetStaticMesh(class UStaticMesh* NewMesh);

	/** Get the StaticMesh used by this instance. */
	TObjectPtr<UStaticMesh> GetStaticMesh() const 
	{ 
#if WITH_EDITOR
		// This should never happen and is a last resort, we should have caught the property overwrite well before we reach this code
		if (KnownStaticMesh != StaticMesh)
		{
			OutdatedKnownStaticMeshDetected();
		}
#endif
		return StaticMesh; 
	}

	ENGINE_API virtual const Nanite::FResources* GetNaniteResources() const;

	/**
	 * Returns true if the component has valid Nanite render data.
	 */
	ENGINE_API virtual bool HasValidNaniteData() const;

	/** Determines if we use the nanite overrides from any materials */
	ENGINE_API virtual bool UseNaniteOverrideMaterials() const override;

	UFUNCTION(BlueprintCallable, Category="Rendering|LOD")
	ENGINE_API void SetForcedLodModel(int32 NewForcedLodModel);

	/** Sets the component's DistanceFieldSelfShadowBias.  bOverrideDistanceFieldSelfShadowBias must be enabled for this to have an effect. */
	UFUNCTION(BlueprintCallable, Category="Rendering|Lighting")
	ENGINE_API void SetDistanceFieldSelfShadowBias(float NewValue);

	UFUNCTION(BlueprintCallable, Category=RayTracing)
	ENGINE_API void SetEvaluateWorldPositionOffsetInRayTracing(bool NewValue);

	UFUNCTION(BlueprintCallable, Category = "Rendering|LOD")
	ENGINE_API void SetEvaluateWorldPositionOffset(bool NewValue);

	UFUNCTION(BlueprintCallable, Category = "Rendering|LOD")
	ENGINE_API void SetWorldPositionOffsetDisableDistance(int32 NewValue);

	/** Get the initial value of bEvaluateWorldPositionOffset. This is the value when BeginPlay() was last called, or if UpdateInitialEvaluateWorldPositionOffset is called. */
	UFUNCTION(BlueprintCallable, Category = "Rendering|LOD")
	bool GetInitialEvaluateWorldPositionOffset() { return bInitialEvaluateWorldPositionOffset; }

	/** This manually updates the initial value of bEvaluateWorldPositionOffset to be the current value.
	 *	This is useful if the default value of bEvaluateWorldPositionOffset is changed after constructing
	 *	the component. */
	UFUNCTION(BlueprintCallable, Category = "Rendering|LOD")
	void UpdateInitialEvaluateWorldPositionOffset() { bInitialEvaluateWorldPositionOffset = bEvaluateWorldPositionOffset; }

	/** 
	 * Get Local bounds
	 */
	UFUNCTION(BlueprintCallable, Category="Components|StaticMesh")
	ENGINE_API void GetLocalBounds(FVector& Min, FVector& Max) const;

	/** 
	 * Set forced reverse culling
	 */
	UFUNCTION(BlueprintCallable, Category="Rendering|Lighting")
	ENGINE_API void SetReverseCulling(bool ReverseCulling);

	/** Force disabling of Nanite rendering. When true, Will swap to the the fallback mesh instead. */
	UFUNCTION(BlueprintCallable, Category="Rendering")
	ENGINE_API void SetForceDisableNanite(bool bInForceDisableNanite);

	ENGINE_API virtual void SetCollisionProfileName(FName InCollisionProfileName, bool bUpdateOverlaps=true) override;

public:

	//~ Begin UObject Interface.
	ENGINE_API virtual void BeginDestroy() override;
	ENGINE_API virtual void ExportCustomProperties(FOutputDevice& Out, uint32 Indent) override;
	ENGINE_API virtual void ImportCustomProperties(const TCHAR* SourceText, FFeedbackContext* Warn) override;	
	ENGINE_API virtual void Serialize(FArchive& Ar) override;
	ENGINE_API virtual void PostInitProperties() override;
	ENGINE_API virtual void PostReinitProperties() override;
	ENGINE_API virtual void PostApplyToComponent() override;
#if WITH_EDITOR
	ENGINE_API virtual void PostEditUndo() override;
	ENGINE_API virtual void PreEditUndo() override;
	ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
	ENGINE_API virtual bool CanEditChange(const FProperty* InProperty) const override;
	ENGINE_API virtual void BeginCacheForCookedPlatformData(const ITargetPlatform* TargetPlatform) override;
	ENGINE_API virtual bool IsCachedCookedPlatformDataLoaded(const ITargetPlatform* TargetPlatform) override;
	ENGINE_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
	ENGINE_API virtual void PostEditImport() override;
	ENGINE_API virtual void InitializeComponent() override;
	ENGINE_API virtual void UpdateBounds() override;
#endif // WITH_EDITOR
#if WITH_EDITORONLY_DATA
	PRAGMA_DISABLE_DEPRECATION_WARNINGS // Suppress compiler warning on override of deprecated function
	UE_DEPRECATED(5.0, "Use version that takes FObjectPreSaveContext instead.")
	ENGINE_API virtual void PreSave(const class ITargetPlatform* TargetPlatform) override;
	ENGINE_API PRAGMA_ENABLE_DEPRECATION_WARNINGS
	virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
#endif // WITH_EDITORONLY_DATA
	ENGINE_API virtual void PostLoad() override;
	ENGINE_API virtual bool IsPostLoadThreadSafe() const override;
	ENGINE_API virtual bool AreNativePropertiesIdenticalTo( UObject* Other ) const override;
	ENGINE_API virtual FString GetDetailedInfoInternal() const override;
	static ENGINE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
	//~ End UObject Interface.

	//~ Begin USceneComponent Interface
#if WITH_EDITOR
	ENGINE_API virtual bool GetMaterialPropertyPath(int32 ElementIndex, UObject*& OutOwner, FString& OutPropertyPath, FProperty*& OutProperty) override;
#endif // WITH_EDITOR
	ENGINE_API virtual FBoxSphereBounds CalcBounds(const FTransform& LocalToWorld) const override;
	ENGINE_API virtual bool HasAnySockets() const override;
	ENGINE_API virtual void QuerySupportedSockets(TArray<FComponentSocketDescription>& OutSockets) const override;
	ENGINE_API virtual FTransform GetSocketTransform(FName InSocketName, ERelativeTransformSpace TransformSpace = RTS_World) const override;
	ENGINE_API virtual bool DoesSocketExist(FName InSocketName) const override;
	virtual bool ShouldCollideWhenPlacing() const override
	{
		// Current Method of collision does not work with non-capsule shapes, enable when it works with static meshes
		// return IsCollisionEnabled() && (StaticMesh != NULL);
		return false;
	}
#if WITH_EDITOR
	ENGINE_API virtual bool ShouldRenderSelected() const override;
#endif
	//~ End USceneComponent Interface

	UE_DECLARE_COMPONENT_ACTOR_INTERFACE(StaticMeshComponent)	

	//~ Begin UActorComponent Interface.
protected: 
	ENGINE_API virtual void OnRegister() override;
	ENGINE_API virtual void OnUnregister() override;
	ENGINE_API virtual void BeginPlay() override;
	ENGINE_API virtual bool RequiresGameThreadEndOfFrameRecreate() const override;
	ENGINE_API virtual void CreateRenderState_Concurrent(FRegisterComponentContext* Context) override;
	ENGINE_API virtual void OnCreatePhysicsState() override;
	ENGINE_API virtual void OnDestroyPhysicsState() override;
	ENGINE_API virtual bool ShouldCreatePhysicsState() const override;
	ENGINE_API virtual bool ShouldCreateRenderState() const override;
public:
	ENGINE_API virtual void InvalidateLightingCacheDetailed(bool bInvalidateBuildEnqueuedLighting, bool bTranslationOnly) override;
	ENGINE_API virtual UObject const* AdditionalStatObject() const override;
#if WITH_EDITOR
	ENGINE_API virtual void CheckForErrors() override;
	ENGINE_API virtual bool IsCompiling() const override;
#endif
	ENGINE_API virtual TStructOnScope<FActorComponentInstanceData> GetComponentInstanceData() const override;
	ENGINE_API virtual bool IsHLODRelevant() const override;
	//~ End UActorComponent Interface.

	//~ Begin UPrimitiveComponent Interface.
	ENGINE_API virtual int32 GetNumMaterials() const override;
#if WITH_EDITOR
	ENGINE_API virtual void GetStaticLightingInfo(FStaticLightingPrimitiveInfo& OutPrimitiveInfo,const TArray<ULightComponent*>& InRelevantLights,const FLightingBuildOptions& Options) override;
	ENGINE_API virtual void AddMapBuildDataGUIDs(TSet<FGuid>& InGUIDs) const override;
#endif
	ENGINE_API virtual float GetEmissiveBoost(int32 ElementIndex) const override;
	ENGINE_API virtual float GetDiffuseBoost(int32 ElementIndex) const override;
	virtual bool GetShadowIndirectOnly() const override
	{
		return LightmassSettings.bShadowIndirectOnly;
	}
	ENGINE_API virtual ELightMapInteractionType GetStaticLightingType() const override;
	ENGINE_API virtual bool IsPrecomputedLightingValid() const override;

	/** Get the scale comming form the component, when computing StreamingTexture data. Used to support instanced meshes. */
	ENGINE_API virtual float GetTextureStreamingTransformScale() const;
	/** Get material, UV density and bounds for a given material index. */
	ENGINE_API virtual bool GetMaterialStreamingData(int32 MaterialIndex, FPrimitiveMaterialInfo& MaterialData) const override;
	/** Build the data to compute accuracte StreaminTexture data. */
	ENGINE_API virtual bool BuildTextureStreamingDataImpl(ETextureStreamingBuildType BuildType, EMaterialQualityLevel::Type QualityLevel, ERHIFeatureLevel::Type FeatureLevel, TSet<FGuid>& DependentResources, bool& bOutSupportsBuildTextureStreamingData) override;
	/** Get the StreaminTexture data. */
	ENGINE_API virtual void GetStreamingRenderAssetInfo(FStreamingTextureLevelContext& LevelContext, TArray<FStreamingRenderAssetPrimitiveInfo>& OutStreamingRenderAssets) const override;
	ENGINE_API virtual void GetUsedTextures(TArray<UTexture*>& OutTextures, EMaterialQualityLevel::Type QualityLevel) override;
#if WITH_EDITOR
	ENGINE_API virtual bool RemapActorTextureStreamingBuiltDataToLevel(const class UActorTextureStreamingBuildDataComponent* InActorTextureBuildData) override;
	ENGINE_API virtual uint32 ComputeHashTextureStreamingBuiltData() const override;
#endif 

	ENGINE_API virtual class UBodySetup* GetBodySetup() override;
	ENGINE_API virtual bool CanEditSimulatePhysics() override;
	ENGINE_API virtual FPrimitiveSceneProxy* CreateSceneProxy() override;
	ENGINE_API virtual bool ShouldRecreateProxyOnUpdateTransform() const override;
	ENGINE_API virtual bool UsesOnlyUnlitMaterials() const override;
	ENGINE_API virtual bool GetLightMapResolution( int32& Width, int32& Height ) const override;
	ENGINE_API virtual int32 GetStaticLightMapResolution() const override;
	/** Returns true if the component is static AND has the right static mesh setup to support lightmaps. */
	ENGINE_API virtual bool HasValidSettingsForStaticLighting(bool bOverlookInvalidComponents) const override;

	ENGINE_API virtual void GetLightAndShadowMapMemoryUsage( int32& LightMapMemoryUsage, int32& ShadowMapMemoryUsage ) const override;
	ENGINE_API virtual void GetUsedMaterials(TArray<UMaterialInterface*>& OutMaterials, bool bGetDebugMaterials = false) const final;
	ENGINE_API virtual UMaterialInterface* GetMaterial(int32 MaterialIndex) const final;
#if WITH_EDITOR
	ENGINE_API virtual UMaterialInterface* GetEditorMaterial(int32 MaterialIndex) const override;
#endif
	ENGINE_API virtual int32 GetMaterialIndex(FName MaterialSlotName) const override;
	ENGINE_API virtual UMaterialInterface* GetMaterialFromCollisionFaceIndex(int32 FaceIndex, int32& SectionIndex) const override;
	ENGINE_API virtual TArray<FName> GetMaterialSlotNames() const override;
	ENGINE_API virtual bool IsMaterialSlotNameValid(FName MaterialSlotName) const override;

	ENGINE_API virtual bool DoCustomNavigableGeometryExport(FNavigableGeometryExport& GeomExport) const override;

	ENGINE_API virtual bool IsShown(const FEngineShowFlags& ShowFlags) const override;
#if WITH_EDITOR
	ENGINE_API void OnMeshRebuild(bool bRenderDataChanged);
	ENGINE_API virtual void PreStaticMeshCompilation();
	ENGINE_API virtual void PostStaticMeshCompilation();
	ENGINE_API virtual bool ComponentIsTouchingSelectionBox(const FBox& InSelBBox, const bool bConsiderOnlyBSP, const bool bMustEncompassEntireComponent) const override;
	ENGINE_API virtual bool ComponentIsTouchingSelectionFrustum(const FConvexVolume& InSelBBox, const bool bConsiderOnlyBSP, const bool bMustEncompassEntireComponent) const override;
#endif
	virtual float GetStreamingScale() const override { return GetComponentTransform().GetMaximumAxisScale(); }
	virtual bool SupportsWorldPositionOffsetVelocity() const override { return bWorldPositionOffsetWritesVelocity; }
	ENGINE_API virtual void GetPrimitiveStats(FPrimitiveStats& PrimitiveStats) const override;	
#if WITH_EDITOR
	ENGINE_API virtual HHitProxy* CreateMeshHitProxy(int32 SectionIndex, int32 MaterialIndex) const override;	
#endif
//~ End UPrimitiveComponent Interface.

	//~ Begin UMeshComponent Interface
	ENGINE_API virtual void RegisterLODStreamingCallback(FLODStreamingCallback&& Callback, int32 LODIdx, float TimeoutSecs, bool bOnStreamIn) override;
	ENGINE_API virtual void RegisterLODStreamingCallback(FLODStreamingCallback&& CallbackStreamingStart, FLODStreamingCallback&& CallbackStreamingDone, float TimeoutStartSecs, float TimeoutDoneSecs) override;
	ENGINE_API virtual bool PrestreamMeshLODs(float Seconds) override;
	ENGINE_API virtual UTexture* GetMeshPaintTexture() const override;
	ENGINE_API virtual void SetMeshPaintTexture(UTexture* Texture) override;
	ENGINE_API virtual void SetMeshPaintTextureOverride(UTexture* OverrideTexture) override;
	ENGINE_API virtual int32 GetMeshPaintTextureCoordinateIndex() const override;
	//~ End UMeshComponent Interface

	//~ Begin INavRelevantInterface Interface.
	ENGINE_API virtual bool IsNavigationRelevant() const override;
	ENGINE_API virtual FBox GetNavigationBounds() const override;
	ENGINE_API virtual void GetNavigationData(FNavigationRelevantData& Data) const override;
	//~ End INavRelevantInterface Interface.
	/**
	 *	Returns true if the component uses texture lightmaps
	 *
	 *	@param	InWidth		[in]	The width of the light/shadow map
	 *	@param	InHeight	[in]	The width of the light/shadow map
	 *
	 *	@return	bool				true if texture lightmaps are used, false if not
	 */
	ENGINE_API virtual bool UsesTextureLightmaps(int32 InWidth, int32 InHeight) const;

	/**
	 *	Returns true if the static mesh the component uses has valid lightmap texture coordinates
	 */
	ENGINE_API virtual bool HasLightmapTextureCoordinates() const;
переведи комментарии на русский язык