You've already forked UnrealEngineUWP
mirror of
https://github.com/izzy2lost/UnrealEngineUWP.git
synced 2026-03-26 18:15:20 -07:00
924baec97b
#lockdown Nick.Penwarden
==========================
MAJOR FEATURES + CHANGES
==========================
Change 3280282 on 2017/01/31 by Matt.Kuhlenschmidt
GitHub 3171 : fix 'memoreport -full' causes ensure condition fail on particle object
Change 3281111 on 2017/02/01 by Michael.Dupuis
#jira UE-36318 : was'nt notifying that we changed the current level in the case where you add/create new level in the Level window
Change 3281225 on 2017/02/01 by Jamie.Dale
Several improvements to culture switching and LocRes files
- LocRes files now de-duplicate translations when they're generated, which can result in smaller LocRes files.
- The localization compilation step now produces a LocNat file, which contains meta-data specifying the native culture during compile, and where the native LocRes file can be found.
- Changing cultures now loads the native localization data prior to loading the non-native translations to ensure that translations are always applied to a consistent base.
- The "leet" culture (available when localization testing is enabled) is now always applied against the native translation, and correctly restores non-translated text when switching away from the "leet" culture.
- "-culture=leet" now works correctly on the command line ("-leet" also works).
- LoadLocalizationResourcesForCulture is no longer called multiple times during initialization of the text localization manager.
- General clean-up of localization code to favor using LocKeyFuncs with maps and sets, rather than rolling their own key funcs.
Change 3281291 on 2017/02/01 by Alexis.Matte
Make sure the sections material slot assignation is persist correctly for staticmesh and for skeletal mesh
#jira UE-39639
Change 3281718 on 2017/02/01 by Michael.Dupuis
#jira UE-34186: invert processing order of special character, to take into account that key name could be considered a special character and would cause the assumption done to no longer be valid
Change 3281861 on 2017/02/01 by Alexis.Matte
Fix import of morph target when there is no animation
#jira UE-41383
Change 3282791 on 2017/02/02 by Chris.Wood
Split crash analytics methods to fix comment parsing issues.
[UE-32787] - Document Crash Report Client analytics events in code
Change 3283316 on 2017/02/02 by Alexis.Matte
Make sure we do not import more then the maximum allowed node
#jira UE-41405
Change 3283349 on 2017/02/02 by Jamie.Dale
Updated Portal to stage its .locnat files
Change 3283927 on 2017/02/02 by Matt.Kuhlenschmidt
Fix component/actor selection becoming out of sync after undo/redo
#jira UE-41416
Change 3284061 on 2017/02/02 by Alexis.Matte
Fix the scene importer front x axis import
#jira UE-41318
Change 3284280 on 2017/02/02 by Alex.Delesky
#jira UE-41060 - Placing blocking volumes in the level via the Content Menu's "Place Actor" command will now place a blocking volume in the level and not generate an empty warning in the output log
Change 3285053 on 2017/02/03 by Michael.Dupuis
#jira UE-33777: Handle the global landscape editor ui command list so specified shortcut will be treated
Change 3285444 on 2017/02/03 by Jamie.Dale
Updated FastDecimalFormat to support the correct 0-9 numerals for the current locale
These are typically still Latin, but Middle Eastern languages have some variants.
This addresses an inconsistency between FText formatting of numbers and dates (since numbers always used Latin, but dates used the culture correct numerals).
Change 3287422 on 2017/02/06 by Michael.Dupuis
#jira UE-36580: Improved the whole word algo to take into consideration localisation
Change 3287455 on 2017/02/06 by Alexis.Matte
When swaping the mesh point by the mesh component, we noe clean up the override material instead of empty it.
#jira UE-41397
Change 3287745 on 2017/02/06 by Alexis.Matte
Merge from orion dev-general cl:3286668
Fix a crash when importing a LOD containing different material with less sections
Change 3287996 on 2017/02/06 by Michael.Dupuis
#jira UE-37290: fixed naming to be "move to level" instead of "move level"
Change 3288090 on 2017/02/06 by Jamie.Dale
Fixing missing include breaking the FText natvis
Change 3288105 on 2017/02/06 by Jamie.Dale
FTextStringHelper::ReadFromString_ComplexText now only looks at the start of the buffer when matching the complex text macros
Change 3288150 on 2017/02/06 by Jamie.Dale
Fixing display names for tutorial categories so that they can be localized
They were already FText, but the config wasn't defining them in a localizable way.
#jira UE-37926
Change 3288469 on 2017/02/06 by Alex.Delesky
#jira UE-35464 - Enables the editor to parse SubRip Subtitles files to create subtitle assets.
This also introduces the Subtitles module.
Change 3288540 on 2017/02/06 by Alex.Delesky
Backing out changelist 3288469 due to build issue with module includes
#jira none
Change 3289074 on 2017/02/06 by Alex.Delesky
Back out changelist 3288540 - reintroducing Subtitles module to parse SubRip Subtitles files
#jira UE-35464
Change 3289753 on 2017/02/07 by Michael.Dupuis
#jira UE-34599: Take into consideration UMaterialExpressionMaterialFunctionCall when getting the GUID
Change 3290097 on 2017/02/07 by Nick.Darnell
Automation - The automation framework no longer buckets errors, warnings and log statements into a seperate set of buckets. There is now only one log, and all entries go into it to provide some context when things fail. Continued working on the styling of the reports.
Change 3290182 on 2017/02/07 by Michael.Trepka
Added missing initialization for SWindow::bIsMirrorWindow
Change 3290472 on 2017/02/07 by Michael.Dupuis
#jira UE-37358: Add reference list in the dialog for all delete type
Change 3290513 on 2017/02/07 by Michael.Dupuis
#jira UE-37958: was testing the trailing number 0 twice and never testing the 1
Change 3290543 on 2017/02/07 by Michael.Dupuis
#jira UE-35931: Refresh detail panel on selection lost
Change 3290581 on 2017/02/07 by Michael.Dupuis
Fixed possible crash if we have no level blueprint specified (was crashing during the delete of an actor)
Change 3290721 on 2017/02/07 by Michael.Dupuis
#jira UE-40360: Pass the custom spawning struct which contain the level override into to the spawn function
Change 3291958 on 2017/02/08 by Alexis.Matte
Back out revision 26 from //UE4/Dev-Editor/Engine/Source/Developer/AssetTools/Private/AssetTools.cpp
Change 3292017 on 2017/02/08 by Alexis.Matte
Add some fbx automation tests to validate material re-import
Change 3292030 on 2017/02/08 by Michael.Dupuis
#jira UE-37958: was testing the trailing number 0 twice and never testing the 1
Change 3293062 on 2017/02/08 by Jamie.Dale
Reduced the number of allocations that happen when rebuilding text
This change removes the wasteful FTextHistory::ToText function and replaces it with two more specialized functions; FTextHistory::BuildLocalizedDisplayString and FTextHistory::BuildInvariantDisplayString.
These new functions return an FString (for the display string), rather than an FText (which was simply mined for its display string). Simply avoiding going via an FText saves at least two allocations per-rebuild.
Changes:
- Removed FTextHistory::ToText and replaced it with FTextHistory::BuildLocalizedDisplayString and FTextHistory::BuildInvariantDisplayString.
- Moved the localization aware chronological and transformation implementations into FTextChronoFormatter and FTextTransformer. These return an FString which avoids an FText allocation during rebuild, and is simply passed into an FText during normal FText usage.
- Moved FText::AsDate, FText::AsDateTime, FText::AsTime, FText::ToUpper, and FText::ToLower into Text.cpp, and these now use FTextChronoFormatter and FTextTransformer from the common text implementation.
- Moved FText::AsTimespan into Text.cpp. This had no dependency on ICU, so this is now the common text implementation.
- Added FTextFormatter::FormatStr variants. FTextFormatter::Format calls these FTextFormatter::FormatStr versions internally, and they're also used during text rebuilding (saving not only an FText allocation, but also a container copy).
- Removed FText::CreateNumericalText and FText::CreateChronologicalText as they were mostly superfluous.
- General update from using MakeShareable to MakeShared (saving 1 allocation).
- General clean-up of L10N/I18N class friendship.
#jira UE-41533
Change 3293292 on 2017/02/08 by Alex.Delesky
Performing some cleanup in the Subtitles module, and creating a SubtitlesEditor module for the subtitles asset factories since it causes issue in client builds.
Change 3293477 on 2017/02/08 by Jamie.Dale
Fixed TProperty::InitializeValueInternal and TProperty::DestroyValueInternal mismatch when dealing with fixed size arrays
#jira UE-41007
Change 3293571 on 2017/02/08 by Matt.Kuhlenschmidt
Fix lots of outline data being added to the font cache due to wrongly hashing outline material and color data.
Change 3293572 on 2017/02/08 by Matt.Kuhlenschmidt
Fix details panel categories in the static mesh editor
Change 3294216 on 2017/02/09 by Michael.Dupuis
#jira UE-40609: manually position the window based on it'S max possible size
#3128 GitHub
Change 3294430 on 2017/02/09 by Jamie.Dale
Kerning-only text shaping no longer draws characters to get their metrics
It now goes via the low-level FT caches like HarfBuzz does.
Change 3294588 on 2017/02/09 by Alexis.Matte
If we remove a LODGroup from baseengine.ini, the fbx importer UI will now be able to recover in case the last fbx import was done with the just removed LODGroup
Change 3294847 on 2017/02/09 by Matt.Kuhlenschmidt
Merging //UE4/Dev-Main to Dev-Editor (//UE4/Dev-Editor)
Change 3295093 on 2017/02/09 by Arciel.Rekman
Linux: fix Setup.sh not working in paths with space (UE-41819).
Change 3295205 on 2017/02/09 by Matt.Kuhlenschmidt
Fix material UV's no longer working om 9 slice elements
Change 3295816 on 2017/02/09 by Arciel.Rekman
Linux: fix starting programs from a path with space.
Change 3296129 on 2017/02/09 by Arciel.Rekman
Linux i686: changes necessary to compile BlankProgram.
- Added new architecture to UBT.
- Fixed system headers.
- Added third party libs for i686:
- jemalloc
- elftoolchain
- zlib
- SDL2
- libc++
Change 3296564 on 2017/02/10 by Jamie.Dale
Cleaned up PO comment preservation
Change 3296694 on 2017/02/10 by Jamie.Dale
AllocateNameEntry now takes TCharType* rather than void* and cast
Change 3296744 on 2017/02/10 by Jamie.Dale
Moved the PO DOM from UnrealEd to Internationalization
Change 3297250 on 2017/02/10 by Jamie.Dale
Split the PO import/export pipeline out of the commandlet
Change 3297420 on 2017/02/10 by Alexis.Matte
Add Isolate and highlight feature for the material panel in the staticmesh and the skeletal editor.
#jira UE-38985
Change 3297594 on 2017/02/10 by Alexis.Matte
When importing from fbx a static mesh with find material anywhere, the next LODs import by the user will create new material entries instead of using the existing one.
Change 3297752 on 2017/02/10 by Arciel.Rekman
i686 support: more third party libs.
- libcurl
- OpenSSL
- libpng
- libvorbis
- libogg
- libopus
Change 3297754 on 2017/02/10 by Arciel.Rekman
i686 support: PhysX
Change 3297922 on 2017/02/10 by Alexis.Matte
When importing a new LOD to a staticmesh, the data source file is not anymore wipe or change to the last fbx import filename.
Change 3298330 on 2017/02/10 by Arciel.Rekman
i686: missing libcurl.
Change 3298620 on 2017/02/11 by Jamie.Dale
FLocTextHelper improvements
- It can now support non-standard target layouts (where the native and foreign cultures are in different locations - see FLocTextTargetPaths).
- The XForeignArchive functions are now more strict, and *only* accept foreign cultures (use the XArchive functions instead if you're using both native and foreign cultures as parameters).
Change 3299293 on 2017/02/13 by Matt.Kuhlenschmidt
PR #3241: UE-41870: Add quotes when passing through the directory path (Contributed by projectgheist)
Change 3299299 on 2017/02/13 by Matt.Kuhlenschmidt
PR #3224: Git plugin: fix git autodetection and add error message (Contributed by SRombauts)
Change 3299391 on 2017/02/13 by Matt.Kuhlenschmidt
Fix material instances being marked dirty when opening
#jira UE-41721, UE-41719
Change 3299441 on 2017/02/13 by Nick.Darnell
PR #3243: Fix bug that UWidget::GetOwningPlayer doesn't return (Contributed by yeonseok-yi)
Change 3299567 on 2017/02/13 by Nick.Darnell
Slate - The Checkbox no longer just passes visibility down to the internal widgets it creates, that prevents future changes to effect it if it starts collapsed.
#jira UE-41904
Change 3299870 on 2017/02/13 by Jamie.Dale
Added cycle counters for font rendering/shaping
Change 3300116 on 2017/02/13 by Michael.Dupuis
#jira UE-41866: Update cache when performing an undo
Change 3300178 on 2017/02/13 by Alexis.Matte
Fix a crash when re-importing a LOD with more sections then the base LOD
Change 3300191 on 2017/02/13 by Alexis.Matte
Make sure we do not loose castshadow and recomputetangents section flags when we re-import a skeletal mesh.
Change 3300351 on 2017/02/13 by Alexis.Matte
Remove the clean up of unused material for the staticmesh editor. Unused material can be delete manually in the UI
#jira UE-39639
Change 3302138 on 2017/02/14 by Nick.Darnell
Automation - Adding support for -DeveloperReportOutputPath and -DeveloperReportUrl to permit local runs of the automation tool to generate reports on the report server, and launch the browser window to view them.
Change 3302139 on 2017/02/14 by Nick.Darnell
UMG - Additional fixes to the way we migrate changes from the preview to the serialized version of the widget tree. This fixes several issues with edit-inline objects on UWidgets.
Change 3302281 on 2017/02/14 by Nick.Darnell
Slate - Bringing over changes to the invalidation panel from one of the game streams. This fixes issues with animations in volatile widgets, as well as some issues with cache relative offset, and offers a method for enabling a different caching method to preserve batching through a commandline, but at the cost of not being able to use GPU buffers, possibly a better option on mobile in some cases.
Change 3302415 on 2017/02/14 by Nick.Darnell
Disabling the open asset editor test.
Change 3302976 on 2017/02/14 by Nick.Darnell
Automation - Updating one of the tests to open 70 different known asset types, and ensure that they open without dirtying the package. AutomationTestSettings are now defaultengine, not sure why they setup to be user specific previously. Most of these settings need to be removed, or split off into the modules that own them, rather than being in Engine. TODO.
Change 3303724 on 2017/02/15 by Matt.Kuhlenschmidt
Removed hard coded list of thumbnails, preventing objects with valid thumbnails from showing up. Thumbnails are now shown by default. Use meta=(DisplayThumbnail=false) to remove
#jira UE-41958
Change 3303729 on 2017/02/15 by Matt.Kuhlenschmidt
PR #3253: UE-34539: (Bugfix) Allow binary files in git stored via git-fat, git-lfs, etc to be diffed (take 2) (Contributed by rpav)
Change 3303733 on 2017/02/15 by Matt.Kuhlenschmidt
PR #3248: Fix for TAssetSubClassOf properties reset on undo. (Contributed by StefanoProsperi)
Change 3303823 on 2017/02/15 by Nick.Darnell
Automation - Continued improvements on screenshots. Added some fixes to turn off the tonemapper when visualizing buffers. Fixed several screenshots due to this change. Adding lightboxes to the reports. Adding some styling to make things sweeter.
Change 3303937 on 2017/02/15 by Matt.Kuhlenschmidt
Fix build error
Change 3303982 on 2017/02/15 by Nick.Darnell
Automation - Making the opening of the image no longer threaded, not really helpful for the IO operation and just makes it harder to follow.
Change 3304058 on 2017/02/15 by Matt.Kuhlenschmidt
Fix build attempt #2 (not reproducible locally)
Change 3304393 on 2017/02/15 by Matt.Barnes
Submitting test content for UEQATC-3548
Change 3304517 on 2017/02/15 by Nick.Darnell
Slate - Making some fixes to the automatic disabling of the pixel snapping code with render transforms. Sometimes it gets confused, we may want to move to a seperate transform stack for layout and render, and make sure the element drawer has access to both.
Change 3304560 on 2017/02/15 by Nick.Darnell
UMG - SA fix.
Change 3304890 on 2017/02/15 by Matt.Kuhlenschmidt
PR #3220: UE-41243: Force resolution in standalone if large than primary workin. (Contributed by projectgheist)
Change 3305360 on 2017/02/15 by Arciel.Rekman
Linux: fix crash on exit (UE-41907).
- It is not safe to dereference UAnimGraphNode_PoseDriver::StaticClass during the final shutdown sequence since the instance has already been destroyed in StaticExit().
Change 3306023 on 2017/02/16 by Nick.Darnell
Paper2D - Adding a method to create SlateBrushes from PaperSprites the same way we can for materials and textures in blueprints.
Change 3306030 on 2017/02/16 by Nick.Darnell
Slate - Making some additional fixes to invalidation panels from a game branch. Adding a RoundToVector function to FVector2D, fixing the 3 places we defined a RoundToInt (which wasn't a great name since the convention wasn't meant to be used that way).
Change 3306031 on 2017/02/16 by Nick.Darnell
Slate - Retainer widgets no longer tick using PreTick on SlateApplication, they now paint during their normal paint.
Change 3306046 on 2017/02/16 by Nick.Darnell
UMG - Adding CanEditChange to WidgetComponent to gray out the CylinderArcAngle property unless you select the right geometry mode.
Change 3308887 on 2017/02/17 by Matt.Kuhlenschmidt
Fix crash if blurs are rotated
#jira UE-42037
Change 3309114 on 2017/02/17 by Jamie.Dale
Unifying non-shaped text to use the same atlas cache as shaped text
Change 3310044 on 2017/02/17 by Matt.Kuhlenschmidt
Outline color on text elements is now inherited properly
#jira UE-40691
Change 3310268 on 2017/02/17 by Matt.Kuhlenschmidt
Guard against rendering MIDs with potentially no parent in slate.
#jira UE-42047
Change 3311531 on 2017/02/20 by Michael.Dupuis
#jira UETOOL-1100:
Add the possibility to have dynamic min/max slider value
Synchonize all Color vector together when changing the min/max slider value
Change 3311534 on 2017/02/20 by Michael.Dupuis
incremental build fix
Change 3311535 on 2017/02/20 by Michael.Dupuis
incremental build fix take 2...
Change 3311743 on 2017/02/20 by Michael.Dupuis
buildfix lunix incremental
Change 3312496 on 2017/02/20 by Arciel.Rekman
Linux: fix PhysX crash in i686.
- Changed layout to one that works.
Change 3313127 on 2017/02/20 by Jamie.Dale
Fixed crash when performing a non-async cooked package save
It isn't safe to call TotalSize on the BulkArchive when it's not a FBufferArchive (as used during async save) once the archive has been closed.
Change 3313990 on 2017/02/21 by Nick.Darnell
Automation - Added a summary area at the top of the report.
Change 3314034 on 2017/02/21 by Jamie.Dale
Fixed crash when deleting a streamed font
Change 3314942 on 2017/02/21 by Nick.Darnell
Automation - More templating styling work.
Change 3315080 on 2017/02/21 by Nick.Darnell
Automation - Providing a way for users to remove explict events from the event log when automated tests run. Needed for other systems linked into the automation system like google mock.
Change 3315452 on 2017/02/21 by Nick.Darnell
Json - Adding support for Map and Set properties to the JsonObjectConverter. Can now save out map and sets. No support for loading them yet.
Change 3315614 on 2017/02/21 by Nick.Darnell
Json - Adding support for loading sets and map json data.
Change 3315924 on 2017/02/21 by Arciel.Rekman
Vulkan: edigrating various Linux fixes by Josh.
- This is to make Linux Vulkan work in Dev-Editor easier (for the contractor and myself).
Original descriptions:
CL 3313445
- Various Vulkan fixes:
- Compiles in Linux
- Many cubemap bugs squashed
- Changed the scratch reflection cubemap clear to SetRenderTargestsAndClear, instead of SetRenderTarget() / Clear()
- Added compute fences
CL 3314152
- Fixed compile error on Mac, but I am pretty sure we can just remote VulkanRHI from Mac building entirely, but needs to be tested.
Change 3316741 on 2017/02/22 by Jamie.Dale
Ensure that enums used by BP nodes have been PostLoaded so they have the correct display names
#jira UE-42253
Change 3316800 on 2017/02/22 by Matt.Kuhlenschmidt
Merging //UE4/Dev-Main to Dev-Editor (//UE4/Dev-Editor)
Change 3317058 on 2017/02/22 by Alexis.Matte
Fix the scene importer to support correctly the obj file format
#jira UE-35606
Change 3318039 on 2017/02/22 by Arciel.Rekman
i686 support: added missing libwebsockets.
Change 3318095 on 2017/02/22 by Arciel.Rekman
i686 support: Oodle.
Change 3319002 on 2017/02/23 by Michael.Dupuis
#jira UE-41794 : Do not exit the landscape mode when doing undo from the creation of the landscape
Change 3319012 on 2017/02/23 by Alexis.Matte
PR #3066: Improve asset import by permitted relative paths and easing editing of mapped mount points. (Contributed by paulevans)
#jira UE-40039
Change 3319035 on 2017/02/23 by Nick.Darnell
UMG - Adding a note about the font sizes in UE4 in Slate, using 96 dpi.
#jira UE-42170
Change 3319040 on 2017/02/23 by Matt.Kuhlenschmidt
PR #3278: Git plugin: fix revision number for blueprint diff menu (Contributed by SRombauts)
#jira UE-42129
Change 3319072 on 2017/02/23 by Michael.Dupuis
#jira UETOOL-1101: Add support for DetailGroup reset to default
Right now it's only enable for the color grading
Change 3319077 on 2017/02/23 by Nick.Darnell
Automation - Moving away from most of the templating being done in C++. Moving to dust.js to just do it in the browser window. The json report file is now the actual source of the information we use to template the resulting report html. Maaay have to move to doing the templating server side in the future to stream it to the client better, but avoiding that so we don't have to ship a server. Disabling several places we were taking editor screenshots, none of that code was actually comparing screenshots, it was a hold-over from earlier days.
PhysX - Fixing a problem with Physx FillInlinePxShapeArray. Deprecating it, adding FillInlinePxShapeArray_AssumesLocked, and locking places we were assuming it was already locked in the landscape component.
Change 3319088 on 2017/02/23 by Nick.Darnell
PR #3245: UE-41707: Re-order includes correctly (Contributed by projectgheist)
#jira UE-41914
Change 3319104 on 2017/02/23 by Michael.Dupuis
fix incremental build
Change 3319146 on 2017/02/23 by Matt.Kuhlenschmidt
PR #3292: Git plugin: fix update status on directories broken since UE4.12 (Contributed by SRombauts)
#jira UE-42272
Change 3319252 on 2017/02/23 by Michael.Dupuis
fix warning with missing #undef LOCTEXT_NAMESPACE
Change 3319298 on 2017/02/23 by Alex.Delesky
Removing the Subtitles and SubtitlesEditor modules (it'll eventually be brought back as the Overlay and OverlayEditor modules)
Change 3319388 on 2017/02/23 by Alexis.Matte
Fbx Importer now find collision model under fbx LOD Group
#jira UE-42141
Change 3319528 on 2017/02/23 by Michael.Dupuis
Fixed Undo/Redo to be consistent with other vector modifcation behavior
Change 3319583 on 2017/02/23 by Alexis.Matte
Fix the sample rate to use the least common multiplier of all keys
#jira UE-42012
Change 3319705 on 2017/02/23 by Nick.Darnell
Static Analysis - Fixing sonobjectconverter.cpp(460) : warning C6011: Dereferencing NULL pointer 'ArrayProperty'.
Change 3319711 on 2017/02/23 by Nick.Darnell
Editor - Adding some checks to make sure the struct we're accessing is still a valid handle.
#jira UE-42262
Change 3319736 on 2017/02/23 by Alex.Delesky
Adding Subtitles and SubtitlesEditor to the JunkManifest file.
Change 3319919 on 2017/02/23 by Nick.Darnell
Automation - Fixing an issue with moving a location that doesn't exist.
Change 3319932 on 2017/02/23 by Alexis.Matte
Fbx importer, do not apply more then one time the transform option to the scene node.
#jira UE-42277
Change 3320105 on 2017/02/23 by Nick.Darnell
Editor - Adding some additional checks to the margin customization.
#jira UE-42262
Change 3321577 on 2017/02/24 by Jamie.Dale
Moving Internationalization module from Runtime to Developer
Change 3321625 on 2017/02/24 by Jamie.Dale
Moving InternationalizationSettings module from Developer to Editor
Change 3321642 on 2017/02/24 by Jamie.Dale
Moving SCulturePicker from the Localization module to the InternationalizationSettings module
Change 3321734 on 2017/02/24 by Alexis.Matte
PR #2979: Fix extra root bone for Blender exported FBX. (Contributed by manmohanbishnoi)
We fix the extra root only when the file creator is from blender and the root node is named armature. We cannot simply remove all dummy node, since this is use by the rigid mesh workflow.
#jira UE-39050
Change 3321912 on 2017/02/24 by Jamie.Dale
Split LocalizationCommandletExecution out of the Localization module to remove some editor dependencies
Change 3322274 on 2017/02/24 by Jamie.Dale
Moving Localization module from Editor to Developer, and merging the Internationalization module into it
Removed hard-dependency between Engine and Localization/Internationalization via an interface.
Change 3322774 on 2017/02/25 by Jamie.Dale
Unifying LocRes and LocNat file format between generation and loading
This lets the code in Core be shared by Localization, and allows some code that was proxying via archives (due to the code being logically identical, but different C++ types) to use these new types directly.
#tests Built Debug, Shipping, and Editor. Verified that LocNat and LocRes generation and loading worked as before.
Change 3322795 on 2017/02/25 by Jamie.Dale
Fixing mismatch between SOURCE_CONTROL_WITH_SLATE and its .Build.cs file
The define was set to disable Slate for Linux program targets only, but the .Build.cs disabled Slate for all Linux targets.
Since the define was touched most recently (CL# 2534983), I updated the .Build.cs file to match its logic, and moved the definition of the define to the .Build.cs file so that they stay in sync with one another.
Change 3322853 on 2017/02/25 by Jamie.Dale
Moved the conflict and word count reporting to FLocTextHelper
Change 3323089 on 2017/02/26 by Jamie.Dale
Added functions to get the target name and path from FLocTextHelper
Change 3323391 on 2017/02/27 by Ben.Cosh
This fixes an issue with blueprint config variables having their value destroyed by CDO serialization
#Jira UE-40586 Blueprint variable defaults set from config files value are overwritten by CDO serialization
#Proj Engine, CoreUObject
Change 3323406 on 2017/02/27 by Ben.Cosh
Fixed a problem that caused UK2Node::ExpandSplitPin to destroy pins it didn't own in when expanding a collapsed graph during compilation.
#jira UE-41211 - Crash when splitting a UDS pin on a collapsed graph
#Proj BlueprintGraph
Change 3323572 on 2017/02/27 by Nick.Darnell
Automation - Continued itteration on the style of the automation reports, now with attentional info, like where the log came from.
Automation - Fixing a bug in the functional actor tests, navigating to the actors sometimes opened other objects in the package, now it only opens the map. Also improved the way we focus the actor so that the level editor is also brought to the foreground.
Automation - Fixing a bug in how the automation system was registering for capturing logging. It was swapping out GWarn for its own version, but GWarn isn't called for anything that isn't an error or warning, meaning that none of the Display/Logging or analytics capture attempts were actually working. Suddenly a flood of informations started being captured during tests. For now - only going to capture 'Display' logs instead of 'Log' level.
Automation - Successful comparisons now print more information so that the automation logs do a better job of tracking the flow of the test.
Automation - The screenshot comparison test now prints more information even during successful comparisons.
Editor - The message log no longer emits a SetSelection, just because the selection is updated the categoriry view model. This was causing things like the automation tool, which sets the selection every time (which may itself be an issue) to completely rebuild the message log every time a new automation message was emited. The message log now checks if the selection would actually change the viewstate before it does it.
Domino Test - Adding an arrow to visualize the state of the up vector the test is looking for; playing with idea for test visualizers that may help with debugging in the future.
Change 3323580 on 2017/02/27 by Michael.Trepka
Fixed some Xcode 8.3 compile errors
Change 3323634 on 2017/02/27 by Nick.Darnell
Build - Fix incremental build.
Change 3323740 on 2017/02/27 by Jamie.Dale
Adding #error if the SOURCE_CONTROL_WITH_SLATE define is missing
Change 3323865 on 2017/02/27 by Nick.Darnell
Automation - Disabling the screenshot from the small editor icons test, until the editor screenshot method starts comparing things, and the screenshots we take are better / more scoped.
Change 3324228 on 2017/02/27 by Jamie.Dale
Can no longer name assets or folders with a leading underscore
#jira UE-40541
Change 3324429 on 2017/02/27 by Jamie.Dale
Removing FLocTextTargetPaths
It was added to support something that I'm now going to do a different way.
Change 3324473 on 2017/02/27 by Jamie.Dale
Moved the GatherText SCC utils into the Localization module
Change 3324481 on 2017/02/27 by Jamie.Dale
Moving the localized asset utils out of GatherText base
Change 3324485 on 2017/02/27 by Jamie.Dale
Cleaning up some includes now that the localization SCC is no longer in GatherText
Change 3324910 on 2017/02/28 by Nick.Darnell
Slate - Moving the SlateRotatedRect into its own file, and removing FSlateRotatedClipRectType, since there's no longer a difference and we only use FSlateRotatedRect.
Change 3325329 on 2017/02/28 by Michael.Dupuis
#jira UE-42083: Removed various Modify(true) that would force user to save the levels even if they did'nt really modified them
Replace TMap<TLazyObjectPtr,...> as it would dirty the level at every Find performed
Change 3325410 on 2017/02/28 by Michael.Dupuis
missing include for incremental build
Change 3325415 on 2017/02/28 by Nick.Darnell
UMG - Adding some setters and getters for RedrawTime to the WidgetComponent.
Change 3325418 on 2017/02/28 by Nick.Darnell
Automation - Fixing the warnings on startup about smoke tests taking longer than 2s. Had to add an option to disable capturing the callstack when running smokes, it adds a bit too much overhead during startup.
Change 3325698 on 2017/02/28 by Alexis.Matte
Put back the code to isolate material versus section in the skeletal mesh. The code was override by a temporary hack done in paragon branch
Change 3325790 on 2017/02/28 by Michael.Trepka
Copy of CL 3319588
Fixed address sanitizer support in MacToolChain (Apple changed the name of the env variable Xcode uses to enable it) and added support for thread sanitizer
Change 3326118 on 2017/02/28 by Alexis.Matte
Add LOD settings LOD distances to fbx import dialog option. The option are not supported yet by the scene importer
#jira UE-41291
Change 3326183 on 2017/02/28 by Alexis.Matte
PR #3298: Import SpecularFactor for Roughness and Shininess for Metallic textures (Contributed by VladimirPobedinskiy)
#jira UE-42301
Change 3326196 on 2017/02/28 by Jamie.Dale
Force the correct package localization ID when duplicating a BP for nativization
Change 3327037 on 2017/03/01 by Michael.Dupuis
fixed fortnite mac non editor build
Change 3327483 on 2017/03/01 by Jamie.Dale
Renaming LocNat to LocMeta
Change 3327486 on 2017/03/01 by Jamie.Dale
Renaming LocNat to LocMeta
Change 3327541 on 2017/03/01 by Michael.Trepka
Removed Mac OpenGL RHI files and disabled building of OpenGL RHI on Mac
Change 3328000 on 2017/03/01 by Nick.Darnell
Automation - Noisy rendering features are now disabled by default when taking screenshots.
Change 3328323 on 2017/03/01 by Michael.Trepka
Copy of CL 3307526
Fixed mouse position issues in fullscreen mode on Mac
Change 3328410 on 2017/03/01 by Alexis.Matte
Remove unwanted option when importing skeletal mesh
Make the FBX tests uptodate with the new ImportUI options
#jira UE-41291
Change 3329586 on 2017/03/02 by Jamie.Dale
Adding missing includes when running with bUseMallocProfiler enabled
Change 3329999 on 2017/03/02 by Nick.Darnell
UMG - Removing a deprecated 4.8 function to get the label on UWidget.
Change 3330004 on 2017/03/02 by Nick.Darnell
UMG - Adding TargetPlatform to the dependencies of UMGEditor module.
Change 3330021 on 2017/03/02 by Nick.Darnell
UMG - Adding TargetPlatform to the private include path of the UMG module.
Change 3330041 on 2017/03/02 by Nick.Darnell
Engine - Adding a comment to the PreLoadMap call so people know what the string being passed in is.
Change 3330048 on 2017/03/02 by Nick.Darnell
Editor - Don't allow querying the cursor in the editor viewport while saving packages. Depending upon the code that gets triggered, it may cause packages to load, or things to be initialized while saving is occuring.
Change 3330602 on 2017/03/02 by mason.seay
Map for Functional Screenshot Test Bug
Change 3330632 on 2017/03/02 by Alexis.Matte
Fix fbx crash when there is only one UVChannel but using the naming convention to place it further then the first index
Change 3330862 on 2017/03/02 by Jamie.Dale
Adding FPaths::SetExtension
This is like FPaths::ChangeExtension, but also applies the extension if the file doesn't have one.
Change 3331491 on 2017/03/03 by Nick.Darnell
Automation - Fixing a threading issue in the SAsyncImage, it was accessing potentially bogus memory if the Widget had been deleted before the task ran.
Change 3331498 on 2017/03/03 by Nick.Darnell
Build - Fixing a build warning.
Change 3331807 on 2017/03/03 by Nick.Darnell
Automation - Making the Disable Noisy Rendering Features more robust, disabling a few more markers. Adding a better way of rolling back the changes.
Change 3331999 on 2017/03/03 by Michael.Trepka
Fixed a memory leak on texture creation with BulkData in OpenGLTexture.cpp
Change 3332481 on 2017/03/03 by Arciel.Rekman
Fix building lighting in commandlet (UE-42551).
- Process task graph while running as commandlet.
- Also, if for any reason - like the lack of -messaging - local swarm interface fails to initialize or takes too much time to send the message, bail out.
Change 3332606 on 2017/03/04 by Jamie.Dale
Fixing crash reporting loc word counts when the report is starting empty
Change 3332614 on 2017/03/04 by Jamie.Dale
Fixed text namespaces being treated as case-insensitive when export to JSON manifests and archives
Change 3332619 on 2017/03/04 by Jamie.Dale
Fixing CIS error
Change 3333000 on 2017/03/06 by Matt.Kuhlenschmidt
PR #3295: Non-editable FStringAssetReference using VisibleAnywhere (Contributed by projectgheist)
#jira UE-42284
Change 3333039 on 2017/03/06 by Alexis.Matte
Make custom ui for FbxSceneImportData object
#jira UE-37896
Change 3333047 on 2017/03/06 by Nick.Darnell
UMG - Removing an extra assignment in WidgetSwitcher.
Change 3333056 on 2017/03/06 by Alexis.Matte
Build fix
Change 3333073 on 2017/03/06 by Matt.Kuhlenschmidt
Added more logging for when window creation fails due to too many windows.
#jira UE-42478
Change 3333081 on 2017/03/06 by Matt.Kuhlenschmidt
PR #3327: Git Plugin: fix RunDumpToFile() to check git ReturnCode (Contributed by SRombauts)
#jira UE-42535
Change 3333103 on 2017/03/06 by Matt.Kuhlenschmidt
PR #3336: UE-42407: using GetWindowMode instead of switching on IsFullscreenViewport (Contributed by stefanzimecki)
#jira UE-42407, UE-42565
Change 3333142 on 2017/03/06 by Jamie.Dale
Added a way to view/copy a list references (including those that aren't loaded) to the reference viewer
Change 3333443 on 2017/03/06 by Matt.Kuhlenschmidt
Eliminate the usage of SWebBrowser to show viewport controls in level viewports. There is an non-trivial startup cost initializing CEF and is not worth paying that cost on editor startup for one tiny control. The button now opens a web page on click.
#jira UE-42461
PR #3314: Drop UE4Editor -> CEF dependency to 2x speedup Linux UE4Editor startup (Contributed by slonopotamus)
Change 3333914 on 2017/03/06 by Matt.Kuhlenschmidt
Remove double middle mouse click to change to perspective view
#jira UE-42444
Change 3333936 on 2017/03/06 by Matt.Kuhlenschmidt
Fixed excessive fname initialization in these files
Change 3334063 on 2017/03/06 by Alexis.Matte
fix build linux
Change 3334166 on 2017/03/06 by Jamie.Dale
Adding Data Table export/import support for TMap and TSet
#jira UE-42415
Change 3334459 on 2017/03/06 by Alexis.Matte
PR #3334: Respect bForceFrontXAxis option when exporting to FBX (Contributed by rajkosto)
#jira UE-42563
Change 3335132 on 2017/03/07 by Jamie.Dale
Fixing typo
Change 3335140 on 2017/03/07 by Jamie.Dale
Fixing CSV import warnings in GameplayEffects test
Change 3335164 on 2017/03/07 by Alexis.Matte
Avoid selecting skeletal mesh section in the level when high light them in persona editor
#jira UE-20151
Change 3335186 on 2017/03/07 by Jamie.Dale
Fixed CSV parser missing empty cells at the end of the string
Change 3335218 on 2017/03/07 by Arciel.Rekman
SDL2: delete unused project/build files.
Change 3335222 on 2017/03/07 by Arciel.Rekman
SDL2: delete more unused project/build files.
Change 3335230 on 2017/03/07 by Matt.Kuhlenschmidt
Additional fixes for blur and blur slot not propagating padding to each other
#jira UE-42553
Change 3335896 on 2017/03/07 by Jamie.Dale
ToolTips and Engine were double gathering the same meta-data
#jira UE-36480
Change 3336009 on 2017/03/07 by Matt.Kuhlenschmidt
Fix details panels becoming unusable if "Show only Modified Properties" is enabled and there are no modified properties
Change 3336247 on 2017/03/07 by Jamie.Dale
Selection height is now the max of the line height and text height to account for negative line scaling
#jira UE-40673
Change 3336253 on 2017/03/07 by Jamie.Dale
Added a setting to control whether we should use the font metrics or the bounding box when laying out a font
#jira UE-41074
Change 3336303 on 2017/03/07 by Arciel.Rekman
Refactor of OS memory allocation functions.
- Bring PageSize/OSAllocationGranularity in line with the established definitions.
- PageSize is a hardware mapping granularity that is also used for PageProtect() and any other functions that involve setting virtual memory properties.
- OSAllocationGranularity is a virtual address allocation granularity that on some platforms may be applied on top of that (notably VirtualAlloc in Windows only returns addresses that are 16 page aligned).
- BinnedPageSize and BinnedAllocationGranularity are the values expected by Binned and Binned2 for size and the alignment of OS allocations.
- Disable the logic in CachedOSPageAllocator that allowed buffers larger than the requested size to be returned.
- This caused wrong allocation size to be passed in BinnedFreeToOS() from Binned2.
- Make Binned2 work on Linux
- Addresses returned from BinnedAllocFromOS() need to be BinnedPageSize (minimum 64KB) aligned for Binned2 to work. This results in the need to artificially align mmap()'d addresses, at some performance cost.
- The same function can be used on other systems with mmap()/munmap() (Mac, Android, iOS)
- Switch Linux to Binned2 by default.
- Add ability to sanity-check OS memory allocations.
- Debug and Development build will store a descriptor to check that values passed to BinnedFreeToOS() are the same (mmap-based allocation only).
Change 3337098 on 2017/03/08 by Michael.Dupuis
#jira UE-42589: Added a guard if the mesh component is not attached, this can happen when moving a component out of the screen
Change 3337183 on 2017/03/08 by Matt.Kuhlenschmidt
Hide the preview toolbar button, it is not being used
Change 3337801 on 2017/03/08 by Michael.Trepka
Fixed some module dependencies to make sure we don't build OpenGLDrv on Mac
Change 3338373 on 2017/03/08 by Joe.Graf
Fixed external plugin cooking and deployment by remapping plugin directories upon cook & deployment
Tested directory structures:
D:\SomePluginDir
D:\UE4\AnotherPluginDir
D:\UE4\Engine\Plugins
D:\UE4\MyProject\Plugins
Change 3338482 on 2017/03/08 by Alexis.Matte
Remove "BlueprinReadOnly" flag on "WITH_EDITORONLY_DATA" class variable
Change 3338679 on 2017/03/08 by Matt.Kuhlenschmidt
Fixed arrow keys not working to navigate between elements in the details panel
Change 3339086 on 2017/03/09 by Dmitriy.Dyomin
Added: Mobile friendly slate settings
Change 3339366 on 2017/03/09 by Nick.Darnell
Build - Attempting to fix build.
#jira UE-42675
Change 3339506 on 2017/03/09 by Jamie.Dale
Fixing Linux Server build error
#jira UE-42675
Change 3340450 on 2017/03/09 by Cody.Albert
Ensure that the hittest grid is valid before trying to find a focusable widget
Change 3340492 on 2017/03/09 by Arciel.Rekman
Fix IOS compile error (UE-42695).
Change 3340565 on 2017/03/09 by Arciel.Rekman
Fix another compile error (UE-42695).
Change 3341527 on 2017/03/10 by Alexis.Matte
Fix crash when dragging a re-import scene and there is new asset created
#jira UE-42766
[CL 3341914 by Nick Darnell in Main branch]
2305 lines
80 KiB
C++
2305 lines
80 KiB
C++
// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
|
|
|
|
/*=============================================================================
|
|
OpenGLVertexBuffer.cpp: OpenGL texture RHI implementation.
|
|
=============================================================================*/
|
|
|
|
#include "CoreMinimal.h"
|
|
#include "Containers/ResourceArray.h"
|
|
#include "Stats/Stats.h"
|
|
#include "RHI.h"
|
|
#include "RenderUtils.h"
|
|
#include "ShaderCache.h"
|
|
#include "OpenGLDrv.h"
|
|
#include "OpenGLDrvPrivate.h"
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
Texture allocator support.
|
|
-----------------------------------------------------------------------------*/
|
|
|
|
/** Caching it here, to avoid getting it every time we create a texture. 0 is no multisampling. */
|
|
GLint GMaxOpenGLColorSamples = 0;
|
|
GLint GMaxOpenGLDepthSamples = 0;
|
|
GLint GMaxOpenGLIntegerSamples = 0;
|
|
|
|
// in bytes, never change after RHI, needed to scale game features
|
|
int64 GOpenGLDedicatedVideoMemory = 0;
|
|
// In bytes. Never changed after RHI init. Our estimate of the amount of memory that we can use for graphics resources in total.
|
|
int64 GOpenGLTotalGraphicsMemory = 0;
|
|
|
|
static bool ShouldCountAsTextureMemory(uint32 Flags)
|
|
{
|
|
return (Flags & (TexCreate_RenderTargetable | TexCreate_ResolveTargetable | TexCreate_DepthStencilTargetable)) == 0;
|
|
}
|
|
|
|
void OpenGLTextureAllocated(FRHITexture* Texture, uint32 Flags)
|
|
{
|
|
int32 TextureSize = 0;
|
|
FOpenGLTextureCube* TextureCube = 0;
|
|
FOpenGLTexture2D* Texture2D = 0;
|
|
FOpenGLTexture2DArray* Texture2DArray = 0;
|
|
FOpenGLTexture3D* Texture3D = 0;
|
|
bool bRenderTarget = !ShouldCountAsTextureMemory(Flags);
|
|
|
|
if (( TextureCube = (FOpenGLTextureCube*)Texture->GetTextureCube()) != NULL)
|
|
{
|
|
TextureSize = CalcTextureSize( TextureCube->GetSize(), TextureCube->GetSize(), TextureCube->GetFormat(), TextureCube->GetNumMips() );
|
|
TextureSize *= TextureCube->GetArraySize() * (TextureCube->GetArraySize() == 1 ? 6 : 1);
|
|
TextureCube->SetMemorySize( TextureSize );
|
|
TextureCube->SetIsPowerOfTwo(FMath::IsPowerOfTwo(TextureCube->GetSizeX()) && FMath::IsPowerOfTwo(TextureCube->GetSizeY()));
|
|
if (bRenderTarget)
|
|
{
|
|
INC_MEMORY_STAT_BY(STAT_RenderTargetMemoryCube,TextureSize);
|
|
}
|
|
else
|
|
{
|
|
INC_MEMORY_STAT_BY(STAT_TextureMemoryCube,TextureSize);
|
|
}
|
|
}
|
|
else if ((Texture2D = (FOpenGLTexture2D*)Texture->GetTexture2D()) != NULL)
|
|
{
|
|
TextureSize = CalcTextureSize( Texture2D->GetSizeX(), Texture2D->GetSizeY(), Texture2D->GetFormat(), Texture2D->GetNumMips() )*Texture2D->GetNumSamples();
|
|
Texture2D->SetMemorySize( TextureSize );
|
|
Texture2D->SetIsPowerOfTwo(FMath::IsPowerOfTwo(Texture2D->GetSizeX()) && FMath::IsPowerOfTwo(Texture2D->GetSizeY()));
|
|
if (bRenderTarget)
|
|
{
|
|
INC_MEMORY_STAT_BY(STAT_RenderTargetMemory2D,TextureSize);
|
|
}
|
|
else
|
|
{
|
|
INC_MEMORY_STAT_BY(STAT_TextureMemory2D,TextureSize);
|
|
}
|
|
}
|
|
else if ((Texture3D = (FOpenGLTexture3D*)Texture->GetTexture3D()) != NULL)
|
|
{
|
|
TextureSize = CalcTextureSize3D( Texture3D->GetSizeX(), Texture3D->GetSizeY(), Texture3D->GetSizeZ(), Texture3D->GetFormat(), Texture3D->GetNumMips() );
|
|
Texture3D->SetMemorySize( TextureSize );
|
|
Texture3D->SetIsPowerOfTwo(FMath::IsPowerOfTwo(Texture3D->GetSizeX()) && FMath::IsPowerOfTwo(Texture3D->GetSizeY()) && FMath::IsPowerOfTwo(Texture3D->GetSizeZ()));
|
|
if (bRenderTarget)
|
|
{
|
|
INC_MEMORY_STAT_BY(STAT_RenderTargetMemory3D,TextureSize);
|
|
}
|
|
else
|
|
{
|
|
INC_MEMORY_STAT_BY(STAT_TextureMemory3D,TextureSize);
|
|
}
|
|
}
|
|
else if ((Texture2DArray = (FOpenGLTexture2DArray*)Texture->GetTexture2DArray()) != NULL)
|
|
{
|
|
TextureSize = Texture2DArray->GetSizeZ() * CalcTextureSize( Texture2DArray->GetSizeX(), Texture2DArray->GetSizeY(), Texture2DArray->GetFormat(), Texture2DArray->GetNumMips() );
|
|
Texture2DArray->SetMemorySize( TextureSize );
|
|
Texture2DArray->SetIsPowerOfTwo(FMath::IsPowerOfTwo(Texture2DArray->GetSizeX()) && FMath::IsPowerOfTwo(Texture2DArray->GetSizeY()));
|
|
if (bRenderTarget)
|
|
{
|
|
INC_MEMORY_STAT_BY(STAT_RenderTargetMemory2D,TextureSize);
|
|
}
|
|
else
|
|
{
|
|
INC_MEMORY_STAT_BY(STAT_TextureMemory2D,TextureSize);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
check(0); // Add handling of other texture types
|
|
}
|
|
|
|
if( bRenderTarget )
|
|
{
|
|
GCurrentRendertargetMemorySize += Align(TextureSize, 1024) / 1024;
|
|
}
|
|
else
|
|
{
|
|
GCurrentTextureMemorySize += Align(TextureSize, 1024) / 1024;
|
|
}
|
|
}
|
|
|
|
void OpenGLTextureDeleted( FRHITexture* Texture )
|
|
{
|
|
FShaderCache::RemoveTexture(Texture);
|
|
|
|
bool bRenderTarget = !ShouldCountAsTextureMemory(Texture->GetFlags());
|
|
int32 TextureSize = 0;
|
|
if (Texture->GetTextureCube())
|
|
{
|
|
TextureSize = ((FOpenGLTextureCube*)Texture->GetTextureCube())->GetMemorySize();
|
|
if (bRenderTarget)
|
|
{
|
|
DEC_MEMORY_STAT_BY(STAT_RenderTargetMemory3D,TextureSize);
|
|
}
|
|
else
|
|
{
|
|
DEC_MEMORY_STAT_BY(STAT_TextureMemory3D,TextureSize);
|
|
}
|
|
}
|
|
else if (Texture->GetTexture2D())
|
|
{
|
|
TextureSize = ((FOpenGLTexture2D*)Texture->GetTexture2D())->GetMemorySize();
|
|
if (bRenderTarget)
|
|
{
|
|
DEC_MEMORY_STAT_BY(STAT_RenderTargetMemory2D,TextureSize);
|
|
}
|
|
else
|
|
{
|
|
DEC_MEMORY_STAT_BY(STAT_TextureMemory2D,TextureSize);
|
|
}
|
|
}
|
|
else if (Texture->GetTexture3D())
|
|
{
|
|
TextureSize = ((FOpenGLTexture3D*)Texture->GetTexture3D())->GetMemorySize();
|
|
if (bRenderTarget)
|
|
{
|
|
DEC_MEMORY_STAT_BY(STAT_RenderTargetMemory3D,TextureSize);
|
|
}
|
|
else
|
|
{
|
|
DEC_MEMORY_STAT_BY(STAT_TextureMemory3D,TextureSize);
|
|
}
|
|
}
|
|
else if (Texture->GetTexture2DArray())
|
|
{
|
|
TextureSize = ((FOpenGLTexture2DArray*)Texture->GetTexture2DArray())->GetMemorySize();
|
|
if (bRenderTarget)
|
|
{
|
|
DEC_MEMORY_STAT_BY(STAT_RenderTargetMemory2D,TextureSize);
|
|
}
|
|
else
|
|
{
|
|
DEC_MEMORY_STAT_BY(STAT_TextureMemory2D,TextureSize);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
check(0); // Add handling of other texture types
|
|
}
|
|
|
|
if( bRenderTarget )
|
|
{
|
|
GCurrentRendertargetMemorySize -= Align(TextureSize, 1024) / 1024;
|
|
}
|
|
else
|
|
{
|
|
GCurrentTextureMemorySize -= Align(TextureSize, 1024) / 1024;
|
|
}
|
|
}
|
|
|
|
uint64 FOpenGLDynamicRHI::RHICalcTexture2DPlatformSize(uint32 SizeX, uint32 SizeY, uint8 Format, uint32 NumMips, uint32 NumSamples, uint32 Flags, uint32& OutAlign)
|
|
{
|
|
OutAlign = 0;
|
|
return CalcTextureSize(SizeX, SizeY, (EPixelFormat)Format, NumMips);
|
|
}
|
|
|
|
uint64 FOpenGLDynamicRHI::RHICalcTexture3DPlatformSize(uint32 SizeX, uint32 SizeY, uint32 SizeZ, uint8 Format, uint32 NumMips, uint32 Flags, uint32& OutAlign)
|
|
{
|
|
OutAlign = 0;
|
|
return CalcTextureSize3D(SizeX, SizeY, SizeZ, (EPixelFormat)Format, NumMips);
|
|
}
|
|
|
|
uint64 FOpenGLDynamicRHI::RHICalcTextureCubePlatformSize(uint32 Size, uint8 Format, uint32 NumMips, uint32 Flags, uint32& OutAlign)
|
|
{
|
|
OutAlign = 0;
|
|
return CalcTextureSize(Size, Size, (EPixelFormat)Format, NumMips) * 6;
|
|
}
|
|
|
|
/**
|
|
* Retrieves texture memory stats. Unsupported with this allocator.
|
|
*
|
|
* @return false, indicating that out variables were left unchanged.
|
|
*/
|
|
void FOpenGLDynamicRHI::RHIGetTextureMemoryStats(FTextureMemoryStats& OutStats)
|
|
{
|
|
OutStats.DedicatedVideoMemory = GOpenGLDedicatedVideoMemory;
|
|
OutStats.DedicatedSystemMemory = 0;
|
|
OutStats.SharedSystemMemory = 0;
|
|
OutStats.TotalGraphicsMemory = GOpenGLTotalGraphicsMemory ? GOpenGLTotalGraphicsMemory : -1;
|
|
|
|
OutStats.AllocatedMemorySize = int64(GCurrentTextureMemorySize) * 1024;
|
|
OutStats.LargestContiguousAllocation = OutStats.AllocatedMemorySize;
|
|
OutStats.TexturePoolSize = GTexturePoolSize;
|
|
OutStats.PendingMemoryAdjustment = 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* Fills a texture with to visualize the texture pool memory.
|
|
*
|
|
* @param TextureData Start address
|
|
* @param SizeX Number of pixels along X
|
|
* @param SizeY Number of pixels along Y
|
|
* @param Pitch Number of bytes between each row
|
|
* @param PixelSize Number of bytes each pixel represents
|
|
*
|
|
* @return true if successful, false otherwise
|
|
*/
|
|
bool FOpenGLDynamicRHI::RHIGetTextureMemoryVisualizeData( FColor* /*TextureData*/, int32 /*SizeX*/, int32 /*SizeY*/, int32 /*Pitch*/, int32 /*PixelSize*/ )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
FRHITexture* FOpenGLDynamicRHI::CreateOpenGLTexture(uint32 SizeX, uint32 SizeY, bool bCubeTexture, bool bArrayTexture, uint8 Format, uint32 NumMips, uint32 NumSamples, uint32 ArraySize, uint32 Flags, const FClearValueBinding& InClearValue, FResourceBulkDataInterface* BulkData)
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
|
|
SCOPE_CYCLE_COUNTER(STAT_OpenGLCreateTextureTime);
|
|
|
|
bool bAllocatedStorage = false;
|
|
|
|
if(NumMips == 0)
|
|
{
|
|
if(NumSamples <= 1)
|
|
{
|
|
NumMips = FindMaxMipmapLevel(SizeX, SizeY);
|
|
}
|
|
else
|
|
{
|
|
NumMips = 1;
|
|
}
|
|
}
|
|
|
|
#if UE_BUILD_DEBUG
|
|
check( !( NumSamples > 1 && bCubeTexture) );
|
|
check( bArrayTexture != (ArraySize == 1));
|
|
#endif
|
|
|
|
// Move NumSamples to on-chip MSAA if supported
|
|
uint32 NumSamplesTileMem = 1;
|
|
GLint MaxSamplesTileMem = FOpenGL::GetMaxMSAASamplesTileMem(); /* RHIs which do not support tiled GPU MSAA return 0 */
|
|
if (MaxSamplesTileMem > 0)
|
|
{
|
|
NumSamplesTileMem = FMath::Min<uint32>(NumSamples, MaxSamplesTileMem);
|
|
NumSamples = 1;
|
|
}
|
|
|
|
bool bNoSRGBSupport = (GMaxRHIFeatureLevel <= ERHIFeatureLevel::ES3_1);
|
|
|
|
if ((Flags & TexCreate_RenderTargetable) && Format == PF_B8G8R8A8 && !FOpenGL::SupportsBGRA8888RenderTarget())
|
|
{
|
|
// Some android devices does not support BGRA as a color attachment
|
|
Format = PF_R8G8B8A8;
|
|
}
|
|
|
|
if (bNoSRGBSupport)
|
|
{
|
|
// Remove sRGB read flag when not supported
|
|
Flags &= ~TexCreate_SRGB;
|
|
}
|
|
|
|
GLuint TextureID = 0;
|
|
FOpenGL::GenTextures(1, &TextureID);
|
|
|
|
GLenum Target = GL_NONE;
|
|
if(bCubeTexture)
|
|
{
|
|
if ( FOpenGL::SupportsTexture3D() )
|
|
{
|
|
Target = bArrayTexture ? GL_TEXTURE_CUBE_MAP_ARRAY : GL_TEXTURE_CUBE_MAP;
|
|
}
|
|
else
|
|
{
|
|
check(!bArrayTexture);
|
|
Target = GL_TEXTURE_CUBE_MAP;
|
|
}
|
|
check(SizeX == SizeY);
|
|
}
|
|
else
|
|
{
|
|
Target = (NumSamples > 1) ? GL_TEXTURE_2D_MULTISAMPLE : GL_TEXTURE_2D;
|
|
|
|
// @todo: refactor 2d texture array support here?
|
|
check(!bArrayTexture);
|
|
}
|
|
|
|
check(Target != GL_NONE);
|
|
|
|
const bool bSRGB = (Flags&TexCreate_SRGB) != 0;
|
|
const FOpenGLTextureFormat& GLFormat = GOpenGLTextureFormats[Format];
|
|
if (GLFormat.InternalFormat[bSRGB] == GL_NONE)
|
|
{
|
|
UE_LOG(LogRHI, Fatal,TEXT("Texture format '%s' not supported (sRGB=%d)."), GPixelFormats[Format].Name, bSRGB);
|
|
}
|
|
|
|
FOpenGLContextState& ContextState = GetContextStateForCurrentContext();
|
|
|
|
// Make sure PBO is disabled
|
|
CachedBindPixelUnpackBuffer(ContextState,0);
|
|
|
|
// Use a texture stage that's not likely to be used for draws, to avoid waiting
|
|
CachedSetupTextureStage(ContextState, FOpenGL::GetMaxCombinedTextureImageUnits() - 1, Target, TextureID, 0, NumMips);
|
|
|
|
// For client storage textures we allocate a single backing store buffer.
|
|
uint8* TextureRange = nullptr;
|
|
|
|
if (NumSamples == 1)
|
|
{
|
|
if (!FMath::IsPowerOfTwo(SizeX) || !FMath::IsPowerOfTwo(SizeY))
|
|
{
|
|
glTexParameteri(Target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(Target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
if ( FOpenGL::SupportsTexture3D() )
|
|
{
|
|
glTexParameteri(Target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
glTexParameteri(Target, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
|
glTexParameteri(Target, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
|
if ( FOpenGL::SupportsTexture3D() )
|
|
{
|
|
glTexParameteri(Target, GL_TEXTURE_WRAP_R, GL_REPEAT);
|
|
}
|
|
}
|
|
glTexParameteri(Target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
if( FOpenGL::SupportsTextureFilterAnisotropic() )
|
|
{
|
|
glTexParameteri(Target, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1);
|
|
}
|
|
if ( FOpenGL::SupportsTextureBaseLevel() )
|
|
{
|
|
glTexParameteri(Target, GL_TEXTURE_BASE_LEVEL, 0);
|
|
}
|
|
if ( FOpenGL::SupportsTextureMaxLevel() )
|
|
{
|
|
glTexParameteri(Target, GL_TEXTURE_MAX_LEVEL, NumMips - 1);
|
|
}
|
|
|
|
TextureMipLimits.Add(TextureID, TPair<GLenum, GLenum>(0, NumMips - 1));
|
|
|
|
if (FOpenGL::SupportsTextureSwizzle() && GLFormat.bBGRA && !(Flags & TexCreate_RenderTargetable))
|
|
{
|
|
glTexParameteri(Target, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
|
|
glTexParameteri(Target, GL_TEXTURE_SWIZZLE_B, GL_RED);
|
|
}
|
|
|
|
if (bArrayTexture)
|
|
{
|
|
FOpenGL::TexStorage3D( Target, NumMips, GLFormat.InternalFormat[bSRGB], SizeX, SizeY, ArraySize, GLFormat.Format, GLFormat.Type);
|
|
}
|
|
else
|
|
{
|
|
// Should we use client-storage to improve update time on platforms that require it
|
|
bool const bRenderable = (Flags & (TexCreate_RenderTargetable|TexCreate_ResolveTargetable|TexCreate_DepthStencilTargetable|TexCreate_CPUReadback)) != 0;
|
|
bool const bUseClientStorage = (FOpenGL::SupportsClientStorage() && !FOpenGL::SupportsTextureView() && !bRenderable && !GLFormat.bCompressed);
|
|
if(bUseClientStorage)
|
|
{
|
|
const bool bIsCubeTexture = Target == GL_TEXTURE_CUBE_MAP;
|
|
const uint32 TextureSize = CalcTextureSize(SizeX, SizeY, (EPixelFormat)Format, NumMips) * (bIsCubeTexture ? 6 : 1);
|
|
const GLenum FirstTarget = bIsCubeTexture ? GL_TEXTURE_CUBE_MAP_POSITIVE_X : Target;
|
|
const uint32 NumTargets = bIsCubeTexture ? 6 : 1;
|
|
|
|
TextureRange = new uint8[TextureSize];
|
|
check(TextureRange);
|
|
|
|
if(FOpenGL::SupportsTextureRange())
|
|
{
|
|
FOpenGL::TextureRange(Target, TextureSize, TextureRange);
|
|
glTexParameteri(Target, GL_TEXTURE_STORAGE_HINT_APPLE, GL_STORAGE_CACHED_APPLE);
|
|
}
|
|
|
|
glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
|
|
uint8* MipPointer = TextureRange;
|
|
for(uint32 MipIndex = 0; MipIndex < uint32(NumMips); MipIndex++)
|
|
{
|
|
const uint32 MipSize = CalcTextureMipMapSize(SizeX, SizeY, (EPixelFormat)Format, MipIndex);
|
|
for(uint32 TargetIndex = 0; TargetIndex < NumTargets; TargetIndex++)
|
|
{
|
|
glTexImage2D(
|
|
FirstTarget + TargetIndex,
|
|
MipIndex,
|
|
GLFormat.InternalFormat[bSRGB],
|
|
FMath::Max<uint32>(1,(SizeX >> MipIndex)),
|
|
FMath::Max<uint32>(1,(SizeY >> MipIndex)),
|
|
0,
|
|
GLFormat.Format,
|
|
GLFormat.Type,
|
|
MipPointer
|
|
);
|
|
MipPointer += MipSize;
|
|
}
|
|
}
|
|
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
|
glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
|
|
|
|
if(FOpenGL::SupportsTextureRange())
|
|
{
|
|
FOpenGL::TextureRange(Target, 0, 0);
|
|
glTexParameteri(Target, GL_TEXTURE_STORAGE_HINT_APPLE, GL_STORAGE_PRIVATE_APPLE);
|
|
}
|
|
|
|
// Leave bAllocatedStorage as false, so that the client storage buffers are setup only when the texture is locked
|
|
}
|
|
// Try to allocate using TexStorage2D
|
|
else if( FOpenGL::TexStorage2D( Target, NumMips, GLFormat.SizedInternalFormat[bSRGB], SizeX, SizeY, GLFormat.Format, GLFormat.Type, Flags) )
|
|
{
|
|
bAllocatedStorage = true;
|
|
}
|
|
else if (!GLFormat.bCompressed)
|
|
{
|
|
// Otherwise, allocate storage for each mip using TexImage2D
|
|
// We can't do so for compressed textures because we can't pass NULL in to CompressedTexImage2D!
|
|
bAllocatedStorage = true;
|
|
|
|
const bool bIsCubeTexture = Target == GL_TEXTURE_CUBE_MAP;
|
|
const GLenum FirstTarget = bIsCubeTexture ? GL_TEXTURE_CUBE_MAP_POSITIVE_X : Target;
|
|
const uint32 NumTargets = bIsCubeTexture ? 6 : 1;
|
|
|
|
for(uint32 MipIndex = 0; MipIndex < uint32(NumMips); MipIndex++)
|
|
{
|
|
for(uint32 TargetIndex = 0; TargetIndex < NumTargets; TargetIndex++)
|
|
{
|
|
glTexImage2D(
|
|
FirstTarget + TargetIndex,
|
|
MipIndex,
|
|
GLFormat.InternalFormat[bSRGB],
|
|
FMath::Max<uint32>(1,(SizeX >> MipIndex)),
|
|
FMath::Max<uint32>(1,(SizeY >> MipIndex)),
|
|
0,
|
|
GLFormat.Format,
|
|
GLFormat.Type,
|
|
NULL
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (BulkData != NULL)
|
|
{
|
|
uint8* Data = (uint8*)BulkData->GetResourceBulkData();
|
|
uint32 MipOffset = 0;
|
|
|
|
const uint32 BlockSizeX = GPixelFormats[Format].BlockSizeX;
|
|
const uint32 BlockSizeY = GPixelFormats[Format].BlockSizeY;
|
|
for(uint32 MipIndex = 0; MipIndex < NumMips; MipIndex++)
|
|
{
|
|
uint32 NumBlocksX = AlignArbitrary(FMath::Max<uint32>(1,(SizeX >> MipIndex)), BlockSizeX) / BlockSizeX;
|
|
uint32 NumBlocksY = AlignArbitrary(FMath::Max<uint32>(1,(SizeY >> MipIndex)), BlockSizeY) / BlockSizeY;
|
|
uint32 NumLayers = FMath::Max<uint32>(1,ArraySize);
|
|
|
|
if(bArrayTexture )
|
|
{
|
|
if(bCubeTexture)
|
|
{
|
|
check(FOpenGL::SupportsTexture3D());
|
|
FOpenGL::TexSubImage3D(
|
|
/*Target=*/ Target,
|
|
/*Level=*/ MipIndex,
|
|
/* XOffset */ 0,
|
|
/* YOffset */ 0,
|
|
/* ZOffset */ 0,
|
|
/*SizeX=*/ FMath::Max<uint32>(1,(SizeX >> MipIndex)),
|
|
/*SizeY=*/ FMath::Max<uint32>(1,(SizeY >> MipIndex)),
|
|
/*SizeZ=*/ ArraySize,
|
|
/*Format=*/ GLFormat.Format,
|
|
/*Type=*/ GLFormat.Type,
|
|
/*Data=*/ &Data[MipOffset]
|
|
);
|
|
}
|
|
else
|
|
{
|
|
// @todo: refactor 2d texture arrays here?
|
|
check(!bCubeTexture);
|
|
}
|
|
|
|
MipOffset += NumBlocksX * NumBlocksY * NumLayers * GPixelFormats[Format].BlockBytes;
|
|
}
|
|
else
|
|
{
|
|
GLenum FirstTarget = bCubeTexture ? GL_TEXTURE_CUBE_MAP_POSITIVE_X : Target;
|
|
uint32 NumTargets = bCubeTexture ? 6 : 1;
|
|
|
|
for(uint32 TargetIndex = 0; TargetIndex < NumTargets; TargetIndex++)
|
|
{
|
|
glTexSubImage2D(
|
|
/*Target=*/ FirstTarget + TargetIndex,
|
|
/*Level=*/ MipIndex,
|
|
/*XOffset*/ 0,
|
|
/*YOffset*/ 0,
|
|
/*SizeX=*/ FMath::Max<uint32>(1,(SizeX >> MipIndex)),
|
|
/*SizeY=*/ FMath::Max<uint32>(1,(SizeY >> MipIndex)),
|
|
/*Format=*/ GLFormat.Format,
|
|
/*Type=*/ GLFormat.Type,
|
|
/*Data=*/ &Data[MipOffset]
|
|
);
|
|
|
|
MipOffset += NumBlocksX * NumBlocksY * NumLayers * GPixelFormats[Format].BlockBytes;
|
|
}
|
|
}
|
|
}
|
|
|
|
BulkData->Discard();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
check( FOpenGL::SupportsMultisampledTextures() );
|
|
check( BulkData == NULL);
|
|
|
|
// Try to create an immutable texture and fallback if it fails
|
|
if (!FOpenGL::TexStorage2DMultisample( Target, NumSamples, GLFormat.InternalFormat[bSRGB], SizeX, SizeY, true))
|
|
{
|
|
FOpenGL::TexImage2DMultisample(
|
|
Target,
|
|
NumSamples,
|
|
GLFormat.InternalFormat[bSRGB],
|
|
SizeX,
|
|
SizeY,
|
|
true
|
|
);
|
|
}
|
|
}
|
|
|
|
// Determine the attachment point for the texture.
|
|
GLenum Attachment = GL_NONE;
|
|
if((Flags & TexCreate_RenderTargetable) || (Flags & TexCreate_CPUReadback))
|
|
{
|
|
Attachment = GL_COLOR_ATTACHMENT0;
|
|
}
|
|
else if(Flags & TexCreate_DepthStencilTargetable)
|
|
{
|
|
Attachment = (Format == PF_DepthStencil && FOpenGL::SupportsPackedDepthStencil()) ? GL_DEPTH_STENCIL_ATTACHMENT : GL_DEPTH_ATTACHMENT;
|
|
}
|
|
else if(Flags & TexCreate_ResolveTargetable)
|
|
{
|
|
Attachment = (Format == PF_DepthStencil && FOpenGL::SupportsPackedDepthStencil())
|
|
? GL_DEPTH_STENCIL_ATTACHMENT
|
|
: ((Format == PF_ShadowDepth || Format == PF_D24)
|
|
? GL_DEPTH_ATTACHMENT
|
|
: GL_COLOR_ATTACHMENT0);
|
|
}
|
|
|
|
switch(Attachment)
|
|
{
|
|
case GL_COLOR_ATTACHMENT0:
|
|
check(GMaxOpenGLColorSamples>=(GLint)NumSamples);
|
|
break;
|
|
case GL_DEPTH_ATTACHMENT:
|
|
case GL_DEPTH_STENCIL_ATTACHMENT:
|
|
check(GMaxOpenGLDepthSamples>=(GLint)NumSamples);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
// @todo: If integer pixel format
|
|
//check(GMaxOpenGLIntegerSamples>=NumSamples);
|
|
|
|
FRHITexture* Texture;
|
|
if (bCubeTexture)
|
|
{
|
|
FOpenGLTextureCube* TextureCube = new FOpenGLTextureCube(this, TextureID, Target, Attachment, SizeX, SizeY, 0, NumMips, 1, 1, ArraySize, (EPixelFormat)Format, true, bAllocatedStorage, Flags, TextureRange, InClearValue);
|
|
Texture = TextureCube;
|
|
}
|
|
else
|
|
{
|
|
FOpenGLTexture2D* Texture2D = new FOpenGLTexture2D(this,TextureID,Target,Attachment,SizeX,SizeY,0,NumMips,NumSamples, NumSamplesTileMem, 1, (EPixelFormat)Format,false,bAllocatedStorage,Flags,TextureRange, InClearValue);
|
|
Texture = Texture2D;
|
|
}
|
|
OpenGLTextureAllocated( Texture, Flags );
|
|
|
|
// No need to restore texture stage; leave it like this,
|
|
// and the next draw will take care of cleaning it up; or
|
|
// next operation that needs the stage will switch something else in on it.
|
|
|
|
return Texture;
|
|
}
|
|
|
|
#if PLATFORM_MAC || PLATFORM_ANDROIDESDEFERRED // Flithy hack to workaround radr://16011763
|
|
GLuint FOpenGLTextureBase::GetOpenGLFramebuffer(uint32 ArrayIndices, uint32 MipmapLevels)
|
|
{
|
|
GLuint FBO = 0;
|
|
switch(Attachment)
|
|
{
|
|
case GL_COLOR_ATTACHMENT0:
|
|
{
|
|
FOpenGLTextureBase* RenderTarget[] = {this};
|
|
FBO = OpenGLRHI->GetOpenGLFramebuffer(1, RenderTarget, &ArrayIndices, &MipmapLevels, NULL);
|
|
break;
|
|
}
|
|
case GL_DEPTH_ATTACHMENT:
|
|
case GL_DEPTH_STENCIL_ATTACHMENT:
|
|
{
|
|
FBO = OpenGLRHI->GetOpenGLFramebuffer(1, NULL, &ArrayIndices, &MipmapLevels, this);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return FBO;
|
|
}
|
|
#endif
|
|
|
|
void FOpenGLTextureBase::InvalidateTextureResourceInCache()
|
|
{
|
|
OpenGLRHI->InvalidateTextureResourceInCache(Resource);
|
|
if (SRVResource)
|
|
{
|
|
OpenGLRHI->InvalidateTextureResourceInCache(SRVResource);
|
|
}
|
|
}
|
|
|
|
template<typename RHIResourceType>
|
|
void TOpenGLTexture<RHIResourceType>::Resolve(uint32 MipIndex,uint32 ArrayIndex)
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
|
|
#if UE_BUILD_DEBUG
|
|
if((FOpenGLTexture2D*)this->GetTexture2D())
|
|
{
|
|
check( ((FOpenGLTexture2D*)this->GetTexture2D())->GetNumSamples() == 1 );
|
|
}
|
|
#endif
|
|
|
|
// Calculate the dimensions of the mip-map.
|
|
EPixelFormat PixelFormat = this->GetFormat();
|
|
const uint32 BlockSizeX = GPixelFormats[PixelFormat].BlockSizeX;
|
|
const uint32 BlockSizeY = GPixelFormats[PixelFormat].BlockSizeY;
|
|
const uint32 BlockBytes = GPixelFormats[PixelFormat].BlockBytes;
|
|
const uint32 MipSizeX = FMath::Max(this->GetSizeX() >> MipIndex,BlockSizeX);
|
|
const uint32 MipSizeY = FMath::Max(this->GetSizeY() >> MipIndex,BlockSizeY);
|
|
uint32 NumBlocksX = (MipSizeX + BlockSizeX - 1) / BlockSizeX;
|
|
uint32 NumBlocksY = (MipSizeY + BlockSizeY - 1) / BlockSizeY;
|
|
if ( PixelFormat == PF_PVRTC2 || PixelFormat == PF_PVRTC4 )
|
|
{
|
|
// PVRTC has minimum 2 blocks width and height
|
|
NumBlocksX = FMath::Max<uint32>(NumBlocksX, 2);
|
|
NumBlocksY = FMath::Max<uint32>(NumBlocksY, 2);
|
|
}
|
|
const uint32 MipBytes = NumBlocksX * NumBlocksY * BlockBytes;
|
|
|
|
const int32 BufferIndex = MipIndex * (bCubemap ? 6 : 1) * this->GetEffectiveSizeZ() + ArrayIndex;
|
|
|
|
// Standard path with a PBO mirroring ever slice of a texture to allow multiple simulataneous maps
|
|
if (!IsValidRef(PixelBuffers[BufferIndex]))
|
|
{
|
|
PixelBuffers[BufferIndex] = new FOpenGLPixelBuffer(0, MipBytes, BUF_Dynamic);
|
|
}
|
|
|
|
TRefCountPtr<FOpenGLPixelBuffer> PixelBuffer = PixelBuffers[BufferIndex];
|
|
check(PixelBuffer->GetSize() == MipBytes);
|
|
check(!PixelBuffer->IsLocked());
|
|
|
|
check( FOpenGL::SupportsPixelBuffers() );
|
|
|
|
// Transfer data from texture to pixel buffer.
|
|
// This may be further optimized by caching information if surface content was changed since last lock.
|
|
|
|
const FOpenGLTextureFormat& GLFormat = GOpenGLTextureFormats[PixelFormat];
|
|
const bool bSRGB = (this->GetFlags() & TexCreate_SRGB) != 0;
|
|
|
|
// Use a texture stage that's not likely to be used for draws, to avoid waiting
|
|
FOpenGLContextState& ContextState = OpenGLRHI->GetContextStateForCurrentContext();
|
|
OpenGLRHI->CachedSetupTextureStage(ContextState, FOpenGL::GetMaxCombinedTextureImageUnits() - 1, Target, Resource, -1, this->GetNumMips());
|
|
|
|
glBindBuffer( GL_PIXEL_PACK_BUFFER, PixelBuffer->Resource );
|
|
|
|
#if PLATFORM_MAC || PLATFORM_ANDROIDESDEFERRED // glReadPixels is async with PBOs - glGetTexImage is not: radr://16011763
|
|
if(Attachment == GL_COLOR_ATTACHMENT0 && !GLFormat.bCompressed)
|
|
{
|
|
GLuint SourceFBO = GetOpenGLFramebuffer(ArrayIndex, MipIndex);
|
|
check(SourceFBO > 0);
|
|
glBindFramebuffer(UGL_READ_FRAMEBUFFER, SourceFBO);
|
|
FOpenGL::ReadBuffer(Attachment);
|
|
glPixelStorei(GL_PACK_ALIGNMENT, 1);
|
|
glReadPixels(0, 0, MipSizeX, MipSizeY, GLFormat.Format, GLFormat.Type, 0 );
|
|
glPixelStorei(GL_PACK_ALIGNMENT, 4);
|
|
ContextState.Framebuffer = (GLuint)-1;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
if( this->GetSizeZ() )
|
|
{
|
|
// apparently it's not possible to retrieve compressed image from GL_TEXTURE_2D_ARRAY in OpenGL for compressed images
|
|
// and for uncompressed ones it's not possible to specify the image index
|
|
check(0);
|
|
}
|
|
else
|
|
{
|
|
if (GLFormat.bCompressed)
|
|
{
|
|
FOpenGL::GetCompressedTexImage(
|
|
bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Target,
|
|
MipIndex,
|
|
0); // offset into PBO
|
|
}
|
|
else
|
|
{
|
|
glPixelStorei(GL_PACK_ALIGNMENT, 1);
|
|
FOpenGL::GetTexImage(
|
|
bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Target,
|
|
MipIndex,
|
|
GLFormat.Format,
|
|
GLFormat.Type,
|
|
0); // offset into PBO
|
|
glPixelStorei(GL_PACK_ALIGNMENT, 4);
|
|
}
|
|
}
|
|
}
|
|
|
|
glBindBuffer( GL_PIXEL_PACK_BUFFER, 0 );
|
|
|
|
// No need to restore texture stage; leave it like this,
|
|
// and the next draw will take care of cleaning it up; or
|
|
// next operation that needs the stage will switch something else in on it.
|
|
}
|
|
|
|
template<typename RHIResourceType>
|
|
void* TOpenGLTexture<RHIResourceType>::Lock(uint32 InMipIndex,uint32 ArrayIndex,EResourceLockMode LockMode,uint32& DestStride)
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
|
|
#if UE_BUILD_DEBUG
|
|
if((FOpenGLTexture2D*)this->GetTexture2D())
|
|
{
|
|
check( ((FOpenGLTexture2D*)this->GetTexture2D())->GetNumSamples() == 1 );
|
|
}
|
|
#endif
|
|
|
|
SCOPE_CYCLE_COUNTER(STAT_OpenGLLockTextureTime);
|
|
|
|
void* result = NULL;
|
|
|
|
// Calculate the dimensions of the mip-map.
|
|
EPixelFormat PixelFormat = this->GetFormat();
|
|
const uint32 BlockSizeX = GPixelFormats[PixelFormat].BlockSizeX;
|
|
const uint32 BlockSizeY = GPixelFormats[PixelFormat].BlockSizeY;
|
|
const uint32 BlockBytes = GPixelFormats[PixelFormat].BlockBytes;
|
|
const uint32 MipSizeX = FMath::Max(this->GetSizeX() >> InMipIndex,BlockSizeX);
|
|
const uint32 MipSizeY = FMath::Max(this->GetSizeY() >> InMipIndex,BlockSizeY);
|
|
uint32 NumBlocksX = (MipSizeX + BlockSizeX - 1) / BlockSizeX;
|
|
uint32 NumBlocksY = (MipSizeY + BlockSizeY - 1) / BlockSizeY;
|
|
if ( PixelFormat == PF_PVRTC2 || PixelFormat == PF_PVRTC4 )
|
|
{
|
|
// PVRTC has minimum 2 blocks width and height
|
|
NumBlocksX = FMath::Max<uint32>(NumBlocksX, 2);
|
|
NumBlocksY = FMath::Max<uint32>(NumBlocksY, 2);
|
|
}
|
|
const uint32 MipBytes = NumBlocksX * NumBlocksY * BlockBytes;
|
|
|
|
DestStride = NumBlocksX * BlockBytes;
|
|
|
|
const int32 BufferIndex = InMipIndex * (bCubemap ? 6 : 1) * this->GetEffectiveSizeZ() + ArrayIndex;
|
|
|
|
// Should we use client-storage to improve update time on platforms that require it
|
|
const FOpenGLTextureFormat& GLFormat = GOpenGLTextureFormats[PixelFormat];
|
|
bool const bRenderable = (this->GetFlags() & (TexCreate_RenderTargetable|TexCreate_ResolveTargetable|TexCreate_DepthStencilTargetable|TexCreate_CPUReadback)) != 0;
|
|
bool const bUseClientStorage = FOpenGL::SupportsClientStorage() && !FOpenGL::SupportsTextureView() && !bRenderable && !this->GetSizeZ() && !GLFormat.bCompressed;
|
|
if(!bUseClientStorage)
|
|
{
|
|
// Standard path with a PBO mirroring ever slice of a texture to allow multiple simulataneous maps
|
|
bool bBufferExists = true;
|
|
if (!IsValidRef(PixelBuffers[BufferIndex]))
|
|
{
|
|
bBufferExists = false;
|
|
PixelBuffers[BufferIndex] = new FOpenGLPixelBuffer(0, MipBytes, BUF_Dynamic);
|
|
}
|
|
|
|
TRefCountPtr<FOpenGLPixelBuffer> PixelBuffer = PixelBuffers[BufferIndex];
|
|
check(PixelBuffer->GetSize() == MipBytes);
|
|
check(!PixelBuffer->IsLocked());
|
|
|
|
// If the buffer already exists & the flags are such that the texture cannot be rendered to & is CPU accessible then we can skip the internal resolve for read locks. This makes HZB occlusion faster.
|
|
const bool bCPUTexResolved = bBufferExists && (this->GetFlags() & TexCreate_CPUReadback) && !(this->GetFlags() & (TexCreate_RenderTargetable|TexCreate_DepthStencilTargetable));
|
|
|
|
if( LockMode != RLM_WriteOnly && !bCPUTexResolved && FOpenGL::SupportsPixelBuffers() )
|
|
{
|
|
Resolve(InMipIndex, ArrayIndex);
|
|
}
|
|
|
|
result = PixelBuffer->Lock(0, PixelBuffer->GetSize(), LockMode == RLM_ReadOnly, LockMode != RLM_ReadOnly);
|
|
}
|
|
else
|
|
{
|
|
// Use APPLE_client_storage to reduce memory usage and improve performance
|
|
// GL's which support this extension only need copy a pointer, not the memory contents
|
|
check( FOpenGL::SupportsClientStorage() && !FOpenGL::SupportsTextureView() );
|
|
if(GetAllocatedStorageForMip(InMipIndex,ArrayIndex))
|
|
{
|
|
result = ClientStorageBuffers[BufferIndex].Data;
|
|
}
|
|
else
|
|
{
|
|
// The assumption at present is that this only applies to 2D & cubemap textures
|
|
// Array, 3D and variants thereof aren't supported.
|
|
const bool bIsCubeTexture = Target == GL_TEXTURE_CUBE_MAP;
|
|
const GLenum FirstTarget = bIsCubeTexture ? GL_TEXTURE_CUBE_MAP_POSITIVE_X : Target;
|
|
const uint32 NumTargets = bIsCubeTexture ? 6 : 1;
|
|
|
|
uint8* MipPointer = TextureRange;
|
|
for(uint32 MipIndex = 0; MipIndex < FOpenGLTextureBase::NumMips; MipIndex++)
|
|
{
|
|
const uint32 MipSize = CalcTextureMipMapSize(this->GetSizeX(), this->GetSizeY(), PixelFormat, MipIndex);
|
|
for(uint32 TargetIndex = 0; TargetIndex < NumTargets; TargetIndex++)
|
|
{
|
|
const int32 ClientIndex = (MipIndex * NumTargets) + TargetIndex;
|
|
ClientStorageBuffers[ClientIndex].Data = MipPointer;
|
|
ClientStorageBuffers[ClientIndex].Size = MipSize;
|
|
ClientStorageBuffers[ClientIndex].bReadOnly = false;
|
|
MipPointer += MipSize;
|
|
SetAllocatedStorageForMip(MipIndex,TargetIndex);
|
|
}
|
|
|
|
}
|
|
|
|
result = ClientStorageBuffers[BufferIndex].Data;
|
|
}
|
|
ClientStorageBuffers[BufferIndex].bReadOnly = (LockMode == RLM_ReadOnly);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// Copied from OpenGLDebugFrameDump.
|
|
inline uint32 HalfFloatToFloatInteger(uint16 HalfFloat)
|
|
{
|
|
uint32 Sign = (HalfFloat >> 15) & 0x00000001;
|
|
uint32 Exponent = (HalfFloat >> 10) & 0x0000001f;
|
|
uint32 Mantiss = HalfFloat & 0x000003ff;
|
|
|
|
if (Exponent == 0)
|
|
{
|
|
if (Mantiss == 0) // Plus or minus zero
|
|
{
|
|
return Sign << 31;
|
|
}
|
|
else // Denormalized number -- renormalize it
|
|
{
|
|
while ((Mantiss & 0x00000400) == 0)
|
|
{
|
|
Mantiss <<= 1;
|
|
Exponent -= 1;
|
|
}
|
|
|
|
Exponent += 1;
|
|
Mantiss &= ~0x00000400;
|
|
}
|
|
}
|
|
else if (Exponent == 31)
|
|
{
|
|
if (Mantiss == 0) // Inf
|
|
return (Sign << 31) | 0x7f800000;
|
|
else // NaN
|
|
return (Sign << 31) | 0x7f800000 | (Mantiss << 13);
|
|
}
|
|
|
|
Exponent = Exponent + (127 - 15);
|
|
Mantiss = Mantiss << 13;
|
|
|
|
return (Sign << 31) | (Exponent << 23) | Mantiss;
|
|
}
|
|
|
|
inline float HalfFloatToFloat(uint16 HalfFloat)
|
|
{
|
|
union
|
|
{
|
|
float F;
|
|
uint32 I;
|
|
} Convert;
|
|
|
|
Convert.I = HalfFloatToFloatInteger(HalfFloat);
|
|
return Convert.F;
|
|
}
|
|
|
|
template<typename RHIResourceType>
|
|
void TOpenGLTexture<RHIResourceType>::Unlock(uint32 MipIndex,uint32 ArrayIndex)
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
|
|
SCOPE_CYCLE_COUNTER(STAT_OpenGLUnlockTextureTime);
|
|
|
|
const int32 BufferIndex = MipIndex * (bCubemap ? 6 : 1) * this->GetEffectiveSizeZ() + ArrayIndex;
|
|
TRefCountPtr<FOpenGLPixelBuffer> PixelBuffer = PixelBuffers[BufferIndex];
|
|
const FOpenGLTextureFormat& GLFormat = GOpenGLTextureFormats[this->GetFormat()];
|
|
const bool bSRGB = (this->GetFlags() & TexCreate_SRGB) != 0;
|
|
|
|
// Should we use client-storage to improve update time on platforms that require it
|
|
bool const bRenderable = (this->GetFlags() & (TexCreate_RenderTargetable|TexCreate_ResolveTargetable|TexCreate_DepthStencilTargetable|TexCreate_CPUReadback)) != 0;
|
|
bool const bUseClientStorage = FOpenGL::SupportsClientStorage() && !FOpenGL::SupportsTextureView() && !bRenderable && !this->GetSizeZ() && !GLFormat.bCompressed;
|
|
check(bUseClientStorage || IsValidRef(PixelBuffers[BufferIndex]));
|
|
|
|
#if PLATFORM_ANDROID
|
|
// check for FloatRGBA to RGBA8 conversion needed
|
|
if (this->GetFormat() == PF_FloatRGBA && GLFormat.Type == GL_UNSIGNED_BYTE)
|
|
{
|
|
UE_LOG(LogRHI, Warning, TEXT("Converting texture from PF_FloatRGBA to RGBA8! Only supported for limited cases of 0.0 to 1.0 values (clamped)"));
|
|
|
|
// Code path for non-PBO: and always uncompressed!
|
|
// Volume/array textures are currently only supported if PixelBufferObjects are also supported.
|
|
check(this->GetSizeZ() == 0);
|
|
|
|
// Use a texture stage that's not likely to be used for draws, to avoid waiting
|
|
FOpenGLContextState& ContextState = OpenGLRHI->GetContextStateForCurrentContext();
|
|
OpenGLRHI->CachedSetupTextureStage(ContextState, FOpenGL::GetMaxCombinedTextureImageUnits() - 1, Target, Resource, -1, this->GetNumMips());
|
|
|
|
CachedBindPixelUnpackBuffer(0);
|
|
|
|
// get the source data and size
|
|
uint16* floatData = (uint16*)PixelBuffer->GetLockedBuffer();
|
|
int32 texWidth = FMath::Max<uint32>(1, (this->GetSizeX() >> MipIndex));
|
|
int32 texHeight = FMath::Max<uint32>(1, (this->GetSizeY() >> MipIndex));
|
|
|
|
// always RGBA8 so 4 bytes / pixel
|
|
int nValues = texWidth * texHeight * 4;
|
|
uint8* rgbaData = (uint8*)FMemory::Malloc(nValues);
|
|
|
|
// convert to GL_BYTE (saturate)
|
|
uint8* outPtr = rgbaData;
|
|
while (nValues--)
|
|
{
|
|
int32 pixelValue = (int32)(HalfFloatToFloat(*floatData++) * 255.0f);
|
|
*outPtr++ = (uint8)(pixelValue < 0 ? 0 : (pixelValue < 256 ? pixelValue : 255));
|
|
}
|
|
|
|
// All construction paths should have called TexStorage2D or TexImage2D. So we will
|
|
// always call TexSubImage2D.
|
|
check(GetAllocatedStorageForMip(MipIndex, ArrayIndex) == true);
|
|
glTexSubImage2D(
|
|
bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Target,
|
|
MipIndex,
|
|
0,
|
|
0,
|
|
texWidth,
|
|
texHeight,
|
|
GLFormat.Format,
|
|
GLFormat.Type,
|
|
rgbaData);
|
|
|
|
// free temporary conversion buffer
|
|
FMemory::Free(rgbaData);
|
|
|
|
// Unlock "PixelBuffer" and free the temp memory after the texture upload.
|
|
PixelBuffer->Unlock();
|
|
|
|
// No need to restore texture stage; leave it like this,
|
|
// and the next draw will take care of cleaning it up; or
|
|
// next operation that needs the stage will switch something else in on it.
|
|
|
|
CachedBindPixelUnpackBuffer(0);
|
|
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
if ( !bUseClientStorage && FOpenGL::SupportsPixelBuffers() )
|
|
{
|
|
// Code path for PBO per slice
|
|
check(IsValidRef(PixelBuffers[BufferIndex]));
|
|
|
|
PixelBuffer->Unlock();
|
|
|
|
// Modify permission?
|
|
if (!PixelBuffer->IsLockReadOnly())
|
|
{
|
|
// Use a texture stage that's not likely to be used for draws, to avoid waiting
|
|
FOpenGLContextState& ContextState = OpenGLRHI->GetContextStateForCurrentContext();
|
|
OpenGLRHI->CachedSetupTextureStage(ContextState, FOpenGL::GetMaxCombinedTextureImageUnits() - 1, Target, Resource, -1, this->GetNumMips());
|
|
|
|
if( this->GetSizeZ() )
|
|
{
|
|
// texture 2D array
|
|
if (GLFormat.bCompressed)
|
|
{
|
|
FOpenGL::CompressedTexSubImage3D(
|
|
Target,
|
|
MipIndex,
|
|
0,
|
|
0,
|
|
ArrayIndex,
|
|
FMath::Max<uint32>(1,(this->GetSizeX() >> MipIndex)),
|
|
FMath::Max<uint32>(1,(this->GetSizeY() >> MipIndex)),
|
|
1,
|
|
GLFormat.InternalFormat[bSRGB],
|
|
PixelBuffer->GetSize(),
|
|
0);
|
|
}
|
|
else
|
|
{
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
check( FOpenGL::SupportsTexture3D() );
|
|
FOpenGL::TexSubImage3D(
|
|
Target,
|
|
MipIndex,
|
|
0,
|
|
0,
|
|
ArrayIndex,
|
|
FMath::Max<uint32>(1,(this->GetSizeX() >> MipIndex)),
|
|
FMath::Max<uint32>(1,(this->GetSizeY() >> MipIndex)),
|
|
1,
|
|
GLFormat.Format,
|
|
GLFormat.Type,
|
|
0); // offset into PBO
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (GLFormat.bCompressed)
|
|
{
|
|
if (GetAllocatedStorageForMip(MipIndex,ArrayIndex))
|
|
{
|
|
glCompressedTexSubImage2D(
|
|
bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Target,
|
|
MipIndex,
|
|
0,
|
|
0,
|
|
FMath::Max<uint32>(1,(this->GetSizeX() >> MipIndex)),
|
|
FMath::Max<uint32>(1,(this->GetSizeY() >> MipIndex)),
|
|
GLFormat.InternalFormat[bSRGB],
|
|
PixelBuffer->GetSize(),
|
|
0); // offset into PBO
|
|
}
|
|
else
|
|
{
|
|
glCompressedTexImage2D(
|
|
bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Target,
|
|
MipIndex,
|
|
GLFormat.InternalFormat[bSRGB],
|
|
FMath::Max<uint32>(1,(this->GetSizeX() >> MipIndex)),
|
|
FMath::Max<uint32>(1,(this->GetSizeY() >> MipIndex)),
|
|
0,
|
|
PixelBuffer->GetSize(),
|
|
0); // offset into PBO
|
|
SetAllocatedStorageForMip(MipIndex,ArrayIndex);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// All construction paths should have called TexStorage2D or TexImage2D. So we will
|
|
// always call TexSubImage2D.
|
|
check(GetAllocatedStorageForMip(MipIndex,ArrayIndex) == true);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
glTexSubImage2D(
|
|
bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Target,
|
|
MipIndex,
|
|
0,
|
|
0,
|
|
FMath::Max<uint32>(1,(this->GetSizeX() >> MipIndex)),
|
|
FMath::Max<uint32>(1,(this->GetSizeY() >> MipIndex)),
|
|
GLFormat.Format,
|
|
GLFormat.Type,
|
|
0); // offset into PBO
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
|
}
|
|
}
|
|
}
|
|
|
|
//need to free PBO if we aren't keeping shadow copies
|
|
if(!PLATFORM_MAC || !GLFormat.bCompressed || Target != GL_TEXTURE_2D)
|
|
{
|
|
PixelBuffers[BufferIndex] = NULL;
|
|
}
|
|
}
|
|
else if(!bUseClientStorage || !ClientStorageBuffers[BufferIndex].bReadOnly)
|
|
{
|
|
// Code path for non-PBO:
|
|
// Volume/array textures are currently only supported if PixelBufferObjects are also supported.
|
|
check(this->GetSizeZ() == 0);
|
|
|
|
// Use a texture stage that's not likely to be used for draws, to avoid waiting
|
|
FOpenGLContextState& ContextState = OpenGLRHI->GetContextStateForCurrentContext();
|
|
OpenGLRHI->CachedSetupTextureStage(ContextState, FOpenGL::GetMaxCombinedTextureImageUnits() - 1, Target, Resource, -1, this->GetNumMips());
|
|
|
|
CachedBindPixelUnpackBuffer( 0 );
|
|
|
|
uint32 LockedSize = 0;
|
|
void* LockedBuffer = nullptr;
|
|
|
|
if(bUseClientStorage)
|
|
{
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
|
|
LockedSize = ClientStorageBuffers[BufferIndex].Size;
|
|
LockedBuffer = ClientStorageBuffers[BufferIndex].Data;
|
|
}
|
|
else
|
|
{
|
|
LockedSize = PixelBuffer->GetSize();
|
|
LockedBuffer = PixelBuffer->GetLockedBuffer();
|
|
}
|
|
if (GLFormat.bCompressed)
|
|
{
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
if (GetAllocatedStorageForMip(MipIndex,ArrayIndex))
|
|
{
|
|
glCompressedTexSubImage2D(
|
|
bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Target,
|
|
MipIndex,
|
|
0,
|
|
0,
|
|
FMath::Max<uint32>(1,(this->GetSizeX() >> MipIndex)),
|
|
FMath::Max<uint32>(1,(this->GetSizeY() >> MipIndex)),
|
|
GLFormat.InternalFormat[bSRGB],
|
|
LockedSize,
|
|
LockedBuffer);
|
|
}
|
|
else
|
|
{
|
|
glCompressedTexImage2D(
|
|
bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Target,
|
|
MipIndex,
|
|
GLFormat.InternalFormat[bSRGB],
|
|
FMath::Max<uint32>(1,(this->GetSizeX() >> MipIndex)),
|
|
FMath::Max<uint32>(1,(this->GetSizeY() >> MipIndex)),
|
|
0,
|
|
LockedSize,
|
|
LockedBuffer);
|
|
SetAllocatedStorageForMip(MipIndex,ArrayIndex);
|
|
}
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
|
}
|
|
else
|
|
{
|
|
if (GetAllocatedStorageForMip(MipIndex,ArrayIndex))
|
|
{
|
|
glTexSubImage2D(
|
|
bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Target,
|
|
MipIndex,
|
|
0,
|
|
0,
|
|
FMath::Max<uint32>(1,(this->GetSizeX() >> MipIndex)),
|
|
FMath::Max<uint32>(1,(this->GetSizeY() >> MipIndex)),
|
|
GLFormat.Format,
|
|
GLFormat.Type,
|
|
LockedBuffer);
|
|
}
|
|
else
|
|
{
|
|
glTexImage2D(
|
|
bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Target,
|
|
MipIndex,
|
|
GLFormat.InternalFormat[bSRGB],
|
|
FMath::Max<uint32>(1,(this->GetSizeX() >> MipIndex)),
|
|
FMath::Max<uint32>(1,(this->GetSizeY() >> MipIndex)),
|
|
0,
|
|
GLFormat.Format,
|
|
GLFormat.Type,
|
|
LockedBuffer);
|
|
SetAllocatedStorageForMip(MipIndex,ArrayIndex);
|
|
}
|
|
}
|
|
if(bUseClientStorage)
|
|
{
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
|
glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
|
|
}
|
|
else
|
|
{
|
|
// Unlock "PixelBuffer" and free the temp memory after the texture upload.
|
|
PixelBuffer->Unlock();
|
|
}
|
|
}
|
|
|
|
// No need to restore texture stage; leave it like this,
|
|
// and the next draw will take care of cleaning it up; or
|
|
// next operation that needs the stage will switch something else in on it.
|
|
|
|
CachedBindPixelUnpackBuffer(0);
|
|
}
|
|
|
|
template<typename RHIResourceType>
|
|
void TOpenGLTexture<RHIResourceType>::CloneViaCopyImage( TOpenGLTexture<RHIResourceType>* Src, uint32 NumMips, int32 SrcOffset, int32 DstOffset)
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
|
|
check(FOpenGL::SupportsCopyImage());
|
|
|
|
for (uint32 ArrayIndex = 0; ArrayIndex < this->GetEffectiveSizeZ(); ArrayIndex++)
|
|
{
|
|
// use the Copy Image functionality to copy mip level by mip level
|
|
for(uint32 MipIndex = 0;MipIndex < NumMips;++MipIndex)
|
|
{
|
|
// Calculate the dimensions of the mip-map.
|
|
const uint32 DstMipIndex = MipIndex + DstOffset;
|
|
const uint32 SrcMipIndex = MipIndex + SrcOffset;
|
|
const uint32 MipSizeX = FMath::Max(this->GetSizeX() >> DstMipIndex,uint32(1));
|
|
const uint32 MipSizeY = FMath::Max(this->GetSizeY() >> DstMipIndex,uint32(1));
|
|
|
|
if(FOpenGL::AmdWorkaround() && ((MipSizeX < 4) || (MipSizeY < 4))) break;
|
|
|
|
// copy the texture data
|
|
FOpenGL::CopyImageSubData( Src->Resource, Src->Target, SrcMipIndex, 0, 0, ArrayIndex,
|
|
Resource, Target, DstMipIndex, 0, 0, ArrayIndex, MipSizeX, MipSizeY, 1);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
template<typename RHIResourceType>
|
|
void TOpenGLTexture<RHIResourceType>::CloneViaPBO( TOpenGLTexture<RHIResourceType>* Src, uint32 NumMips, int32 SrcOffset, int32 DstOffset)
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
|
|
// apparently it's not possible to retrieve compressed image from GL_TEXTURE_2D_ARRAY in OpenGL for compressed images
|
|
// and for uncompressed ones it's not possible to specify the image index
|
|
check(this->GetSizeZ() == 0);
|
|
|
|
// only PBO path is supported here
|
|
check( FOpenGL::SupportsPixelBuffers() );
|
|
|
|
EPixelFormat PixelFormat = this->GetFormat();
|
|
check(PixelFormat == Src->GetFormat());
|
|
|
|
const FOpenGLTextureFormat& GLFormat = GOpenGLTextureFormats[PixelFormat];
|
|
const bool bSRGB = (this->GetFlags() & TexCreate_SRGB) != 0;
|
|
check(bSRGB == ((Src->GetFlags() & TexCreate_SRGB) != 0));
|
|
|
|
const uint32 BlockSizeX = GPixelFormats[PixelFormat].BlockSizeX;
|
|
const uint32 BlockSizeY = GPixelFormats[PixelFormat].BlockSizeY;
|
|
const uint32 BlockBytes = GPixelFormats[PixelFormat].BlockBytes;
|
|
|
|
FOpenGLContextState& ContextState = OpenGLRHI->GetContextStateForCurrentContext();
|
|
|
|
for (uint32 ArrayIndex = 0; ArrayIndex < this->GetEffectiveSizeZ(); ArrayIndex++)
|
|
{
|
|
// use PBO functionality to copy mip level by mip level
|
|
for(uint32 MipIndex = 0;MipIndex < NumMips;++MipIndex)
|
|
{
|
|
// Actual mip levels
|
|
const uint32 DstMipIndex = MipIndex + DstOffset;
|
|
const uint32 SrcMipIndex = MipIndex + SrcOffset;
|
|
|
|
// Calculate the dimensions of the mip-map.
|
|
const uint32 MipSizeX = FMath::Max(this->GetSizeX() >> DstMipIndex,1u);
|
|
const uint32 MipSizeY = FMath::Max(this->GetSizeY() >> DstMipIndex,1u);
|
|
|
|
// Then the rounded PBO size required to capture this mip
|
|
const uint32 DataSizeX = FMath::Max(MipSizeX,BlockSizeX);
|
|
const uint32 DataSizeY = FMath::Max(MipSizeY,BlockSizeY);
|
|
uint32 NumBlocksX = (DataSizeX + BlockSizeX - 1) / BlockSizeX;
|
|
uint32 NumBlocksY = (DataSizeY + BlockSizeY - 1) / BlockSizeY;
|
|
if ( PixelFormat == PF_PVRTC2 || PixelFormat == PF_PVRTC4 )
|
|
{
|
|
// PVRTC has minimum 2 blocks width and height
|
|
NumBlocksX = FMath::Max<uint32>(NumBlocksX, 2);
|
|
NumBlocksY = FMath::Max<uint32>(NumBlocksY, 2);
|
|
}
|
|
|
|
const uint32 MipBytes = NumBlocksX * NumBlocksY * BlockBytes;
|
|
const int32 BufferIndex = DstMipIndex * (bCubemap ? 6 : 1) * this->GetEffectiveSizeZ() + ArrayIndex;
|
|
const int32 SrcBufferIndex = SrcMipIndex * (Src->bCubemap ? 6 : 1) * Src->GetEffectiveSizeZ() + ArrayIndex;
|
|
|
|
// Retain the existing PBO for this texture data - as it is compressed it won't change
|
|
if(PLATFORM_MAC && GLFormat.bCompressed && Target == GL_TEXTURE_2D)
|
|
{
|
|
PixelBuffers[BufferIndex] = Src->PixelBuffers[SrcBufferIndex];
|
|
check(PixelBuffers[BufferIndex]->GetSize() == MipBytes);
|
|
check(!PixelBuffers[BufferIndex]->IsLocked());
|
|
}
|
|
|
|
// Standard path with a PBO mirroring ever slice of a texture to allow multiple simulataneous maps
|
|
if (!IsValidRef(PixelBuffers[BufferIndex]))
|
|
{
|
|
PixelBuffers[BufferIndex] = new FOpenGLPixelBuffer(0, MipBytes, BUF_Dynamic);
|
|
}
|
|
|
|
TRefCountPtr<FOpenGLPixelBuffer> PixelBuffer = PixelBuffers[BufferIndex];
|
|
check(PixelBuffer->GetSize() == MipBytes);
|
|
check(!PixelBuffer->IsLocked());
|
|
|
|
// Transfer data from texture to pixel buffer.
|
|
// This may be further optimized by caching information if surface content was changed since last lock.
|
|
if(!PLATFORM_MAC || !GLFormat.bCompressed || !IsValidRef(Src->PixelBuffers[SrcBufferIndex]))
|
|
{
|
|
// Use a texture stage that's not likely to be used for draws, to avoid waiting
|
|
OpenGLRHI->CachedSetupTextureStage(ContextState, FOpenGL::GetMaxCombinedTextureImageUnits() - 1, Src->Target, Src->Resource, -1, this->GetNumMips());
|
|
|
|
glBindBuffer( GL_PIXEL_PACK_BUFFER, PixelBuffer->Resource );
|
|
|
|
#if PLATFORM_MAC || PLATFORM_ANDROIDESDEFERRED // glReadPixels is async with PBOs - glGetTexImage is not: radr://16011763
|
|
if(Attachment == GL_COLOR_ATTACHMENT0 && !GLFormat.bCompressed)
|
|
{
|
|
GLuint SourceFBO = Src->GetOpenGLFramebuffer(ArrayIndex, SrcMipIndex);
|
|
check(SourceFBO > 0);
|
|
glBindFramebuffer(UGL_READ_FRAMEBUFFER, SourceFBO);
|
|
FOpenGL::ReadBuffer(Attachment);
|
|
glPixelStorei(GL_PACK_ALIGNMENT, 1);
|
|
glReadPixels(0, 0, MipSizeX, MipSizeY, GLFormat.Format, GLFormat.Type, 0 );
|
|
glPixelStorei(GL_PACK_ALIGNMENT, 4);
|
|
ContextState.Framebuffer = (GLuint)-1;
|
|
}
|
|
else
|
|
#endif
|
|
if (GLFormat.bCompressed)
|
|
{
|
|
FOpenGL::GetCompressedTexImage(Src->bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Src->Target,
|
|
SrcMipIndex,
|
|
0); // offset into PBO
|
|
}
|
|
else
|
|
{
|
|
glPixelStorei(GL_PACK_ALIGNMENT, 1);
|
|
FOpenGL::GetTexImage(Src->bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Src->Target,
|
|
SrcMipIndex,
|
|
GLFormat.Format,
|
|
GLFormat.Type,
|
|
0); // offset into PBO
|
|
glPixelStorei(GL_PACK_ALIGNMENT, 4);
|
|
}
|
|
}
|
|
|
|
// copy the texture data
|
|
// Upload directly into Dst to avoid out-of-band synchronization caused by glMapBuffer!
|
|
{
|
|
CachedBindPixelUnpackBuffer( PixelBuffer->Resource );
|
|
|
|
// Use a texture stage that's not likely to be used for draws, to avoid waiting
|
|
OpenGLRHI->CachedSetupTextureStage(ContextState, FOpenGL::GetMaxCombinedTextureImageUnits() - 1, Target, Resource, -1, this->GetNumMips());
|
|
|
|
if( this->GetSizeZ() )
|
|
{
|
|
// texture 2D array
|
|
if (GLFormat.bCompressed)
|
|
{
|
|
FOpenGL::CompressedTexSubImage3D(Target,
|
|
DstMipIndex,
|
|
0,
|
|
0,
|
|
ArrayIndex,
|
|
MipSizeX,
|
|
MipSizeY,
|
|
1,
|
|
GLFormat.InternalFormat[bSRGB],
|
|
PixelBuffer->GetSize(),
|
|
0);
|
|
}
|
|
else
|
|
{
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
check( FOpenGL::SupportsTexture3D() );
|
|
FOpenGL::TexSubImage3D(Target,
|
|
DstMipIndex,
|
|
0,
|
|
0,
|
|
ArrayIndex,
|
|
MipSizeX,
|
|
MipSizeY,
|
|
1,
|
|
GLFormat.Format,
|
|
GLFormat.Type,
|
|
0); // offset into PBO
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (GLFormat.bCompressed)
|
|
{
|
|
if (GetAllocatedStorageForMip(DstMipIndex,ArrayIndex))
|
|
{
|
|
glCompressedTexSubImage2D(bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Target,
|
|
DstMipIndex,
|
|
0,
|
|
0,
|
|
MipSizeX,
|
|
MipSizeY,
|
|
GLFormat.InternalFormat[bSRGB],
|
|
PixelBuffer->GetSize(),
|
|
0); // offset into PBO
|
|
}
|
|
else
|
|
{
|
|
glCompressedTexImage2D(bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Target,
|
|
DstMipIndex,
|
|
GLFormat.InternalFormat[bSRGB],
|
|
MipSizeX,
|
|
MipSizeY,
|
|
0,
|
|
PixelBuffer->GetSize(),
|
|
0); // offset into PBO
|
|
SetAllocatedStorageForMip(DstMipIndex,ArrayIndex);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// All construction paths should have called TexStorage2D or TexImage2D. So we will
|
|
// always call TexSubImage2D.
|
|
check(GetAllocatedStorageForMip(DstMipIndex,ArrayIndex) == true);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
glTexSubImage2D(bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Target,
|
|
DstMipIndex,
|
|
0,
|
|
0,
|
|
MipSizeX,
|
|
MipSizeY,
|
|
GLFormat.Format,
|
|
GLFormat.Type,
|
|
0); // offset into PBO
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!PLATFORM_MAC || !GLFormat.bCompressed || Target != GL_TEXTURE_2D)
|
|
{
|
|
// need to free PBO if we aren't keeping shadow copies
|
|
PixelBuffers[BufferIndex] = NULL;
|
|
}
|
|
|
|
// No need to restore texture stage; leave it like this,
|
|
// and the next draw will take care of cleaning it up; or
|
|
// next operation that needs the stage will switch something else in on it.
|
|
}
|
|
}
|
|
|
|
// Reset the buffer bindings on exit only
|
|
glBindBuffer( GL_PIXEL_PACK_BUFFER, 0 );
|
|
CachedBindPixelUnpackBuffer(0);
|
|
}
|
|
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
2D texture support.
|
|
-----------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* Creates a 2D RHI texture resource
|
|
* @param SizeX - width of the texture to create
|
|
* @param SizeY - height of the texture to create
|
|
* @param Format - EPixelFormat texture format
|
|
* @param NumMips - number of mips to generate or 0 for full mip pyramid
|
|
* @param Flags - ETextureCreateFlags creation flags
|
|
*/
|
|
FTexture2DRHIRef FOpenGLDynamicRHI::RHICreateTexture2D(uint32 SizeX,uint32 SizeY,uint8 Format,uint32 NumMips,uint32 NumSamples,uint32 Flags,FRHIResourceCreateInfo& Info)
|
|
{
|
|
return (FRHITexture2D*)CreateOpenGLTexture(SizeX,SizeY,false,false,Format,NumMips,NumSamples,1,Flags,Info.ClearValueBinding,Info.BulkData);
|
|
}
|
|
|
|
FTexture2DRHIRef FOpenGLDynamicRHI::RHIAsyncCreateTexture2D(uint32 SizeX, uint32 SizeY, uint8 Format, uint32 NumMips, uint32 Flags, void** InitialMipData, uint32 NumInitialMips)
|
|
{
|
|
check(0);
|
|
return FTexture2DRHIRef();
|
|
}
|
|
|
|
void FOpenGLDynamicRHI::RHICopySharedMips(FTexture2DRHIParamRef DestTexture2D,FTexture2DRHIParamRef SrcTexture2D)
|
|
{
|
|
check(0);
|
|
}
|
|
|
|
FTexture2DArrayRHIRef FOpenGLDynamicRHI::RHICreateTexture2DArray(uint32 SizeX,uint32 SizeY,uint32 SizeZ,uint8 Format,uint32 NumMips,uint32 Flags, FRHIResourceCreateInfo& Info)
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
|
|
SCOPE_CYCLE_COUNTER(STAT_OpenGLCreateTextureTime);
|
|
|
|
check( FOpenGL::SupportsTexture3D() );
|
|
|
|
if(NumMips == 0)
|
|
{
|
|
NumMips = FindMaxMipmapLevel(SizeX, SizeY);
|
|
}
|
|
|
|
if (GMaxRHIFeatureLevel <= ERHIFeatureLevel::ES3_1)
|
|
{
|
|
// Remove sRGB read flag when not supported
|
|
Flags &= ~TexCreate_SRGB;
|
|
}
|
|
|
|
GLuint TextureID = 0;
|
|
FOpenGL::GenTextures(1, &TextureID);
|
|
|
|
const GLenum Target = GL_TEXTURE_2D_ARRAY;
|
|
|
|
// Use a texture stage that's not likely to be used for draws, to avoid waiting
|
|
FOpenGLContextState& ContextState = GetContextStateForCurrentContext();
|
|
CachedSetupTextureStage(ContextState, FOpenGL::GetMaxCombinedTextureImageUnits() - 1, Target, TextureID, 0, NumMips);
|
|
|
|
glTexParameteri(Target, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
|
glTexParameteri(Target, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
|
glTexParameteri(Target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, NumMips > 1 ? GL_NEAREST_MIPMAP_NEAREST : GL_NEAREST);
|
|
if( FOpenGL::SupportsTextureFilterAnisotropic() )
|
|
{
|
|
glTexParameteri(Target, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1);
|
|
}
|
|
glTexParameteri(Target, GL_TEXTURE_BASE_LEVEL, 0);
|
|
glTexParameteri(Target, GL_TEXTURE_MAX_LEVEL, NumMips - 1);
|
|
|
|
TextureMipLimits.Add(TextureID, TPair<GLenum, GLenum>(0, NumMips - 1));
|
|
|
|
const bool bSRGB = (Flags&TexCreate_SRGB) != 0;
|
|
const FOpenGLTextureFormat& GLFormat = GOpenGLTextureFormats[Format];
|
|
if (GLFormat.InternalFormat[bSRGB] == GL_NONE)
|
|
{
|
|
UE_LOG(LogRHI, Fatal,TEXT("Texture format '%s' not supported."), GPixelFormats[Format].Name);
|
|
}
|
|
|
|
checkf(!GLFormat.bCompressed, TEXT("%s compressed 2D texture arrays not currently supported by the OpenGL RHI"), GPixelFormats[Format].Name);
|
|
|
|
// Make sure PBO is disabled
|
|
CachedBindPixelUnpackBuffer(ContextState, 0);
|
|
|
|
uint8* Data = Info.BulkData ? (uint8*)Info.BulkData->GetResourceBulkData() : NULL;
|
|
uint32 MipOffset = 0;
|
|
|
|
FOpenGL::TexStorage3D( Target, NumMips, GLFormat.InternalFormat[bSRGB], SizeX, SizeY, SizeZ, GLFormat.Format, GLFormat.Type );
|
|
|
|
if (Data)
|
|
{
|
|
for(uint32 MipIndex = 0; MipIndex < NumMips; MipIndex++)
|
|
{
|
|
FOpenGL::TexSubImage3D(
|
|
/*Target=*/ Target,
|
|
/*Level=*/ MipIndex,
|
|
0,
|
|
0,
|
|
0,
|
|
/*SizeX=*/ FMath::Max<uint32>(1,(SizeX >> MipIndex)),
|
|
/*SizeY=*/ FMath::Max<uint32>(1,(SizeY >> MipIndex)),
|
|
/*SizeZ=*/ SizeZ,
|
|
/*Format=*/ GLFormat.Format,
|
|
/*Type=*/ GLFormat.Type,
|
|
/*Data=*/ Data ? &Data[MipOffset] : NULL
|
|
);
|
|
|
|
uint32 SysMemPitch = FMath::Max<uint32>(1,SizeX >> MipIndex) * GPixelFormats[Format].BlockBytes;
|
|
uint32 SysMemSlicePitch = FMath::Max<uint32>(1,SizeY >> MipIndex) * SysMemPitch;
|
|
MipOffset += SizeZ * SysMemSlicePitch;
|
|
}
|
|
|
|
Info.BulkData->Discard();
|
|
}
|
|
|
|
// Determine the attachment point for the texture.
|
|
GLenum Attachment = GL_NONE;
|
|
if(Flags & TexCreate_RenderTargetable)
|
|
{
|
|
Attachment = GL_COLOR_ATTACHMENT0;
|
|
}
|
|
else if(Flags & TexCreate_DepthStencilTargetable)
|
|
{
|
|
Attachment = (FOpenGL::SupportsPackedDepthStencil() && Format == PF_DepthStencil) ? GL_DEPTH_STENCIL_ATTACHMENT : GL_DEPTH_ATTACHMENT;
|
|
}
|
|
else if(Flags & TexCreate_ResolveTargetable)
|
|
{
|
|
Attachment = (Format == PF_DepthStencil && FOpenGL::SupportsPackedDepthStencil())
|
|
? GL_DEPTH_STENCIL_ATTACHMENT
|
|
: ((Format == PF_ShadowDepth || Format == PF_D24)
|
|
? GL_DEPTH_ATTACHMENT
|
|
: GL_COLOR_ATTACHMENT0);
|
|
}
|
|
|
|
FOpenGLTexture2DArray* Texture = new FOpenGLTexture2DArray(this,TextureID,Target,Attachment,SizeX,SizeY,SizeZ,NumMips,1, 1, SizeZ, (EPixelFormat)Format,false,true,Flags,nullptr,Info.ClearValueBinding);
|
|
OpenGLTextureAllocated( Texture, Flags );
|
|
|
|
// No need to restore texture stage; leave it like this,
|
|
// and the next draw will take care of cleaning it up; or
|
|
// next operation that needs the stage will switch something else in on it.
|
|
|
|
return Texture;
|
|
}
|
|
|
|
FTexture3DRHIRef FOpenGLDynamicRHI::RHICreateTexture3D(uint32 SizeX,uint32 SizeY,uint32 SizeZ,uint8 Format,uint32 NumMips,uint32 Flags,FRHIResourceCreateInfo& CreateInfo)
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
|
|
SCOPE_CYCLE_COUNTER(STAT_OpenGLCreateTextureTime);
|
|
|
|
check( FOpenGL::SupportsTexture3D() );
|
|
|
|
if(NumMips == 0)
|
|
{
|
|
NumMips = FindMaxMipmapLevel(SizeX, SizeY, SizeZ);
|
|
}
|
|
|
|
if (GMaxRHIFeatureLevel <= ERHIFeatureLevel::ES3_1)
|
|
{
|
|
// Remove sRGB read flag when not supported
|
|
Flags &= ~TexCreate_SRGB;
|
|
}
|
|
|
|
GLuint TextureID = 0;
|
|
FOpenGL::GenTextures(1, &TextureID);
|
|
|
|
const GLenum Target = GL_TEXTURE_3D;
|
|
|
|
// Use a texture stage that's not likely to be used for draws, to avoid waiting
|
|
FOpenGLContextState& ContextState = GetContextStateForCurrentContext();
|
|
CachedSetupTextureStage(ContextState, FOpenGL::GetMaxCombinedTextureImageUnits() - 1, Target, TextureID, 0, NumMips);
|
|
|
|
glTexParameteri(Target, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
|
glTexParameteri(Target, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
|
glTexParameteri(Target, GL_TEXTURE_WRAP_R, GL_REPEAT);
|
|
glTexParameteri(Target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
|
|
if( FOpenGL::SupportsTextureFilterAnisotropic() )
|
|
{
|
|
glTexParameteri(Target, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1);
|
|
}
|
|
glTexParameteri(Target, GL_TEXTURE_BASE_LEVEL, 0);
|
|
glTexParameteri(Target, GL_TEXTURE_MAX_LEVEL, NumMips - 1);
|
|
|
|
TextureMipLimits.Add(TextureID, TPair<GLenum, GLenum>(0, NumMips - 1));
|
|
|
|
const bool bSRGB = (Flags&TexCreate_SRGB) != 0;
|
|
const FOpenGLTextureFormat& GLFormat = GOpenGLTextureFormats[Format];
|
|
if (GLFormat.InternalFormat[bSRGB] == GL_NONE)
|
|
{
|
|
UE_LOG(LogRHI, Fatal,TEXT("Texture format '%s' not supported."), GPixelFormats[Format].Name);
|
|
}
|
|
|
|
// Make sure PBO is disabled
|
|
CachedBindPixelUnpackBuffer(ContextState,0);
|
|
|
|
uint8* Data = CreateInfo.BulkData ? (uint8*)CreateInfo.BulkData->GetResourceBulkData() : NULL;
|
|
uint32 MipOffset = 0;
|
|
|
|
FOpenGL::TexStorage3D( Target, NumMips, GLFormat.InternalFormat[bSRGB], SizeX, SizeY, SizeZ, GLFormat.Format, GLFormat.Type );
|
|
|
|
if (Data)
|
|
{
|
|
for(uint32 MipIndex = 0; MipIndex < NumMips; MipIndex++)
|
|
{
|
|
FOpenGL::TexSubImage3D(
|
|
/*Target=*/ Target,
|
|
/*Level=*/ MipIndex,
|
|
0,
|
|
0,
|
|
0,
|
|
/*SizeX=*/ FMath::Max<uint32>(1,(SizeX >> MipIndex)),
|
|
/*SizeY=*/ FMath::Max<uint32>(1,(SizeY >> MipIndex)),
|
|
/*SizeZ=*/ FMath::Max<uint32>(1,(SizeZ >> MipIndex)),
|
|
/*Format=*/ GLFormat.Format,
|
|
/*Type=*/ GLFormat.Type,
|
|
/*Data=*/ Data ? &Data[MipOffset] : NULL
|
|
);
|
|
|
|
uint32 SysMemPitch = FMath::Max<uint32>(1,SizeX >> MipIndex) * GPixelFormats[Format].BlockBytes;
|
|
uint32 SysMemSlicePitch = FMath::Max<uint32>(1,SizeY >> MipIndex) * SysMemPitch;
|
|
MipOffset += FMath::Max<uint32>(1,SizeZ >> MipIndex) * SysMemSlicePitch;
|
|
}
|
|
|
|
CreateInfo.BulkData->Discard();
|
|
}
|
|
|
|
// Determine the attachment point for the texture.
|
|
GLenum Attachment = GL_NONE;
|
|
if(Flags & TexCreate_RenderTargetable)
|
|
{
|
|
Attachment = GL_COLOR_ATTACHMENT0;
|
|
}
|
|
else if(Flags & TexCreate_DepthStencilTargetable)
|
|
{
|
|
Attachment = Format == PF_DepthStencil ? GL_DEPTH_STENCIL_ATTACHMENT : GL_DEPTH_ATTACHMENT;
|
|
}
|
|
else if(Flags & TexCreate_ResolveTargetable)
|
|
{
|
|
Attachment = (Format == PF_DepthStencil && FOpenGL::SupportsCombinedDepthStencilAttachment())
|
|
? GL_DEPTH_STENCIL_ATTACHMENT
|
|
: ((Format == PF_ShadowDepth || Format == PF_D24)
|
|
? GL_DEPTH_ATTACHMENT
|
|
: GL_COLOR_ATTACHMENT0);
|
|
}
|
|
|
|
FOpenGLTexture3D* Texture = new FOpenGLTexture3D(this,TextureID,Target,Attachment,SizeX,SizeY,SizeZ,NumMips,1,1,1, (EPixelFormat)Format,false,true,Flags,nullptr,CreateInfo.ClearValueBinding);
|
|
OpenGLTextureAllocated( Texture, Flags );
|
|
|
|
// No need to restore texture stage; leave it like this,
|
|
// and the next draw will take care of cleaning it up; or
|
|
// next operation that needs the stage will switch something else in on it.
|
|
|
|
return Texture;
|
|
}
|
|
|
|
void FOpenGLDynamicRHI::RHIGetResourceInfo(FTextureRHIParamRef Ref, FRHIResourceInfo& OutInfo)
|
|
{
|
|
}
|
|
|
|
FShaderResourceViewRHIRef FOpenGLDynamicRHI::RHICreateShaderResourceView(FTexture2DRHIParamRef Texture2DRHI, uint8 MipLevel)
|
|
{
|
|
FOpenGLTexture2D* Texture2D = ResourceCast(Texture2DRHI);
|
|
|
|
FOpenGLShaderResourceView *View = 0;
|
|
|
|
if (FOpenGL::SupportsTextureView())
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
|
|
GLuint Resource = 0;
|
|
|
|
FOpenGL::GenTextures( 1, &Resource);
|
|
const FOpenGLTextureFormat& GLFormat = GOpenGLTextureFormats[Texture2D->GetFormat()];
|
|
const bool bSRGB = (Texture2D->GetFlags()&TexCreate_SRGB) != 0;
|
|
|
|
FOpenGL::TextureView( Resource, Texture2D->Target, Texture2D->Resource, GLFormat.InternalFormat[bSRGB], MipLevel, 1, 0, 1);
|
|
|
|
View = new FOpenGLShaderResourceView(this, Resource, Texture2D->Target, MipLevel, true);
|
|
}
|
|
else
|
|
{
|
|
View = new FOpenGLShaderResourceView(this, Texture2D->Resource, Texture2D->Target, MipLevel, false);
|
|
}
|
|
|
|
FShaderCache::LogSRV(View, Texture2DRHI, MipLevel, 1, PF_Unknown);
|
|
|
|
return View;
|
|
}
|
|
|
|
FShaderResourceViewRHIRef FOpenGLDynamicRHI::RHICreateShaderResourceView(FTexture2DRHIParamRef Texture2DRHI, uint8 MipLevel, uint8 NumMipLevels, uint8 Format)
|
|
{
|
|
FOpenGLTexture2D* Texture2D = ResourceCast(Texture2DRHI);
|
|
|
|
FOpenGLShaderResourceView *View = 0;
|
|
|
|
if (FOpenGL::SupportsTextureView())
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
|
|
GLuint Resource = 0;
|
|
|
|
FOpenGL::GenTextures( 1, &Resource);
|
|
|
|
if (Format != PF_X24_G8)
|
|
{
|
|
const FOpenGLTextureFormat& GLFormat = GOpenGLTextureFormats[Format];
|
|
const bool bSRGB = (Texture2D->GetFlags()&TexCreate_SRGB) != 0;
|
|
|
|
FOpenGL::TextureView( Resource, Texture2D->Target, Texture2D->Resource, GLFormat.InternalFormat[bSRGB], MipLevel, NumMipLevels, 0, 1);
|
|
}
|
|
else
|
|
{
|
|
// PF_X24_G8 doesn't correspond to a real format under OpenGL
|
|
// The solution is to create a view with the original format, and convert it to return the stencil index
|
|
// To match component locations, texture swizzle needs to be setup too
|
|
const FOpenGLTextureFormat& GLFormat = GOpenGLTextureFormats[Texture2D->GetFormat()];
|
|
|
|
// create a second depth/stencil view
|
|
FOpenGL::TextureView( Resource, Texture2D->Target, Texture2D->Resource, GLFormat.InternalFormat[0], MipLevel, NumMipLevels, 0, 1);
|
|
|
|
// Use a texture stage that's not likely to be used for draws, to avoid waiting
|
|
FOpenGLContextState& ContextState = GetContextStateForCurrentContext();
|
|
CachedSetupTextureStage(ContextState, FOpenGL::GetMaxCombinedTextureImageUnits() - 1, Texture2D->Target, Resource, 0, NumMipLevels);
|
|
|
|
//set the texture to return the stencil index, and then force the components to match D3D
|
|
glTexParameteri( Texture2D->Target, GL_DEPTH_STENCIL_TEXTURE_MODE, GL_STENCIL_INDEX);
|
|
glTexParameteri( Texture2D->Target, GL_TEXTURE_SWIZZLE_R, GL_ZERO);
|
|
glTexParameteri( Texture2D->Target, GL_TEXTURE_SWIZZLE_G, GL_RED);
|
|
glTexParameteri( Texture2D->Target, GL_TEXTURE_SWIZZLE_B, GL_ZERO);
|
|
glTexParameteri( Texture2D->Target, GL_TEXTURE_SWIZZLE_A, GL_ZERO);
|
|
}
|
|
|
|
View = new FOpenGLShaderResourceView(this, Resource, Texture2D->Target, MipLevel, true);
|
|
}
|
|
else
|
|
{
|
|
uint32 const Target = Texture2D->Target;
|
|
GLuint Resource = Texture2D->Resource;
|
|
|
|
FTexture2DRHIParamRef DepthStencilTex = nullptr;
|
|
|
|
// For stencil sampling we have to use a separate single channel texture to blit stencil data into
|
|
#if PLATFORM_DESKTOP || PLATFORM_ANDROIDESDEFERRED
|
|
if (FOpenGL::GetFeatureLevel() >= ERHIFeatureLevel::SM4 && Format == PF_X24_G8 && FOpenGL::SupportsPixelBuffers())
|
|
{
|
|
check(NumMipLevels == 1 && MipLevel == 0);
|
|
|
|
if (!Texture2D->SRVResource)
|
|
{
|
|
FOpenGL::GenTextures(1, &Texture2D->SRVResource);
|
|
|
|
GLenum const InternalFormat = GL_R8UI;
|
|
GLenum const ChannelFormat = GL_RED_INTEGER;
|
|
uint32 const SizeX = Texture2D->GetSizeX();
|
|
uint32 const SizeY = Texture2D->GetSizeY();
|
|
GLenum const Type = GL_UNSIGNED_BYTE;
|
|
uint32 const Flags = 0;
|
|
|
|
FOpenGLContextState& ContextState = GetContextStateForCurrentContext();
|
|
CachedSetupTextureStage(ContextState, FOpenGL::GetMaxCombinedTextureImageUnits() - 1, Target, Texture2D->SRVResource, MipLevel, NumMipLevels);
|
|
|
|
if (!FOpenGL::TexStorage2D(Target, NumMipLevels, InternalFormat, SizeX, SizeY, ChannelFormat, Type, Flags))
|
|
{
|
|
glTexImage2D(Target, 0, InternalFormat, SizeX, SizeY, 0, ChannelFormat, Type, nullptr);
|
|
}
|
|
|
|
TArray<uint8> ZeroData;
|
|
ZeroData.AddZeroed(SizeX * SizeY);
|
|
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
glTexSubImage2D(
|
|
Target,
|
|
0,
|
|
0,
|
|
0,
|
|
SizeX,
|
|
SizeY,
|
|
ChannelFormat,
|
|
Type,
|
|
ZeroData.GetData());
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
|
|
|
//set the texture to return the stencil index, and then force the components to match D3D
|
|
glTexParameteri( Target, GL_TEXTURE_SWIZZLE_R, GL_ZERO);
|
|
glTexParameteri( Target, GL_TEXTURE_SWIZZLE_G, GL_RED);
|
|
glTexParameteri( Target, GL_TEXTURE_SWIZZLE_B, GL_ZERO);
|
|
glTexParameteri( Target, GL_TEXTURE_SWIZZLE_A, GL_ZERO);
|
|
}
|
|
check(Texture2D->SRVResource);
|
|
|
|
Resource = Texture2D->SRVResource;
|
|
DepthStencilTex = Texture2DRHI;
|
|
}
|
|
#endif
|
|
|
|
View = new FOpenGLShaderResourceView(this, Resource, Target, MipLevel, false);
|
|
View->Texture2D = DepthStencilTex;
|
|
}
|
|
|
|
FShaderCache::LogSRV(View, Texture2DRHI, MipLevel, NumMipLevels, Format);
|
|
|
|
return View;
|
|
}
|
|
|
|
FShaderResourceViewRHIRef FOpenGLDynamicRHI::RHICreateShaderResourceView(FTexture3DRHIParamRef Texture3DRHI, uint8 MipLevel)
|
|
{
|
|
FOpenGLTexture3D* Texture3D = ResourceCast(Texture3DRHI);
|
|
|
|
FOpenGLShaderResourceView *View = 0;
|
|
|
|
if (FOpenGL::SupportsTextureView())
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
|
|
GLuint Resource = 0;
|
|
|
|
FOpenGL::GenTextures( 1, &Resource);
|
|
const FOpenGLTextureFormat& GLFormat = GOpenGLTextureFormats[Texture3D->GetFormat()];
|
|
const bool bSRGB = (Texture3D->GetFlags()&TexCreate_SRGB) != 0;
|
|
|
|
FOpenGL::TextureView( Resource, Texture3D->Target, Texture3D->Resource, GLFormat.InternalFormat[bSRGB], MipLevel, 1, 0, 1);
|
|
|
|
View = new FOpenGLShaderResourceView(this, Resource, Texture3D->Target, MipLevel, true);
|
|
}
|
|
else
|
|
{
|
|
View = new FOpenGLShaderResourceView(this, Texture3D->Resource, Texture3D->Target, MipLevel, false);
|
|
}
|
|
|
|
FShaderCache::LogSRV(View, Texture3DRHI, MipLevel, Texture3DRHI->GetNumMips(), Texture3DRHI->GetFormat());
|
|
|
|
return View;
|
|
}
|
|
|
|
FShaderResourceViewRHIRef FOpenGLDynamicRHI::RHICreateShaderResourceView(FTexture2DArrayRHIParamRef Texture2DArrayRHI, uint8 MipLevel)
|
|
{
|
|
FOpenGLTexture2DArray* Texture2DArray = ResourceCast(Texture2DArrayRHI);
|
|
|
|
FOpenGLShaderResourceView *View = 0;
|
|
|
|
if (FOpenGL::SupportsTextureView())
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
|
|
GLuint Resource = 0;
|
|
|
|
FOpenGL::GenTextures( 1, &Resource);
|
|
const FOpenGLTextureFormat& GLFormat = GOpenGLTextureFormats[Texture2DArray->GetFormat()];
|
|
const bool bSRGB = (Texture2DArray->GetFlags()&TexCreate_SRGB) != 0;
|
|
|
|
FOpenGL::TextureView( Resource, Texture2DArray->Target, Texture2DArray->Resource, GLFormat.InternalFormat[bSRGB], MipLevel, 1, 0, 1);
|
|
|
|
View = new FOpenGLShaderResourceView(this, Resource, Texture2DArray->Target, MipLevel, true);
|
|
}
|
|
else
|
|
{
|
|
View = new FOpenGLShaderResourceView(this, Texture2DArray->Resource, Texture2DArray->Target, MipLevel, false);
|
|
}
|
|
|
|
FShaderCache::LogSRV(View, Texture2DArrayRHI, MipLevel, Texture2DArrayRHI->GetNumMips(), Texture2DArrayRHI->GetFormat());
|
|
|
|
return View;
|
|
}
|
|
|
|
FShaderResourceViewRHIRef FOpenGLDynamicRHI::RHICreateShaderResourceView(FTextureCubeRHIParamRef TextureCubeRHI, uint8 MipLevel)
|
|
{
|
|
FOpenGLTextureCube* TextureCube = ResourceCast(TextureCubeRHI);
|
|
|
|
FOpenGLShaderResourceView *View = 0;
|
|
|
|
if (FOpenGL::SupportsTextureView())
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
|
|
GLuint Resource = 0;
|
|
|
|
FOpenGL::GenTextures( 1, &Resource);
|
|
const FOpenGLTextureFormat& GLFormat = GOpenGLTextureFormats[TextureCube->GetFormat()];
|
|
const bool bSRGB = (TextureCube->GetFlags()&TexCreate_SRGB) != 0;
|
|
|
|
FOpenGL::TextureView( Resource, TextureCube->Target, TextureCube->Resource, GLFormat.InternalFormat[bSRGB], MipLevel, 1, 0, 6);
|
|
|
|
View = new FOpenGLShaderResourceView(this, Resource, TextureCube->Target, MipLevel, true);
|
|
}
|
|
else
|
|
{
|
|
View = new FOpenGLShaderResourceView(this, TextureCube->Resource, TextureCube->Target, MipLevel, false);
|
|
}
|
|
|
|
FShaderCache::LogSRV(View, TextureCube, MipLevel, TextureCubeRHI->GetNumMips(), TextureCubeRHI->GetFormat());
|
|
|
|
return View;
|
|
}
|
|
|
|
|
|
/** Generates mip maps for the surface. */
|
|
void FOpenGLDynamicRHI::RHIGenerateMips(FTextureRHIParamRef SurfaceRHI)
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
|
|
FOpenGLTextureBase* Texture = GetOpenGLTextureFromRHITexture(SurfaceRHI);
|
|
|
|
if ( FOpenGL::SupportsGenerateMipmap())
|
|
{
|
|
GPUProfilingData.RegisterGPUWork(0);
|
|
|
|
FOpenGLContextState& ContextState = GetContextStateForCurrentContext();
|
|
// Setup the texture on a disused unit
|
|
// need to figure out how to setup mips properly in no views case
|
|
CachedSetupTextureStage(ContextState, FOpenGL::GetMaxCombinedTextureImageUnits() - 1, Texture->Target, Texture->Resource, -1, 1);
|
|
|
|
FOpenGL::GenerateMipmap( Texture->Target);
|
|
}
|
|
else
|
|
{
|
|
UE_LOG( LogRHI, Fatal, TEXT("Generate Mipmaps unsupported on this OpenGL version"));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Computes the size in memory required by a given texture.
|
|
*
|
|
* @param TextureRHI - Texture we want to know the size of
|
|
* @return - Size in Bytes
|
|
*/
|
|
uint32 FOpenGLDynamicRHI::RHIComputeMemorySize(FTextureRHIParamRef TextureRHI)
|
|
{
|
|
if(!TextureRHI)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
FOpenGLTextureBase* Texture = GetOpenGLTextureFromRHITexture(TextureRHI);
|
|
return Texture->GetMemorySize();
|
|
}
|
|
|
|
/**
|
|
* Starts an asynchronous texture reallocation. It may complete immediately if the reallocation
|
|
* could be performed without any reshuffling of texture memory, or if there isn't enough memory.
|
|
* The specified status counter will be decremented by 1 when the reallocation is complete (success or failure).
|
|
*
|
|
* Returns a new reference to the texture, which will represent the new mip count when the reallocation is complete.
|
|
* RHIGetAsyncReallocateTexture2DStatus() can be used to check the status of an ongoing or completed reallocation.
|
|
*
|
|
* @param Texture2D - Texture to reallocate
|
|
* @param NewMipCount - New number of mip-levels
|
|
* @param RequestStatus - Will be decremented by 1 when the reallocation is complete (success or failure).
|
|
* @return - New reference to the texture, or an invalid reference upon failure
|
|
*/
|
|
FTexture2DRHIRef FOpenGLDynamicRHI::RHIAsyncReallocateTexture2D(FTexture2DRHIParamRef Texture2DRHI, int32 NewMipCount, int32 NewSizeX, int32 NewSizeY, FThreadSafeCounter* RequestStatus)
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
|
|
FOpenGLTexture2D* Texture2D = ResourceCast(Texture2DRHI);
|
|
|
|
// Allocate a new texture.
|
|
FOpenGLTexture2D* NewTexture2D = (FOpenGLTexture2D*)CreateOpenGLTexture(NewSizeX,NewSizeY,false,false, Texture2D->GetFormat(),NewMipCount,1,1, Texture2D->GetFlags(), Texture2DRHI->GetClearBinding());
|
|
|
|
const uint32 BlockSizeX = GPixelFormats[Texture2D->GetFormat()].BlockSizeX;
|
|
const uint32 BlockSizeY = GPixelFormats[Texture2D->GetFormat()].BlockSizeY;
|
|
const uint32 NumBytesPerBlock = GPixelFormats[Texture2D->GetFormat()].BlockBytes;
|
|
|
|
// Should we use client-storage to improve update time on platforms that require it
|
|
const bool bCompressed = GOpenGLTextureFormats[Texture2D->GetFormat()].bCompressed;
|
|
bool const bRenderable = (Texture2D->GetFlags() & (TexCreate_RenderTargetable|TexCreate_ResolveTargetable|TexCreate_DepthStencilTargetable|TexCreate_CPUReadback)) != 0;
|
|
const bool bUseClientStorage = (FOpenGL::SupportsClientStorage() && !FOpenGL::SupportsTextureView() && !bRenderable && !bCompressed);
|
|
|
|
// Use the GPU to asynchronously copy the old mip-maps into the new texture.
|
|
const uint32 NumSharedMips = FMath::Min(Texture2D->GetNumMips(),NewTexture2D->GetNumMips());
|
|
const uint32 SourceMipOffset = Texture2D->GetNumMips() - NumSharedMips;
|
|
const uint32 DestMipOffset = NewTexture2D->GetNumMips() - NumSharedMips;
|
|
|
|
if (FOpenGL::SupportsCopyImage())
|
|
{
|
|
FOpenGLTexture2D *NewOGLTexture2D = (FOpenGLTexture2D*)NewTexture2D;
|
|
FOpenGLTexture2D *OGLTexture2D = (FOpenGLTexture2D*)Texture2D;
|
|
NewOGLTexture2D->CloneViaCopyImage( OGLTexture2D, NumSharedMips, SourceMipOffset, DestMipOffset);
|
|
}
|
|
else if (FOpenGL::SupportsCopyTextureLevels())
|
|
{
|
|
FOpenGL::CopyTextureLevels( NewTexture2D->Resource, Texture2D->Resource, SourceMipOffset, NumSharedMips);
|
|
}
|
|
else if (FOpenGL::SupportsPixelBuffers() && !bUseClientStorage)
|
|
{
|
|
FOpenGLTexture2D *NewOGLTexture2D = (FOpenGLTexture2D*)NewTexture2D;
|
|
FOpenGLTexture2D *OGLTexture2D = (FOpenGLTexture2D*)Texture2D;
|
|
NewOGLTexture2D->CloneViaPBO( OGLTexture2D, NumSharedMips, SourceMipOffset, DestMipOffset);
|
|
}
|
|
else
|
|
{
|
|
for(uint32 MipIndex = 0;MipIndex < NumSharedMips;++MipIndex)
|
|
{
|
|
const uint32 MipSizeX = FMath::Max<uint32>(1,NewSizeX >> (MipIndex+DestMipOffset));
|
|
const uint32 MipSizeY = FMath::Max<uint32>(1,NewSizeY >> (MipIndex+DestMipOffset));
|
|
const uint32 NumBlocksX = AlignArbitrary(MipSizeX, BlockSizeX) / BlockSizeX;
|
|
const uint32 NumBlocksY = AlignArbitrary(MipSizeY, BlockSizeY) / BlockSizeY;
|
|
const uint32 NumMipBlocks = NumBlocksX * NumBlocksY;
|
|
|
|
// Lock old and new texture.
|
|
uint32 SrcStride;
|
|
uint32 DestStride;
|
|
|
|
void* Src = RHILockTexture2D( Texture2D, MipIndex + SourceMipOffset, RLM_ReadOnly, SrcStride, false );
|
|
void* Dst = RHILockTexture2D( NewTexture2D, MipIndex + DestMipOffset, RLM_WriteOnly, DestStride, false );
|
|
check(SrcStride == DestStride);
|
|
FMemory::Memcpy( Dst, Src, NumMipBlocks * NumBytesPerBlock );
|
|
RHIUnlockTexture2D( Texture2D, MipIndex + SourceMipOffset, false );
|
|
RHIUnlockTexture2D( NewTexture2D, MipIndex + DestMipOffset, false );
|
|
}
|
|
}
|
|
|
|
// Decrement the thread-safe counter used to track the completion of the reallocation, since D3D handles sequencing the
|
|
// async mip copies with other D3D calls.
|
|
RequestStatus->Decrement();
|
|
|
|
return NewTexture2D;
|
|
}
|
|
|
|
/**
|
|
* Returns the status of an ongoing or completed texture reallocation:
|
|
* TexRealloc_Succeeded - The texture is ok, reallocation is not in progress.
|
|
* TexRealloc_Failed - The texture is bad, reallocation is not in progress.
|
|
* TexRealloc_InProgress - The texture is currently being reallocated async.
|
|
*
|
|
* @param Texture2D - Texture to check the reallocation status for
|
|
* @return - Current reallocation status
|
|
*/
|
|
ETextureReallocationStatus FOpenGLDynamicRHI::RHIFinalizeAsyncReallocateTexture2D( FTexture2DRHIParamRef Texture2D, bool bBlockUntilCompleted )
|
|
{
|
|
return TexRealloc_Succeeded;
|
|
}
|
|
|
|
/**
|
|
* Cancels an async reallocation for the specified texture.
|
|
* This should be called for the new texture, not the original.
|
|
*
|
|
* @param Texture Texture to cancel
|
|
* @param bBlockUntilCompleted If true, blocks until the cancellation is fully completed
|
|
* @return Reallocation status
|
|
*/
|
|
ETextureReallocationStatus FOpenGLDynamicRHI::RHICancelAsyncReallocateTexture2D( FTexture2DRHIParamRef Texture2D, bool bBlockUntilCompleted )
|
|
{
|
|
return TexRealloc_Succeeded;
|
|
}
|
|
|
|
void* FOpenGLDynamicRHI::RHILockTexture2D(FTexture2DRHIParamRef TextureRHI,uint32 MipIndex,EResourceLockMode LockMode,uint32& DestStride,bool bLockWithinMiptail)
|
|
{
|
|
FOpenGLTexture2D* Texture = ResourceCast(TextureRHI);
|
|
return Texture->Lock(MipIndex,0,LockMode,DestStride);
|
|
}
|
|
|
|
void FOpenGLDynamicRHI::RHIUnlockTexture2D(FTexture2DRHIParamRef TextureRHI,uint32 MipIndex,bool bLockWithinMiptail)
|
|
{
|
|
FOpenGLTexture2D* Texture = ResourceCast(TextureRHI);
|
|
Texture->Unlock(MipIndex, 0);
|
|
}
|
|
|
|
void* FOpenGLDynamicRHI::RHILockTexture2DArray(FTexture2DArrayRHIParamRef TextureRHI,uint32 TextureIndex,uint32 MipIndex,EResourceLockMode LockMode,uint32& DestStride,bool bLockWithinMiptail)
|
|
{
|
|
FOpenGLTexture2DArray* Texture = ResourceCast(TextureRHI);
|
|
return Texture->Lock(MipIndex,TextureIndex,LockMode,DestStride);
|
|
}
|
|
|
|
void FOpenGLDynamicRHI::RHIUnlockTexture2DArray(FTexture2DArrayRHIParamRef TextureRHI,uint32 TextureIndex,uint32 MipIndex,bool bLockWithinMiptail)
|
|
{
|
|
FOpenGLTexture2DArray* Texture = ResourceCast(TextureRHI);
|
|
Texture->Unlock(MipIndex, TextureIndex);
|
|
}
|
|
|
|
void FOpenGLDynamicRHI::RHIUpdateTexture2D(FTexture2DRHIParamRef TextureRHI,uint32 MipIndex,const FUpdateTextureRegion2D& UpdateRegion,uint32 SourcePitch,const uint8* SourceData)
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
|
|
FOpenGLTexture2D* Texture = ResourceCast(TextureRHI);
|
|
|
|
// Use a texture stage that's not likely to be used for draws, to avoid waiting
|
|
FOpenGLContextState& ContextState = GetContextStateForCurrentContext();
|
|
CachedSetupTextureStage(ContextState, FOpenGL::GetMaxCombinedTextureImageUnits() - 1, Texture->Target, Texture->Resource, 0, Texture->GetNumMips());
|
|
CachedBindPixelUnpackBuffer(ContextState, 0);
|
|
|
|
EPixelFormat PixelFormat = Texture->GetFormat();
|
|
check(GPixelFormats[PixelFormat].BlockSizeX == 1);
|
|
check(GPixelFormats[PixelFormat].BlockSizeY == 1);
|
|
const FOpenGLTextureFormat& GLFormat = GOpenGLTextureFormats[PixelFormat];
|
|
const uint32 FormatBPP = GPixelFormats[PixelFormat].BlockBytes;
|
|
checkf(!GLFormat.bCompressed, TEXT("RHIUpdateTexture2D not currently supported for compressed (%s) textures by the OpenGL RHI"), GPixelFormats[PixelFormat].Name);
|
|
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, SourcePitch / FormatBPP);
|
|
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
glTexSubImage2D(Texture->Target, MipIndex, UpdateRegion.DestX, UpdateRegion.DestY, UpdateRegion.Width, UpdateRegion.Height,
|
|
GLFormat.Format, GLFormat.Type, SourceData);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
|
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
|
|
|
|
// No need to restore texture stage; leave it like this,
|
|
// and the next draw will take care of cleaning it up; or
|
|
// next operation that needs the stage will switch something else in on it.
|
|
}
|
|
|
|
void FOpenGLDynamicRHI::RHIUpdateTexture3D(FTexture3DRHIParamRef TextureRHI,uint32 MipIndex,const FUpdateTextureRegion3D& UpdateRegion,uint32 SourceRowPitch,uint32 SourceDepthPitch,const uint8* SourceData)
|
|
{
|
|
VERIFY_GL_SCOPE();
|
|
check( FOpenGL::SupportsTexture3D() );
|
|
FOpenGLTexture3D* Texture = ResourceCast(TextureRHI);
|
|
|
|
// Use a texture stage that's not likely to be used for draws, to avoid waiting
|
|
FOpenGLContextState& ContextState = GetContextStateForCurrentContext();
|
|
CachedSetupTextureStage(ContextState, FOpenGL::GetMaxCombinedTextureImageUnits() - 1, Texture->Target, Texture->Resource, 0, Texture->GetNumMips());
|
|
CachedBindPixelUnpackBuffer(ContextState, 0);
|
|
|
|
EPixelFormat PixelFormat = Texture->GetFormat();
|
|
check(GPixelFormats[PixelFormat].BlockSizeX == 1);
|
|
check(GPixelFormats[PixelFormat].BlockSizeY == 1);
|
|
|
|
// TO DO - add appropriate offsets to source data when necessary
|
|
check(UpdateRegion.SrcX == 0);
|
|
check(UpdateRegion.SrcY == 0);
|
|
check(UpdateRegion.SrcZ == 0);
|
|
|
|
const FOpenGLTextureFormat& GLFormat = GOpenGLTextureFormats[PixelFormat];
|
|
const uint32 FormatBPP = GPixelFormats[PixelFormat].BlockBytes;
|
|
checkf(!GLFormat.bCompressed, TEXT("RHIUpdateTexture3D not currently supported for compressed (%s) textures by the OpenGL RHI"), GPixelFormats[PixelFormat].Name);
|
|
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, SourceRowPitch / FormatBPP);
|
|
|
|
check( SourceDepthPitch % ( FormatBPP * UpdateRegion.Width ) == 0 );
|
|
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, SourceDepthPitch / UpdateRegion.Width / FormatBPP);
|
|
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
FOpenGL::TexSubImage3D(Texture->Target, MipIndex, UpdateRegion.DestX, UpdateRegion.DestY, UpdateRegion.DestZ, UpdateRegion.Width, UpdateRegion.Height, UpdateRegion.Depth,
|
|
GLFormat.Format, GLFormat.Type, SourceData);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
|
|
|
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
|
|
|
|
// No need to restore texture stage; leave it like this,
|
|
// and the next draw will take care of cleaning it up; or
|
|
// next operation that needs the stage will switch something else in on it.
|
|
}
|
|
|
|
void FOpenGLDynamicRHI::InvalidateTextureResourceInCache(GLuint Resource)
|
|
{
|
|
for (int32 SamplerIndex = 0; SamplerIndex < FOpenGL::GetMaxCombinedTextureImageUnits(); ++SamplerIndex)
|
|
{
|
|
if (SharedContextState.Textures[SamplerIndex].Resource == Resource)
|
|
{
|
|
SharedContextState.Textures[SamplerIndex].Target = GL_NONE;
|
|
SharedContextState.Textures[SamplerIndex].Resource = 0;
|
|
}
|
|
|
|
if (RenderingContextState.Textures[SamplerIndex].Resource == Resource)
|
|
{
|
|
RenderingContextState.Textures[SamplerIndex].Target = GL_NONE;
|
|
RenderingContextState.Textures[SamplerIndex].Resource = 0;
|
|
}
|
|
}
|
|
|
|
TextureMipLimits.Remove(Resource);
|
|
|
|
if (PendingState.DepthStencil && PendingState.DepthStencil->Resource == Resource)
|
|
{
|
|
PendingState.DepthStencil = nullptr;
|
|
}
|
|
}
|
|
|
|
void FOpenGLDynamicRHI::InvalidateUAVResourceInCache(GLuint Resource)
|
|
{
|
|
for (int32 UAVIndex = 0; UAVIndex < OGL_MAX_COMPUTE_STAGE_UAV_UNITS; ++UAVIndex)
|
|
{
|
|
if (SharedContextState.UAVs[UAVIndex].Resource == Resource)
|
|
{
|
|
SharedContextState.UAVs[UAVIndex].Format = GL_NONE;
|
|
SharedContextState.UAVs[UAVIndex].Resource = 0;
|
|
}
|
|
|
|
if (RenderingContextState.UAVs[UAVIndex].Resource == Resource)
|
|
{
|
|
RenderingContextState.UAVs[UAVIndex].Format = GL_NONE;
|
|
RenderingContextState.UAVs[UAVIndex].Resource = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
Cubemap texture support.
|
|
-----------------------------------------------------------------------------*/
|
|
FTextureCubeRHIRef FOpenGLDynamicRHI::RHICreateTextureCube( uint32 Size, uint8 Format, uint32 NumMips, uint32 Flags, FRHIResourceCreateInfo& CreateInfo )
|
|
{
|
|
// not yet supported
|
|
check(!CreateInfo.BulkData);
|
|
|
|
return (FRHITextureCube*)CreateOpenGLTexture(Size,Size,true, false, Format, NumMips, 1, 1, Flags, CreateInfo.ClearValueBinding);
|
|
}
|
|
|
|
FTextureCubeRHIRef FOpenGLDynamicRHI::RHICreateTextureCubeArray( uint32 Size, uint32 ArraySize, uint8 Format, uint32 NumMips, uint32 Flags, FRHIResourceCreateInfo& CreateInfo )
|
|
{
|
|
// not yet supported
|
|
check(!CreateInfo.BulkData);
|
|
|
|
return (FRHITextureCube*)CreateOpenGLTexture(Size, Size, true, true, Format, NumMips, 1, 6 * ArraySize, Flags, CreateInfo.ClearValueBinding);
|
|
}
|
|
|
|
void* FOpenGLDynamicRHI::RHILockTextureCubeFace(FTextureCubeRHIParamRef TextureCubeRHI,uint32 FaceIndex,uint32 ArrayIndex,uint32 MipIndex,EResourceLockMode LockMode,uint32& DestStride,bool bLockWithinMiptail)
|
|
{
|
|
FOpenGLTextureCube* TextureCube = ResourceCast(TextureCubeRHI);
|
|
return TextureCube->Lock(MipIndex,FaceIndex + 6 * ArrayIndex,LockMode,DestStride);
|
|
}
|
|
|
|
void FOpenGLDynamicRHI::RHIUnlockTextureCubeFace(FTextureCubeRHIParamRef TextureCubeRHI,uint32 FaceIndex,uint32 ArrayIndex,uint32 MipIndex,bool bLockWithinMiptail)
|
|
{
|
|
FOpenGLTextureCube* TextureCube = ResourceCast(TextureCubeRHI);
|
|
TextureCube->Unlock(MipIndex,FaceIndex + ArrayIndex * 6);
|
|
}
|
|
|
|
void FOpenGLDynamicRHI::RHIBindDebugLabelName(FTextureRHIParamRef TextureRHI, const TCHAR* Name)
|
|
{
|
|
FOpenGLTextureBase* Texture = GetOpenGLTextureFromRHITexture(TextureRHI);
|
|
FOpenGL::LabelObject(GL_TEXTURE, Texture->Resource, TCHAR_TO_ANSI(Name));
|
|
}
|
|
|
|
void FOpenGLDynamicRHI::RHIVirtualTextureSetFirstMipInMemory(FTexture2DRHIParamRef TextureRHI, uint32 FirstMip)
|
|
{
|
|
}
|
|
|
|
void FOpenGLDynamicRHI::RHIVirtualTextureSetFirstMipVisible(FTexture2DRHIParamRef TextureRHI, uint32 FirstMip)
|
|
{
|
|
}
|
|
|
|
FTextureReferenceRHIRef FOpenGLDynamicRHI::RHICreateTextureReference(FLastRenderTimeContainer* InLastRenderTime)
|
|
{
|
|
return new FOpenGLTextureReference(InLastRenderTime);
|
|
}
|
|
|
|
void FOpenGLTextureReference::SetReferencedTexture(FRHITexture* InTexture)
|
|
{
|
|
FRHITextureReference::SetReferencedTexture(InTexture);
|
|
TexturePtr = GetOpenGLTextureFromRHITexture(InTexture);
|
|
}
|
|
|
|
void FOpenGLDynamicRHI::RHIUpdateTextureReference(FTextureReferenceRHIParamRef TextureRefRHI, FTextureRHIParamRef NewTextureRHI)
|
|
{
|
|
auto* TextureRef = (FOpenGLTextureReference*)TextureRefRHI;
|
|
if (TextureRef)
|
|
{
|
|
TextureRef->SetReferencedTexture(NewTextureRHI);
|
|
}
|
|
}
|