Merge branch 'main' into SPEC6476_ReflectNetworkProperties
Gene Walters
5 years ago
commit
b9a0bf52ab
@ -1,14 +0,0 @@
|
||||
{
|
||||
"Amazon": {
|
||||
"AssetProcessor": {
|
||||
"Settings": {
|
||||
"RC cgf": {
|
||||
"ignore": true
|
||||
},
|
||||
"RC fbx": {
|
||||
"ignore": true
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,128 @@
|
||||
"""
|
||||
All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
its licensors.
|
||||
|
||||
For complete copyright and license terms please see the LICENSE at the root of this
|
||||
distribution (the "License"). All use of this software is governed by the License,
|
||||
or, if provided, by the license below or the license accompanying this file. Do not
|
||||
remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
|
||||
Test case ID: T92562988
|
||||
Test Case Title: Left-click/double click expands and collapses node categories
|
||||
"""
|
||||
|
||||
|
||||
# fmt: off
|
||||
class Tests():
|
||||
pane_open = ("Script Canvas pane successfully opened", "Script Canvas pane failed to open")
|
||||
click_expand = ("Category expanded on left click", "Category failed to expand on left click")
|
||||
click_collapse = ("Category collapsed on left click", "Category failed to collapse on left click")
|
||||
dClick_expand = ("Category expanded on double click", "Category failed to expand on double click")
|
||||
dClick_collapse = ("Category collapsed on double click", "Category failed to collapse on double click")
|
||||
# fmt: on
|
||||
|
||||
|
||||
def NodeCategory_ExpandOnClick():
|
||||
"""
|
||||
Summary:
|
||||
Verifying the expand/collapse functionality on node categories
|
||||
|
||||
Expected Behavior:
|
||||
The node category should expand when double clicked or when the drop down indicator is
|
||||
left-clicked. Once expanded, it should be collapsed via the same actions.
|
||||
|
||||
Test Steps:
|
||||
1) Open Script Canvas pane
|
||||
2) Get the SC window objects
|
||||
3) Ensure all categories are collapsed for a clean state
|
||||
4) Left-Click on a node category arrow to expand it
|
||||
5) Verify it expanded
|
||||
6) Left-Click on a node category arrow to collapse it
|
||||
7) Verify it collapsed
|
||||
8) Double-Click on a node category to expand it
|
||||
9) Verify it expanded
|
||||
10) Double-Click on a node category to collapse it
|
||||
11) Verify it collapsed
|
||||
|
||||
Note:
|
||||
- This test file must be called from the Open 3D Engine Editor command terminal
|
||||
- Any passed and failed tests are written to the Editor.log file.
|
||||
Parsing the file or running a log_monitor are required to observe the test results.
|
||||
|
||||
:return: None
|
||||
"""
|
||||
from utils import Report
|
||||
from PySide2 import QtCore, QtWidgets, QtTest
|
||||
from PySide2.QtTest import QTest
|
||||
import pyside_utils
|
||||
import azlmbr.legacy.general as general
|
||||
|
||||
def left_click_arrow(item_view, index):
|
||||
original_state = item_view.isExpanded(index)
|
||||
rect_center_y = item_view.visualRect(index).center().y()
|
||||
rect_left_x = item_view.visualRect(index).left()
|
||||
for i in range(5): # this range can be increased for safe side
|
||||
QtTest.QTest.mouseClick(
|
||||
item_view.viewport(),
|
||||
QtCore.Qt.LeftButton,
|
||||
QtCore.Qt.NoModifier,
|
||||
QtCore.QPoint(rect_left_x - i, rect_center_y),
|
||||
)
|
||||
if item_view.isExpanded(index) != original_state:
|
||||
break
|
||||
|
||||
def double_click(item_view, index):
|
||||
item_index_center = item_view.visualRect(index).center()
|
||||
# Left click on the item before trying to double click, will otherwise fail to expand
|
||||
# as first click would highlight and second click would be a 'single click'
|
||||
pyside_utils.item_view_index_mouse_click(item_view, index)
|
||||
QTest.mouseDClick(item_view.viewport(), QtCore.Qt.LeftButton, QtCore.Qt.NoModifier, item_index_center)
|
||||
|
||||
# 1) Open Script Canvas pane
|
||||
general.open_pane("Script Canvas")
|
||||
Report.critical_result(Tests.pane_open, general.is_pane_visible("Script Canvas"))
|
||||
|
||||
# 2) Get the SC window objects
|
||||
editor_window = pyside_utils.get_editor_main_window()
|
||||
sc = editor_window.findChild(QtWidgets.QDockWidget, "Script Canvas")
|
||||
if sc.findChild(QtWidgets.QDockWidget, "NodePalette") is None:
|
||||
action = pyside_utils.find_child_by_pattern(sc, {"text": "Node Palette", "type": QtWidgets.QAction})
|
||||
action.trigger()
|
||||
node_palette = sc.findChild(QtWidgets.QDockWidget, "NodePalette")
|
||||
nodeTree = node_palette.findChild(QtWidgets.QTreeView, "treeView")
|
||||
ai_index = pyside_utils.find_child_by_pattern(nodeTree, "AI")
|
||||
|
||||
# 3) Ensure all categories are collapsed for a clean state
|
||||
nodeTree.collapseAll()
|
||||
|
||||
# 4) Left-Click on a node category arrow to expand it
|
||||
left_click_arrow(nodeTree, ai_index)
|
||||
|
||||
# 5) Verify it expanded
|
||||
Report.result(Tests.click_expand, nodeTree.isExpanded(ai_index))
|
||||
|
||||
# 6) Left-Click on a node category arrow to collapse it
|
||||
left_click_arrow(nodeTree, ai_index)
|
||||
|
||||
# 7) Verify it collapsed
|
||||
Report.result(Tests.click_collapse, not nodeTree.isExpanded(ai_index))
|
||||
|
||||
# 8) Double-Click on a node category to expand it
|
||||
double_click(nodeTree, ai_index)
|
||||
|
||||
# 9) Verify it expanded
|
||||
Report.result(Tests.dClick_expand, nodeTree.isExpanded(ai_index))
|
||||
|
||||
# 10) Double-Click on a node category to collapse it
|
||||
double_click(nodeTree, ai_index)
|
||||
|
||||
# 11) Verify it collapsed
|
||||
Report.result(Tests.dClick_collapse, not nodeTree.isExpanded(ai_index))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
import ImportPathHelper as imports
|
||||
imports.init()
|
||||
from utils import Report
|
||||
Report.start_test(NodeCategory_ExpandOnClick)
|
||||
@ -0,0 +1,91 @@
|
||||
"""
|
||||
All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
its licensors.
|
||||
|
||||
For complete copyright and license terms please see the LICENSE at the root of this
|
||||
distribution (the "License"). All use of this software is governed by the License,
|
||||
or, if provided, by the license below or the license accompanying this file. Do not
|
||||
remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
"""
|
||||
|
||||
|
||||
# fmt: off
|
||||
class Tests():
|
||||
set_search_string = ("Search string is set", "Search string is not set")
|
||||
search_string_deleted = ("Search string deleted as expected", "Search string not deleted")
|
||||
# fmt: on
|
||||
|
||||
|
||||
def NodePalette_SearchText_Deletion():
|
||||
"""
|
||||
Summary:
|
||||
We enter some string in the Node Palette Search box, select that text and delete it.
|
||||
|
||||
Expected Behavior:
|
||||
After RightClick->Delete the text in the Searchbox should be deleted.
|
||||
|
||||
Test Steps:
|
||||
1) Open Script Canvas window (Tools > Script Canvas)
|
||||
2) Get the SC window object
|
||||
3) Open Node Manager if not opened already
|
||||
4) Set some string in the Search box
|
||||
5) Verify if the test string is set
|
||||
6) Delete search string using right click and verify if it is cleared
|
||||
|
||||
Note:
|
||||
- This test file must be called from the Open 3D Engine Editor command terminal
|
||||
- Any passed and failed tests are written to the Editor.log file.
|
||||
Parsing the file or running a log_monitor are required to observe the test results.
|
||||
|
||||
:return: None
|
||||
"""
|
||||
|
||||
from PySide2 import QtWidgets, QtTest, QtCore
|
||||
|
||||
from utils import TestHelper as helper
|
||||
|
||||
import azlmbr.legacy.general as general
|
||||
|
||||
import pyside_utils
|
||||
|
||||
TEST_STRING = "TestString"
|
||||
|
||||
# 1) Open Script Canvas window (Tools > Script Canvas)
|
||||
general.idle_enable(True)
|
||||
general.open_pane("Script Canvas")
|
||||
helper.wait_for_condition(lambda: general.is_pane_visible("Script Canvas"), 3.0)
|
||||
|
||||
# 2) Get the SC window object
|
||||
editor_window = pyside_utils.get_editor_main_window()
|
||||
sc = editor_window.findChild(QtWidgets.QDockWidget, "Script Canvas")
|
||||
|
||||
# 3) Open Node Manager if not opened already
|
||||
if sc.findChild(QtWidgets.QDockWidget, "NodePalette") is None:
|
||||
action = pyside_utils.find_child_by_pattern(sc, {"text": "Node Palette", "type": QtWidgets.QAction})
|
||||
action.trigger()
|
||||
node_palette = sc.findChild(QtWidgets.QDockWidget, "NodePalette")
|
||||
search_frame = node_palette.findChild(QtWidgets.QFrame, "searchFrame")
|
||||
|
||||
# 4) Set some string in the Search box
|
||||
search_box = search_frame.findChild(QtWidgets.QLineEdit, "searchFilter")
|
||||
search_box.setText(TEST_STRING)
|
||||
|
||||
# 5) Verify if the test string is set
|
||||
result = helper.wait_for_condition(lambda: search_box.text() == TEST_STRING, 1.0)
|
||||
Report.result(Tests.set_search_string, result)
|
||||
|
||||
# 6) Delete search string using right click and verify if it is cleared
|
||||
QtTest.QTest.keyClick(search_box, QtCore.Qt.Key_A, QtCore.Qt.ControlModifier)
|
||||
pyside_utils.trigger_context_menu_entry(search_box, "Delete")
|
||||
result = helper.wait_for_condition(lambda: search_box.text() == "", 2.0)
|
||||
Report.result(Tests.search_string_deleted, result)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
import ImportPathHelper as imports
|
||||
|
||||
imports.init()
|
||||
from utils import Report
|
||||
|
||||
Report.start_test(NodePalette_SearchText_Deletion)
|
||||
@ -0,0 +1,112 @@
|
||||
"""
|
||||
All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
its licensors.
|
||||
|
||||
For complete copyright and license terms please see the LICENSE at the root of this
|
||||
distribution (the "License"). All use of this software is governed by the License,
|
||||
or, if provided, by the license below or the license accompanying this file. Do not
|
||||
remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
|
||||
Test Case Title: Event can return a value of set type successfully
|
||||
"""
|
||||
|
||||
|
||||
# fmt: off
|
||||
class Tests():
|
||||
level_created = ("Successfully created temporary level", "Failed to create temporary level")
|
||||
entity_created = ("Successfully created test entity", "Failed to create test entity")
|
||||
enter_game_mode = ("Successfully entered game mode", "Failed to enter game mode")
|
||||
lines_found = ("Successfully found expected message", "Failed to find expected message")
|
||||
exit_game_mode = ("Successfully exited game mode", "Failed to exit game mode")
|
||||
# fmt: on
|
||||
|
||||
|
||||
def ScriptEvents_ReturnSetType_Successfully():
|
||||
"""
|
||||
Summary: A temporary level is created with an Entity having ScriptCanvas component.
|
||||
ScriptEvent(T92569006_ScriptEvent.scriptevents) is created with one Method that has a return value.
|
||||
ScriptCanvas(T92569006_ScriptCanvas.scriptcanvas) is attached to Entity. Graph has Send node that sends the Method
|
||||
of the ScriptEvent and prints the returned result ( On Entity Activated -> Send node -> Print) and Receive node is
|
||||
set to return custom value ( Receive node -> Print).
|
||||
Verify that the entity containing T92569006_ScriptCanvas.scriptcanvas should print the custom value set in both
|
||||
Send and Receive nodes.
|
||||
|
||||
Expected Behavior:
|
||||
After entering game mode, the graph on the entity should print an expected message to the console
|
||||
|
||||
Test Steps:
|
||||
1) Create test level
|
||||
2) Create test entity
|
||||
3) Start Tracer
|
||||
4) Enter Game Mode
|
||||
5) Read for line
|
||||
6) Exit Game Mode
|
||||
|
||||
Note:
|
||||
- This test file must be called from the Open 3D Engine Editor command terminal
|
||||
- Any passed and failed tests are written to the Editor.log file.
|
||||
Parsing the file or running a log_monitor are required to observe the test results.
|
||||
|
||||
:return: None
|
||||
"""
|
||||
import os
|
||||
from editor_entity_utils import EditorEntity as Entity
|
||||
from utils import Report
|
||||
from utils import TestHelper as helper
|
||||
from utils import Tracer
|
||||
|
||||
import azlmbr.legacy.general as general
|
||||
import azlmbr.asset as asset
|
||||
import azlmbr.math as math
|
||||
import azlmbr.bus as bus
|
||||
|
||||
LEVEL_NAME = "tmp_level"
|
||||
WAIT_TIME = 3.0 # SECONDS
|
||||
EXPECTED_LINES = ["T92569006_ScriptEvent_Sent", "T92569006_ScriptEvent_Received"]
|
||||
SC_ASSET_PATH = os.path.join("ScriptCanvas", "T92569006_ScriptCanvas.scriptcanvas")
|
||||
|
||||
def create_editor_entity(name, sc_asset):
|
||||
entity = Entity.create_editor_entity(name)
|
||||
sc_comp = entity.add_component("Script Canvas")
|
||||
asset_id = asset.AssetCatalogRequestBus(bus.Broadcast, "GetAssetIdByPath", sc_asset, math.Uuid(), False)
|
||||
sc_comp.set_component_property_value("Script Canvas Asset|Script Canvas Asset", asset_id)
|
||||
Report.critical_result(Tests.entity_created, entity.id.isValid())
|
||||
|
||||
def locate_expected_lines(line_list: list):
|
||||
found_lines = [printInfo.message.strip() for printInfo in section_tracer.prints]
|
||||
|
||||
return all(line in found_lines for line in line_list)
|
||||
|
||||
# 1) Create temp level
|
||||
general.idle_enable(True)
|
||||
result = general.create_level_no_prompt(LEVEL_NAME, 128, 1, 512, True)
|
||||
Report.critical_result(Tests.level_created, result == 0)
|
||||
helper.wait_for_condition(lambda: general.get_current_level_name() == LEVEL_NAME, WAIT_TIME)
|
||||
general.close_pane("Error Report")
|
||||
|
||||
# 2) Create test entity
|
||||
create_editor_entity("TestEntity", SC_ASSET_PATH)
|
||||
|
||||
# 3) Start Tracer
|
||||
with Tracer() as section_tracer:
|
||||
|
||||
# 4) Enter Game Mode
|
||||
helper.enter_game_mode(Tests.enter_game_mode)
|
||||
|
||||
# 5) Read for line
|
||||
lines_located = helper.wait_for_condition(lambda: locate_expected_lines(EXPECTED_LINES), WAIT_TIME)
|
||||
Report.result(Tests.lines_found, lines_located)
|
||||
|
||||
# 6) Exit Game Mode
|
||||
helper.exit_game_mode(Tests.exit_game_mode)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
import ImportPathHelper as imports
|
||||
|
||||
imports.init()
|
||||
|
||||
from utils import Report
|
||||
|
||||
Report.start_test(ScriptEvents_ReturnSetType_Successfully)
|
||||
@ -0,0 +1,121 @@
|
||||
"""
|
||||
All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
its licensors.
|
||||
For complete copyright and license terms please see the LICENSE at the root of this
|
||||
distribution (the "License"). All use of this software is governed by the License,
|
||||
or, if provided, by the license below or the license accompanying this file. Do not
|
||||
remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
"""
|
||||
|
||||
|
||||
# fmt: off
|
||||
class Tests():
|
||||
variable_manager_opened = ("VariableManager is opened successfully", "Failed to open VariableManager")
|
||||
variable_pinned = ("Variable is pinned", "Variable is not pinned, But it should be unpinned")
|
||||
variable_unpinned = ("Variable is unpinned", "Variable is not unpinned, But it should be pinned")
|
||||
variable_unpinned_after_reopen = ("Variable is unpinned after reopening create variable menu", "Variable is not unpinned after reopening create variable menu")
|
||||
# fmt: on
|
||||
|
||||
|
||||
def VariableManager_UnpinVariableType_Works():
|
||||
"""
|
||||
Summary:
|
||||
Unpin variable types in create variable menu.
|
||||
Expected Behavior:
|
||||
The variable unpinned in create variable menu remains unpinned after reopening create variable menu.
|
||||
Test Steps:
|
||||
1) Open Script Canvas window (Tools > Script Canvas)
|
||||
2) Get the SC window object
|
||||
3) Open Variable Manager in Script Canvas window
|
||||
4) Create new graph
|
||||
5) Click on the Create Variable button in the Variable Manager
|
||||
6) Unpin Boolean by clicking the "Pin" icon on its left side
|
||||
7) Close and Reopen Create Variable menu and make sure Boolean is unpinned after reopening Create Variable menu
|
||||
8) Restore default layout and close SC window
|
||||
Note:
|
||||
- This test file must be called from the Open 3D Engine Editor command terminal
|
||||
- Any passed and failed tests are written to the Editor.log file.
|
||||
Parsing the file or running a log_monitor are required to observe the test results.
|
||||
:return: None
|
||||
"""
|
||||
|
||||
from PySide2 import QtWidgets
|
||||
import azlmbr.legacy.general as general
|
||||
|
||||
import pyside_utils
|
||||
from utils import TestHelper as helper
|
||||
from utils import Report
|
||||
from PySide2.QtCore import Qt
|
||||
|
||||
GENERAL_WAIT = 1.0 # seconds
|
||||
|
||||
def find_pane(window, pane_name):
|
||||
return window.findChild(QtWidgets.QDockWidget, pane_name)
|
||||
|
||||
def click_menu_option(window, option_text):
|
||||
action = pyside_utils.find_child_by_pattern(window, {"text": option_text, "type": QtWidgets.QAction})
|
||||
action.trigger()
|
||||
|
||||
# 1) Open Script Canvas window (Tools > Script Canvas)
|
||||
general.idle_enable(True)
|
||||
general.open_pane("Script Canvas")
|
||||
helper.wait_for_condition(lambda: general.is_pane_visible("Script Canvas"), 6.0)
|
||||
|
||||
# 2) Get the SC window object
|
||||
editor_window = pyside_utils.get_editor_main_window()
|
||||
sc = editor_window.findChild(QtWidgets.QDockWidget, "Script Canvas")
|
||||
sc_main = sc.findChild(QtWidgets.QMainWindow)
|
||||
|
||||
# 3) Open Variable Manager in Script Canvas window
|
||||
pane = find_pane(sc, "VariableManager")
|
||||
if not pane.isVisible():
|
||||
click_menu_option(sc, "Variable Manager")
|
||||
pane = find_pane(sc, "VariableManager")
|
||||
Report.result(Tests.variable_manager_opened, pane.isVisible())
|
||||
|
||||
# 4) Create new graph
|
||||
create_new_graph = pyside_utils.find_child_by_pattern(
|
||||
sc_main, {"objectName": "action_New_Script", "type": QtWidgets.QAction}
|
||||
)
|
||||
create_new_graph.trigger()
|
||||
|
||||
# 5) Click on the Create Variable button in the Variable Manager
|
||||
variable_manager = sc_main.findChild(QtWidgets.QDockWidget, "VariableManager")
|
||||
button = variable_manager.findChild(QtWidgets.QPushButton, "addButton")
|
||||
button.click()
|
||||
|
||||
# 6) Unpin Boolean by clicking the "Pin" icon on its left side
|
||||
table_view = variable_manager.findChild(QtWidgets.QTableView, "variablePalette")
|
||||
model_index = pyside_utils.find_child_by_pattern(table_view, "Boolean")
|
||||
# Make sure Boolean is pinned
|
||||
is_boolean = model_index.siblingAtColumn(0)
|
||||
result = helper.wait_for_condition(lambda: is_boolean.data(Qt.DecorationRole) is not None, GENERAL_WAIT)
|
||||
Report.result(Tests.variable_pinned, result)
|
||||
# Unpin Boolean and make sure Boolean is unpinned.
|
||||
pyside_utils.item_view_index_mouse_click(table_view, is_boolean)
|
||||
result = helper.wait_for_condition(lambda: is_boolean.data(Qt.DecorationRole) is None, GENERAL_WAIT)
|
||||
Report.result(Tests.variable_unpinned, result)
|
||||
|
||||
# 7) Close and Reopen Create Variable menu and make sure Boolean is unpinned after reopening Create Variable menu
|
||||
button.click()
|
||||
button.click()
|
||||
model_index = pyside_utils.find_child_by_pattern(table_view, "Boolean")
|
||||
result = helper.wait_for_condition(
|
||||
lambda: model_index.siblingAtColumn(0).data(Qt.DecorationRole) is None, GENERAL_WAIT
|
||||
)
|
||||
Report.result(Tests.variable_unpinned_after_reopen, result)
|
||||
|
||||
# 8) Restore default layout and close SC window
|
||||
click_menu_option(sc, "Restore Default Layout")
|
||||
general.close_pane("Script Canvas")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
import ImportPathHelper as imports
|
||||
|
||||
imports.init()
|
||||
|
||||
from utils import Report
|
||||
|
||||
Report.start_test(VariableManager_UnpinVariableType_Works)
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,126 @@
|
||||
<ObjectStream version="3">
|
||||
<Class name="ScriptEventsAsset" version="1" type="{CB4D603E-8CB0-4D80-8165-4244F28AF187}">
|
||||
<Class name="ScriptEvent" field="m_definition" version="1" type="{10A08CD3-32C9-4E18-8039-4B8A8157918E}">
|
||||
<Class name="unsigned int" field="m_version" value="4" type="{43DA906B-7DEF-4CA8-9790-854106D3F983}"/>
|
||||
<Class name="VersionedProperty" field="m_name" version="4" type="{828CA9C0-32F1-40B3-8018-EE7C3C38192A}">
|
||||
<Class name="AZ::Uuid" field="m_id" value="{1E4A668C-8300-4047-AEA2-F5FEBF11EBA0}" type="{E152C105-A133-4D03-BBF8-3D4B2FBA3E2A}"/>
|
||||
<Class name="AZStd::string" field="m_label" value="Name" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
<Class name="unsigned int" field="m_version" value="1" type="{43DA906B-7DEF-4CA8-9790-854106D3F983}"/>
|
||||
<Class name="AZStd::vector" field="m_versions" type="{326CAAFE-9101-56E2-B869-D770629A6B19}">
|
||||
<Class name="VersionedProperty" field="element" version="4" type="{828CA9C0-32F1-40B3-8018-EE7C3C38192A}">
|
||||
<Class name="AZ::Uuid" field="m_id" value="{1E4A668C-8300-4047-AEA2-F5FEBF11EBA0}" type="{E152C105-A133-4D03-BBF8-3D4B2FBA3E2A}"/>
|
||||
<Class name="AZStd::string" field="m_label" value="Name" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
<Class name="unsigned int" field="m_version" value="0" type="{43DA906B-7DEF-4CA8-9790-854106D3F983}"/>
|
||||
<Class name="AZStd::vector" field="m_versions" type="{326CAAFE-9101-56E2-B869-D770629A6B19}"/>
|
||||
<Class name="any" field="m_data" type="{03924488-C7F4-4D6D-948B-ABC2D1AE2FD3}">
|
||||
<Class name="AZStd::string" field="m_data" value="EventName" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
</Class>
|
||||
</Class>
|
||||
</Class>
|
||||
<Class name="any" field="m_data" type="{03924488-C7F4-4D6D-948B-ABC2D1AE2FD3}">
|
||||
<Class name="AZStd::string" field="m_data" value="T92569006_ScriptEvent" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
</Class>
|
||||
</Class>
|
||||
<Class name="VersionedProperty" field="m_category" version="4" type="{828CA9C0-32F1-40B3-8018-EE7C3C38192A}">
|
||||
<Class name="AZ::Uuid" field="m_id" value="{73D97530-40F2-48FD-91BA-C20ABB0C6620}" type="{E152C105-A133-4D03-BBF8-3D4B2FBA3E2A}"/>
|
||||
<Class name="AZStd::string" field="m_label" value="Category" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
<Class name="unsigned int" field="m_version" value="0" type="{43DA906B-7DEF-4CA8-9790-854106D3F983}"/>
|
||||
<Class name="AZStd::vector" field="m_versions" type="{326CAAFE-9101-56E2-B869-D770629A6B19}"/>
|
||||
<Class name="any" field="m_data" type="{03924488-C7F4-4D6D-948B-ABC2D1AE2FD3}">
|
||||
<Class name="AZStd::string" field="m_data" value="Script Events" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
</Class>
|
||||
</Class>
|
||||
<Class name="VersionedProperty" field="m_tooltip" version="4" type="{828CA9C0-32F1-40B3-8018-EE7C3C38192A}">
|
||||
<Class name="AZ::Uuid" field="m_id" value="{9D4BB4C1-8A94-43B9-BED7-C104D7758916}" type="{E152C105-A133-4D03-BBF8-3D4B2FBA3E2A}"/>
|
||||
<Class name="AZStd::string" field="m_label" value="Tooltip" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
<Class name="unsigned int" field="m_version" value="0" type="{43DA906B-7DEF-4CA8-9790-854106D3F983}"/>
|
||||
<Class name="AZStd::vector" field="m_versions" type="{326CAAFE-9101-56E2-B869-D770629A6B19}"/>
|
||||
<Class name="any" field="m_data" type="{03924488-C7F4-4D6D-948B-ABC2D1AE2FD3}">
|
||||
<Class name="AZStd::string" field="m_data" value="" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
</Class>
|
||||
</Class>
|
||||
<Class name="VersionedProperty" field="m_addressType" version="4" type="{828CA9C0-32F1-40B3-8018-EE7C3C38192A}">
|
||||
<Class name="AZ::Uuid" field="m_id" value="{8D528B1F-1FEE-43BA-BD5D-C7EB3707B781}" type="{E152C105-A133-4D03-BBF8-3D4B2FBA3E2A}"/>
|
||||
<Class name="AZStd::string" field="m_label" value="Address Type" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
<Class name="unsigned int" field="m_version" value="0" type="{43DA906B-7DEF-4CA8-9790-854106D3F983}"/>
|
||||
<Class name="AZStd::vector" field="m_versions" type="{326CAAFE-9101-56E2-B869-D770629A6B19}"/>
|
||||
<Class name="any" field="m_data" type="{03924488-C7F4-4D6D-948B-ABC2D1AE2FD3}">
|
||||
<Class name="AZ::Uuid" field="m_data" value="{C0F1AFAD-5CB3-450E-B0F5-ADB5D46B0E22}" type="{E152C105-A133-4D03-BBF8-3D4B2FBA3E2A}"/>
|
||||
</Class>
|
||||
</Class>
|
||||
<Class name="AZStd::vector" field="m_methods" type="{D9866B79-D11A-58E6-B974-0B45783F53A4}">
|
||||
<Class name="Method" field="element" type="{E034EA83-C798-413D-ACE8-4923C51CF4F7}">
|
||||
<Class name="VersionedProperty" field="m_name" version="4" type="{828CA9C0-32F1-40B3-8018-EE7C3C38192A}">
|
||||
<Class name="AZ::Uuid" field="m_id" value="{0DEB2C25-6B32-44B7-9750-56CAA789C016}" type="{E152C105-A133-4D03-BBF8-3D4B2FBA3E2A}"/>
|
||||
<Class name="AZStd::string" field="m_label" value="Name" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
<Class name="unsigned int" field="m_version" value="0" type="{43DA906B-7DEF-4CA8-9790-854106D3F983}"/>
|
||||
<Class name="AZStd::vector" field="m_versions" type="{326CAAFE-9101-56E2-B869-D770629A6B19}"/>
|
||||
<Class name="any" field="m_data" type="{03924488-C7F4-4D6D-948B-ABC2D1AE2FD3}">
|
||||
<Class name="AZStd::string" field="m_data" value="MethodName" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
</Class>
|
||||
</Class>
|
||||
<Class name="VersionedProperty" field="m_tooltip" version="4" type="{828CA9C0-32F1-40B3-8018-EE7C3C38192A}">
|
||||
<Class name="AZ::Uuid" field="m_id" value="{664A28E6-AD74-4EA7-BDE8-49CA02D1C5C7}" type="{E152C105-A133-4D03-BBF8-3D4B2FBA3E2A}"/>
|
||||
<Class name="AZStd::string" field="m_label" value="Tooltip" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
<Class name="unsigned int" field="m_version" value="0" type="{43DA906B-7DEF-4CA8-9790-854106D3F983}"/>
|
||||
<Class name="AZStd::vector" field="m_versions" type="{326CAAFE-9101-56E2-B869-D770629A6B19}"/>
|
||||
<Class name="any" field="m_data" type="{03924488-C7F4-4D6D-948B-ABC2D1AE2FD3}">
|
||||
<Class name="AZStd::string" field="m_data" value="" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
</Class>
|
||||
</Class>
|
||||
<Class name="VersionedProperty" field="m_returnType" version="4" type="{828CA9C0-32F1-40B3-8018-EE7C3C38192A}">
|
||||
<Class name="AZ::Uuid" field="m_id" value="{D2C6D979-A036-4523-B79E-98D3A1D4F623}" type="{E152C105-A133-4D03-BBF8-3D4B2FBA3E2A}"/>
|
||||
<Class name="AZStd::string" field="m_label" value="String" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
<Class name="unsigned int" field="m_version" value="1" type="{43DA906B-7DEF-4CA8-9790-854106D3F983}"/>
|
||||
<Class name="AZStd::vector" field="m_versions" type="{326CAAFE-9101-56E2-B869-D770629A6B19}">
|
||||
<Class name="VersionedProperty" field="element" version="4" type="{828CA9C0-32F1-40B3-8018-EE7C3C38192A}">
|
||||
<Class name="AZ::Uuid" field="m_id" value="{A2629A45-21A2-4101-BF0D-1F843B3398D7}" type="{E152C105-A133-4D03-BBF8-3D4B2FBA3E2A}"/>
|
||||
<Class name="AZStd::string" field="m_label" value="Return Type" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
<Class name="unsigned int" field="m_version" value="0" type="{43DA906B-7DEF-4CA8-9790-854106D3F983}"/>
|
||||
<Class name="AZStd::vector" field="m_versions" type="{326CAAFE-9101-56E2-B869-D770629A6B19}"/>
|
||||
<Class name="any" field="m_data" type="{03924488-C7F4-4D6D-948B-ABC2D1AE2FD3}">
|
||||
<Class name="AZ::Uuid" field="m_data" value="{C0F1AFAD-5CB3-450E-B0F5-ADB5D46B0E22}" type="{E152C105-A133-4D03-BBF8-3D4B2FBA3E2A}"/>
|
||||
</Class>
|
||||
</Class>
|
||||
</Class>
|
||||
<Class name="any" field="m_data" type="{03924488-C7F4-4D6D-948B-ABC2D1AE2FD3}">
|
||||
<Class name="AZ::Uuid" field="m_data" value="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}" type="{E152C105-A133-4D03-BBF8-3D4B2FBA3E2A}"/>
|
||||
</Class>
|
||||
</Class>
|
||||
<Class name="AZStd::vector" field="m_parameters" type="{6ED13EA7-791B-57A8-A4F1-560B5F35B472}">
|
||||
<Class name="Parameter" field="element" type="{0DA4809B-08A6-49DC-9024-F81645D97FAC}">
|
||||
<Class name="VersionedProperty" field="m_name" version="4" type="{828CA9C0-32F1-40B3-8018-EE7C3C38192A}">
|
||||
<Class name="AZ::Uuid" field="m_id" value="{CD536CCB-29E7-4155-8C20-E37FA3B3A3D2}" type="{E152C105-A133-4D03-BBF8-3D4B2FBA3E2A}"/>
|
||||
<Class name="AZStd::string" field="m_label" value="Name" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
<Class name="unsigned int" field="m_version" value="0" type="{43DA906B-7DEF-4CA8-9790-854106D3F983}"/>
|
||||
<Class name="AZStd::vector" field="m_versions" type="{326CAAFE-9101-56E2-B869-D770629A6B19}"/>
|
||||
<Class name="any" field="m_data" type="{03924488-C7F4-4D6D-948B-ABC2D1AE2FD3}">
|
||||
<Class name="AZStd::string" field="m_data" value="ParameterName" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
</Class>
|
||||
</Class>
|
||||
<Class name="VersionedProperty" field="m_tooltip" version="4" type="{828CA9C0-32F1-40B3-8018-EE7C3C38192A}">
|
||||
<Class name="AZ::Uuid" field="m_id" value="{62907B85-6C12-49E3-8A92-82E41AF029D5}" type="{E152C105-A133-4D03-BBF8-3D4B2FBA3E2A}"/>
|
||||
<Class name="AZStd::string" field="m_label" value="Tooltip" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
<Class name="unsigned int" field="m_version" value="0" type="{43DA906B-7DEF-4CA8-9790-854106D3F983}"/>
|
||||
<Class name="AZStd::vector" field="m_versions" type="{326CAAFE-9101-56E2-B869-D770629A6B19}"/>
|
||||
<Class name="any" field="m_data" type="{03924488-C7F4-4D6D-948B-ABC2D1AE2FD3}">
|
||||
<Class name="AZStd::string" field="m_data" value="" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
</Class>
|
||||
</Class>
|
||||
<Class name="VersionedProperty" field="m_type" version="4" type="{828CA9C0-32F1-40B3-8018-EE7C3C38192A}">
|
||||
<Class name="AZ::Uuid" field="m_id" value="{E3509DD4-13B0-4096-8AC4-115D9A8BCD6B}" type="{E152C105-A133-4D03-BBF8-3D4B2FBA3E2A}"/>
|
||||
<Class name="AZStd::string" field="m_label" value="String" type="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}"/>
|
||||
<Class name="unsigned int" field="m_version" value="0" type="{43DA906B-7DEF-4CA8-9790-854106D3F983}"/>
|
||||
<Class name="AZStd::vector" field="m_versions" type="{326CAAFE-9101-56E2-B869-D770629A6B19}"/>
|
||||
<Class name="any" field="m_data" type="{03924488-C7F4-4D6D-948B-ABC2D1AE2FD3}">
|
||||
<Class name="AZ::Uuid" field="m_data" value="{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9}" type="{E152C105-A133-4D03-BBF8-3D4B2FBA3E2A}"/>
|
||||
</Class>
|
||||
</Class>
|
||||
</Class>
|
||||
</Class>
|
||||
</Class>
|
||||
</Class>
|
||||
</Class>
|
||||
</Class>
|
||||
</ObjectStream>
|
||||
|
||||
@ -1,173 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef __animtime_h__
|
||||
#define __animtime_h__
|
||||
|
||||
#include <IXml.h>
|
||||
#include <AzCore/Casting/numeric_cast.h>
|
||||
#include <Serialization/IArchive.h>
|
||||
|
||||
struct SAnimTime
|
||||
{
|
||||
static const uint numTicksPerSecond = 6000;
|
||||
|
||||
// List of possible frame rates (dividers of 6000). Most commonly used ones first.
|
||||
enum EFrameRate
|
||||
{
|
||||
// Common
|
||||
eFrameRate_30fps, eFrameRate_60fps, eFrameRate_120fps,
|
||||
|
||||
// Possible
|
||||
eFrameRate_10fps, eFrameRate_12fps, eFrameRate_15fps, eFrameRate_24fps,
|
||||
eFrameRate_25fps, eFrameRate_40fps, eFrameRate_48fps, eFrameRate_50fps,
|
||||
eFrameRate_75fps, eFrameRate_80fps, eFrameRate_100fps, eFrameRate_125fps,
|
||||
eFrameRate_150fps, eFrameRate_200fps, eFrameRate_240fps, eFrameRate_250fps,
|
||||
eFrameRate_300fps, eFrameRate_375fps, eFrameRate_400fps, eFrameRate_500fps,
|
||||
eFrameRate_600fps, eFrameRate_750fps, eFrameRate_1000fps, eFrameRate_1200fps,
|
||||
eFrameRate_1500fps, eFrameRate_2000fps, eFrameRate_3000fps, eFrameRate_6000fps,
|
||||
|
||||
eFrameRate_Num
|
||||
};
|
||||
|
||||
SAnimTime()
|
||||
: m_ticks(0) {}
|
||||
explicit SAnimTime(int32 ticks)
|
||||
: m_ticks(ticks) {}
|
||||
explicit SAnimTime(float time)
|
||||
: m_ticks(aznumeric_caster(std::lround(static_cast<double>(time) * numTicksPerSecond))) {}
|
||||
|
||||
static uint GetFrameRateValue(EFrameRate frameRate)
|
||||
{
|
||||
const uint frameRateValues[eFrameRate_Num] =
|
||||
{
|
||||
// Common
|
||||
30, 60, 120,
|
||||
|
||||
// Possible
|
||||
10, 12, 15, 24, 25, 40, 48, 50, 75, 80, 100, 125,
|
||||
150, 200, 240, 250, 300, 375, 400, 500, 600, 750,
|
||||
1000, 1200, 1500, 2000, 3000, 6000
|
||||
};
|
||||
|
||||
return frameRateValues[frameRate];
|
||||
}
|
||||
|
||||
static const char* GetFrameRateName(EFrameRate frameRate)
|
||||
{
|
||||
const char* frameRateNames[eFrameRate_Num] =
|
||||
{
|
||||
// Common
|
||||
"30 fps", "60 fps", "120 fps",
|
||||
|
||||
// Possible
|
||||
"10 fps", "12 fps", "15 fps", "24 fps",
|
||||
"25 fps", "40 fps", "48 fps", "50 fps",
|
||||
"75 fps", "80 fps", "100 fps", "125 fps",
|
||||
"150 fps", "200 fps", "240 fps", "250 fps",
|
||||
"300 fps", "375 fps", "400 fps", "500 fps",
|
||||
"600 fps", "750 fps", "1000 fps", "1200 fps",
|
||||
"1500 fps", "2000 fps", "3000 fps", "6000 fps"
|
||||
};
|
||||
|
||||
return frameRateNames[frameRate];
|
||||
}
|
||||
|
||||
float ToFloat() const { return static_cast<float>(m_ticks) / numTicksPerSecond; }
|
||||
|
||||
void Serialize(Serialization::IArchive& ar)
|
||||
{
|
||||
ar(m_ticks, "ticks", "Ticks");
|
||||
}
|
||||
|
||||
// Helper to serialize from ticks or old float time
|
||||
void Serialize(XmlNodeRef keyNode, bool bLoading, const char* pName, const char* pLegacyName)
|
||||
{
|
||||
if (bLoading)
|
||||
{
|
||||
int32 ticks;
|
||||
if (!keyNode->getAttr(pName, ticks))
|
||||
{
|
||||
// Backwards compatibility
|
||||
float time = 0.0f;
|
||||
keyNode->getAttr(pLegacyName, time);
|
||||
*this = SAnimTime(time);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_ticks = ticks;
|
||||
}
|
||||
}
|
||||
else if (m_ticks > 0)
|
||||
{
|
||||
keyNode->setAttr(pName, m_ticks);
|
||||
}
|
||||
}
|
||||
|
||||
int32 GetTicks() const { return m_ticks; }
|
||||
|
||||
static SAnimTime Min() { SAnimTime minTime; minTime.m_ticks = std::numeric_limits<int32>::lowest(); return minTime; }
|
||||
static SAnimTime Max() { SAnimTime maxTime; maxTime.m_ticks = (std::numeric_limits<int32>::max)(); return maxTime; }
|
||||
|
||||
SAnimTime operator-() const { return SAnimTime(-m_ticks); }
|
||||
SAnimTime operator-(SAnimTime r) const { SAnimTime temp = *this; temp.m_ticks -= r.m_ticks; return temp; }
|
||||
SAnimTime operator+(SAnimTime r) const { SAnimTime temp = *this; temp.m_ticks += r.m_ticks; return temp; }
|
||||
SAnimTime operator*(SAnimTime r) const { SAnimTime temp = *this; temp.m_ticks *= r.m_ticks; return temp; }
|
||||
SAnimTime operator/(SAnimTime r) const { SAnimTime temp; temp.m_ticks = static_cast<int32>((static_cast<int64>(m_ticks) * numTicksPerSecond) / r.m_ticks); return temp; }
|
||||
SAnimTime operator%(SAnimTime r) const { SAnimTime temp = *this; temp.m_ticks %= r.m_ticks; return temp; }
|
||||
SAnimTime operator*(float r) const { SAnimTime temp; temp.m_ticks = aznumeric_caster(std::lround(static_cast<double>(m_ticks) * r)); return temp; }
|
||||
SAnimTime operator/(float r) const { SAnimTime temp; temp.m_ticks = aznumeric_caster(std::lround(static_cast<double>(m_ticks) / r)); return temp; }
|
||||
SAnimTime& operator+=(SAnimTime r) { *this = *this + r; return *this; }
|
||||
SAnimTime& operator-=(SAnimTime r) { *this = *this - r; return *this; }
|
||||
SAnimTime& operator*=(SAnimTime r) { *this = *this * r; return *this; }
|
||||
SAnimTime& operator/=(SAnimTime r) { *this = *this / r; return *this; }
|
||||
SAnimTime& operator%=(SAnimTime r) { *this = *this % r; return *this; }
|
||||
SAnimTime& operator*=(float r) { *this = *this * r; return *this; }
|
||||
SAnimTime& operator/=(float r) { *this = *this / r; return *this; }
|
||||
|
||||
bool operator<(SAnimTime r) const { return m_ticks < r.m_ticks; }
|
||||
bool operator<=(SAnimTime r) const { return m_ticks <= r.m_ticks; }
|
||||
bool operator>(SAnimTime r) const { return m_ticks > r.m_ticks; }
|
||||
bool operator>=(SAnimTime r) const { return m_ticks >= r.m_ticks; }
|
||||
bool operator==(SAnimTime r) const { return m_ticks == r.m_ticks; }
|
||||
bool operator!=(SAnimTime r) const { return m_ticks != r.m_ticks; }
|
||||
|
||||
// Snap to nearest multiple of given frame rate
|
||||
SAnimTime SnapToNearest(const EFrameRate frameRate)
|
||||
{
|
||||
const int sign = sgn(m_ticks);
|
||||
const int32 absTicks = abs(m_ticks);
|
||||
|
||||
const int framesMod = numTicksPerSecond / GetFrameRateValue(frameRate);
|
||||
const int32 remainder = absTicks % framesMod;
|
||||
const bool bNextMultiple = remainder >= (framesMod / 2);
|
||||
return SAnimTime(sign * ((absTicks - remainder) + (bNextMultiple ? framesMod : 0)));
|
||||
}
|
||||
|
||||
private:
|
||||
int32 m_ticks;
|
||||
|
||||
friend bool Serialize(Serialization::IArchive& ar, SAnimTime& animTime, const char* name, const char* label);
|
||||
};
|
||||
|
||||
inline bool Serialize(Serialization::IArchive& ar, SAnimTime& animTime, const char* name, const char* label)
|
||||
{
|
||||
return ar(animTime.m_ticks, name, label);
|
||||
}
|
||||
|
||||
inline SAnimTime abs(SAnimTime time)
|
||||
{
|
||||
return (time >= SAnimTime(0)) ? time : -time;
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,321 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef __BEZIER_H__
|
||||
#define __BEZIER_H__
|
||||
|
||||
#include <AnimTime.h>
|
||||
#include <Serialization/IArchive.h>
|
||||
#include <Serialization/Math.h>
|
||||
|
||||
struct SBezierControlPoint
|
||||
{
|
||||
SBezierControlPoint()
|
||||
: m_value(0.0f)
|
||||
, m_inTangent(ZERO)
|
||||
, m_outTangent(ZERO)
|
||||
, m_inTangentType(eTangentType_Auto)
|
||||
, m_outTangentType(eTangentType_Auto)
|
||||
, m_bBreakTangents(false)
|
||||
{
|
||||
}
|
||||
|
||||
enum ETangentType
|
||||
{
|
||||
eTangentType_Custom,
|
||||
eTangentType_Auto,
|
||||
eTangentType_Zero,
|
||||
eTangentType_Step,
|
||||
eTangentType_Linear,
|
||||
};
|
||||
|
||||
void Serialize(Serialization::IArchive& ar)
|
||||
{
|
||||
ar(m_value, "value", "Value");
|
||||
|
||||
if (ar.IsOutput())
|
||||
{
|
||||
bool breakTangents = m_bBreakTangents;
|
||||
ar(breakTangents, "breakTangents", "Break Tangents");
|
||||
}
|
||||
else
|
||||
{
|
||||
bool breakTangents = false;
|
||||
ar(breakTangents, "breakTangents", "Break Tangents");
|
||||
m_bBreakTangents = breakTangents;
|
||||
}
|
||||
|
||||
if (ar.IsOutput())
|
||||
{
|
||||
ETangentType inTangentType = m_inTangentType;
|
||||
ar(inTangentType, "inTangentType", "Incoming tangent type");
|
||||
}
|
||||
else
|
||||
{
|
||||
ETangentType inTangentType = eTangentType_Auto;
|
||||
ar(inTangentType, "inTangentType", "Incoming tangent type");
|
||||
m_inTangentType = inTangentType;
|
||||
}
|
||||
|
||||
ar(m_inTangent, "inTangent", (m_inTangentType == eTangentType_Custom) ? "Incoming Tangent" : NULL);
|
||||
|
||||
if (ar.IsOutput())
|
||||
{
|
||||
ETangentType outTangentType = m_outTangentType;
|
||||
ar(outTangentType, "outTangentType", "Outgoing tangent type");
|
||||
}
|
||||
else
|
||||
{
|
||||
ETangentType outTangentType = eTangentType_Auto;
|
||||
ar(outTangentType, "outTangentType", "Outgoing tangent type");
|
||||
m_outTangentType = outTangentType;
|
||||
}
|
||||
|
||||
ar(m_outTangent, "outTangent", (m_outTangentType == eTangentType_Custom) ? "Outgoing Tangent" : NULL);
|
||||
}
|
||||
|
||||
float m_value;
|
||||
|
||||
// For 1D Bezier only the Y component is used
|
||||
Vec2 m_inTangent;
|
||||
Vec2 m_outTangent;
|
||||
|
||||
ETangentType m_inTangentType : 4;
|
||||
ETangentType m_outTangentType : 4;
|
||||
bool m_bBreakTangents : 1;
|
||||
};
|
||||
|
||||
struct SBezierKey
|
||||
{
|
||||
SBezierKey()
|
||||
: m_time(0) {}
|
||||
|
||||
void Serialize(Serialization::IArchive& ar)
|
||||
{
|
||||
ar(m_time, "time", "Time");
|
||||
ar(m_controlPoint, "controlPoint", "Control Point");
|
||||
}
|
||||
|
||||
SAnimTime m_time;
|
||||
SBezierControlPoint m_controlPoint;
|
||||
};
|
||||
|
||||
namespace Bezier
|
||||
{
|
||||
inline float Evaluate(float t, float p0, float p1, float p2, float p3)
|
||||
{
|
||||
const float a = 1 - t;
|
||||
const float aSq = a * a;
|
||||
const float tSq = t * t;
|
||||
return (aSq * a * p0) + (3.0f * aSq * t * p1) + (3.0f * a * tSq * p2) + (tSq * t * p3);
|
||||
}
|
||||
|
||||
inline float EvaluateDeriv(float t, float p0, float p1, float p2, float p3)
|
||||
{
|
||||
const float a = 1 - t;
|
||||
const float ta = t * a;
|
||||
const float aSq = a * a;
|
||||
const float tSq = t * t;
|
||||
return 3.0f * ((-p2 * tSq) + (p3 * tSq) - (p0 * aSq) + (p1 * aSq) + 2.0f * ((-p1 * ta) + (p2 * ta)));
|
||||
}
|
||||
|
||||
inline float EvaluateX(const float t, const float duration, const SBezierControlPoint& start, const SBezierControlPoint& end)
|
||||
{
|
||||
const float p0 = 0.0f;
|
||||
const float p1 = p0 + start.m_outTangent.x;
|
||||
const float p3 = duration;
|
||||
const float p2 = p3 + end.m_inTangent.x;
|
||||
return Evaluate(t, p0, p1, p2, p3);
|
||||
}
|
||||
|
||||
inline float EvaluateY(const float t, const SBezierControlPoint& start, const SBezierControlPoint& end)
|
||||
{
|
||||
const float p0 = start.m_value;
|
||||
const float p1 = p0 + start.m_outTangent.y;
|
||||
const float p3 = end.m_value;
|
||||
const float p2 = p3 + end.m_inTangent.y;
|
||||
return Evaluate(t, p0, p1, p2, p3);
|
||||
}
|
||||
|
||||
// Duration = (time at end key) - (time at start key)
|
||||
inline float EvaluateDerivX(const float t, const float duration, const SBezierControlPoint& start, const SBezierControlPoint& end)
|
||||
{
|
||||
const float p0 = 0.0f;
|
||||
const float p1 = p0 + start.m_outTangent.x;
|
||||
const float p3 = duration;
|
||||
const float p2 = p3 + end.m_inTangent.x;
|
||||
return EvaluateDeriv(t, p0, p1, p2, p3);
|
||||
}
|
||||
|
||||
inline float EvaluateDerivY(const float t, const SBezierControlPoint& start, const SBezierControlPoint& end)
|
||||
{
|
||||
const float p0 = start.m_value;
|
||||
const float p1 = p0 + start.m_outTangent.y;
|
||||
const float p3 = end.m_value;
|
||||
const float p2 = p3 + end.m_inTangent.y;
|
||||
return EvaluateDeriv(t, p0, p1, p2, p3);
|
||||
}
|
||||
|
||||
// Find interpolation factor where 2D bezier curve has the given x value. Works only for curves where x is monotonically increasing.
|
||||
// The passed x must be in range [0, duration]. Uses the Newton-Raphson root finding method. Usually takes 2 or 3 iterations.
|
||||
//
|
||||
// Note: This is for "1D" 2D bezier curves as used in TrackView. The curves are restricted by the curve editor to be monotonically increasing.
|
||||
//
|
||||
inline float InterpolationFactorFromX(const float x, const float duration, const SBezierControlPoint& start, const SBezierControlPoint& end)
|
||||
{
|
||||
float t = (x / duration);
|
||||
|
||||
const float epsilon = 0.00001f;
|
||||
const uint maxSteps = 10;
|
||||
|
||||
for (uint i = 0; i < maxSteps; ++i)
|
||||
{
|
||||
const float currentX = EvaluateX(t, duration, start, end) - x;
|
||||
if (fabs(currentX) <= epsilon)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
const float currentXDeriv = EvaluateDerivX(t, duration, start, end);
|
||||
t -= currentX / currentXDeriv;
|
||||
}
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
inline SBezierControlPoint CalculateInTangent(
|
||||
float time, const SBezierControlPoint& point,
|
||||
float leftTime, const SBezierControlPoint* pLeftPoint,
|
||||
float rightTime, const SBezierControlPoint* pRightPoint)
|
||||
{
|
||||
SBezierControlPoint newPoint = point;
|
||||
|
||||
// In tangent X can never be positive
|
||||
newPoint.m_inTangent.x = std::min(point.m_inTangent.x, 0.0f);
|
||||
|
||||
if (pLeftPoint)
|
||||
{
|
||||
switch (point.m_inTangentType)
|
||||
{
|
||||
case SBezierControlPoint::eTangentType_Custom:
|
||||
{
|
||||
// Need to clamp tangent if it is reaching over last point
|
||||
const float deltaTime = time - leftTime;
|
||||
if (deltaTime < -newPoint.m_inTangent.x)
|
||||
{
|
||||
if (newPoint.m_inTangent.x == 0)
|
||||
{
|
||||
newPoint.m_inTangent = Vec2(ZERO);
|
||||
}
|
||||
else
|
||||
{
|
||||
float scaleFactor = deltaTime / -newPoint.m_inTangent.x;
|
||||
newPoint.m_inTangent.x = -deltaTime;
|
||||
newPoint.m_inTangent.y *= scaleFactor;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case SBezierControlPoint::eTangentType_Zero:
|
||||
// Fall through. Zero for y is same as Auto, x is set to 0.0f
|
||||
case SBezierControlPoint::eTangentType_Auto:
|
||||
{
|
||||
const SBezierControlPoint& rightPoint = pRightPoint ? *pRightPoint : point;
|
||||
const float deltaTime = (pRightPoint ? rightTime : time) - leftTime;
|
||||
if (deltaTime > 0.0f)
|
||||
{
|
||||
const float ratio = (time - leftTime) / deltaTime;
|
||||
const float deltaValue = rightPoint.m_value - pLeftPoint->m_value;
|
||||
const bool bIsZeroTangent = (point.m_inTangentType == SBezierControlPoint::eTangentType_Zero);
|
||||
newPoint.m_inTangent = Vec2(-(deltaTime * ratio) / 3.0f, bIsZeroTangent ? 0.0f : -(deltaValue * ratio) / 3.0f);
|
||||
}
|
||||
else
|
||||
{
|
||||
newPoint.m_inTangent = Vec2(ZERO);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case SBezierControlPoint::eTangentType_Linear:
|
||||
newPoint.m_inTangent = Vec2((leftTime - time) / 3.0f,
|
||||
(pLeftPoint->m_value - point.m_value) / 3.0f);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return newPoint;
|
||||
}
|
||||
|
||||
inline SBezierControlPoint CalculateOutTangent(
|
||||
float time, const SBezierControlPoint& point,
|
||||
float leftTime, const SBezierControlPoint* pLeftPoint,
|
||||
float rightTime, const SBezierControlPoint* pRightPoint)
|
||||
{
|
||||
SBezierControlPoint newPoint = point;
|
||||
|
||||
// Out tangent X can never be negative
|
||||
newPoint.m_outTangent.x = std::max(point.m_outTangent.x, 0.0f);
|
||||
|
||||
if (pRightPoint)
|
||||
{
|
||||
switch (point.m_outTangentType)
|
||||
{
|
||||
case SBezierControlPoint::eTangentType_Custom:
|
||||
{
|
||||
// Need to clamp tangent if it is reaching over next point
|
||||
const float deltaTime = rightTime - time;
|
||||
if (deltaTime < newPoint.m_outTangent.x)
|
||||
{
|
||||
if (newPoint.m_outTangent.x == 0)
|
||||
{
|
||||
newPoint.m_outTangent = Vec2(ZERO);
|
||||
}
|
||||
else
|
||||
{
|
||||
float scaleFactor = deltaTime / newPoint.m_outTangent.x;
|
||||
newPoint.m_outTangent.x = deltaTime;
|
||||
newPoint.m_outTangent.y *= scaleFactor;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case SBezierControlPoint::eTangentType_Zero:
|
||||
// Fall through. Zero for y is same as Auto, x is set to 0.0f
|
||||
case SBezierControlPoint::eTangentType_Auto:
|
||||
{
|
||||
const SBezierControlPoint& leftPoint = pLeftPoint ? *pLeftPoint : point;
|
||||
const float deltaTime = rightTime - (pLeftPoint ? leftTime : time);
|
||||
if (deltaTime > 0.0f)
|
||||
{
|
||||
const float ratio = (rightTime - time) / deltaTime;
|
||||
const float deltaValue = pRightPoint->m_value - leftPoint.m_value;
|
||||
const bool bIsZeroTangent = (point.m_outTangentType == SBezierControlPoint::eTangentType_Zero);
|
||||
newPoint.m_outTangent = Vec2((deltaTime * ratio) / 3.0f, bIsZeroTangent ? 0.0f : (deltaValue * ratio) / 3.0f);
|
||||
}
|
||||
else
|
||||
{
|
||||
newPoint.m_outTangent = Vec2(ZERO);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case SBezierControlPoint::eTangentType_Linear:
|
||||
newPoint.m_outTangent = Vec2((rightTime - time) / 3.0f,
|
||||
(pRightPoint->m_value - point.m_value) / 3.0f);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return newPoint;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,158 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef __CREBASECLOUD_H__
|
||||
#define __CREBASECLOUD_H__
|
||||
|
||||
//================================================================================
|
||||
|
||||
class SCloudParticle
|
||||
{
|
||||
public:
|
||||
inline SCloudParticle();
|
||||
inline SCloudParticle(const Vec3& vPos, float fRadius, const ColorF& baseColor, float fTransparency = 0);
|
||||
inline SCloudParticle(const Vec3& vPos, float fRadiusX, float fRadiusY, float fRotMin, float fRotMax, Vec2 vUV[]);
|
||||
inline ~SCloudParticle();
|
||||
|
||||
float GetRadiusX() const { return m_fSize[0]; }
|
||||
float GetRadiusY() const { return m_fSize[1]; }
|
||||
float GetTransparency() const { return m_fTransparency; }
|
||||
const Vec3& GetPosition() const { return m_vPosition; }
|
||||
const ColorF& GetBaseColor() const { return m_vBaseColor; }
|
||||
uint32 GetNumLitColors() const { return m_vLitColors.size(); }
|
||||
inline const ColorF GetLitColor(unsigned int index) const;
|
||||
float GetSquareSortDistance() const { return m_fSquareSortDistance; }
|
||||
|
||||
//! Sets the radius of the particle.
|
||||
void SetRadiusX(float rad) { m_fSize[0] = rad; }
|
||||
void SetRadiusY(float rad) { m_fSize[1] = rad; }
|
||||
void SetTransparency(float trans) { m_fTransparency = trans; }
|
||||
void SetPosition(const Vec3& pos) { m_vPosition = pos; }
|
||||
void SetBaseColor(const ColorF& col) { m_vBaseColor = col; }
|
||||
void AddLitColor(const ColorF& col) { m_vLitColors.push_back(col); }
|
||||
void ClearLitColors() { m_vLitColors.clear(); }
|
||||
void SetSquareSortDistance(float fSquareDistance) { m_fSquareSortDistance = fSquareDistance; }
|
||||
|
||||
bool operator<(const SCloudParticle& p) const
|
||||
{
|
||||
return (m_fSquareSortDistance < p.m_fSquareSortDistance);
|
||||
}
|
||||
|
||||
bool operator>(const SCloudParticle& p) const
|
||||
{
|
||||
return (m_fSquareSortDistance > p.m_fSquareSortDistance);
|
||||
}
|
||||
|
||||
protected:
|
||||
float m_fTransparency;
|
||||
Vec3 m_vPosition;
|
||||
float m_fSize[2];
|
||||
float m_fRotMin;
|
||||
float m_fRotMax;
|
||||
ColorF m_vBaseColor;
|
||||
TArray<ColorF> m_vLitColors;
|
||||
Vec3 m_vEye;
|
||||
|
||||
// for sorting particles during shading
|
||||
float m_fSquareSortDistance;
|
||||
public:
|
||||
Vec2 m_vUV[2];
|
||||
};
|
||||
|
||||
inline SCloudParticle::SCloudParticle()
|
||||
{
|
||||
m_fSize[0] = 0;
|
||||
m_fTransparency = 0;
|
||||
m_vPosition = Vec3(0, 0, 0);
|
||||
m_vBaseColor = Col_Black;
|
||||
m_vEye = Vec3(0, 0, 0);
|
||||
m_fSquareSortDistance = 0;
|
||||
|
||||
m_vLitColors.clear();
|
||||
}
|
||||
|
||||
inline SCloudParticle::SCloudParticle(const Vec3& pos, float fRadius, const ColorF& baseColor, float fTransparency)
|
||||
{
|
||||
m_fSize[0] = fRadius;
|
||||
m_fSize[1] = fRadius;
|
||||
m_fTransparency = fTransparency;
|
||||
m_vPosition = pos;
|
||||
m_vBaseColor = baseColor;
|
||||
m_vUV[0] = Vec2(0, 0);
|
||||
m_vUV[1] = Vec2(1, 1);
|
||||
|
||||
m_fRotMin = 0;
|
||||
m_fRotMax = 0;
|
||||
m_vEye = Vec3(0, 0, 0);
|
||||
m_fSquareSortDistance = 0;
|
||||
|
||||
m_vLitColors.clear();
|
||||
}
|
||||
|
||||
inline SCloudParticle::SCloudParticle(const Vec3& vPos, float fRadiusX, float fRadiusY, float fRotMin, float fRotMax, Vec2 vUV[2])
|
||||
{
|
||||
m_fSize[0] = fRadiusX;
|
||||
m_fSize[1] = fRadiusY;
|
||||
m_vPosition = vPos;
|
||||
m_vBaseColor = Col_White;
|
||||
m_vUV[0] = vUV[0];
|
||||
m_vUV[1] = vUV[1];
|
||||
m_fRotMin = fRotMin;
|
||||
m_fRotMax = fRotMax;
|
||||
|
||||
m_fTransparency = 1.0f;
|
||||
m_vEye = Vec3(0, 0, 0);
|
||||
m_fSquareSortDistance = 0;
|
||||
|
||||
m_vLitColors.clear();
|
||||
}
|
||||
|
||||
inline SCloudParticle::~SCloudParticle()
|
||||
{
|
||||
m_vLitColors.clear();
|
||||
}
|
||||
|
||||
inline const ColorF SCloudParticle::GetLitColor(unsigned int index) const
|
||||
{
|
||||
if (index <= m_vLitColors.size())
|
||||
{
|
||||
return m_vLitColors[index];
|
||||
}
|
||||
else
|
||||
{
|
||||
return Col_Black;
|
||||
}
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
class CREBaseCloud
|
||||
: public CRendElementBase
|
||||
{
|
||||
friend class CRECloud;
|
||||
|
||||
public:
|
||||
CREBaseCloud()
|
||||
: CRendElementBase()
|
||||
{
|
||||
mfSetType(eDATA_Cloud);
|
||||
mfUpdateFlags(FCEF_TRANSFORM);
|
||||
}
|
||||
virtual void SetParticles(SCloudParticle* pParticles, int nNumParticles) = 0;
|
||||
|
||||
virtual void GetMemoryUsage(ICrySizer* pSizer) const
|
||||
{
|
||||
pSizer->AddObject(this, sizeof(*this));
|
||||
}
|
||||
};
|
||||
|
||||
#endif // __CREBASECLOUD_H__
|
||||
@ -1,66 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
#ifndef _CREFOGVOLUME_
|
||||
#define _CREFOGVOLUME_
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "VertexFormats.h"
|
||||
|
||||
|
||||
struct IFogVolumeRenderNode;
|
||||
|
||||
|
||||
class CREFogVolume
|
||||
: public CRendElementBase
|
||||
{
|
||||
public:
|
||||
CREFogVolume();
|
||||
|
||||
virtual ~CREFogVolume();
|
||||
virtual void mfPrepare(bool bCheckOverflow);
|
||||
virtual bool mfDraw(CShader* ef, SShaderPass* sfm);
|
||||
|
||||
virtual void GetMemoryUsage(ICrySizer* pSizer) const
|
||||
{
|
||||
pSizer->AddObject(this, sizeof(*this));
|
||||
}
|
||||
|
||||
Vec3 m_center;
|
||||
uint32 m_viewerInsideVolume : 1;
|
||||
uint32 m_affectsThisAreaOnly : 1;
|
||||
uint32 m_stencilRef : 8;
|
||||
uint32 m_volumeType : 1;
|
||||
uint32 m_reserved : 21;
|
||||
AABB m_localAABB;
|
||||
Matrix34 m_matWSInv;
|
||||
float m_globalDensity;
|
||||
float m_densityOffset;
|
||||
float m_nearCutoff;
|
||||
Vec2 m_softEdgesLerp;
|
||||
ColorF m_fogColor; // color already combined with fHDRDynamic
|
||||
Vec3 m_heightFallOffDirScaled;
|
||||
Vec3 m_heightFallOffBasePoint;
|
||||
Vec3 m_eyePosInWS;
|
||||
Vec3 m_eyePosInOS;
|
||||
Vec3 m_rampParams;
|
||||
Vec3 m_windOffset;
|
||||
float m_noiseScale;
|
||||
Vec3 m_noiseFreq;
|
||||
float m_noiseOffset;
|
||||
float m_noiseElapsedTime;
|
||||
Vec3 m_scale;
|
||||
};
|
||||
|
||||
|
||||
#endif // #ifndef _CREFOGVOLUME_
|
||||
@ -1,63 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
#ifndef _CREGameEffect_
|
||||
#define _CREGameEffect_
|
||||
|
||||
#pragma once
|
||||
|
||||
//==================================================================================================
|
||||
// Name: IREGameEffect
|
||||
// Desc: Interface for game effect render elements, designed to be instantiated in game code, and
|
||||
// called from the CREGameEffect within the engine. This then allows render elements
|
||||
// to be created in game code as well as in the engine.
|
||||
// Author: James Chilvers
|
||||
//==================================================================================================
|
||||
struct IREGameEffect
|
||||
{
|
||||
virtual ~IREGameEffect(){}
|
||||
|
||||
virtual void mfPrepare(bool bCheckOverflow) = 0;
|
||||
virtual bool mfDraw(CShader* ef, SShaderPass* sfm, CRenderObject* renderObj) = 0;
|
||||
};//------------------------------------------------------------------------------------------------
|
||||
|
||||
//==================================================================================================
|
||||
// Name: CREGameEffect
|
||||
// Desc: Render element that uses the IREGameEffect interface for its functionality
|
||||
// Author: James Chilvers
|
||||
//==================================================================================================
|
||||
class CREGameEffect
|
||||
: public CRendElementBase
|
||||
{
|
||||
public:
|
||||
|
||||
CREGameEffect();
|
||||
~CREGameEffect();
|
||||
|
||||
// CRendElementBase interface
|
||||
void mfPrepare(bool bCheckOverflow);
|
||||
bool mfDraw(CShader* ef, SShaderPass* sfm);
|
||||
|
||||
// CREGameEffect interface
|
||||
inline void SetPrivateImplementation(IREGameEffect* pImpl) { m_pImpl = pImpl; }
|
||||
inline IREGameEffect* GetPrivateImplementation() const { return m_pImpl; }
|
||||
|
||||
virtual void GetMemoryUsage(ICrySizer* pSizer) const
|
||||
{
|
||||
pSizer->AddObject(this, sizeof(*this));
|
||||
}
|
||||
private:
|
||||
|
||||
IREGameEffect* m_pImpl; // Implementation of of render element
|
||||
};//------------------------------------------------------------------------------------------------
|
||||
|
||||
#endif // #ifndef _CREGameEffect_
|
||||
@ -1,95 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
// Description : Backend part of geometry cache rendering
|
||||
|
||||
#ifndef CRYINCLUDE_CRYCOMMON_CREGEOMCACHE_H
|
||||
#define CRYINCLUDE_CRYCOMMON_CREGEOMCACHE_H
|
||||
#pragma once
|
||||
|
||||
#if defined(USE_GEOM_CACHES)
|
||||
|
||||
#include <Vertex.h>
|
||||
#include <CryCommon/StaticInstance.h>
|
||||
|
||||
class CREGeomCache
|
||||
: public CRendElementBase
|
||||
{
|
||||
public:
|
||||
struct SMeshInstance
|
||||
{
|
||||
AABB m_aabb;
|
||||
Matrix34 m_matrix;
|
||||
Matrix34 m_prevMatrix;
|
||||
};
|
||||
|
||||
struct SMeshRenderData
|
||||
{
|
||||
DynArray<SMeshInstance> m_instances;
|
||||
_smart_ptr<IRenderMesh> m_pRenderMesh;
|
||||
};
|
||||
|
||||
struct UpdateList
|
||||
{
|
||||
CryCriticalSection m_mutex;
|
||||
AZStd::vector<CREGeomCache*, AZ::AZStdAlloc<CryLegacySTLAllocator>> m_geoms;
|
||||
};
|
||||
|
||||
public:
|
||||
CREGeomCache();
|
||||
~CREGeomCache();
|
||||
|
||||
bool Update(const int flags, const bool bTesselation);
|
||||
static void UpdateModified();
|
||||
|
||||
// CRendElementBase interface
|
||||
virtual bool mfUpdate(int Flags, bool bTessellation);
|
||||
virtual void mfPrepare(bool bCheckOverflow);
|
||||
virtual bool mfDraw(CShader* ef, SShaderPass* sfm);
|
||||
|
||||
// CREGeomCache interface
|
||||
virtual void InitializeRenderElement(const uint numMeshes, _smart_ptr<IRenderMesh>* pMeshes, uint16 materialId);
|
||||
virtual void SetupMotionBlur(CRenderObject* pRenderObject, const SRenderingPassInfo& passInfo);
|
||||
|
||||
virtual volatile int* SetAsyncUpdateState(int& threadId);
|
||||
virtual DynArray<SMeshRenderData>* GetMeshFillDataPtr();
|
||||
virtual DynArray<SMeshRenderData>* GetRenderDataPtr();
|
||||
virtual void DisplayFilledBuffer(const int threadId);
|
||||
|
||||
|
||||
AZ::Vertex::Format GetVertexFormat() const override;
|
||||
bool GetGeometryInfo(SGeometryInfo &streams) override;
|
||||
|
||||
private:
|
||||
uint16 m_materialId;
|
||||
volatile bool m_bUpdateFrame[2];
|
||||
volatile int m_transformUpdateState[2];
|
||||
|
||||
// We use a double buffered m_meshFillData array for input from the main thread. When data
|
||||
// was successfully sent from the main thread it gets copied to m_meshRenderData
|
||||
// This simplifies the cases where frame data is missing, e.g. meshFillData is not updated for a frame
|
||||
// Note that meshFillData really needs to be double buffered because the copy occurs in render thread
|
||||
// so the next main thread could already be touching the data again
|
||||
//
|
||||
// Note: m_meshRenderData is directly accessed for ray intersections via GetRenderDataPtr.
|
||||
// This is safe, because it's only used in editor.
|
||||
DynArray<SMeshRenderData> m_meshFillData[2];
|
||||
DynArray<SMeshRenderData> m_meshRenderData;
|
||||
|
||||
static StaticInstance<UpdateList> sm_updateList[2]; // double buffered update lists
|
||||
|
||||
AZ::Vertex::Format m_geomCacheVertexFormat;
|
||||
};
|
||||
|
||||
#endif
|
||||
#endif // CRYINCLUDE_CRYCOMMON_CREGEOMCACHE_H
|
||||
@ -1,194 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <IRenderer.h>
|
||||
#include "Cry_Camera.h"
|
||||
|
||||
//================================================================================
|
||||
|
||||
struct SDynTexture2;
|
||||
struct SDynTexture;
|
||||
class IDynTexture;
|
||||
class CameraViewParameters;
|
||||
|
||||
struct IImposterRenderElement
|
||||
{
|
||||
virtual void GetMemoryUsage(ICrySizer* pSizer) const = 0;
|
||||
virtual void mfPrepare(bool bCheckOverflow) = 0;
|
||||
virtual bool mfDraw(CShader* ef, SShaderPass* sl) = 0;
|
||||
virtual const SMinMaxBox& mfGetWorldSpaceBounds() = 0;
|
||||
|
||||
virtual bool IsSplit() = 0;
|
||||
virtual bool IsScreenImposter() = 0;
|
||||
|
||||
virtual float GetRadiusX() = 0;
|
||||
virtual float GetRadiusY() = 0;
|
||||
virtual Vec3* GetQuadCorners() = 0;
|
||||
virtual Vec3 GetNearPoint() = 0;
|
||||
virtual Vec3 GetFarPoint() = 0;
|
||||
virtual float GetErrorToleranceCosAngle() = 0;
|
||||
virtual uint32 GetState() = 0;
|
||||
virtual int GetAlphaRef() = 0;
|
||||
virtual ColorF GetColorHelper() = 0;
|
||||
virtual Vec3 GetLastSunDirection() = 0;
|
||||
virtual uint8 GetLastBestEdge() = 0;
|
||||
virtual float GetNear() = 0;
|
||||
virtual float GetFar() = 0;
|
||||
virtual float GetTransparency() = 0;
|
||||
virtual Vec3 GetPosition();
|
||||
virtual int GetLogResolutionX() = 0;
|
||||
virtual int GetLogResolutionY() = 0;
|
||||
virtual CameraViewParameters& GetLastViewParameters() = 0;
|
||||
virtual IDynTexture* GetTexture() = 0;
|
||||
virtual IDynTexture* GetScreenTexture() = 0;
|
||||
virtual IDynTexture* GetFrontTexture() = 0;
|
||||
virtual IDynTexture* GetDepthTexture() = 0;
|
||||
virtual const SMinMaxBox& GetWorldSpaceBounds() = 0;
|
||||
|
||||
virtual void SetBBox(const Vec3& min, const Vec3& max) = 0;
|
||||
virtual void SetScreenImposterState(bool state) = 0;
|
||||
virtual void SetState(uint32 state) = 0;
|
||||
virtual void SetAlphaRef(uint32 ref) = 0;
|
||||
virtual void SetPosition(Vec3 pos) = 0;
|
||||
virtual void SetFrameResetValue(int frameResetValue) = 0;
|
||||
virtual void SetTexture(IDynTexture* texture) = 0;
|
||||
virtual void SetScreenTexture(IDynTexture* texture) = 0;
|
||||
virtual void SetFrontTexture(IDynTexture* texture) = 0;
|
||||
virtual void SetDepthTexture(IDynTexture* texture) = 0;
|
||||
};
|
||||
|
||||
class CREImposter
|
||||
: public CRendElementBase
|
||||
{
|
||||
friend class CRECloud;
|
||||
static IDynTexture* m_pScreenTexture;
|
||||
|
||||
CameraViewParameters m_LastViewParameters;
|
||||
bool m_bScreenImposter;
|
||||
bool m_bSplit;
|
||||
float m_fRadiusX;
|
||||
float m_fRadiusY;
|
||||
Vec3 m_vQuadCorners[4]; // in world space, relative to m_vPos, in clockwise order, can be rotated
|
||||
Vec3 m_vNearPoint;
|
||||
Vec3 m_vFarPoint;
|
||||
int m_nLogResolutionX;
|
||||
int m_nLogResolutionY;
|
||||
IDynTexture* m_pTexture;
|
||||
IDynTexture* m_pFrontTexture;
|
||||
IDynTexture* m_pTextureDepth;
|
||||
float m_fErrorToleranceCosAngle; // cosine of m_fErrorToleranceAngle used to check if IsImposterValid
|
||||
SMinMaxBox m_WorldSpaceBV;
|
||||
uint32 m_State;
|
||||
int m_AlphaRef;
|
||||
float m_fCurTransparency;
|
||||
ColorF m_ColorHelper;
|
||||
Vec3 m_vPos;
|
||||
Vec3 m_vLastSunDir;
|
||||
uint8 m_nLastBestEdge; // 0..11 this edge is favored to not jitter between different edges
|
||||
float m_fNear;
|
||||
float m_fFar;
|
||||
|
||||
bool IsImposterValid(const CameraViewParameters& viewParameters, float fRadiusX, float fRadiusY, float fCamRadiusX, float fCamRadiusY,
|
||||
const int iRequiredLogResX, const int iRequiredLogResY, const uint32 dwBestEdge);
|
||||
|
||||
bool Display(bool bDisplayFrontOfSplit);
|
||||
|
||||
public:
|
||||
int m_nFrameReset;
|
||||
int m_FrameUpdate;
|
||||
float m_fTimeUpdate;
|
||||
|
||||
static int m_MemUpdated;
|
||||
static int m_MemPostponed;
|
||||
static int m_PrevMemUpdated;
|
||||
static int m_PrevMemPostponed;
|
||||
|
||||
CREImposter()
|
||||
: CRendElementBase()
|
||||
, m_pTexture(NULL)
|
||||
, m_pFrontTexture(NULL)
|
||||
, m_pTextureDepth(NULL)
|
||||
, m_bSplit(false)
|
||||
, m_fRadiusX(0)
|
||||
, m_fRadiusY(0)
|
||||
, m_fErrorToleranceCosAngle(cos(DEG2RAD(0.25f)))
|
||||
, m_bScreenImposter(false)
|
||||
, m_State(GS_DEPTHWRITE)
|
||||
, m_AlphaRef(-1)
|
||||
, m_fCurTransparency(1.0f)
|
||||
, m_FrameUpdate(0)
|
||||
, m_nFrameReset(0)
|
||||
, m_fTimeUpdate(0)
|
||||
, m_vLastSunDir(0, 0, 0)
|
||||
, m_nLogResolutionX(0)
|
||||
, m_nLogResolutionY(0)
|
||||
, m_nLastBestEdge(0)
|
||||
{
|
||||
mfSetType(eDATA_Imposter);
|
||||
mfUpdateFlags(FCEF_TRANSFORM);
|
||||
m_ColorHelper = Col_White;
|
||||
}
|
||||
virtual ~CREImposter()
|
||||
{
|
||||
ReleaseResources();
|
||||
}
|
||||
|
||||
bool UpdateImposter();
|
||||
void ReleaseResources();
|
||||
|
||||
bool PrepareForUpdate();
|
||||
|
||||
virtual void GetMemoryUsage(ICrySizer* pSizer) const
|
||||
{
|
||||
pSizer->AddObject(this, sizeof(*this));
|
||||
}
|
||||
virtual void mfPrepare(bool bCheckOverflow);
|
||||
virtual bool mfDraw(CShader* ef, SShaderPass* sl);
|
||||
const SMinMaxBox& mfGetWorldSpaceBounds() { return m_WorldSpaceBV; }
|
||||
|
||||
virtual bool IsSplit() { return m_bSplit; }
|
||||
virtual bool IsScreenImposter() { return m_bScreenImposter; }
|
||||
|
||||
virtual float GetRadiusX() { return m_fRadiusX; }
|
||||
virtual float GetRadiusY() { return m_fRadiusY; }
|
||||
virtual Vec3* GetQuadCorners() { return &m_vQuadCorners[0]; }
|
||||
virtual Vec3 GetNearPoint() { return m_vNearPoint; }
|
||||
virtual Vec3 GetFarPoint() { return m_vFarPoint; }
|
||||
virtual float GetErrorToleranceCosAngle() { return m_fErrorToleranceCosAngle; }
|
||||
virtual uint32 GetState() { return m_State; }
|
||||
virtual int GetAlphaRef() { return m_AlphaRef; }
|
||||
virtual ColorF GetColorHelper() { return m_ColorHelper; }
|
||||
virtual Vec3 GetLastSunDirection() { return m_vLastSunDir; }
|
||||
virtual uint8 GetLastBestEdge() { return m_nLastBestEdge; }
|
||||
virtual float GetNear() { return m_fNear; }
|
||||
virtual float GetFar() { return m_fFar; }
|
||||
virtual float GetTransparency() { return m_fCurTransparency; }
|
||||
virtual Vec3 GetPosition();
|
||||
virtual int GetLogResolutionX() { return m_nLogResolutionX; }
|
||||
virtual int GetLogResolutionY() { return m_nLogResolutionY; }
|
||||
virtual CameraViewParameters& GetLastViewParameters() { return m_LastViewParameters; }
|
||||
virtual IDynTexture** GetTexture() { return &m_pTexture; }
|
||||
virtual IDynTexture** GetScreenTexture() { return &m_pScreenTexture; }
|
||||
virtual IDynTexture** GetFrontTexture() { return &m_pFrontTexture; }
|
||||
virtual IDynTexture** GetDepthTexture() { return &m_pTextureDepth; }
|
||||
virtual const SMinMaxBox& GetWorldSpaceBounds() { return m_WorldSpaceBV; }
|
||||
virtual int GetFrameReset() { return m_nFrameReset; }
|
||||
virtual void SetBBox(const Vec3& min, const Vec3& max) { m_WorldSpaceBV.SetMin(min); m_WorldSpaceBV.SetMax(max); }
|
||||
virtual void SetScreenImposterState(bool state) { m_bScreenImposter = state; }
|
||||
virtual void SetState(uint32 state) { m_State = state; }
|
||||
virtual void SetAlphaRef(uint32 ref) { m_AlphaRef = ref; }
|
||||
virtual void SetPosition(Vec3 pos) { m_vPos = pos; }
|
||||
virtual void SetFrameResetValue(int frameResetValue) { m_nFrameReset = frameResetValue; }
|
||||
};
|
||||
@ -1,57 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef __CREMESH_H__
|
||||
#define __CREMESH_H__
|
||||
|
||||
class CREMesh
|
||||
: public CRendElementBase
|
||||
{
|
||||
public:
|
||||
|
||||
struct CRenderChunk* m_pChunk;
|
||||
class CRenderMesh* m_pRenderMesh;
|
||||
|
||||
// Copy of Chunk to avoid indirections
|
||||
int32 m_nFirstIndexId;
|
||||
int32 m_nNumIndices;
|
||||
|
||||
uint32 m_nFirstVertId;
|
||||
uint32 m_nNumVerts;
|
||||
|
||||
protected:
|
||||
CREMesh()
|
||||
{
|
||||
mfSetType(eDATA_Mesh);
|
||||
mfUpdateFlags(FCEF_TRANSFORM);
|
||||
|
||||
m_pChunk = NULL;
|
||||
m_pRenderMesh = NULL;
|
||||
m_nFirstIndexId = -1;
|
||||
m_nNumIndices = -1;
|
||||
m_nFirstVertId = 0;
|
||||
m_nNumVerts = 0;
|
||||
}
|
||||
|
||||
virtual ~CREMesh()
|
||||
{
|
||||
}
|
||||
|
||||
// Ideally should be declared and left unimplemented to prevent slicing at compile time
|
||||
// but this would prevent auto code gen in renderer later on.
|
||||
// To track potential slicing, uncomment the following (and their equivalent in CREMeshImpl)
|
||||
//CREMesh(CREMesh&);
|
||||
//CREMesh& operator=(CREMesh& rhs);
|
||||
};
|
||||
|
||||
#endif // __CREMESH_H__
|
||||
@ -1,116 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef __CREOCCLUSIONQUERY_H__
|
||||
#define __CREOCCLUSIONQUERY_H__
|
||||
|
||||
#define SUPP_HMAP_OCCL
|
||||
#define SUPP_HWOBJ_OCCL
|
||||
|
||||
//=============================================================
|
||||
|
||||
class CRenderMesh;
|
||||
|
||||
class CREOcclusionQuery
|
||||
: public CRendElementBase
|
||||
{
|
||||
friend class CRender3D;
|
||||
bool m_bSucceeded;
|
||||
public:
|
||||
|
||||
int m_nVisSamples;
|
||||
int m_nCheckFrame;
|
||||
int m_nDrawFrame;
|
||||
Vec3 m_vBoxMin;
|
||||
Vec3 m_vBoxMax;
|
||||
|
||||
UINT_PTR m_nOcclusionID; // this will carry a pointer LPDIRECT3DQUERY9, so it needs to be 64-bit on Windows 64
|
||||
|
||||
CRenderMesh* m_pRMBox;
|
||||
static uint32 m_nQueriesPerFrameCounter;
|
||||
static uint32 m_nReadResultNowCounter;
|
||||
static uint32 m_nReadResultTryCounter;
|
||||
|
||||
CREOcclusionQuery()
|
||||
{
|
||||
m_nOcclusionID = 0;
|
||||
|
||||
m_nVisSamples = 800 * 600;
|
||||
m_nCheckFrame = 0;
|
||||
m_nDrawFrame = 0;
|
||||
m_vBoxMin = Vec3(0, 0, 0);
|
||||
m_vBoxMax = Vec3(0, 0, 0);
|
||||
m_pRMBox = NULL;
|
||||
|
||||
mfSetType(eDATA_OcclusionQuery);
|
||||
mfUpdateFlags(FCEF_TRANSFORM);
|
||||
}
|
||||
|
||||
bool RT_ReadResult_Try(uint32 nDefaultNumSamples);
|
||||
|
||||
ILINE bool HasSucceeded() const { return m_bSucceeded; }
|
||||
|
||||
virtual ~CREOcclusionQuery();
|
||||
|
||||
virtual void mfPrepare(bool bCheckOverflow);
|
||||
virtual bool mfDraw(CShader* ef, SShaderPass* sfm);
|
||||
virtual void mfReset();
|
||||
virtual bool mfReadResult_Try(uint32 nDefaultNumSamples = 1);
|
||||
virtual bool mfReadResult_Now();
|
||||
|
||||
virtual void GetMemoryUsage(ICrySizer* pSizer) const
|
||||
{
|
||||
pSizer->AddObject(this, sizeof(*this));
|
||||
}
|
||||
};
|
||||
|
||||
struct OcclusionTestClient
|
||||
{
|
||||
OcclusionTestClient()
|
||||
: nLastOccludedMainFrameID(0)
|
||||
, nLastVisibleMainFrameID(0)
|
||||
{
|
||||
#ifdef SUPP_HMAP_OCCL
|
||||
vLastVisPoint.Set(0, 0, 0);
|
||||
nTerrainOccLastFrame = 0;
|
||||
#endif
|
||||
#ifdef SUPP_HWOBJ_OCCL
|
||||
bOccluded = true;
|
||||
pREOcclusionQuery = 0;
|
||||
#endif
|
||||
//nInstantTestRequested=0;
|
||||
}
|
||||
#ifdef SUPP_HWOBJ_OCCL
|
||||
~OcclusionTestClient()
|
||||
{
|
||||
if (pREOcclusionQuery)
|
||||
{
|
||||
pREOcclusionQuery->Release(false);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
uint32 nLastVisibleMainFrameID, nLastOccludedMainFrameID;
|
||||
uint32 nLastShadowCastMainFrameID, nLastNoShadowCastMainFrameID;
|
||||
#ifdef SUPP_HMAP_OCCL
|
||||
Vec3 vLastVisPoint;
|
||||
int nTerrainOccLastFrame;
|
||||
#endif
|
||||
#ifdef SUPP_HWOBJ_OCCL
|
||||
CREOcclusionQuery* pREOcclusionQuery;
|
||||
uint8 bOccluded;
|
||||
#endif
|
||||
//uint8 nInstantTestRequested;
|
||||
};
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_CRYCOMMON_CREOCCLUSIONQUERY_H
|
||||
@ -1,56 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_CRYCOMMON_CREPOSTPROCESS_H
|
||||
#define CRYINCLUDE_CRYCOMMON_CREPOSTPROCESS_H
|
||||
#pragma once
|
||||
|
||||
|
||||
class CREPostProcess
|
||||
: public CRendElementBase
|
||||
{
|
||||
friend class CD3D9Renderer;
|
||||
|
||||
public:
|
||||
|
||||
CREPostProcess();
|
||||
virtual ~CREPostProcess();
|
||||
|
||||
virtual void mfPrepare(bool bCheckOverflow);
|
||||
virtual bool mfDraw(CShader* ef, SShaderPass* sfm);
|
||||
|
||||
// Use for setting numeric values, vec4 (colors, position, vectors, wtv), strings
|
||||
virtual int mfSetParameter(const char* pszParam, float fValue, bool bForceValue = false) const;
|
||||
virtual int mfSetParameterVec4(const char* pszParam, const Vec4& pValue, bool bForceValue = false) const;
|
||||
virtual int mfSetParameterString(const char* pszParam, const char* pszArg) const;
|
||||
|
||||
virtual void mfGetParameter(const char* pszParam, float& fValue) const;
|
||||
virtual void mfGetParameterVec4(const char* pszParam, Vec4& pValue) const;
|
||||
virtual void mfGetParameterString(const char* pszParam, const char*& pszArg) const;
|
||||
|
||||
virtual int32 mfGetPostEffectID(const char* pPostEffectName) const;
|
||||
|
||||
// Reset all post processing effects
|
||||
virtual void Reset(bool bOnSpecChange = false);
|
||||
virtual void mfReset()
|
||||
{
|
||||
Reset();
|
||||
}
|
||||
|
||||
virtual void GetMemoryUsage(ICrySizer* pSizer) const
|
||||
{
|
||||
pSizer->AddObject(this, sizeof(*this));
|
||||
}
|
||||
};
|
||||
|
||||
#endif // CRYINCLUDE_CRYCOMMON_CREPOSTPROCESS_H
|
||||
@ -1,40 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
#ifndef _CREPRISMOBJECT_
|
||||
#define _CREPRISMOBJECT_
|
||||
|
||||
#pragma once
|
||||
|
||||
#if !defined(EXCLUDE_DOCUMENTATION_PURPOSE)
|
||||
|
||||
class CREPrismObject
|
||||
: public CRendElementBase
|
||||
{
|
||||
public:
|
||||
CREPrismObject();
|
||||
|
||||
virtual ~CREPrismObject() {}
|
||||
virtual void mfPrepare(bool bCheckOverflow);
|
||||
virtual bool mfDraw(CShader* ef, SShaderPass* sfm);
|
||||
|
||||
virtual void GetMemoryUsage(ICrySizer* pSizer) const
|
||||
{
|
||||
pSizer->AddObject(this, sizeof(*this));
|
||||
}
|
||||
|
||||
Vec3 m_center;
|
||||
};
|
||||
|
||||
#endif // EXCLUDE_DOCUMENTATION_PURPOSE
|
||||
|
||||
#endif // _CREPRISMOBJECT_
|
||||
@ -1,92 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef __CRESKY_H__
|
||||
#define __CRESKY_H__
|
||||
|
||||
//=============================================================
|
||||
|
||||
#include "VertexFormats.h"
|
||||
#include <Vertex.h>
|
||||
|
||||
struct SSkyLightRenderParams;
|
||||
|
||||
class CRESky
|
||||
: public CRendElementBase
|
||||
{
|
||||
friend class CRender3D;
|
||||
|
||||
public:
|
||||
|
||||
float m_fTerrainWaterLevel;
|
||||
float m_fSkyBoxStretching;
|
||||
float m_fAlpha;
|
||||
int m_nSphereListId;
|
||||
|
||||
public:
|
||||
CRESky();
|
||||
virtual ~CRESky();
|
||||
virtual void mfPrepare(bool bCheckOverflow);
|
||||
virtual bool mfDraw(CShader* ef, SShaderPass* sfm);
|
||||
|
||||
virtual void GetMemoryUsage(ICrySizer* pSizer) const
|
||||
{
|
||||
pSizer->AddObject(this, sizeof(*this));
|
||||
}
|
||||
|
||||
AZ::Vertex::Format GetVertexFormat() const override;
|
||||
bool GetGeometryInfo(SGeometryInfo& streams) override;
|
||||
|
||||
private:
|
||||
AZ::Vertex::Format m_skyVertexFormat;
|
||||
};
|
||||
|
||||
class CREHDRSky
|
||||
: public CRendElementBase
|
||||
{
|
||||
public:
|
||||
CREHDRSky();
|
||||
virtual ~CREHDRSky();
|
||||
virtual void mfPrepare(bool bCheckOverflow);
|
||||
virtual bool mfDraw(CShader* ef, SShaderPass* sfm);
|
||||
|
||||
virtual void GetMemoryUsage(ICrySizer* pSizer) const
|
||||
{
|
||||
pSizer->AddObject(this, sizeof(*this));
|
||||
}
|
||||
|
||||
void GenerateSkyDomeTextures(int32 width, int32 height);
|
||||
|
||||
virtual AZ::Vertex::Format GetVertexFormat() const override;
|
||||
virtual bool GetGeometryInfo(SGeometryInfo& streams) override;
|
||||
|
||||
public:
|
||||
const SSkyLightRenderParams* m_pRenderParams;
|
||||
int m_moonTexId;
|
||||
class CTexture* m_pSkyDomeTextureMie;
|
||||
class CTexture* m_pSkyDomeTextureRayleigh;
|
||||
|
||||
static void SetCommonMoonParams(CShader* ef, bool bUseMoon = false);
|
||||
|
||||
private:
|
||||
void Init();
|
||||
|
||||
private:
|
||||
int m_skyDomeTextureLastTimeStamp;
|
||||
int m_frameReset;
|
||||
class CStars* m_pStars;
|
||||
AZ::Vertex::Format m_hdrSkyVertexFormat;
|
||||
};
|
||||
|
||||
|
||||
#endif // __CRESKY_H__
|
||||
@ -1,70 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
#ifndef _CREVOLUMEOBJECT_
|
||||
#define _CREVOLUMEOBJECT_
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "VertexFormats.h"
|
||||
|
||||
|
||||
struct IVolumeObjectRenderNode;
|
||||
|
||||
struct IVolumeTexture
|
||||
{
|
||||
public:
|
||||
virtual ~IVolumeTexture() {}
|
||||
virtual void Release() = 0;
|
||||
virtual bool Create(unsigned int width, unsigned int height, unsigned int depth, unsigned char* pData) = 0;
|
||||
virtual bool Update(unsigned int width, unsigned int height, unsigned int depth, const unsigned char* pData) = 0;
|
||||
virtual int GetTexID() const = 0;
|
||||
virtual uint32 GetWidth() const = 0;
|
||||
virtual uint32 GetHeight() const = 0;
|
||||
virtual uint32 GetDepth() const = 0;
|
||||
virtual ITexture* GetTexture() const = 0;
|
||||
};
|
||||
|
||||
class CREVolumeObject
|
||||
: public CRendElementBase
|
||||
{
|
||||
public:
|
||||
CREVolumeObject();
|
||||
|
||||
virtual ~CREVolumeObject();
|
||||
virtual void mfPrepare(bool bCheckOverflow);
|
||||
virtual bool mfDraw(CShader* ef, SShaderPass* sfm);
|
||||
|
||||
virtual IVolumeTexture* CreateVolumeTexture() const;
|
||||
|
||||
virtual void GetMemoryUsage(ICrySizer* pSizer) const
|
||||
{
|
||||
pSizer->AddObject(this, sizeof(*this));
|
||||
}
|
||||
|
||||
Vec3 m_center;
|
||||
Matrix34 m_matInv;
|
||||
Vec3 m_eyePosInWS;
|
||||
Vec3 m_eyePosInOS;
|
||||
Plane_tpl<f32> m_volumeTraceStartPlane;
|
||||
AABB m_renderBoundsOS;
|
||||
bool m_viewerInsideVolume;
|
||||
bool m_nearPlaneIntersectsVolume;
|
||||
float m_alpha;
|
||||
float m_scale;
|
||||
|
||||
IVolumeTexture* m_pDensVol;
|
||||
IVolumeTexture* m_pShadVol;
|
||||
_smart_ptr<IRenderMesh> m_pHullMesh;
|
||||
};
|
||||
|
||||
#endif // #ifndef _CREVOLUMEOBJECT_
|
||||
@ -1,57 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef _CREWATEROCEAN_
|
||||
#define _CREWATEROCEAN_
|
||||
|
||||
class CWater;
|
||||
|
||||
class CREWaterOcean
|
||||
: public CRendElementBase
|
||||
{
|
||||
public:
|
||||
CREWaterOcean();
|
||||
virtual ~CREWaterOcean();
|
||||
|
||||
virtual void mfPrepare(bool bCheckOverflow);
|
||||
virtual bool mfDraw(CShader* ef, SShaderPass* sfm);
|
||||
virtual void mfGetPlane(Plane_tpl<f32>& pl);
|
||||
|
||||
virtual void Create(uint32 nVerticesCount, SVF_P3F_C4B_T2F* pVertices, uint32 nIndicesCount, const void* pIndices, uint32 nIndexSizeof);
|
||||
void ReleaseOcean();
|
||||
|
||||
virtual Vec3 GetPositionAt(float x, float y) const;
|
||||
virtual Vec4* GetDisplaceGrid() const;
|
||||
|
||||
virtual void GetMemoryUsage(ICrySizer* pSizer) const
|
||||
{
|
||||
pSizer->AddObject(this, sizeof(*this));
|
||||
}
|
||||
private:
|
||||
|
||||
uint32 m_nVerticesCount;
|
||||
uint32 m_nIndicesCount;
|
||||
uint32 m_nIndexSizeof;
|
||||
|
||||
void* m_pVertDecl;
|
||||
void* m_pVertices;
|
||||
void* m_pIndices;
|
||||
|
||||
private:
|
||||
|
||||
void UpdateFFT();
|
||||
void FrameUpdate();
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
@ -1,110 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
#ifndef _CREWATERVOLUME_
|
||||
#define _CREWATERVOLUME_
|
||||
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "VertexFormats.h"
|
||||
|
||||
class CREWaterVolume
|
||||
: public CRendElementBase
|
||||
{
|
||||
public:
|
||||
CREWaterVolume();
|
||||
|
||||
virtual ~CREWaterVolume();
|
||||
virtual void mfPrepare(bool bCheckOverflow);
|
||||
virtual bool mfDraw(CShader* ef, SShaderPass* sfm);
|
||||
virtual void mfGetPlane(Plane_tpl<f32>& pl);
|
||||
virtual void mfCenter(Vec3& vCenter, CRenderObject* pObj);
|
||||
|
||||
virtual void GetMemoryUsage(ICrySizer* pSizer) const
|
||||
{
|
||||
pSizer->AddObject(this, sizeof(*this));
|
||||
}
|
||||
|
||||
public:
|
||||
struct SParams
|
||||
{
|
||||
SParams()
|
||||
: m_pVertices(0)
|
||||
, m_pIndices(0)
|
||||
, m_numVertices(0)
|
||||
, m_numIndices(0)
|
||||
, m_center(0, 0, 0)
|
||||
, m_WSBBox(Vec3(-1, -1, -1), Vec3(1, 1, 1))
|
||||
, m_fogPlane(Vec3(0, 0, 1), 0)
|
||||
, m_fogDensity(0.1f)
|
||||
, m_fogColor(0.2f, 0.5f, 0.7f)
|
||||
, m_fogColorAffectedBySun(true)
|
||||
, m_fogShadowing(0.5f)
|
||||
, m_caustics(true)
|
||||
, m_causticIntensity(1.0f)
|
||||
, m_causticTiling(1.0f)
|
||||
, m_causticHeight(0.9f)
|
||||
, m_viewerInsideVolume(false)
|
||||
, m_viewerCloseToWaterPlane(false)
|
||||
, m_viewerCloseToWaterVolume(false)
|
||||
{
|
||||
}
|
||||
|
||||
const SVF_P3F_C4B_T2F* m_pVertices;
|
||||
const uint16* m_pIndices;
|
||||
|
||||
size_t m_numVertices;
|
||||
size_t m_numIndices;
|
||||
|
||||
Vec3 m_center;
|
||||
AABB m_WSBBox;
|
||||
|
||||
Plane_tpl<f32> m_fogPlane;
|
||||
float m_fogDensity;
|
||||
Vec3 m_fogColor;
|
||||
bool m_fogColorAffectedBySun;
|
||||
float m_fogShadowing;
|
||||
|
||||
bool m_caustics;
|
||||
float m_causticIntensity;
|
||||
float m_causticTiling;
|
||||
float m_causticHeight;
|
||||
|
||||
bool m_viewerInsideVolume;
|
||||
bool m_viewerCloseToWaterPlane;
|
||||
bool m_viewerCloseToWaterVolume;
|
||||
};
|
||||
|
||||
struct SOceanParams
|
||||
{
|
||||
SOceanParams()
|
||||
: m_fogColor(0.2f, 0.5f, 0.7f)
|
||||
, m_fogColorShallow(0.2f, 0.5f, 0.7f)
|
||||
, m_fogDensity(0.2f)
|
||||
{
|
||||
}
|
||||
|
||||
Vec3 m_fogColor;
|
||||
Vec3 m_fogColorShallow;
|
||||
float m_fogDensity;
|
||||
};
|
||||
|
||||
public:
|
||||
const SParams* m_pParams;
|
||||
const SOceanParams* m_pOceanParams;
|
||||
bool m_drawWaterSurface;
|
||||
bool m_drawFastPath;
|
||||
};
|
||||
|
||||
|
||||
#endif // #ifndef _CREWATERVOLUME_
|
||||
@ -1,96 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
// Description : Part of CryEngine's extension framework.
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYEXTENSION_CRYCREATECLASSINSTANCE_H
|
||||
#define CRYINCLUDE_CRYEXTENSION_CRYCREATECLASSINSTANCE_H
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "ICryUnknown.h"
|
||||
#include "ICryFactory.h"
|
||||
#include "ICryFactoryRegistry.h"
|
||||
#include <ISystem.h> // <> required for Interfuscator
|
||||
|
||||
|
||||
template <class T>
|
||||
bool CryCreateClassInstance(const CryClassID& cid, AZStd::shared_ptr<T>& p)
|
||||
{
|
||||
p = AZStd::shared_ptr<T>();
|
||||
ICryFactoryRegistry* pFactoryReg = gEnv->pSystem->GetCryFactoryRegistry();
|
||||
if (pFactoryReg)
|
||||
{
|
||||
ICryFactory* pFactory = pFactoryReg->GetFactory(cid);
|
||||
if (pFactory && pFactory->ClassSupports(cryiidof<T>()))
|
||||
{
|
||||
ICryUnknownPtr pUnk = pFactory->CreateClassInstance();
|
||||
AZStd::shared_ptr<T> pT = cryinterface_cast<T>(pUnk);
|
||||
if (pT)
|
||||
{
|
||||
p = pT;
|
||||
}
|
||||
}
|
||||
}
|
||||
return p.get() != NULL;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
bool CryCreateClassInstance(const char* cname, AZStd::shared_ptr<T>& p)
|
||||
{
|
||||
p = AZStd::shared_ptr<T>();
|
||||
ICryFactoryRegistry* pFactoryReg = gEnv->pSystem->GetCryFactoryRegistry();
|
||||
if (pFactoryReg)
|
||||
{
|
||||
ICryFactory* pFactory = pFactoryReg->GetFactory(cname);
|
||||
if (pFactory != NULL && pFactory->ClassSupports(cryiidof<T>()))
|
||||
{
|
||||
ICryUnknownPtr pUnk = pFactory->CreateClassInstance();
|
||||
AZStd::shared_ptr<T> pT = cryinterface_cast<T>(pUnk);
|
||||
if (pT)
|
||||
{
|
||||
p = pT;
|
||||
}
|
||||
}
|
||||
}
|
||||
return p.get() != NULL;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
bool CryCreateClassInstanceForInterface(const CryInterfaceID& iid, AZStd::shared_ptr<T>& p)
|
||||
{
|
||||
p = AZStd::shared_ptr<T>();
|
||||
ICryFactoryRegistry* pFactoryReg = gEnv->pSystem->GetCryFactoryRegistry();
|
||||
if (pFactoryReg)
|
||||
{
|
||||
size_t numFactories = 1;
|
||||
ICryFactory* pFactory = 0;
|
||||
pFactoryReg->IterateFactories(iid, &pFactory, numFactories);
|
||||
if (numFactories == 1 && pFactory)
|
||||
{
|
||||
ICryUnknownPtr pUnk = pFactory->CreateClassInstance();
|
||||
AZStd::shared_ptr<T> pT = cryinterface_cast<T>(pUnk);
|
||||
if (pT)
|
||||
{
|
||||
p = pT;
|
||||
}
|
||||
}
|
||||
}
|
||||
return p.get() != NULL;
|
||||
}
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_CRYEXTENSION_CRYCREATECLASSINSTANCE_H
|
||||
@ -1,123 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
// Description : Part of CryEngine's extension framework.
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYEXTENSION_CRYGUID_H
|
||||
#define CRYINCLUDE_CRYEXTENSION_CRYGUID_H
|
||||
#pragma once
|
||||
|
||||
#include "Serialization/IArchive.h"
|
||||
#include "Random.h"
|
||||
|
||||
#include <functional>
|
||||
|
||||
struct CryGUID
|
||||
{
|
||||
uint64 hipart;
|
||||
uint64 lopart;
|
||||
|
||||
// !!! Do NOT turn CryGUID into a non-aggregate !!!
|
||||
// It will prevent inlining and type list unrolling opportunities within
|
||||
// cryinterface_cast<T>() and cryiidof<T>(). As such prevent constructors,
|
||||
// non-public members, base classes and virtual functions!
|
||||
|
||||
//CryGUID() : hipart(0), lopart(0) {}
|
||||
//CryGUID(uint64 h, uint64 l) : hipart(h), lopart(l) {}
|
||||
|
||||
static CryGUID Construct(const uint64& hipart, const uint64& lopart)
|
||||
{
|
||||
CryGUID guid = {hipart, lopart};
|
||||
return guid;
|
||||
}
|
||||
|
||||
static CryGUID Create()
|
||||
{
|
||||
uint64 lopart = 0;
|
||||
uint64 hipart = 0;
|
||||
while (lopart == 0 || hipart == 0)
|
||||
{
|
||||
const uint32 a = cry_random_uint32();
|
||||
const uint32 b = cry_random_uint32();
|
||||
const uint32 c = cry_random_uint32();
|
||||
const uint32 d = cry_random_uint32();
|
||||
lopart = (uint64)a | ((uint64)b << 32);
|
||||
hipart = (uint64)c | ((uint64)d << 32);
|
||||
}
|
||||
|
||||
return Construct(lopart, hipart);
|
||||
}
|
||||
|
||||
static CryGUID Null()
|
||||
{
|
||||
return Construct(0, 0);
|
||||
}
|
||||
|
||||
bool operator ==(const CryGUID& rhs) const {return hipart == rhs.hipart && lopart == rhs.lopart; }
|
||||
bool operator !=(const CryGUID& rhs) const {return hipart != rhs.hipart || lopart != rhs.lopart; }
|
||||
bool operator <(const CryGUID& rhs) const {return hipart == rhs.hipart ? lopart < rhs.lopart : hipart < rhs.hipart; }
|
||||
|
||||
void Serialize(Serialization::IArchive& ar)
|
||||
{
|
||||
if (ar.IsInput())
|
||||
{
|
||||
uint32 dwords[4];
|
||||
ar(dwords, "guid");
|
||||
lopart = (((uint64)dwords[1]) << 32) | (uint64)dwords[0];
|
||||
hipart = (((uint64)dwords[3]) << 32) | (uint64)dwords[2];
|
||||
}
|
||||
else
|
||||
{
|
||||
uint32 guid[4] = {
|
||||
(uint32)(lopart & 0xFFFFFFFF), (uint32)((lopart >> 32) & 0xFFFFFFFF),
|
||||
(uint32)(hipart & 0xFFFFFFFF), (uint32)((hipart >> 32) & 0xFFFFFFFF)
|
||||
};
|
||||
ar(guid, "guid");
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// This is only used by the editor where we use C++ 11.
|
||||
namespace std
|
||||
{
|
||||
template<>
|
||||
struct hash<CryGUID>
|
||||
{
|
||||
public:
|
||||
size_t operator()(const CryGUID& guid) const
|
||||
{
|
||||
std::hash<uint64> hasher;
|
||||
return hasher(guid.lopart) ^ hasher(guid.hipart);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
namespace AZStd
|
||||
{
|
||||
template<>
|
||||
struct hash<CryGUID>
|
||||
{
|
||||
public:
|
||||
size_t operator()(const CryGUID& guid) const
|
||||
{
|
||||
std::hash<CryGUID> hasher;
|
||||
return hasher(guid);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#define MAKE_CRYGUID(high, low) CryGUID::Construct((uint64) high##LL, (uint64) low##LL)
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_CRYEXTENSION_CRYGUID_H
|
||||
@ -1,29 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
// Description : Part of CryEngine's extension framework.
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYEXTENSION_CRYTYPEID_H
|
||||
#define CRYINCLUDE_CRYEXTENSION_CRYTYPEID_H
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "CryGUID.h"
|
||||
|
||||
|
||||
typedef CryGUID CryInterfaceID;
|
||||
typedef CryGUID CryClassID;
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_CRYEXTENSION_CRYTYPEID_H
|
||||
@ -1,41 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
// Description : Part of CryEngine's extension framework.
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYEXTENSION_ICRYFACTORY_H
|
||||
#define CRYINCLUDE_CRYEXTENSION_ICRYFACTORY_H
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "CryTypeID.h"
|
||||
#include <SmartPointersHelpers.h>
|
||||
|
||||
struct ICryUnknown;
|
||||
DECLARE_SMART_POINTERS(ICryUnknown);
|
||||
|
||||
struct ICryFactory
|
||||
{
|
||||
virtual const char* GetName() const = 0;
|
||||
virtual const CryClassID& GetClassID() const = 0;
|
||||
virtual bool ClassSupports(const CryInterfaceID& iid) const = 0;
|
||||
virtual void ClassSupports(const CryInterfaceID*& pIIDs, size_t& numIIDs) const = 0;
|
||||
virtual ICryUnknownPtr CreateClassInstance() const = 0;
|
||||
|
||||
protected:
|
||||
// prevent explicit destruction from client side (delete, shared_ptr, etc)
|
||||
virtual ~ICryFactory() {}
|
||||
};
|
||||
|
||||
#endif // CRYINCLUDE_CRYEXTENSION_ICRYFACTORY_H
|
||||
@ -1,56 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
// Description : Part of CryEngine's extension framework.
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYEXTENSION_ICRYFACTORYREGISTRY_H
|
||||
#define CRYINCLUDE_CRYEXTENSION_ICRYFACTORYREGISTRY_H
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "CryTypeID.h"
|
||||
|
||||
|
||||
struct ICryFactory;
|
||||
|
||||
|
||||
struct ICryFactoryRegistry
|
||||
{
|
||||
virtual ICryFactory* GetFactory(const char* cname) const = 0;
|
||||
virtual ICryFactory* GetFactory(const CryClassID& cid) const = 0;
|
||||
/**
|
||||
* Iterates all factories implementing the interface specified by \p iid.
|
||||
* \param[in] iid ID of the interface to iterate. Often procured using cryiidof<...>().
|
||||
* \param[out] pFactories A pointer of the array of factories to fill in. May be nullptr (see below).
|
||||
* \param[in] Size (in elements) of the pFactories array [out] Number of elements actually written to pFactories or, when pFactories is null, the number of elements that would be written if sufficient storage was available.
|
||||
*
|
||||
* Example:
|
||||
* \code{.cpp}
|
||||
* size_t factoryCount = 0;
|
||||
* // Assigns the number of found factories to factoryCount
|
||||
* factoryRegistry->IterateFactories(cryiidof<TPointer>(), 0, factoryCount);
|
||||
* // Allocate an array of the proper length on the stack
|
||||
* ICryFactory** factories = static_cast<ICryFactory**>(alloca(sizeof(ICryFactory*) * factoryCount);
|
||||
* // Fill in factories with factoryCount results.
|
||||
* factoryRegistry->IterateFactories(cryiidof<TPointer>(), factories, factoryCount);
|
||||
* \endcode
|
||||
*/
|
||||
virtual void IterateFactories(const CryInterfaceID& iid, ICryFactory** pFactories, size_t& numFactories) const = 0;
|
||||
|
||||
protected:
|
||||
// prevent explicit destruction from client side (delete, shared_ptr, etc)
|
||||
virtual ~ICryFactoryRegistry() {}
|
||||
};
|
||||
|
||||
#endif // CRYINCLUDE_CRYEXTENSION_ICRYFACTORYREGISTRY_H
|
||||
@ -1,224 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
// Description : Part of CryEngine's extension framework.
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYEXTENSION_ICRYUNKNOWN_H
|
||||
#define CRYINCLUDE_CRYEXTENSION_ICRYUNKNOWN_H
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "CryTypeID.h"
|
||||
#include <SmartPointersHelpers.h>
|
||||
|
||||
|
||||
struct ICryFactory;
|
||||
struct ICryUnknown;
|
||||
|
||||
namespace InterfaceCastSemantics
|
||||
{
|
||||
template <class T>
|
||||
const CryInterfaceID& cryiidof()
|
||||
{
|
||||
return T::IID();
|
||||
}
|
||||
|
||||
#define _BEFRIEND_CRYIIDOF() \
|
||||
template <class T> \
|
||||
friend const CryInterfaceID&InterfaceCastSemantics::cryiidof();
|
||||
|
||||
|
||||
template <class Dst, class Src>
|
||||
Dst* cryinterface_cast(Src* p)
|
||||
{
|
||||
return static_cast<Dst*>(p ? p->QueryInterface(cryiidof<Dst>()) : 0);
|
||||
}
|
||||
|
||||
template <class Dst, class Src>
|
||||
Dst* cryinterface_cast(const Src* p)
|
||||
{
|
||||
return static_cast<const Dst*>(p ? p->QueryInterface(cryiidof<Dst>()) : 0);
|
||||
}
|
||||
|
||||
namespace Internal
|
||||
{
|
||||
template <class Dst, class Src>
|
||||
struct cryinterface_cast_shared_ptr_helper;
|
||||
|
||||
template <class Dst, class Src>
|
||||
struct cryinterface_cast_shared_ptr_helper
|
||||
{
|
||||
static AZStd::shared_ptr<Dst> Op(const AZStd::shared_ptr<Src>& p)
|
||||
{
|
||||
Dst* dp = cryinterface_cast<Dst>(p.get());
|
||||
return dp ? AZStd::shared_ptr<Dst>(p, dp) : AZStd::shared_ptr<Dst>();
|
||||
}
|
||||
};
|
||||
|
||||
template <class Src>
|
||||
struct cryinterface_cast_shared_ptr_helper<ICryUnknown, Src>
|
||||
{
|
||||
static AZStd::shared_ptr<ICryUnknown> Op(const AZStd::shared_ptr<Src>& p)
|
||||
{
|
||||
ICryUnknown* dp = cryinterface_cast<ICryUnknown>(p.get());
|
||||
return dp ? AZStd::shared_ptr<ICryUnknown>(*((const AZStd::shared_ptr<ICryUnknown>*) & p), dp) : AZStd::shared_ptr<ICryUnknown>();
|
||||
}
|
||||
};
|
||||
|
||||
template <class Src>
|
||||
struct cryinterface_cast_shared_ptr_helper<const ICryUnknown, Src>
|
||||
{
|
||||
static AZStd::shared_ptr<const ICryUnknown> Op(const AZStd::shared_ptr<Src>& p)
|
||||
{
|
||||
const ICryUnknown* dp = cryinterface_cast<const ICryUnknown>(p.get());
|
||||
return dp ? AZStd::shared_ptr<const ICryUnknown>(*((const AZStd::shared_ptr<const ICryUnknown>*) & p), dp) : AZStd::shared_ptr<const ICryUnknown>();
|
||||
}
|
||||
};
|
||||
} // namespace Internal
|
||||
|
||||
template <class Dst, class Src>
|
||||
AZStd::shared_ptr<Dst> cryinterface_cast(const AZStd::shared_ptr<Src>& p)
|
||||
{
|
||||
return Internal::cryinterface_cast_shared_ptr_helper<Dst, Src>::Op(p);
|
||||
}
|
||||
|
||||
#define _BEFRIEND_CRYINTERFACE_CAST() \
|
||||
template <class Dst, class Src> \
|
||||
friend Dst * InterfaceCastSemantics::cryinterface_cast(Src*); \
|
||||
template <class Dst, class Src> \
|
||||
friend Dst * InterfaceCastSemantics::cryinterface_cast(const Src*); \
|
||||
template <class Dst, class Src> \
|
||||
friend AZStd::shared_ptr<Dst> InterfaceCastSemantics::cryinterface_cast(const AZStd::shared_ptr<Src>&);
|
||||
} // namespace InterfaceCastSemantics
|
||||
|
||||
using InterfaceCastSemantics::cryiidof;
|
||||
using InterfaceCastSemantics::cryinterface_cast;
|
||||
|
||||
|
||||
template <class S, class T>
|
||||
bool CryIsSameClassInstance(S* p0, T* p1)
|
||||
{
|
||||
return static_cast<const void*>(p0) == static_cast<const void*>(p1) || cryinterface_cast<const ICryUnknown>(p0) == cryinterface_cast<const ICryUnknown>(p1);
|
||||
}
|
||||
|
||||
template <class S, class T>
|
||||
bool CryIsSameClassInstance(const AZStd::shared_ptr<S>& p0, T* p1)
|
||||
{
|
||||
return CryIsSameClassInstance(p0.get(), p1);
|
||||
}
|
||||
|
||||
template <class S, class T>
|
||||
bool CryIsSameClassInstance(S* p0, const AZStd::shared_ptr<T>& p1)
|
||||
{
|
||||
return CryIsSameClassInstance(p0, p1.get());
|
||||
}
|
||||
|
||||
template <class S, class T>
|
||||
bool CryIsSameClassInstance(const AZStd::shared_ptr<S>& p0, const AZStd::shared_ptr<T>& p1)
|
||||
{
|
||||
return CryIsSameClassInstance(p0.get(), p1.get());
|
||||
}
|
||||
|
||||
|
||||
namespace CompositeQuerySemantics
|
||||
{
|
||||
template <class Src>
|
||||
AZStd::shared_ptr<ICryUnknown> crycomposite_query(Src* p, const char* name, bool* pExposed = 0)
|
||||
{
|
||||
void* pComposite = p ? p->QueryComposite(name) : 0;
|
||||
pExposed ? *pExposed = pComposite != 0 : 0;
|
||||
return pComposite ? *static_cast<AZStd::shared_ptr<ICryUnknown>*>(pComposite) : AZStd::shared_ptr<ICryUnknown>();
|
||||
}
|
||||
|
||||
template <class Src>
|
||||
AZStd::shared_ptr<const ICryUnknown> crycomposite_query(const Src* p, const char* name, bool* pExposed = 0)
|
||||
{
|
||||
void* pComposite = p ? p->QueryComposite(name) : 0;
|
||||
pExposed ? *pExposed = pComposite != 0 : 0;
|
||||
return pComposite ? *static_cast<AZStd::shared_ptr<const ICryUnknown>*>(pComposite) : AZStd::shared_ptr<const ICryUnknown>();
|
||||
}
|
||||
|
||||
template <class Src>
|
||||
AZStd::shared_ptr<ICryUnknown> crycomposite_query(const AZStd::shared_ptr<Src>& p, const char* name, bool* pExposed = 0)
|
||||
{
|
||||
return crycomposite_query(p.get(), name, pExposed);
|
||||
}
|
||||
|
||||
template <class Src>
|
||||
AZStd::shared_ptr<const ICryUnknown> crycomposite_query(const AZStd::shared_ptr<const Src>& p, const char* name, bool* pExposed = 0)
|
||||
{
|
||||
return crycomposite_query(p.get(), name, pExposed);
|
||||
}
|
||||
|
||||
#define _BEFRIEND_CRYCOMPOSITE_QUERY() \
|
||||
template <class Src> \
|
||||
friend AZStd::shared_ptr<ICryUnknown> CompositeQuerySemantics::crycomposite_query(Src*, const char*, bool*); \
|
||||
template <class Src> \
|
||||
friend AZStd::shared_ptr<const ICryUnknown> CompositeQuerySemantics::crycomposite_query(const Src*, const char*, bool*); \
|
||||
template <class Src> \
|
||||
friend AZStd::shared_ptr<ICryUnknown> CompositeQuerySemantics::crycomposite_query(const AZStd::shared_ptr<Src>&, const char*, bool*); \
|
||||
template <class Src> \
|
||||
friend AZStd::shared_ptr<const ICryUnknown> CompositeQuerySemantics::crycomposite_query(const AZStd::shared_ptr<const Src>&, const char*, bool*);
|
||||
} // namespace CompositeQuerySemantics
|
||||
|
||||
using CompositeQuerySemantics::crycomposite_query;
|
||||
|
||||
|
||||
#define _BEFRIEND_MAKE_SHARED() \
|
||||
template <class T> \
|
||||
friend class AZStd::Internal::sp_ms_deleter; \
|
||||
template <class T> \
|
||||
friend AZStd::shared_ptr<T> AZStd::make_shared(); \
|
||||
template <class T, class A> \
|
||||
friend AZStd::shared_ptr<T> AZStd::allocate_shared(A const& a);
|
||||
|
||||
// prevent explicit destruction from client side
|
||||
#define _PROTECTED_DTOR(iname) \
|
||||
protected: \
|
||||
virtual ~iname() {}
|
||||
|
||||
|
||||
// Befriending cryinterface_cast<T>() and crycomposite_query() via CRYINTERFACE_DECLARE is actually only needed for ICryUnknown
|
||||
// since QueryInterface() and QueryComposite() are usually not redeclared in derived interfaces but it doesn't hurt either
|
||||
#define CRYINTERFACE_DECLARE(iname, iidHigh, iidLow) \
|
||||
_BEFRIEND_CRYIIDOF() \
|
||||
_BEFRIEND_CRYINTERFACE_CAST() \
|
||||
_BEFRIEND_CRYCOMPOSITE_QUERY() \
|
||||
_BEFRIEND_MAKE_SHARED() \
|
||||
_PROTECTED_DTOR(iname) \
|
||||
\
|
||||
private: \
|
||||
static const CryInterfaceID& IID() \
|
||||
{ \
|
||||
static const CryInterfaceID iid = {(uint64) iidHigh##LL, (uint64) iidLow##LL}; \
|
||||
return iid; \
|
||||
} \
|
||||
public:
|
||||
|
||||
|
||||
struct ICryUnknown
|
||||
{
|
||||
CRYINTERFACE_DECLARE(ICryUnknown, 0x1000000010001000, 0x1000100000000000)
|
||||
|
||||
virtual ICryFactory * GetFactory() const = 0;
|
||||
|
||||
protected:
|
||||
virtual void* QueryInterface(const CryInterfaceID& iid) const = 0;
|
||||
virtual void* QueryComposite(const char* name) const = 0;
|
||||
};
|
||||
|
||||
DECLARE_SMART_POINTERS(ICryUnknown);
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_CRYEXTENSION_ICRYUNKNOWN_H
|
||||
@ -1,461 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
// Description : Part of CryEngine's extension framework.
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYEXTENSION_IMPL_CLASSWEAVER_H
|
||||
#define CRYINCLUDE_CRYEXTENSION_IMPL_CLASSWEAVER_H
|
||||
#pragma once
|
||||
|
||||
#include "TypeList.h"
|
||||
#include "Conversion.h"
|
||||
#include "RegFactoryNode.h"
|
||||
#include "../ICryUnknown.h"
|
||||
#include "../ICryFactory.h"
|
||||
#include <AzCore/Memory/Memory.h>
|
||||
|
||||
namespace CW
|
||||
{
|
||||
namespace Internal
|
||||
{
|
||||
template <class Dst>
|
||||
struct InterfaceCast;
|
||||
|
||||
template <class Dst>
|
||||
struct InterfaceCast
|
||||
{
|
||||
template <class T>
|
||||
static void* Op(T* p)
|
||||
{
|
||||
return (Dst*) p;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct InterfaceCast<ICryUnknown>
|
||||
{
|
||||
template <class T>
|
||||
static void* Op(T* p)
|
||||
{
|
||||
return const_cast<ICryUnknown*>(static_cast<const ICryUnknown*>(static_cast<const void*>(p)));
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
template <class TList>
|
||||
struct InterfaceCast;
|
||||
|
||||
template <>
|
||||
struct InterfaceCast<TL::NullType>
|
||||
{
|
||||
template <class T>
|
||||
static void* Op(T*, const CryInterfaceID&)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
|
||||
template <class Head, class Tail>
|
||||
struct InterfaceCast<TL::Typelist<Head, Tail> >
|
||||
{
|
||||
template <class T>
|
||||
static void* Op(T* p, const CryInterfaceID& iid)
|
||||
{
|
||||
if (cryiidof<Head>() == iid)
|
||||
{
|
||||
return Internal::InterfaceCast<Head>::Op(p);
|
||||
}
|
||||
return InterfaceCast<Tail>::Op(p, iid);
|
||||
}
|
||||
};
|
||||
|
||||
template <class TList>
|
||||
struct FillIIDs;
|
||||
|
||||
template <>
|
||||
struct FillIIDs<TL::NullType>
|
||||
{
|
||||
static void Op(CryInterfaceID*)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
template <class Head, class Tail>
|
||||
struct FillIIDs<TL::Typelist<Head, Tail> >
|
||||
{
|
||||
static void Op(CryInterfaceID* p)
|
||||
{
|
||||
*p++ = cryiidof<Head>();
|
||||
FillIIDs<Tail>::Op(p);
|
||||
}
|
||||
};
|
||||
|
||||
namespace Internal
|
||||
{
|
||||
template <bool, typename S>
|
||||
struct PickList;
|
||||
|
||||
template <bool, typename S>
|
||||
struct PickList
|
||||
{
|
||||
typedef TL::BuildTypelist<>::Result Result;
|
||||
};
|
||||
|
||||
template <typename S>
|
||||
struct PickList<true, S>
|
||||
{
|
||||
typedef typename S::FullCompositeList Result;
|
||||
};
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct ProbeFullCompositeList
|
||||
{
|
||||
private:
|
||||
typedef char y[1];
|
||||
typedef char n[2];
|
||||
|
||||
template <typename S>
|
||||
static y& test(typename S::FullCompositeList*);
|
||||
|
||||
template <typename>
|
||||
static n& test(...);
|
||||
|
||||
public:
|
||||
enum
|
||||
{
|
||||
listFound = sizeof(test<T>(0)) == sizeof(y)
|
||||
};
|
||||
|
||||
typedef typename Internal::PickList<listFound, T>::Result ListType;
|
||||
};
|
||||
|
||||
namespace Internal
|
||||
{
|
||||
template <class TList>
|
||||
struct CompositeQuery;
|
||||
|
||||
template <>
|
||||
struct CompositeQuery<TL::NullType>
|
||||
{
|
||||
template<typename T>
|
||||
static void* Op(const T&, const char*)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
|
||||
template <class Head, class Tail>
|
||||
struct CompositeQuery<TL::Typelist<Head, Tail> >
|
||||
{
|
||||
template<typename T>
|
||||
static void* Op(const T& ref, const char* name)
|
||||
{
|
||||
void* p = ref.Head::CompositeQueryImpl(name);
|
||||
return p ? p : CompositeQuery<Tail>::Op(ref, name);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
struct CompositeQuery
|
||||
{
|
||||
template <typename T>
|
||||
static void* Op(const T& ref, const char* name)
|
||||
{
|
||||
return Internal::CompositeQuery<typename ProbeFullCompositeList<T>::ListType>::Op(ref, name);
|
||||
}
|
||||
};
|
||||
|
||||
inline bool NameMatch(const char* name, const char* compositeName)
|
||||
{
|
||||
if (!name || !compositeName)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
size_t i = 0;
|
||||
for (; name[i] && name[i] == compositeName[i]; ++i)
|
||||
{
|
||||
}
|
||||
return name[i] == compositeName[i];
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void* CheckCompositeMatch(const char* name, const AZStd::shared_ptr<T>& composite, const char* compositeName)
|
||||
{
|
||||
typedef TC::SuperSubClass<ICryUnknown, T> Rel;
|
||||
COMPILE_TIME_ASSERT(Rel::exists);
|
||||
return NameMatch(name, compositeName) ? const_cast<void*>(static_cast<const void*>(&composite)) : 0;
|
||||
}
|
||||
} // namespace CW
|
||||
|
||||
|
||||
#define CRYINTERFACE_BEGIN() \
|
||||
private: \
|
||||
typedef TL::BuildTypelist < ICryUnknown
|
||||
|
||||
#define CRYINTERFACE_ADD(iname) , iname
|
||||
|
||||
#define CRYINTERFACE_END() > ::Result _UserDefinedPartialInterfaceList; \
|
||||
protected: \
|
||||
typedef TL::NoDuplicates<_UserDefinedPartialInterfaceList>::Result FullInterfaceList;
|
||||
|
||||
#define _CRY_TPL_APPEND0(base) TL::Append<base::FullInterfaceList, _UserDefinedPartialInterfaceList>::Result
|
||||
#define _CRY_TPL_APPEND(base, intermediate) TL::Append<base::FullInterfaceList, intermediate>::Result
|
||||
|
||||
#define CRYINTERFACE_ENDWITHBASE(base) > ::Result _UserDefinedPartialInterfaceList; \
|
||||
protected: \
|
||||
typedef TL::NoDuplicates<_CRY_TPL_APPEND0(base)>::Result FullInterfaceList;
|
||||
|
||||
#define CRYINTERFACE_ENDWITHBASE2(base0, base1) > ::Result _UserDefinedPartialInterfaceList; \
|
||||
protected: \
|
||||
typedef TL::NoDuplicates<_CRY_TPL_APPEND(base0, _CRY_TPL_APPEND0(base1))>::Result FullInterfaceList;
|
||||
|
||||
#define CRYINTERFACE_ENDWITHBASE3(base0, base1, base2) > ::Result _UserDefinedPartialInterfaceList; \
|
||||
protected: \
|
||||
typedef TL::NoDuplicates<_CRY_TPL_APPEND(base0, _CRY_TPL_APPEND(base1, _CRY_TPL_APPEND0(base2)))>::Result FullInterfaceList;
|
||||
|
||||
#define CRYINTERFACE_SIMPLE(iname) \
|
||||
CRYINTERFACE_BEGIN() \
|
||||
CRYINTERFACE_ADD(iname) \
|
||||
CRYINTERFACE_END()
|
||||
|
||||
#define CRYCOMPOSITE_BEGIN() \
|
||||
private: \
|
||||
void* CompositeQueryImpl(const char* name) const \
|
||||
{ \
|
||||
(void)(name); \
|
||||
void* res = 0; (void)(res); \
|
||||
|
||||
#define CRYCOMPOSITE_ADD(member, membername) \
|
||||
COMPILE_TIME_ASSERT((sizeof(membername) / sizeof(membername[0])) > 1); \
|
||||
if ((res = CW::CheckCompositeMatch(name, member, membername)) != 0) { \
|
||||
return res; }
|
||||
|
||||
#define _CRYCOMPOSITE_END(implclassname) \
|
||||
return 0; \
|
||||
}; \
|
||||
protected: \
|
||||
typedef TL::BuildTypelist<implclassname>::Result _PartialCompositeList; \
|
||||
\
|
||||
template <bool, typename S> \
|
||||
friend struct CW::Internal::PickList;
|
||||
|
||||
#define CRYCOMPOSITE_END(implclassname) \
|
||||
_CRYCOMPOSITE_END(implclassname) \
|
||||
protected: \
|
||||
typedef _PartialCompositeList FullCompositeList;
|
||||
|
||||
#define _CRYCOMPOSITE_APPEND0(base) TL::Append<_PartialCompositeList, CW::ProbeFullCompositeList<base>::ListType>::Result
|
||||
#define _CRYCOMPOSITE_APPEND(base, intermediate) TL::Append<intermediate, CW::ProbeFullCompositeList<base>::ListType>::Result
|
||||
|
||||
#define CRYCOMPOSITE_ENDWITHBASE(implclassname, base) \
|
||||
_CRYCOMPOSITE_END(implclassname) \
|
||||
protected: \
|
||||
typedef _CRYCOMPOSITE_APPEND0 (base) FullCompositeList;
|
||||
|
||||
#define CRYCOMPOSITE_ENDWITHBASE2(implclassname, base0, base1) \
|
||||
_CRYCOMPOSITE_END(implclassname) \
|
||||
protected: \
|
||||
typedef TL::NoDuplicates<_CRYCOMPOSITE_APPEND(base1, _CRYCOMPOSITE_APPEND0(base0))>::Result FullCompositeList;
|
||||
|
||||
#define CRYCOMPOSITE_ENDWITHBASE3(implclassname, base0, base1, base2) \
|
||||
_CRYCOMPOSITE_END(implclassname) \
|
||||
protected: \
|
||||
typedef TL::NoDuplicates<_CRYCOMPOSITE_APPEND(base2, _CRYCOMPOSITE_APPEND(base1, _CRYCOMPOSITE_APPEND0(base0)))>::Result FullCompositeList;
|
||||
|
||||
template<typename T>
|
||||
class CFactory
|
||||
: public ICryFactory
|
||||
{
|
||||
public:
|
||||
virtual const char* GetName() const
|
||||
{
|
||||
return T::GetCName();
|
||||
}
|
||||
|
||||
virtual const CryClassID& GetClassID() const
|
||||
{
|
||||
return T::GetCID();
|
||||
}
|
||||
|
||||
virtual bool ClassSupports(const CryInterfaceID& iid) const
|
||||
{
|
||||
for (size_t i = 0; i < m_numIIDs; ++i)
|
||||
{
|
||||
if (iid == m_pIIDs[i])
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
virtual void ClassSupports(const CryInterfaceID*& pIIDs, size_t& numIIDs) const
|
||||
{
|
||||
pIIDs = m_pIIDs;
|
||||
numIIDs = m_numIIDs;
|
||||
}
|
||||
public:
|
||||
virtual ICryUnknownPtr CreateClassInstance() const
|
||||
{
|
||||
AZStd::shared_ptr<T> p = AZStd::make_shared<T>();
|
||||
return cryinterface_cast<ICryUnknown> (p);
|
||||
}
|
||||
|
||||
CFactory<T>()
|
||||
: m_numIIDs(0)
|
||||
, m_pIIDs(0)
|
||||
, m_regFactory()
|
||||
{
|
||||
static CryInterfaceID supportedIIDs[TL::Length < typename T::FullInterfaceList > ::value];
|
||||
CW::FillIIDs<typename T::FullInterfaceList>::Op(supportedIIDs);
|
||||
m_pIIDs = &supportedIIDs[0];
|
||||
m_numIIDs = TL::Length<typename T::FullInterfaceList>::value;
|
||||
new(&m_regFactory)SRegFactoryNode(this);
|
||||
}
|
||||
|
||||
protected:
|
||||
CFactory(const CFactory&);
|
||||
CFactory& operator =(const CFactory&);
|
||||
|
||||
|
||||
size_t m_numIIDs;
|
||||
CryInterfaceID* m_pIIDs;
|
||||
SRegFactoryNode m_regFactory;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
class CSingletonFactory
|
||||
: public CFactory<T>
|
||||
{
|
||||
public:
|
||||
CSingletonFactory()
|
||||
: CFactory<T>()
|
||||
, m_csCreateClassInstance()
|
||||
{
|
||||
}
|
||||
|
||||
virtual ICryUnknownPtr CreateClassInstance() const
|
||||
{
|
||||
CryAutoLock<CryCriticalSection> lock(m_csCreateClassInstance);
|
||||
// override the allocator. These function static instances are being destroyed after the AZ alloctor has been deleted.
|
||||
// On win, TerminateProcess() prevents these destructors from being called, but that is not the case on OSX.
|
||||
static typename AZStd::aligned_storage<sizeof(AZStd::Internal::sp_counted_impl_pda<T*, AZStd::Internal::sp_ms_deleter<T>,SingletonAllocator>), AZStd::alignment_of<T>::value>::type m_storage;
|
||||
static ICryUnknownPtr p = AZStd::allocate_shared<T>(SingletonAllocator(AZStd::addressof(m_storage)));
|
||||
return p;
|
||||
}
|
||||
|
||||
mutable CryCriticalSection m_csCreateClassInstance;
|
||||
|
||||
struct SingletonAllocator
|
||||
{
|
||||
SingletonAllocator(void* ptr) :
|
||||
m_data(ptr)
|
||||
{}
|
||||
void* allocate(size_t /*byteSize*/, size_t /*alignment*/, int /*flags*/ = 0)
|
||||
{
|
||||
return m_data;
|
||||
}
|
||||
void deallocate(void* /*ptr*/, size_t /*byteSize*/, size_t /*alignment*/)
|
||||
{
|
||||
// nothing to see here
|
||||
}
|
||||
void* m_data;
|
||||
};
|
||||
};
|
||||
|
||||
#define _CRYFACTORY_DECLARE(implclassname) \
|
||||
private: \
|
||||
friend class CFactory<implclassname>; \
|
||||
static CFactory<implclassname> s_factory;
|
||||
|
||||
#define _CRYFACTORY_DECLARE_SINGLETON(implclassname) \
|
||||
private: \
|
||||
friend class CFactory<implclassname>; \
|
||||
friend void* Get##implclassname##Factory(); \
|
||||
static CSingletonFactory<implclassname> s_factory;
|
||||
|
||||
#define _IMPLEMENT_ICRYUNKNOWN() \
|
||||
public: \
|
||||
virtual ICryFactory* GetFactory() const \
|
||||
{ \
|
||||
return &s_factory; \
|
||||
} \
|
||||
\
|
||||
protected: \
|
||||
virtual void* QueryInterface(const CryInterfaceID&iid) const \
|
||||
{ \
|
||||
return CW::InterfaceCast<FullInterfaceList>::Op(this, iid); \
|
||||
} \
|
||||
\
|
||||
template <class TList> \
|
||||
friend struct CW::Internal::CompositeQuery; \
|
||||
\
|
||||
virtual void* QueryComposite(const char* name) const \
|
||||
{ \
|
||||
return CW::CompositeQuery::Op(*this, name); \
|
||||
}
|
||||
|
||||
#define _ENFORCE_CRYFACTORY_USAGE(implclassname, cname, cidHigh, cidLow) \
|
||||
public: \
|
||||
static const char* GetCName() \
|
||||
{ \
|
||||
return cname; \
|
||||
} \
|
||||
static const CryClassID& GetCID() \
|
||||
{ \
|
||||
static const CryClassID cid = {(uint64) cidHigh##LL, (uint64) cidLow##LL}; \
|
||||
return cid; \
|
||||
} \
|
||||
static AZStd::shared_ptr<implclassname> CreateClassInstance() \
|
||||
{ \
|
||||
ICryUnknownPtr p = s_factory.CreateClassInstance(); \
|
||||
return AZStd::shared_ptr<implclassname>(*static_cast<AZStd::shared_ptr<implclassname>*>(static_cast<void*>(&p))); \
|
||||
} \
|
||||
\
|
||||
protected: \
|
||||
implclassname(); \
|
||||
virtual ~implclassname();
|
||||
|
||||
#define _BEFRIEND_OPS() \
|
||||
_BEFRIEND_CRYINTERFACE_CAST() \
|
||||
_BEFRIEND_CRYCOMPOSITE_QUERY() \
|
||||
_BEFRIEND_MAKE_SHARED()
|
||||
|
||||
#define CRYGENERATE_CLASS(implclassname, cname, cidHigh, cidLow) \
|
||||
_CRYFACTORY_DECLARE(implclassname) \
|
||||
_BEFRIEND_OPS() \
|
||||
_IMPLEMENT_ICRYUNKNOWN() \
|
||||
_ENFORCE_CRYFACTORY_USAGE(implclassname, cname, cidHigh, cidLow)
|
||||
|
||||
#define CRYGENERATE_SINGLETONCLASS(implclassname, cname, cidHigh, cidLow) \
|
||||
_CRYFACTORY_DECLARE_SINGLETON(implclassname) \
|
||||
_BEFRIEND_OPS() \
|
||||
_IMPLEMENT_ICRYUNKNOWN() \
|
||||
_ENFORCE_CRYFACTORY_USAGE(implclassname, cname, cidHigh, cidLow)
|
||||
|
||||
|
||||
#define CRYREGISTER_CLASS(implclassname) \
|
||||
CFactory<implclassname> implclassname::s_factory;
|
||||
|
||||
#define DECLARE_CRYREGISTER_SINGLETON_CLASS(implclassname) \
|
||||
void* Get##implclassname##Factory();
|
||||
|
||||
#define CRYREGISTER_SINGLETON_CLASS(implclassname) \
|
||||
CSingletonFactory<implclassname> implclassname::s_factory; \
|
||||
void* Get##implclassname##Factory() { \
|
||||
return &implclassname::s_factory; \
|
||||
}
|
||||
|
||||
#endif // CRYINCLUDE_CRYEXTENSION_IMPL_CLASSWEAVER_H
|
||||
@ -1,109 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
// Description : Part of CryEngine's extension framework.
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYEXTENSION_IMPL_CONVERSION_H
|
||||
#define CRYINCLUDE_CRYEXTENSION_IMPL_CONVERSION_H
|
||||
#pragma once
|
||||
|
||||
|
||||
namespace TC
|
||||
{
|
||||
//template <class T, class U>
|
||||
//struct Conversion
|
||||
//{
|
||||
//private:
|
||||
// typedef char y[1];
|
||||
// typedef char n[2];
|
||||
// static y& Test(U);
|
||||
// static n& Test(...);
|
||||
// static T MakeT();
|
||||
|
||||
//public:
|
||||
// enum
|
||||
// {
|
||||
// exists = sizeof(Test(MakeT())) == sizeof(y),
|
||||
// sameType = false
|
||||
// };
|
||||
//};
|
||||
|
||||
//template <class T>
|
||||
//struct Conversion<T, T>
|
||||
//{
|
||||
//public:
|
||||
// enum
|
||||
// {
|
||||
// exists = true,
|
||||
// sameType = true
|
||||
// };
|
||||
//};
|
||||
|
||||
//template<typename Base, typename Derived>
|
||||
//struct CheckInheritance
|
||||
//{
|
||||
// enum
|
||||
// {
|
||||
// exists = Conversion<const Derived*, const Base*>::exists && !Conversion<const Base*, const void*>::sameType
|
||||
// };
|
||||
//};
|
||||
|
||||
//template<typename Base, typename Derived>
|
||||
//struct CheckStrictInheritance
|
||||
//{
|
||||
// enum
|
||||
// {
|
||||
// exists = CheckInheritance<Base, Derived>::exists && !Conversion<const Base*, const Derived*>::sameType
|
||||
// };
|
||||
//};
|
||||
|
||||
|
||||
template <typename Base, typename Derived>
|
||||
struct SuperSubClass
|
||||
{
|
||||
private:
|
||||
typedef char y[1];
|
||||
typedef char n[2];
|
||||
|
||||
template<typename T>
|
||||
static y& check(const volatile Derived&, T);
|
||||
static n& check(const volatile Base&, int);
|
||||
|
||||
struct C
|
||||
{
|
||||
operator const volatile Base&() const;
|
||||
operator const volatile Derived&();
|
||||
};
|
||||
|
||||
static C getC();
|
||||
|
||||
public:
|
||||
enum
|
||||
{
|
||||
exists = sizeof(check(getC(), 0)) == sizeof(y),
|
||||
sameType = false
|
||||
};
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct SuperSubClass<T, T>
|
||||
{
|
||||
enum
|
||||
{
|
||||
exists = true
|
||||
};
|
||||
};
|
||||
} // namespace TC
|
||||
|
||||
#endif // CRYINCLUDE_CRYEXTENSION_IMPL_CONVERSION_H
|
||||
@ -1,67 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
// Description : Part of CryEngine's extension framework.
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYEXTENSION_IMPL_CRYGUIDHELPER_H
|
||||
#define CRYINCLUDE_CRYEXTENSION_IMPL_CRYGUIDHELPER_H
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "../CryGUID.h"
|
||||
#include "../../CryString.h"
|
||||
|
||||
|
||||
namespace CryGUIDHelper
|
||||
{
|
||||
string Print(const CryGUID& val)
|
||||
{
|
||||
char buf[39]; // sizeof("{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}")
|
||||
|
||||
static const char hex[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
|
||||
char* p = buf;
|
||||
*p++ = '{';
|
||||
for (int i = 15; i >= 8; --i)
|
||||
{
|
||||
*p++ = hex[(unsigned char) ((val.hipart >> (i << 2)) & 0xF)];
|
||||
}
|
||||
*p++ = '-';
|
||||
for (int i = 7; i >= 4; --i)
|
||||
{
|
||||
*p++ = hex[(unsigned char) ((val.hipart >> (i << 2)) & 0xF)];
|
||||
}
|
||||
*p++ = '-';
|
||||
for (int i = 3; i >= 0; --i)
|
||||
{
|
||||
*p++ = hex[(unsigned char) ((val.hipart >> (i << 2)) & 0xF)];
|
||||
}
|
||||
*p++ = '-';
|
||||
for (int i = 15; i >= 12; --i)
|
||||
{
|
||||
*p++ = hex[(unsigned char) ((val.lopart >> (i << 2)) & 0xF)];
|
||||
}
|
||||
*p++ = '-';
|
||||
for (int i = 11; i >= 0; --i)
|
||||
{
|
||||
*p++ = hex[(unsigned char) ((val.lopart >> (i << 2)) & 0xF)];
|
||||
}
|
||||
*p++ = '}';
|
||||
*p++ = '\0';
|
||||
|
||||
return string(buf);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_CRYEXTENSION_IMPL_CRYGUIDHELPER_H
|
||||
@ -1,58 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
// Description : Part of CryEngine's extension framework.
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYEXTENSION_IMPL_ICRYFACTORYREGISTRYIMPL_H
|
||||
#define CRYINCLUDE_CRYEXTENSION_IMPL_ICRYFACTORYREGISTRYIMPL_H
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "../ICryFactoryRegistry.h"
|
||||
|
||||
|
||||
struct SRegFactoryNode;
|
||||
|
||||
|
||||
struct ICryFactoryRegistryCallback
|
||||
{
|
||||
virtual void OnNotifyFactoryRegistered(ICryFactory* pFactory) = 0;
|
||||
virtual void OnNotifyFactoryUnregistered(ICryFactory* pFactory) = 0;
|
||||
|
||||
protected:
|
||||
virtual ~ICryFactoryRegistryCallback() {}
|
||||
};
|
||||
|
||||
|
||||
struct ICryFactoryRegistryImpl
|
||||
: public ICryFactoryRegistry
|
||||
{
|
||||
virtual ICryFactory* GetFactory(const char* cname) const = 0;
|
||||
virtual ICryFactory* GetFactory(const CryClassID& cid) const = 0;
|
||||
virtual void IterateFactories(const CryInterfaceID& iid, ICryFactory** pFactories, size_t& numFactories) const = 0;
|
||||
|
||||
virtual void RegisterCallback(ICryFactoryRegistryCallback* pCallback) = 0;
|
||||
virtual void UnregisterCallback(ICryFactoryRegistryCallback* pCallback) = 0;
|
||||
|
||||
virtual void RegisterFactories(const SRegFactoryNode* pFactories) = 0;
|
||||
virtual void UnregisterFactories(const SRegFactoryNode* pFactories) = 0;
|
||||
|
||||
virtual void UnregisterFactory(ICryFactory* const pFactory) = 0;
|
||||
|
||||
protected:
|
||||
// prevent explicit destruction from client side (delete, shared_ptr, etc)
|
||||
virtual ~ICryFactoryRegistryImpl() {}
|
||||
};
|
||||
|
||||
#endif // CRYINCLUDE_CRYEXTENSION_IMPL_ICRYFACTORYREGISTRYIMPL_H
|
||||
@ -1,52 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
// Description : Part of CryEngine's extension framework.
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYEXTENSION_IMPL_REGFACTORYNODE_H
|
||||
#define CRYINCLUDE_CRYEXTENSION_IMPL_REGFACTORYNODE_H
|
||||
#pragma once
|
||||
|
||||
struct ICryFactory;
|
||||
struct SRegFactoryNode;
|
||||
|
||||
extern SRegFactoryNode* g_pHeadToRegFactories;
|
||||
|
||||
struct SRegFactoryNode
|
||||
{
|
||||
SRegFactoryNode()
|
||||
{
|
||||
}
|
||||
|
||||
SRegFactoryNode(ICryFactory* pFactory)
|
||||
: m_pFactory(pFactory)
|
||||
, m_pNext(g_pHeadToRegFactories)
|
||||
{
|
||||
g_pHeadToRegFactories = this;
|
||||
}
|
||||
|
||||
static void* operator new(size_t, void* p)
|
||||
{
|
||||
return p;
|
||||
}
|
||||
|
||||
static void operator delete(void*, void*)
|
||||
{
|
||||
}
|
||||
|
||||
ICryFactory* m_pFactory;
|
||||
SRegFactoryNode* m_pNext;
|
||||
};
|
||||
|
||||
#endif // CRYINCLUDE_CRYEXTENSION_IMPL_REGFACTORYNODE_H
|
||||
@ -1,236 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
// Description : Part of CryEngine's extension framework.
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYEXTENSION_TYPELIST_H
|
||||
#define CRYINCLUDE_CRYEXTENSION_TYPELIST_H
|
||||
#pragma once
|
||||
|
||||
|
||||
namespace TL
|
||||
{
|
||||
// typelist terminator
|
||||
class NullType
|
||||
{
|
||||
};
|
||||
|
||||
|
||||
// structure for typelist generation
|
||||
template <class T, class U = NullType>
|
||||
struct Typelist
|
||||
{
|
||||
typedef T Head;
|
||||
typedef U Tail;
|
||||
};
|
||||
|
||||
|
||||
// helper structure to automatically build typelists containing n types
|
||||
template
|
||||
<
|
||||
typename T0 = NullType, typename T1 = NullType, typename T2 = NullType, typename T3 = NullType, typename T4 = NullType,
|
||||
typename T5 = NullType, typename T6 = NullType, typename T7 = NullType, typename T8 = NullType, typename T9 = NullType,
|
||||
typename T10 = NullType, typename T11 = NullType, typename T12 = NullType, typename T13 = NullType, typename T14 = NullType,
|
||||
typename T15 = NullType, typename T16 = NullType, typename T17 = NullType, typename T18 = NullType, typename T19 = NullType
|
||||
>
|
||||
struct BuildTypelist
|
||||
{
|
||||
private:
|
||||
typedef typename BuildTypelist<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>::Result TailResult;
|
||||
|
||||
public:
|
||||
typedef Typelist<T0, TailResult> Result;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct BuildTypelist<>
|
||||
{
|
||||
typedef NullType Result;
|
||||
};
|
||||
|
||||
// typelist operation : Length
|
||||
template <class TList>
|
||||
struct Length;
|
||||
|
||||
template <>
|
||||
struct Length<NullType>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = 0
|
||||
};
|
||||
};
|
||||
|
||||
template <class T, class U>
|
||||
struct Length<Typelist<T, U> >
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = 1 + Length<U>::value
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
// typelist operation : TypeAt
|
||||
template <class TList, unsigned int index>
|
||||
struct TypeAt;
|
||||
|
||||
template <class Head, class Tail>
|
||||
struct TypeAt<Typelist<Head, Tail>, 0>
|
||||
{
|
||||
typedef Head Result;
|
||||
};
|
||||
|
||||
template <class Head, class Tail, unsigned int index>
|
||||
struct TypeAt<Typelist<Head, Tail>, index>
|
||||
{
|
||||
typedef typename TypeAt<Tail, index - 1>::Result Result;
|
||||
};
|
||||
|
||||
|
||||
// typelist operation : IndexOf
|
||||
template <class TList, class T>
|
||||
struct IndexOf;
|
||||
|
||||
template <class T>
|
||||
struct IndexOf<NullType, T>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = -1
|
||||
};
|
||||
};
|
||||
|
||||
template <class T, class Tail>
|
||||
struct IndexOf<Typelist<T, Tail>, T>
|
||||
{
|
||||
enum
|
||||
{
|
||||
value = 0
|
||||
};
|
||||
};
|
||||
|
||||
template <class Head, class Tail, class T>
|
||||
struct IndexOf<Typelist<Head, Tail>, T>
|
||||
{
|
||||
private:
|
||||
enum
|
||||
{
|
||||
temp = IndexOf<Tail, T>::value
|
||||
};
|
||||
public:
|
||||
enum
|
||||
{
|
||||
value = temp == -1 ? -1 : 1 + temp
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
// typelist operation : Append
|
||||
template <class TList, class T>
|
||||
struct Append;
|
||||
|
||||
template <>
|
||||
struct Append<NullType, NullType>
|
||||
{
|
||||
typedef NullType Result;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct Append<NullType, T>
|
||||
{
|
||||
typedef Typelist<T, NullType> Result;
|
||||
};
|
||||
|
||||
template <class Head, class Tail>
|
||||
struct Append<NullType, Typelist<Head, Tail> >
|
||||
{
|
||||
typedef Typelist<Head, Tail> Result;
|
||||
};
|
||||
|
||||
template <class Head, class Tail, class T>
|
||||
struct Append<Typelist<Head, Tail>, T>
|
||||
{
|
||||
typedef Typelist<Head, typename Append<Tail, T>::Result> Result;
|
||||
};
|
||||
|
||||
|
||||
// typelist operation : Erase
|
||||
template <class TList, class T>
|
||||
struct Erase;
|
||||
|
||||
template <class T>
|
||||
struct Erase<NullType, T>
|
||||
{
|
||||
typedef NullType Result;
|
||||
};
|
||||
|
||||
template <class T, class Tail>
|
||||
struct Erase<Typelist<T, Tail>, T>
|
||||
{
|
||||
typedef Tail Result;
|
||||
};
|
||||
|
||||
template <class Head, class Tail, class T>
|
||||
struct Erase<Typelist<Head, Tail>, T>
|
||||
{
|
||||
typedef Typelist<Head, typename Erase<Tail, T>::Result> Result;
|
||||
};
|
||||
|
||||
|
||||
// typelist operation : Erase All
|
||||
template <class TList, class T>
|
||||
struct EraseAll;
|
||||
|
||||
template <class T>
|
||||
struct EraseAll<NullType, T>
|
||||
{
|
||||
typedef NullType Result;
|
||||
};
|
||||
|
||||
template <class T, class Tail>
|
||||
struct EraseAll<Typelist<T, Tail>, T>
|
||||
{
|
||||
typedef typename EraseAll<Tail, T>::Result Result;
|
||||
};
|
||||
|
||||
template <class Head, class Tail, class T>
|
||||
struct EraseAll<Typelist<Head, Tail>, T>
|
||||
{
|
||||
typedef Typelist<Head, typename EraseAll<Tail, T>::Result> Result;
|
||||
};
|
||||
|
||||
|
||||
// typelist operation : NoDuplicates
|
||||
template <class TList>
|
||||
struct NoDuplicates;
|
||||
|
||||
template <>
|
||||
struct NoDuplicates<NullType>
|
||||
{
|
||||
typedef NullType Result;
|
||||
};
|
||||
|
||||
template <class Head, class Tail>
|
||||
struct NoDuplicates<Typelist<Head, Tail> >
|
||||
{
|
||||
private:
|
||||
typedef typename NoDuplicates<Tail>::Result L1;
|
||||
typedef typename Erase<L1, Head>::Result L2;
|
||||
public:
|
||||
typedef Typelist<Head, L2> Result;
|
||||
};
|
||||
} // namespace TL
|
||||
|
||||
#endif // CRYINCLUDE_CRYEXTENSION_TYPELIST_H
|
||||
@ -1,207 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_CRYPOOL_ALLOCATOR_H
|
||||
#define CRYINCLUDE_CRYPOOL_ALLOCATOR_H
|
||||
#pragma once
|
||||
|
||||
|
||||
namespace NCryPoolAlloc
|
||||
{
|
||||
template<class TPool, class TItem>
|
||||
class CFirstFit
|
||||
: public TPool
|
||||
{
|
||||
public:
|
||||
ILINE CFirstFit()
|
||||
{
|
||||
}
|
||||
|
||||
template<class T>
|
||||
ILINE T Allocate(size_t Size, size_t Align = 1)
|
||||
{
|
||||
//fastpath?
|
||||
if (TPool::m_pEmpty && TPool::m_pEmpty->Available(Size, Align))
|
||||
{
|
||||
TItem* pItem = TPool::Split(TPool::m_pEmpty, Size, Align);
|
||||
if (!pItem)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
pItem->InUse(Align);
|
||||
TPool::AllocatedMemory(pItem->MemSize());
|
||||
|
||||
//not fully occupied empty space?
|
||||
TPool::m_pEmpty = pItem != TPool::m_pEmpty ? TPool::m_pEmpty : 0;
|
||||
return TPool::Handle(pItem);
|
||||
}
|
||||
|
||||
TItem* pBestItem;
|
||||
for (pBestItem = TPool::m_Items.First(); pBestItem; pBestItem = pBestItem->Next())
|
||||
{
|
||||
if (pBestItem->Available(Size, Align)) // && (!pBestItem || pItem->MemSize()<pBestItem->MemSize()))
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!pBestItem)
|
||||
{
|
||||
return 0; //out of mem
|
||||
}
|
||||
TItem* pItem = TPool::Split(pBestItem, Size, Align);
|
||||
if (!pItem) //no free node
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
pItem->InUse(Align);
|
||||
TPool::AllocatedMemory(pItem->MemSize());
|
||||
|
||||
//not fully occupied empty space?
|
||||
TPool::m_pEmpty = pItem != pBestItem ? pBestItem : 0;
|
||||
return TPool::Handle(pItem);
|
||||
}
|
||||
template<class T>
|
||||
ILINE bool Free(T Handle, bool ForceBoundsCheck = false)
|
||||
{
|
||||
return Handle ? TPool::Free(Handle, ForceBoundsCheck) : false;
|
||||
}
|
||||
};
|
||||
|
||||
template<class TPool, class TItem>
|
||||
class CWorstFit
|
||||
: public TPool
|
||||
{
|
||||
public:
|
||||
ILINE CWorstFit()
|
||||
{
|
||||
}
|
||||
|
||||
template<class T>
|
||||
ILINE T Allocate(size_t Size, size_t Align = 1)
|
||||
{
|
||||
TItem* pBestItem = 0;
|
||||
for (TItem* pItem = TPool::m_Items.First(); pItem; pItem = pItem->Next())
|
||||
{
|
||||
if (pItem->IsFree() && (!pBestItem || pItem->MemSize() > pBestItem->MemSize()))
|
||||
{
|
||||
pBestItem = pItem;
|
||||
}
|
||||
}
|
||||
if (!pBestItem || !pBestItem->Available(Size, Align))
|
||||
{
|
||||
return 0; //out of mem
|
||||
}
|
||||
TItem* pItem = Split(pBestItem, Size, Align);
|
||||
if (!pItem) //no free node
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
pItem->InUse(Align);
|
||||
AllocatedMemory(pItem->MemSize());
|
||||
return Handle(pItem);
|
||||
}
|
||||
};
|
||||
|
||||
template<class TPool, class TItem>
|
||||
class CBestFit
|
||||
: public TPool
|
||||
{
|
||||
public:
|
||||
ILINE CBestFit()
|
||||
{
|
||||
}
|
||||
|
||||
template<class T>
|
||||
ILINE T Allocate(size_t Size, size_t Align = 1)
|
||||
{
|
||||
TItem* pBestItem = 0;
|
||||
for (TItem* pItem = TPool::m_Items.First(); pItem; pItem = pItem->Next())
|
||||
{
|
||||
if ((!pBestItem || pItem->MemSize() < pBestItem->MemSize()) && pItem->Available(Size, Align))
|
||||
{
|
||||
if (pItem->MemSize() == Size)
|
||||
{
|
||||
pItem->InUse(Align);
|
||||
AllocatedMemory(pItem->MemSize());
|
||||
return (T)Handle(pItem);
|
||||
}
|
||||
pBestItem = pItem;
|
||||
}
|
||||
}
|
||||
if (!pBestItem)
|
||||
{
|
||||
return 0; //out of mem
|
||||
}
|
||||
TItem* pItem = Split(pBestItem, Size, Align);
|
||||
if (!pItem) //no free node
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
pItem->InUse(Align);
|
||||
AllocatedMemory(pItem->MemSize());
|
||||
return (T)Handle(pItem);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<class TAllocator>
|
||||
class CReallocator
|
||||
: public TAllocator
|
||||
{
|
||||
public:
|
||||
|
||||
template<class T>
|
||||
ILINE bool Reallocate(T* pData, size_t Size, size_t Alignment)
|
||||
{
|
||||
//special cases
|
||||
if (!Size) //just free?
|
||||
{
|
||||
TAllocator::Free(*pData);
|
||||
*pData = 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!*pData) //just alloc?
|
||||
{
|
||||
*pData = TAllocator::template Allocate<T>(Size, Alignment);
|
||||
return *pData != 0;
|
||||
}
|
||||
|
||||
//same size, nothing to do at all?
|
||||
if (TAllocator::Item(*pData)->MemSize() == Size)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
if (TAllocator::ReSize(pData, Size))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
T pNewData = TAllocator::template Allocate<T>(Size, Alignment);
|
||||
if (!pNewData)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
memcpy(TAllocator::template Resolve<uint8*>(pNewData),
|
||||
TAllocator::template Resolve<uint8*>(*pData), min(TAllocator::Item(*pData)->MemSize(), Size));
|
||||
TAllocator::template Free(*pData);
|
||||
*pData = pNewData;
|
||||
return true;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_CRYPOOL_ALLOCATOR_H
|
||||
|
||||
@ -1,655 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_CRYPOOL_CONTAINER_H
|
||||
#define CRYINCLUDE_CRYPOOL_CONTAINER_H
|
||||
#pragma once
|
||||
|
||||
|
||||
namespace NCryPoolAlloc
|
||||
{
|
||||
template<size_t TElementCount, class TElement>
|
||||
class CPool
|
||||
: public CMemoryStatic<TElementCount* sizeof(TElement)>
|
||||
{
|
||||
class CPoolNode;
|
||||
class CPoolNode
|
||||
: public CListItem<CPoolNode>
|
||||
{
|
||||
};
|
||||
CList<CPoolNode> m_List;
|
||||
public:
|
||||
ILINE CPool()
|
||||
{
|
||||
CPoolNode* pPrev = 0;
|
||||
CPoolNode* pNode = 0;
|
||||
for (size_t a = 1; a < TElementCount; a++) //skip first element as it would be counted as zero ptr
|
||||
{
|
||||
uint8* pData = &CMemoryStatic<TElementCount* sizeof(TElement)>::Data()[a * sizeof(TElement)];
|
||||
pNode = reinterpret_cast<CPoolNode*>(pData);
|
||||
pNode->Prev(pPrev);
|
||||
if (pPrev)
|
||||
{
|
||||
pPrev->Next(pNode);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_List.First(pNode);
|
||||
}
|
||||
pPrev = pNode;
|
||||
// m_List.AddLast(pNode);
|
||||
}
|
||||
if (pPrev)
|
||||
{
|
||||
pPrev->Next(0);
|
||||
m_List.Last(pPrev);
|
||||
}
|
||||
}
|
||||
ILINE uint8* Allocate([[maybe_unused]] size_t Size, [[maybe_unused]] size_t Align = 1)
|
||||
{
|
||||
CPoolNode* pNode = m_List.PopFirst();
|
||||
return reinterpret_cast<uint8*>(pNode);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
ILINE void Free(T* pData)
|
||||
{
|
||||
if (pData)
|
||||
{
|
||||
CPoolNode* pNode = reinterpret_cast<CPoolNode*>(pData);
|
||||
m_List.AddLast(pNode);
|
||||
}
|
||||
}
|
||||
|
||||
ILINE TElement& operator[](uint32 Idx)
|
||||
{
|
||||
uint8* pData = &CMemoryStatic<TElementCount* sizeof(TElement)>::Data()[Idx * sizeof(TElement)];
|
||||
return *reinterpret_cast<TElement*>(pData);
|
||||
}
|
||||
|
||||
ILINE const TElement& operator[](uint32 Idx) const
|
||||
{
|
||||
const uint8* pData = &CMemoryStatic<TElementCount* sizeof(TElement)>::Data()[Idx * sizeof(TElement)];
|
||||
return *reinterpret_cast<const TElement*>(pData);
|
||||
}
|
||||
};
|
||||
|
||||
template<class TMemory, bool BoundsCheck = false>
|
||||
class CInPlace
|
||||
: public TMemory
|
||||
{
|
||||
protected:
|
||||
CList<CListItemInPlace> m_Items;
|
||||
size_t m_Allocated;
|
||||
CListItemInPlace* m_pEmpty;
|
||||
|
||||
|
||||
ILINE void AllocatedMemory(size_t S)
|
||||
{
|
||||
m_Allocated += S + sizeof(CListItemInPlace);
|
||||
}
|
||||
ILINE void FreedMemory(size_t S)
|
||||
{
|
||||
m_Allocated -= S + sizeof(CListItemInPlace);
|
||||
}
|
||||
ILINE void Stack(CListItemInPlace* pItem)
|
||||
{
|
||||
}
|
||||
public:
|
||||
ILINE CInPlace()
|
||||
: m_Allocated(0)
|
||||
{
|
||||
}
|
||||
|
||||
ILINE void InitMem(const size_t S = 0, uint8* pData = 0)
|
||||
{
|
||||
TMemory::InitMem(S, pData);
|
||||
if (!TMemory::MemSize())
|
||||
{
|
||||
return;
|
||||
}
|
||||
pData = TMemory::Data();
|
||||
CListItemInPlace* pFirst = reinterpret_cast<CListItemInPlace*>(pData);
|
||||
CListItemInPlace* pFree = pFirst + 1;
|
||||
CListItemInPlace* pLast = reinterpret_cast<CListItemInPlace*>(pData + TMemory::MemSize()) - 1;
|
||||
m_Items.~CList<CListItemInPlace>();
|
||||
new (&m_Items)CList<CListItemInPlace>();
|
||||
m_Items.AddLast(pFirst);
|
||||
m_Items.AddLast(pFree);
|
||||
m_Items.AddLast(pLast);
|
||||
|
||||
pFirst->InUse(0); //static first item
|
||||
pFree->Free();
|
||||
pLast->InUse(0); //static last item
|
||||
m_pEmpty = pFree;
|
||||
m_Allocated = 0;
|
||||
}
|
||||
|
||||
ILINE size_t FragmentCount() const
|
||||
{
|
||||
return m_Items.Count();
|
||||
}
|
||||
|
||||
ILINE CListItemInPlace* Split(CListItemInPlace* pItem, size_t Size, size_t Align)
|
||||
{
|
||||
size_t Offset = reinterpret_cast<size_t>(pItem->Data());
|
||||
Offset += pItem->MemSize(); //ptr to end
|
||||
Offset -= Size; //minus size
|
||||
Size += Offset & (Align - 1); //adjust size to fit required alignment
|
||||
Offset -= Offset & (Align - 1);
|
||||
size_t TSize = sizeof(CListItemInPlace);
|
||||
Offset -= TSize; //header
|
||||
|
||||
if (Offset <= reinterpret_cast<size_t>(pItem + 1)) //not enough space for splitting?
|
||||
{
|
||||
return pItem;
|
||||
}
|
||||
|
||||
CListItemInPlace* pItemNext = reinterpret_cast<CListItemInPlace*>(Offset);
|
||||
|
||||
const size_t Offset2 = reinterpret_cast<size_t>(pItemNext->Data());
|
||||
CPA_ASSERT(!(Offset2 & (Align - 1)));
|
||||
m_Items.AddBehind(pItemNext, pItem);
|
||||
//pItemNext->Prev(pItem);
|
||||
//pItemNext->Next(pItem->Next());
|
||||
|
||||
// if(pItem->Next())
|
||||
// pItem->Next()->Prev(pItemNext);
|
||||
|
||||
// pItem->Next(pItemNext);
|
||||
pItemNext->Free();
|
||||
return pItemNext;
|
||||
}
|
||||
|
||||
ILINE void Merge(CListItemInPlace* pItem)
|
||||
{
|
||||
//merge with next if possible
|
||||
CListItemInPlace* pItemNext = pItem->Next();
|
||||
if (pItemNext->IsFree())
|
||||
{
|
||||
if (m_pEmpty == pItemNext)
|
||||
{
|
||||
m_pEmpty = pItem;
|
||||
}
|
||||
m_Items.Remove(pItemNext);
|
||||
//pItem->Next(pItemNext->Next());
|
||||
//pItem->Next()->Prev(pItem);
|
||||
}
|
||||
//merge with prev if possible
|
||||
CListItemInPlace* pItemPrev = pItem->Prev();
|
||||
if (pItemPrev->IsFree())
|
||||
{
|
||||
if (m_pEmpty == pItem)
|
||||
{
|
||||
m_pEmpty = pItemPrev;
|
||||
}
|
||||
m_Items.Remove(pItem);
|
||||
//pItemPrev->Next(pItem->Next());
|
||||
//pItem->Next()->Prev(pItemPrev);
|
||||
pItem = pItemPrev;
|
||||
}
|
||||
}
|
||||
template<class T>
|
||||
ILINE T Resolve(void* rItem) const
|
||||
{
|
||||
return reinterpret_cast<T>(rItem);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
ILINE size_t Size(const T* pData) const
|
||||
{
|
||||
const CListItemInPlace* pItem = Item(pData);
|
||||
return pItem->MemSize();
|
||||
}
|
||||
|
||||
bool InBounds(const void* pData, const bool Check) const
|
||||
{
|
||||
return !Check || (
|
||||
reinterpret_cast<size_t>(pData) >= reinterpret_cast<size_t>(TMemory::Data()) &&
|
||||
reinterpret_cast<size_t>(pData) < reinterpret_cast<size_t>(TMemory::Data()) + TMemory::MemSize());
|
||||
}
|
||||
|
||||
template<class T>
|
||||
ILINE bool Free(T* pData, bool ForceBoundsCheck = false)
|
||||
{
|
||||
if (pData && InBounds(pData, BoundsCheck | ForceBoundsCheck))
|
||||
{
|
||||
CListItemInPlace* pItem = Item(pData);
|
||||
FreedMemory(pItem->MemSize());
|
||||
pItem->Free();
|
||||
Merge(pItem);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
ILINE bool Beat(){return false; }//dummy beat in case no defragmentator is wraping
|
||||
ILINE size_t MemFree() const{return TMemory::MemSize() - m_Allocated; }
|
||||
ILINE size_t MemSize() const{return TMemory::MemSize(); }
|
||||
|
||||
ILINE uint8* Handle(CListItemInPlace* pItem) const
|
||||
{
|
||||
return pItem->Data();
|
||||
}
|
||||
template<class T>
|
||||
ILINE CListItemInPlace* Item(T* pData)
|
||||
{
|
||||
return reinterpret_cast<CListItemInPlace*>(pData) - 1;
|
||||
}
|
||||
template<class T>
|
||||
ILINE const CListItemInPlace* Item(const T* pData) const
|
||||
{
|
||||
return reinterpret_cast<const CListItemInPlace*>(pData) - 1;
|
||||
}
|
||||
ILINE static bool Defragmentable(){return false; }
|
||||
|
||||
template<class T>
|
||||
ILINE bool ReSize(T* pData, size_t SizeNew)
|
||||
{
|
||||
//special cases
|
||||
CListItemInPlace* pItem = Item(*pData);
|
||||
const size_t SizeOld = pItem->MemSize();
|
||||
|
||||
//reduction
|
||||
if (SizeOld > SizeNew)
|
||||
{
|
||||
if (pItem->Next()->IsFree())
|
||||
{
|
||||
CListItemInPlace* pNextNext = pItem->Next()->Next();
|
||||
size_t Offset = reinterpret_cast<size_t>(pItem->Data());
|
||||
Offset += SizeNew; //Offset to next
|
||||
CListItemInPlace* pItemNext = reinterpret_cast<CListItemInPlace*>(Offset);
|
||||
pItem->Next(pItemNext);
|
||||
pNextNext->Prev(pItemNext);
|
||||
pItemNext->Prev(pItem);
|
||||
pItemNext->Next(pNextNext);
|
||||
pItemNext->Free();
|
||||
return true;
|
||||
}
|
||||
|
||||
if (SizeOld - SizeNew <= sizeof(CListItemInPlace))
|
||||
{
|
||||
return true; //header is bigger than the amount of freed memory
|
||||
}
|
||||
//split
|
||||
size_t Offset = reinterpret_cast<size_t>(pItem->Data());
|
||||
Offset += SizeNew; //Offset to next
|
||||
CListItemInPlace* pItemNext = reinterpret_cast<CListItemInPlace*>(Offset);
|
||||
m_Items.AddBehind(pItemNext, pItem);
|
||||
pItemNext->Free();
|
||||
return true;
|
||||
}
|
||||
|
||||
//SizeOld<SizeNew grow
|
||||
CListItemInPlace* pNext = pItem->Next();
|
||||
CListItemInPlace* pNextNext = pNext->Next();
|
||||
const size_t SizeNext = pNext->IsFree() ? pNext->MemSize() + sizeof(CListItemInPlace) : 0;
|
||||
if (SizeNew <= SizeNext + SizeOld)
|
||||
{
|
||||
if (SizeNew + sizeof(CListItemInPlace) + 1 < SizeNext + SizeOld)
|
||||
{
|
||||
size_t Offset = reinterpret_cast<size_t>(pItem->Data());
|
||||
Offset += SizeNew; //Offset to next
|
||||
CListItemInPlace* pItemNext = reinterpret_cast<CListItemInPlace*>(Offset);
|
||||
pItem->Next(pItemNext);
|
||||
pNextNext->Prev(pItemNext);
|
||||
pItemNext->Prev(pItem);
|
||||
pItemNext->Next(pNextNext);
|
||||
pItemNext->Free();
|
||||
}
|
||||
else
|
||||
{
|
||||
pItem->Next(pNextNext);
|
||||
pNextNext->Prev(pItem);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false; //no further in-place realloc possible
|
||||
}
|
||||
};
|
||||
|
||||
template<class TMemory, size_t TNodeCount, bool BoundsCheck = false>
|
||||
class CReferenced
|
||||
: public TMemory
|
||||
{
|
||||
typedef CPool<TNodeCount, CListItemReference> tdNodePool;
|
||||
|
||||
protected:
|
||||
tdNodePool m_NodePool;
|
||||
CList<CListItemReference> m_Items;
|
||||
size_t m_Allocated;
|
||||
CListItemReference* m_pEmpty;
|
||||
|
||||
ILINE void AllocatedMemory(size_t S)
|
||||
{
|
||||
m_Allocated += S;
|
||||
}
|
||||
ILINE void FreedMemory(size_t S)
|
||||
{
|
||||
m_Allocated -= S;
|
||||
}
|
||||
ILINE void Stack(CListItemReference* pItem)
|
||||
{
|
||||
m_Items.Validate(pItem);
|
||||
CListItemReference* pItem2 = 0;
|
||||
CListItemReference* pNext = pItem->Next();
|
||||
uint8* pData = pItem->Data(pNext->Align());
|
||||
if (pData != pItem->Data()) //needs splitting 'cause of alignment?
|
||||
{
|
||||
pItem2 = reinterpret_cast<CListItemReference*>(m_NodePool.Allocate(1, 1));
|
||||
if (!pItem2) //no free node found for splitting?
|
||||
{
|
||||
return; //failed to stack -> return
|
||||
}
|
||||
}
|
||||
|
||||
memmove(pData, pNext->Data(), pNext->MemSize());
|
||||
|
||||
if (pItem2) //was not aligned?
|
||||
{
|
||||
//then keep the current ITem
|
||||
const size_t SizeItem = pItem->MemSize();
|
||||
const size_t SizeNext = pNext->MemSize();
|
||||
m_Items.AddBehind(pItem2, pNext);
|
||||
pItem2->Data(pData + SizeNext);
|
||||
pNext->Data(pData);
|
||||
pItem2->MemSize(pItem2->Next()->Data() - pItem2->Data());
|
||||
pNext->MemSize(SizeNext);
|
||||
pItem->MemSize(pNext->Data() - pItem->Data());
|
||||
m_Items.Validate(pItem);
|
||||
m_Items.Validate(pItem2);
|
||||
m_Items.Validate(pNext);
|
||||
}
|
||||
else
|
||||
{
|
||||
const size_t SizeItem = pItem->MemSize();
|
||||
const size_t SizeNext = pNext->MemSize();
|
||||
m_Items.Remove(pItem);
|
||||
m_Items.AddBehind(pItem, pNext);
|
||||
pItem->Data(pNext->Data());
|
||||
pNext->Data(pData);
|
||||
pNext->MemSize(SizeItem);
|
||||
pItem->MemSize(SizeNext);
|
||||
m_Items.Validate(pItem);
|
||||
m_Items.Validate(pNext);
|
||||
}
|
||||
}
|
||||
public:
|
||||
ILINE CReferenced()
|
||||
: m_Allocated(0)
|
||||
{
|
||||
}
|
||||
|
||||
ILINE void InitMem(const size_t S = 0, uint8* pData = 0)
|
||||
{
|
||||
TMemory::InitMem(S, pData);
|
||||
if (!TMemory::MemSize())
|
||||
{
|
||||
return;
|
||||
}
|
||||
pData = TMemory::Data();
|
||||
CListItemReference* pItem = reinterpret_cast<CListItemReference*>(m_NodePool.Allocate(1, 1));
|
||||
CListItemReference* pLast = reinterpret_cast<CListItemReference*>(m_NodePool.Allocate(1, 1));
|
||||
m_Items.AddFirst(pItem);
|
||||
m_Items.AddLast(pLast);
|
||||
pLast->Init(pData + TMemory::MemSize(), 0, pItem, 0);
|
||||
pLast->InUse(0);
|
||||
pItem->Init(pData, TMemory::MemSize(), 0, pLast);
|
||||
pItem->Free();
|
||||
m_pEmpty = pItem;
|
||||
m_Allocated = 0;
|
||||
}
|
||||
|
||||
ILINE size_t FragmentCount() const
|
||||
{
|
||||
return m_Items.Count();
|
||||
}
|
||||
|
||||
ILINE CListItemReference* Split(CListItemReference* pItem, size_t Size, size_t Align)
|
||||
{
|
||||
size_t Offset = reinterpret_cast<size_t>(pItem->Data());
|
||||
if (!(Offset & (Align - 1))) //perfectly aligned?
|
||||
{
|
||||
if (pItem->MemSize() != Size) //not perfectly fitting?
|
||||
{ //then split
|
||||
CListItemReference* pItemPrev = reinterpret_cast<CListItemReference*>(m_NodePool.Allocate(1, 1));
|
||||
if (!pItemPrev)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
const size_t OrgSize = pItem->MemSize();
|
||||
m_Items.AddBefore(pItemPrev, pItem);
|
||||
pItemPrev->Data(pItem->Data());
|
||||
pItem->Data(pItem->Data() + Size);
|
||||
pItem->MemSize(OrgSize - Size);
|
||||
pItemPrev->MemSize(Size);
|
||||
pItem = pItemPrev;
|
||||
}
|
||||
return pItem;
|
||||
}
|
||||
|
||||
//not aligned to block start
|
||||
//then lets try to align to block end
|
||||
Offset += pItem->MemSize(); //ptr to end
|
||||
Offset -= Size; //minus size
|
||||
if (!(Offset & (Align - 1))) //perfectly aligned?
|
||||
{
|
||||
CListItemReference* pItemPrev = reinterpret_cast<CListItemReference*>(m_NodePool.Allocate(1, 1));
|
||||
if (!pItemPrev)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
const size_t OrgSize = pItem->MemSize();
|
||||
m_Items.AddBefore(pItemPrev, pItem);
|
||||
pItemPrev->Data(pItem->Data());
|
||||
pItem->Data(reinterpret_cast<uint8*>(Offset));
|
||||
pItemPrev->MemSize(OrgSize - Size);
|
||||
pItem->MemSize(Size);
|
||||
pItemPrev->Free();
|
||||
return pItem;
|
||||
}
|
||||
//last resort, fragment it into 3 parts
|
||||
|
||||
//Size +=Offset&(Align-1); //adjust size to fit required alignment
|
||||
Offset -= Offset & (Align - 1);
|
||||
|
||||
CListItemReference* pItemPrev = reinterpret_cast<CListItemReference*>(m_NodePool.Allocate(1, 1));
|
||||
CListItemReference* pItemNext = reinterpret_cast<CListItemReference*>(m_NodePool.Allocate(1, 1));
|
||||
if (!pItemPrev || !pItemNext)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
const size_t OrgSize = pItem->MemSize();
|
||||
|
||||
m_Items.AddBefore(pItemPrev, pItem);
|
||||
m_Items.AddBehind(pItemNext, pItem);
|
||||
|
||||
pItemPrev->Data(pItem->Data());
|
||||
pItem->Data(reinterpret_cast<uint8*>(Offset));
|
||||
pItemNext->Data(pItem->Data() + Size);
|
||||
pItemPrev->MemSize(pItem->Data() - pItemPrev->Data());
|
||||
pItemNext->MemSize(OrgSize - pItemPrev->MemSize() - Size);
|
||||
pItem->MemSize(Size);
|
||||
|
||||
pItemPrev->Free();
|
||||
pItemNext->Free();
|
||||
return pItem;
|
||||
}
|
||||
|
||||
ILINE void Merge(CListItemReference* pItem)
|
||||
{
|
||||
m_Items.Validate(pItem);
|
||||
|
||||
//merge with next if possible
|
||||
CListItemReference* pItemNext = pItem->Next();
|
||||
if (pItemNext && pItemNext->IsFree())
|
||||
{
|
||||
if (m_pEmpty == pItemNext)
|
||||
{
|
||||
m_pEmpty = pItem;
|
||||
}
|
||||
const size_t OrgSize = pItem->MemSize();
|
||||
const size_t NextSize = pItemNext->MemSize();
|
||||
m_Items.Remove(pItemNext);
|
||||
pItem->MemSize(OrgSize + NextSize);
|
||||
m_NodePool.Free(pItemNext);
|
||||
}
|
||||
//merge with prev if possible
|
||||
CListItemReference* pItemPrev = pItem->Prev();
|
||||
if (pItemPrev && pItemPrev->IsFree())
|
||||
{
|
||||
if (m_pEmpty == pItem)
|
||||
{
|
||||
m_pEmpty = pItemPrev;
|
||||
}
|
||||
const size_t OrgSize = pItem->MemSize();
|
||||
const size_t PrevSize = pItemPrev->MemSize();
|
||||
m_Items.Remove(pItem);
|
||||
pItemPrev->MemSize(PrevSize + OrgSize);
|
||||
m_NodePool.Free(pItem);
|
||||
}
|
||||
}
|
||||
|
||||
template<class T>
|
||||
ILINE T Resolve(const uint32 ID)
|
||||
{
|
||||
CPA_ASSERT(ID); //0 is invalid
|
||||
return reinterpret_cast<T>(Item(ID)->Data());
|
||||
}
|
||||
|
||||
ILINE uint32 AddressToHandle(void* pData)
|
||||
{
|
||||
for (CListItemReference* pItem = m_Items.First(); pItem; pItem = pItem->Next())
|
||||
{
|
||||
if (pItem->Data() == pData)
|
||||
{
|
||||
return Handle(pItem);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
ILINE size_t Size(T ID) const
|
||||
{
|
||||
CPA_ASSERT(ID); //0 is invalid
|
||||
return Item(ID)->MemSize();
|
||||
}
|
||||
template<class T>
|
||||
bool InBounds([[maybe_unused]] T ID, [[maybe_unused]] const bool Check) const
|
||||
{
|
||||
//boundscheck doesn't work for Referenced containers
|
||||
return true;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
ILINE bool Free(T ID, bool ForceBoundsCheck = false)
|
||||
{
|
||||
IF (!ID, false)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
IF (!InBounds(ID, BoundsCheck | ForceBoundsCheck), false)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
CListItemReference* pItem = Item(ID);
|
||||
FreedMemory(pItem->MemSize());
|
||||
pItem->Free();
|
||||
Merge(pItem);
|
||||
return true;
|
||||
}
|
||||
|
||||
ILINE bool Beat(){return false; }//dummy beat in case no defragmentator is wraping
|
||||
|
||||
ILINE size_t MemFree() const{return TMemory::MemSize() - m_Allocated; }
|
||||
|
||||
ILINE size_t MemSize() const{return TMemory::MemSize(); }
|
||||
|
||||
ILINE uint32 Handle(CListItemReference* pItem) const
|
||||
{
|
||||
return static_cast<uint32>(pItem - &m_NodePool[0]);
|
||||
}
|
||||
ILINE CListItemReference* Item(uint32 ID)
|
||||
{
|
||||
return &m_NodePool[ID];
|
||||
}
|
||||
ILINE const CListItemReference* Item(uint32 ID) const
|
||||
{
|
||||
return &m_NodePool[ID];
|
||||
}
|
||||
ILINE static bool Defragmentable(){return true; }
|
||||
|
||||
|
||||
|
||||
template<class T>
|
||||
ILINE bool ReSize(T* pData, size_t SizeNew)
|
||||
{
|
||||
CListItemReference* pItem = Item(*pData);
|
||||
const size_t SizeOld = pItem->MemSize();
|
||||
|
||||
//reduction
|
||||
if (SizeOld > SizeNew)
|
||||
{
|
||||
if (pItem->Next()->IsFree())
|
||||
{
|
||||
CListItemReference* pNext = pItem->Next();
|
||||
const size_t NextSize = pNext->MemSize();
|
||||
pNext->Data(pNext->Data() + SizeNew - SizeOld);
|
||||
pNext->MemSize(NextSize - SizeNew + SizeOld);
|
||||
pItem->MemSize(SizeNew);
|
||||
return true;
|
||||
}
|
||||
|
||||
//split
|
||||
CListItemReference* pItemNext = reinterpret_cast<CListItemReference*>(m_NodePool.Allocate(1, 1));
|
||||
m_Items.AddBehind(pItemNext, pItem);
|
||||
pItemNext->Data(pItem->Data() + SizeNew);
|
||||
pItem->MemSize(SizeNew);
|
||||
pItemNext->MemSize(SizeOld - SizeNew);
|
||||
pItemNext->Free();
|
||||
return true;
|
||||
}
|
||||
|
||||
//SizeOld<SizeNew grow
|
||||
CListItemReference* pNext = pItem->Next();
|
||||
const size_t SizeNext = pNext->IsFree() ? pNext->MemSize() : 0;
|
||||
if (SizeNew <= SizeNext + SizeOld)
|
||||
{
|
||||
if (SizeNew == SizeNext + SizeOld)
|
||||
{
|
||||
m_Items.Remove(pNext);
|
||||
m_NodePool.Free(pNext);
|
||||
}
|
||||
else
|
||||
{
|
||||
pNext->Data(pNext->Data() + SizeNew - SizeOld);
|
||||
pNext->MemSize(SizeNext - SizeNew + SizeOld);
|
||||
}
|
||||
pItem->MemSize(SizeNew);
|
||||
return true;
|
||||
}
|
||||
return false; //no further in-place realloc possible
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_CRYPOOL_CONTAINER_H
|
||||
|
||||
@ -1,65 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_CRYPOOL_DEFRAG_H
|
||||
#define CRYINCLUDE_CRYPOOL_DEFRAG_H
|
||||
#pragma once
|
||||
|
||||
|
||||
namespace NCryPoolAlloc
|
||||
{
|
||||
template<class T>
|
||||
class CDefragStacked
|
||||
: public T
|
||||
{
|
||||
template<class TItem>
|
||||
ILINE bool DefragElement(TItem* pItem)
|
||||
{
|
||||
T::m_Items.Validate();
|
||||
if (pItem)
|
||||
{
|
||||
for (; pItem->Next(); pItem = pItem->Next())
|
||||
{
|
||||
if (!pItem->IsFree())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if (pItem->Next()->Locked())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if (!pItem->Available(pItem->Next()->Align(), pItem->Next()->Align()))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
T::m_Items.Validate(pItem);
|
||||
Stack(pItem);
|
||||
T::m_Items.Validate(pItem);
|
||||
Merge(pItem);
|
||||
T::m_Items.Validate();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
public:
|
||||
ILINE bool Beat()
|
||||
{
|
||||
return T::Defragmentable() && DefragElement(T::m_Items.First());
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_CRYPOOL_DEFRAG_H
|
||||
|
||||
@ -1,81 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_CRYPOOL_FALLBACK_H
|
||||
#define CRYINCLUDE_CRYPOOL_FALLBACK_H
|
||||
#pragma once
|
||||
|
||||
|
||||
namespace NCryPoolAlloc
|
||||
{
|
||||
enum EFallbackMode
|
||||
{
|
||||
EFM_DISABLED,
|
||||
EFM_ENABLED,
|
||||
EFM_ALWAYS
|
||||
};
|
||||
template<class TAllocator>
|
||||
class CFallback
|
||||
: public TAllocator
|
||||
{
|
||||
EFallbackMode m_Fallback;
|
||||
public:
|
||||
ILINE CFallback()
|
||||
: m_Fallback(EFM_DISABLED)
|
||||
{
|
||||
}
|
||||
|
||||
template<class T>
|
||||
ILINE T Allocate(size_t Size, size_t Align = 1)
|
||||
{
|
||||
if (EFM_ALWAYS == m_Fallback)
|
||||
{
|
||||
return reinterpret_cast<T>(CPA_ALLOC(Align, Size));
|
||||
}
|
||||
T pRet = TAllocator::template Allocate<T>(Size, Align);
|
||||
if (!pRet && EFM_ENABLED == m_Fallback)
|
||||
{
|
||||
return reinterpret_cast<T>(CPA_ALLOC(Align, Size));
|
||||
}
|
||||
return pRet;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
ILINE bool Free(T Handle)
|
||||
{
|
||||
if (!Handle)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
if (EFM_ALWAYS == m_Fallback)
|
||||
{
|
||||
CPA_FREE(Handle);
|
||||
return true;
|
||||
}
|
||||
|
||||
if (EFM_ENABLED == m_Fallback && TAllocator::InBounds(Handle, true))
|
||||
{
|
||||
CPA_FREE(Handle);
|
||||
return true;
|
||||
}
|
||||
return TAllocator::template Free<T>(Handle);
|
||||
}
|
||||
|
||||
void FallbackMode(EFallbackMode M){m_Fallback = M; }
|
||||
EFallbackMode FallbaclMode() const{return m_Fallback; }
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_CRYPOOL_FALLBACK_H
|
||||
|
||||
@ -1,203 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_CRYPOOL_INSPECTOR_H
|
||||
#define CRYINCLUDE_CRYPOOL_INSPECTOR_H
|
||||
#pragma once
|
||||
|
||||
|
||||
namespace NCryPoolAlloc
|
||||
{
|
||||
template<class TAllocator>
|
||||
class CInspector
|
||||
: public TAllocator
|
||||
{
|
||||
enum
|
||||
{
|
||||
EITableSize = 30
|
||||
};
|
||||
size_t m_Allocations[EITableSize];
|
||||
size_t m_Alignment[EITableSize];
|
||||
char m_LogFileName[1024];
|
||||
size_t m_AllocCount;
|
||||
size_t m_FreeCount;
|
||||
size_t m_ResizeCount;
|
||||
size_t m_FailAllocCount;
|
||||
size_t m_FailFreeCount;
|
||||
size_t m_FailResizeCount;
|
||||
|
||||
void WriteOut(const char* pFileName, uint32 Stack, const char* pFormat, ...) const
|
||||
{
|
||||
/*
|
||||
if(!pFileName)
|
||||
{
|
||||
if(!*m_LogFileName)
|
||||
return;
|
||||
pFileName = m_LogFileName;
|
||||
}
|
||||
FILE* File = fopen(pFileName,"a");
|
||||
if(File)
|
||||
{
|
||||
|
||||
char Buffer[1024];
|
||||
for(uint32 a=0;a<Stack;a++)
|
||||
Buffer[a]=' ';
|
||||
va_list args;
|
||||
va_start(args,pFormat);
|
||||
vsprintf(Buffer+Stack,pFormat,args);
|
||||
fwrite(Buffer,1,strlen(Buffer),File);
|
||||
fclose(File);
|
||||
va_end(args);
|
||||
}
|
||||
*/
|
||||
}
|
||||
size_t Bit(size_t C) const
|
||||
{
|
||||
size_t Count = 0;
|
||||
C >>= 1;
|
||||
while (C)
|
||||
{
|
||||
Count++;
|
||||
C >>= 1;
|
||||
}
|
||||
return Count >= EITableSize ? EITableSize - 1 : Count;
|
||||
}
|
||||
public:
|
||||
CInspector()
|
||||
{
|
||||
for (size_t a = 0; a < EITableSize; a++)
|
||||
{
|
||||
m_Allocations[a] = m_Alignment[a] = 0;
|
||||
}
|
||||
|
||||
m_LogFileName[0] = 0;
|
||||
m_AllocCount = 0;
|
||||
m_FreeCount = 0;
|
||||
m_ResizeCount = 0;
|
||||
m_FailAllocCount = 0;
|
||||
m_FailFreeCount = 0;
|
||||
m_FailResizeCount = 0;
|
||||
}
|
||||
|
||||
bool LogFileName(const char* pFileName)
|
||||
{
|
||||
const size_t Size = strlen(pFileName) + 1;
|
||||
if (Size > sizeof(m_LogFileName))
|
||||
{
|
||||
m_LogFileName[0] = 0;
|
||||
return false;
|
||||
}
|
||||
memcpy(m_LogFileName, pFileName, Size);
|
||||
WriteOut(0, "[log start]\n");
|
||||
return true;
|
||||
}
|
||||
void SaveStats(const char* pFileName) const
|
||||
{
|
||||
WriteOut(pFileName, 0, "stats:\n");
|
||||
|
||||
WriteOut(pFileName, 1, "Counter calls|fails\n");
|
||||
WriteOut(pFileName, 2, "Alloc: %6d|%6d\n", m_AllocCount, m_FailAllocCount);
|
||||
WriteOut(pFileName, 2, "Free: %6d|%6d\n", m_FreeCount, m_FailFreeCount);
|
||||
WriteOut(pFileName, 2, "Resize:%6d|%6d\n", m_ResizeCount, m_FailResizeCount);
|
||||
|
||||
WriteOut(pFileName, 1, "Allocations:\n");
|
||||
for (size_t a = 0; a < EITableSize; a++)
|
||||
{
|
||||
WriteOut(pFileName, 2, "%9dByte: %8d\n", 1 << a, m_Allocations[a]);
|
||||
}
|
||||
|
||||
WriteOut(pFileName, 1, "Alignment:\n");
|
||||
for (size_t a = 0; a < EITableSize; a++)
|
||||
{
|
||||
WriteOut(pFileName, 2, "%9dByte: %8d\n", 1 << a, m_Alignment[a]);
|
||||
}
|
||||
}
|
||||
|
||||
template<class T>
|
||||
ILINE T Allocate(size_t Size, size_t Align = 1)
|
||||
{
|
||||
m_AllocCount++;
|
||||
m_Allocations[Bit(Size)]++;
|
||||
m_Alignment[Bit(Align)]++;
|
||||
T pData = TAllocator::template Allocate<T>(Size, Align);
|
||||
WriteOut(0, 0, "[A|%d|%d|%d]", (int)pData, Size, Align);
|
||||
if (!pData)
|
||||
{
|
||||
m_FailAllocCount++;
|
||||
WriteOut(0, 0, "[failed]", Size, Align);
|
||||
}
|
||||
return pData;
|
||||
}
|
||||
|
||||
|
||||
template<class T>
|
||||
ILINE bool Free(T pData, bool ForceBoundsCheck = false)
|
||||
{
|
||||
m_FreeCount++;
|
||||
const bool Ret = TAllocator::Free(pData, ForceBoundsCheck);
|
||||
WriteOut(0, 0, "[F|%d|%d|%d]", (int)pData, (int)ForceBoundsCheck, (int)Ret);
|
||||
m_FailFreeCount += !Ret;
|
||||
return Ret;
|
||||
}
|
||||
//template<class T>
|
||||
//ILINE bool Free(T pData)
|
||||
// {
|
||||
// m_FreeCount++;
|
||||
// const bool Ret = TAllocator::Free(pData);
|
||||
// WriteOut(0,0,"[F|%d|%d|%d]",(int)pData,(int)-1,(int)Ret);
|
||||
// m_FailFreeCount+=!Ret;
|
||||
// return Ret;
|
||||
// }
|
||||
|
||||
template<class T>
|
||||
ILINE bool Resize(T** pData, size_t Size, size_t Alignment)
|
||||
{
|
||||
m_ResizeCount++;
|
||||
const bool Ret = TAllocator::Resize(pData, Size, Alignment);
|
||||
WriteOut(0, 0, "[R|%d|%d|%d]", (int)*pData, (int)-1, (int)Ret);
|
||||
m_FailResizeCount += !Ret;
|
||||
return Ret;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
ILINE size_t FindBiggest(const T* pItem)
|
||||
{
|
||||
size_t Biggest = 0;
|
||||
while (pItem)
|
||||
{
|
||||
if (pItem->IsFree() && pItem->MemSize() > Biggest)
|
||||
{
|
||||
Biggest = pItem->MemSize();
|
||||
}
|
||||
pItem = pItem->Next();
|
||||
}
|
||||
return Biggest;
|
||||
}
|
||||
|
||||
ILINE size_t BiggestFreeBlock()
|
||||
{
|
||||
return FindBiggest(TAllocator::m_Items.First());
|
||||
}
|
||||
|
||||
ILINE uint8* FirstItem()
|
||||
{
|
||||
return TAllocator::m_Items.First()->Data();
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_CRYPOOL_INSPECTOR_H
|
||||
|
||||
@ -1,366 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_CRYPOOL_LIST_H
|
||||
#define CRYINCLUDE_CRYPOOL_LIST_H
|
||||
#pragma once
|
||||
|
||||
namespace NCryPoolAlloc
|
||||
{
|
||||
class CListItemInPlace;
|
||||
class CListItemReference;
|
||||
|
||||
template<typename TItem>
|
||||
class CListItem
|
||||
{
|
||||
TItem* m_pPrev;
|
||||
TItem* m_pNext;
|
||||
public:
|
||||
|
||||
ILINE TItem* Prev(){return m_pPrev; }
|
||||
ILINE TItem* Next(){return m_pNext; }
|
||||
ILINE const TItem* Prev() const{return m_pPrev; }
|
||||
ILINE const TItem* Next() const{return m_pNext; }
|
||||
ILINE void Prev(TItem* pPrev){ m_pPrev = pPrev; }
|
||||
ILINE void Next(TItem* pNext){ m_pNext = pNext; }
|
||||
|
||||
//debugging
|
||||
void Validate();
|
||||
};
|
||||
|
||||
template<typename TItem>
|
||||
class CListItemFlagged
|
||||
: public CListItem<TItem>
|
||||
{
|
||||
enum
|
||||
{
|
||||
ELIF_INUSE = (1 << 0),
|
||||
ELIF_LOCKED = (1 << 1),
|
||||
};
|
||||
uint32 m_Flags : 8;
|
||||
uint32 m_Align : 24;
|
||||
public:
|
||||
ILINE CListItemFlagged()
|
||||
: m_Flags(0)
|
||||
{
|
||||
}
|
||||
ILINE bool IsFree() const{return (m_Flags & ELIF_INUSE) != ELIF_INUSE; }
|
||||
ILINE void Free(){m_Flags &= ~ELIF_INUSE; }
|
||||
ILINE void InUse(uint32 A){m_Flags |= ELIF_INUSE; m_Align = A; }
|
||||
ILINE bool Locked() const{return ELIF_LOCKED == (m_Flags & ELIF_LOCKED); }
|
||||
ILINE void Lock(){m_Flags |= ELIF_LOCKED; }
|
||||
ILINE void Unlock(){m_Flags &= ~ELIF_LOCKED; }
|
||||
ILINE uint32 Align() const{return m_Align; }
|
||||
};
|
||||
|
||||
class CListItemInPlace
|
||||
: public CListItemFlagged<CListItemInPlace>
|
||||
{
|
||||
public:
|
||||
ILINE void Init([[maybe_unused]] uint8* pData, [[maybe_unused]] size_t Size, CListItemInPlace* pPrev, CListItemInPlace* pNext)
|
||||
{
|
||||
Prev(pPrev);
|
||||
Next(pNext);
|
||||
CPA_ASSERT(Size == MemSize());
|
||||
}
|
||||
|
||||
ILINE bool Available(size_t Size, size_t Align) const
|
||||
{
|
||||
size_t Offset = reinterpret_cast<size_t>(Data());
|
||||
if (Offset & (Align - 1)) //not aligned?
|
||||
{
|
||||
Size += sizeof(CListItemInPlace) + Align - 1; //then an intermedian node needs to fit
|
||||
}
|
||||
return Size <= MemSize() && IsFree();
|
||||
}
|
||||
ILINE uint8* Data(){return reinterpret_cast<uint8*>(this) + sizeof(CListItemInPlace); }
|
||||
ILINE const uint8* Data() const{return reinterpret_cast<const uint8*>(this) + sizeof(CListItemInPlace); }
|
||||
ILINE size_t MemSize() const
|
||||
{
|
||||
const uint8* pNext = reinterpret_cast<const uint8*>(Next());
|
||||
const uint8* pThis = reinterpret_cast<const uint8*>(this);
|
||||
const size_t ESize = sizeof(CListItemInPlace);
|
||||
size_t Delta = pNext - pThis;
|
||||
Delta -= ESize;
|
||||
return Delta;
|
||||
}
|
||||
};
|
||||
|
||||
class CListItemReference
|
||||
: public CListItemFlagged<CListItemReference>
|
||||
{
|
||||
uint8* m_pData;
|
||||
// size_t m_Size;
|
||||
public:
|
||||
ILINE void Init(uint8* pData, size_t Size, CListItemReference* pPrev, CListItemReference* pNext)
|
||||
{
|
||||
Data(pData);
|
||||
Prev(pPrev);
|
||||
Next(pNext);
|
||||
MemSize(Size);
|
||||
}
|
||||
ILINE bool Available(size_t Size, size_t Align) const
|
||||
{
|
||||
size_t Offset = reinterpret_cast<size_t>(Data());
|
||||
if ((Offset & (Align - 1)))
|
||||
{
|
||||
Size += Align - (Offset & (Align - 1));
|
||||
}
|
||||
return Size <= MemSize() && IsFree();
|
||||
}
|
||||
ILINE void Data(uint8* pData){m_pData = pData; }
|
||||
ILINE uint8* Data(size_t Align)
|
||||
{
|
||||
Align--;
|
||||
size_t Offset = reinterpret_cast<size_t>(m_pData);
|
||||
Offset = (Offset + Align) & ~Align;
|
||||
return reinterpret_cast<uint8*>(Offset);
|
||||
}
|
||||
ILINE uint8* Data(){return m_pData; }
|
||||
ILINE const uint8* Data() const{return m_pData; }
|
||||
ILINE void MemSize([[maybe_unused]] size_t Size) { }
|
||||
ILINE size_t MemSize() const
|
||||
{
|
||||
const size_t T = reinterpret_cast<size_t>(Data());
|
||||
const size_t N = Next() ? reinterpret_cast<size_t>(Next()->Data()) : T;
|
||||
return N - T;
|
||||
}
|
||||
//ILINE void MemSize(size_t Size){m_Size=Size;}
|
||||
//ILINE size_t MemSize()const{return m_Size;}
|
||||
};
|
||||
|
||||
template<class TItem, bool VALIDATE = false>
|
||||
class CList
|
||||
{
|
||||
TItem* m_pFirst;
|
||||
TItem* m_pLast;
|
||||
size_t m_Count;
|
||||
public:
|
||||
ILINE CList()
|
||||
: m_pFirst(0)
|
||||
, m_pLast(0)
|
||||
, m_Count(0)
|
||||
{
|
||||
}
|
||||
|
||||
ILINE void First(TItem* pItem){m_pFirst = pItem; }
|
||||
ILINE TItem* First(){return m_pFirst; }
|
||||
ILINE void Last(TItem* pItem){m_pLast = pItem; }
|
||||
ILINE TItem* Last(){return m_pLast; }
|
||||
ILINE bool Empty() const{return m_pFirst == 0; }
|
||||
|
||||
ILINE TItem* PopFirst()
|
||||
{
|
||||
Validate();
|
||||
|
||||
if (!m_pFirst)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
TItem* pRet = m_pFirst;
|
||||
|
||||
m_pFirst = m_pFirst->Next();
|
||||
|
||||
if (m_pFirst) //if any element exists
|
||||
{
|
||||
m_pFirst->Prev(0); //set prev ptr of this element to 0
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pLast = 0; //set ptr to last element to 0 if ptr to first is zero as well
|
||||
}
|
||||
Validate();
|
||||
m_Count--;
|
||||
return pRet;
|
||||
}
|
||||
|
||||
ILINE TItem* PopLast()
|
||||
{
|
||||
Validate();
|
||||
|
||||
if (!m_pLast)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
TItem* pRet = m_pLast;
|
||||
|
||||
m_pLast = m_pLast->Prev();
|
||||
|
||||
if (m_pLast) //if any element exists
|
||||
{
|
||||
m_pLast->Next(0); //set prev ptr of this element to 0
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pFirst = 0; //set ptr to last element to 0 if ptr to first is zero as well
|
||||
}
|
||||
Validate();
|
||||
m_Count--;
|
||||
return pRet;
|
||||
}
|
||||
|
||||
ILINE void AddFirst(TItem* pItem)
|
||||
{
|
||||
CPA_ASSERT(pItem); //ERROR AddFirst got 0 pointer
|
||||
|
||||
Validate();
|
||||
|
||||
pItem->Prev(0);
|
||||
pItem->Next(m_pFirst);
|
||||
if (!m_pFirst)
|
||||
{
|
||||
m_pLast = pItem;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pFirst->Prev(pItem);
|
||||
}
|
||||
m_pFirst = pItem;
|
||||
|
||||
m_Count++;
|
||||
Validate();
|
||||
}
|
||||
|
||||
ILINE void AddLast(TItem* pItem)
|
||||
{
|
||||
CPA_ASSERT(pItem); //ERROR AddLast got 0 pointer
|
||||
|
||||
Validate();
|
||||
|
||||
pItem->Prev(m_pLast);
|
||||
pItem->Next(0);
|
||||
if (!m_pLast)
|
||||
{
|
||||
m_pFirst = pItem;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pLast->Next(pItem);
|
||||
}
|
||||
m_pLast = pItem;
|
||||
|
||||
m_Count++;
|
||||
Validate();
|
||||
}
|
||||
ILINE void AddBefore(TItem* pItem, TItem* pItemSuccessor)
|
||||
{
|
||||
CPA_ASSERT(pItem);
|
||||
CPA_ASSERT(pItemSuccessor);
|
||||
|
||||
Validate();
|
||||
|
||||
pItem->Next(pItemSuccessor);
|
||||
pItem->Prev(pItemSuccessor->Prev());
|
||||
pItemSuccessor->Prev(pItem);
|
||||
|
||||
if (pItemSuccessor == m_pFirst)
|
||||
{
|
||||
m_pFirst = pItem;
|
||||
}
|
||||
else
|
||||
{
|
||||
pItem->Prev()->Next(pItem);
|
||||
}
|
||||
|
||||
m_Count++;
|
||||
Validate();
|
||||
}
|
||||
ILINE void AddBehind(TItem* pItem, TItem* pItemPredecessor)
|
||||
{
|
||||
CPA_ASSERT(pItem);
|
||||
CPA_ASSERT(pItemPredecessor);
|
||||
|
||||
Validate();
|
||||
|
||||
pItem->Next(pItemPredecessor->Next());
|
||||
pItem->Prev(pItemPredecessor);
|
||||
pItemPredecessor->Next(pItem);
|
||||
|
||||
if (pItemPredecessor == m_pLast)
|
||||
{
|
||||
m_pLast = pItem;
|
||||
}
|
||||
else
|
||||
{
|
||||
pItem->Next()->Prev(pItem);
|
||||
}
|
||||
|
||||
m_Count++;
|
||||
Validate();
|
||||
}
|
||||
|
||||
ILINE void Remove(TItem* pItem)
|
||||
{
|
||||
CPA_ASSERT(pItem); //ERROR releasing empty item
|
||||
|
||||
if (pItem == m_pFirst)
|
||||
{
|
||||
PopFirst();
|
||||
return;
|
||||
}
|
||||
if (pItem == m_pLast)
|
||||
{
|
||||
PopLast();
|
||||
return;
|
||||
}
|
||||
|
||||
Validate(pItem);
|
||||
|
||||
pItem->Prev()->Next(pItem->Next());
|
||||
pItem->Next()->Prev(pItem->Prev());
|
||||
|
||||
m_Count--;
|
||||
Validate();
|
||||
}
|
||||
|
||||
//debug
|
||||
ILINE void Validate(TItem* pReferenceItem = 0)
|
||||
{
|
||||
if (!VALIDATE)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
//one-sided empty?
|
||||
CPA_ASSERT((!First() && !Last()) || (First() && Last())); //ERROR validating item-list, just one end is 0
|
||||
|
||||
// endles linking?
|
||||
TItem* pPrev = 0;
|
||||
TItem* pItem = First();
|
||||
while (pItem)
|
||||
{
|
||||
if (pReferenceItem == pItem)
|
||||
{
|
||||
pReferenceItem = 0;
|
||||
}
|
||||
CPA_ASSERT(pPrev == pItem->Prev()); //ERROR validating item-list, endless linking NULL
|
||||
pPrev = pItem;
|
||||
pItem = pItem->Next();
|
||||
}
|
||||
|
||||
CPA_ASSERT(pPrev == Last()); //ERROR validating item-list, broken list, does not end at specified Last item
|
||||
CPA_ASSERT(!pReferenceItem); //ERROR reference item not found in the item-list
|
||||
}
|
||||
ILINE size_t Count() const{return m_Count; }
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_CRYPOOL_LIST_H
|
||||
|
||||
@ -1,70 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_CRYPOOL_MEMORY_H
|
||||
#define CRYINCLUDE_CRYPOOL_MEMORY_H
|
||||
#pragma once
|
||||
|
||||
namespace NCryPoolAlloc
|
||||
{
|
||||
class CMemoryDynamic
|
||||
{
|
||||
size_t m_Size;
|
||||
uint8* m_pData;
|
||||
|
||||
protected:
|
||||
ILINE CMemoryDynamic()
|
||||
: m_Size(0)
|
||||
, m_pData(0){}
|
||||
|
||||
public:
|
||||
ILINE void InitMem(const size_t S, uint8* pData)
|
||||
{
|
||||
m_Size = S;
|
||||
m_pData = pData;
|
||||
CPA_ASSERT(S);
|
||||
CPA_ASSERT(pData);
|
||||
}
|
||||
|
||||
ILINE size_t MemSize() const{return m_Size; }
|
||||
ILINE uint8* Data(){return m_pData; }
|
||||
ILINE const uint8* Data() const{return m_pData; }
|
||||
};
|
||||
|
||||
template<size_t TSize>
|
||||
class CMemoryStatic
|
||||
{
|
||||
uint8 m_Data[TSize];
|
||||
|
||||
protected:
|
||||
ILINE CMemoryStatic()
|
||||
{
|
||||
}
|
||||
public:
|
||||
ILINE void InitMem(const size_t S, uint8* pData)
|
||||
{
|
||||
}
|
||||
ILINE size_t MemSize() const{return TSize; }
|
||||
ILINE uint8* Data(){return m_Data; }
|
||||
ILINE const uint8* Data() const{return m_Data; }
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_CRYPOOL_MEMORY_H
|
||||
|
||||
@ -1,55 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#pragma once
|
||||
|
||||
#if defined(POOLALLOCTESTSUIT)
|
||||
//cheat just for unit testing on windows
|
||||
#include "BaseTypes.h"
|
||||
#define ILINE inline
|
||||
#endif
|
||||
|
||||
// Traits
|
||||
#if defined(AZ_RESTRICTED_PLATFORM)
|
||||
#include AZ_RESTRICTED_FILE(CryPool/PoolAlloc_h)
|
||||
#elif defined(APPLE) || defined(LINUX)
|
||||
#define POOLALLOC_H_TRAIT_USE_MEMALIGN 1
|
||||
#endif
|
||||
|
||||
|
||||
#if POOLALLOC_H_TRAIT_USE_MEMALIGN
|
||||
#define CPA_ALLOC memalign
|
||||
#define CPA_FREE free
|
||||
#else
|
||||
#define CPA_ALLOC _aligned_malloc
|
||||
#define CPA_FREE _aligned_free
|
||||
#endif
|
||||
#define CPA_ASSERT assert
|
||||
#define CPA_ASSERT_STATIC(X) {uint8 assertdata[(X) ? 0 : 1]; }
|
||||
#define CPA_BREAK __debugbreak()
|
||||
|
||||
#include "List.h"
|
||||
#include "Memory.h"
|
||||
#include "Container.h"
|
||||
#include "Allocator.h"
|
||||
#include "Defrag.h"
|
||||
#include "STLWrapper.h"
|
||||
#include "Inspector.h"
|
||||
#include "Fallback.h"
|
||||
#if !defined(POOLALLOCTESTSUIT)
|
||||
#include "ThreadSafe.h"
|
||||
#endif
|
||||
|
||||
#undef CPA_ASSERT
|
||||
#undef CPA_ASSERT_STATIC
|
||||
#undef CPA_BREAK
|
||||
@ -1,148 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_CRYPOOL_STLWRAPPER_H
|
||||
#define CRYINCLUDE_CRYPOOL_STLWRAPPER_H
|
||||
#pragma once
|
||||
|
||||
namespace NCryPoolAlloc
|
||||
{
|
||||
//namespace CSTLPoolAllocWrapperHelper
|
||||
//{
|
||||
// inline void destruct(char *) {}
|
||||
// inline void destruct(wchar_t*) {}
|
||||
// template <typename T>
|
||||
// inline void destruct(T *t) {t->~T();}
|
||||
//}
|
||||
|
||||
//template <size_t S, class L, size_t A, typename T>
|
||||
//struct CSTLPoolAllocWrapperStatic
|
||||
//{
|
||||
// static PoolAllocator<S, L, A> * allocator;
|
||||
//};
|
||||
|
||||
//template <class T, class L, size_t A>
|
||||
//struct CSTLPoolAllocWrapperKungFu : public CSTLPoolAllocWrapperStatic<sizeof(T),L,A,T>
|
||||
//{
|
||||
//};
|
||||
|
||||
template <class T, class TCont>
|
||||
class CSTLPoolAllocWrapper
|
||||
{
|
||||
private:
|
||||
static TCont* m_pContainer;
|
||||
public:
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef T* pointer;
|
||||
typedef const T* const_pointer;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef T value_type;
|
||||
|
||||
static TCont* Container(){return m_pContainer; }
|
||||
static void Container(TCont* pContainer){m_pContainer = pContainer; }
|
||||
|
||||
|
||||
template <class U>
|
||||
struct rebind
|
||||
{
|
||||
typedef CSTLPoolAllocWrapper<T, TCont> other;
|
||||
};
|
||||
|
||||
CSTLPoolAllocWrapper() throw()
|
||||
{
|
||||
}
|
||||
|
||||
CSTLPoolAllocWrapper(const CSTLPoolAllocWrapper&) throw()
|
||||
{
|
||||
}
|
||||
|
||||
template <class TTemp, class TTempCont>
|
||||
CSTLPoolAllocWrapper(const CSTLPoolAllocWrapper<TTemp, TTempCont>&) throw()
|
||||
{
|
||||
}
|
||||
|
||||
~CSTLPoolAllocWrapper() throw()
|
||||
{
|
||||
}
|
||||
|
||||
pointer address(reference x) const
|
||||
{
|
||||
return &x;
|
||||
}
|
||||
|
||||
const_pointer address(const_reference x) const
|
||||
{
|
||||
return &x;
|
||||
}
|
||||
|
||||
pointer allocate(size_type n = 1, const_pointer hint = 0)
|
||||
{
|
||||
TCont* pContainer = Container();
|
||||
uint8* pData = pContainer->TCont::template Allocate<uint8*>(n * sizeof(T), sizeof(T));
|
||||
return pContainer->TCont::template Resolve<pointer>(pData);
|
||||
// return Container()?Container()->Allocate<void*>(n*sizeof(T),sizeof(T)):0
|
||||
}
|
||||
|
||||
void deallocate(pointer p, size_type n = 1)
|
||||
{
|
||||
if (Container())
|
||||
{
|
||||
Container()->Free(p);
|
||||
}
|
||||
}
|
||||
|
||||
size_type max_size() const throw()
|
||||
{
|
||||
return Container() ? Container()->MemSize() : 0;
|
||||
}
|
||||
|
||||
void construct(pointer p, const T& val)
|
||||
{
|
||||
new(static_cast<void*>(p))T(val);
|
||||
}
|
||||
|
||||
void construct(pointer p)
|
||||
{
|
||||
new(static_cast<void*>(p))T();
|
||||
}
|
||||
|
||||
void destroy(pointer p)
|
||||
{
|
||||
p->~T();
|
||||
}
|
||||
|
||||
pointer new_pointer()
|
||||
{
|
||||
return new(allocate())T();
|
||||
}
|
||||
|
||||
pointer new_pointer(const T& val)
|
||||
{
|
||||
return new(allocate())T(val);
|
||||
}
|
||||
|
||||
void delete_pointer(pointer p)
|
||||
{
|
||||
p->~T();
|
||||
deallocate(p);
|
||||
}
|
||||
|
||||
bool operator==(const CSTLPoolAllocWrapper&) {return true; }
|
||||
bool operator!=(const CSTLPoolAllocWrapper&) {return false; }
|
||||
};
|
||||
}
|
||||
|
||||
#endif // CRYINCLUDE_CRYPOOL_STLWRAPPER_H
|
||||
|
||||
@ -1,58 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_CRYPOOL_THREADSAFE_H
|
||||
#define CRYINCLUDE_CRYPOOL_THREADSAFE_H
|
||||
#pragma once
|
||||
|
||||
|
||||
#include <CryThread.h>
|
||||
|
||||
namespace NCryPoolAlloc
|
||||
{
|
||||
template<class TAllocator>
|
||||
class CThreadSafe
|
||||
: public TAllocator
|
||||
{
|
||||
CryCriticalSection m_Mutex;
|
||||
public:
|
||||
|
||||
template<class T>
|
||||
ILINE T Allocate(size_t Size, size_t Align = 1)
|
||||
{
|
||||
CryAutoLock<CryCriticalSection> lock(m_Mutex);
|
||||
return TAllocator::template Allocate<T>(Size, Align);
|
||||
}
|
||||
|
||||
|
||||
template<class T>
|
||||
ILINE bool Free(T pData, bool ForceBoundsCheck = false)
|
||||
{
|
||||
CryAutoLock<CryCriticalSection> lock(m_Mutex);
|
||||
return TAllocator::Free(pData, ForceBoundsCheck);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
ILINE bool Resize(T** pData, size_t Size, size_t Alignment)
|
||||
{
|
||||
CryAutoLock<CryCriticalSection> lock(m_Mutex);
|
||||
return TAllocator::Resize(pData, Size, Alignment);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_CRYPOOL_THREADSAFE_H
|
||||
|
||||
@ -1,287 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_CRYPOOL_EXAMPLE_H
|
||||
#define CRYINCLUDE_CRYPOOL_EXAMPLE_H
|
||||
#pragma once
|
||||
|
||||
|
||||
//The documentation is split up into 3 main parts, so strg+f for
|
||||
// -Theory
|
||||
// -Building blocks
|
||||
// -Usage
|
||||
// -FAQ
|
||||
// -Realloc/Resize
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// -Theory
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
//this includes the 3 major parts of the allocate suite
|
||||
//1. the memory location templates
|
||||
//2. container types
|
||||
//3. some allocator version
|
||||
//addtional you get
|
||||
//4. a simple stack based defragmentation template
|
||||
//5. helper
|
||||
|
||||
//1. memory location templates
|
||||
// There are two types of them, static and dynamic
|
||||
//1.1 CMemoryStatic<size> allows you do define on compile time what size
|
||||
// it should have, suitable for pool you know that they won't grow or
|
||||
// shrink
|
||||
//1.2 CMemoryDynamic, this one has no template parameter, it has just one
|
||||
// indirection via ptr to the memory location and size, that you will
|
||||
// set during initialization.
|
||||
|
||||
//2. Container types
|
||||
// We have also two container types, one so called "In Place"
|
||||
// and one "Referenced".
|
||||
//2.1 "In Place" means that a header is placed above every allocation,
|
||||
// this is the usual way most allocators work.
|
||||
//2.2 "Referenced", has an extra pool of headers that point to the actual
|
||||
// memory. This is suitable for
|
||||
// - external memory locations that are not directly accessable by the
|
||||
// cpu. E.g. pools on disk, networks, rsx memory..
|
||||
// - defragmentation, because you don't save a ptr to the real memory
|
||||
// location, just a "handle" of the referencing item.
|
||||
// - big alignments, having 4kb of alignment would waste also
|
||||
// - 4kb for ever "In Place" header, you might not want that.
|
||||
|
||||
//3. Allocators
|
||||
// This time we have 3 of them, "BestFit", "WorstFit" and "FirstFit"
|
||||
//3.1 FirstFit just seeks for any location big enought to fit your
|
||||
// requested size of memory. Internally it also saves the last used
|
||||
// free memory area to speed up allocations.
|
||||
// Use this also if you have just one particular allocation size.
|
||||
//3.2 WorstFit, although it might sound illogical, WorstFit can reduce
|
||||
// memory fragmentation in a cases with very random allocation sizes,
|
||||
// because it gives smaller free blocks the chance to concatenate to
|
||||
// bigger free blocks again while filling up those previously
|
||||
// generated big blocks. The bad side is that it takes quite some time
|
||||
// to find the biggest block as this needs to be done every time you
|
||||
// allocate, so use this just when having a low amount of allocations
|
||||
// or you're really desperately looking for mem.
|
||||
//3.3 BestFit, it's best used if you don't have just one allocation size,
|
||||
// but still very few varying sizes. Previously released blocks of
|
||||
// the currently allocating sizes will be seeked and reused, this
|
||||
// strongly helps to reduce fragmentation. While this might be slow
|
||||
// in some cases, it can save you from doing any defragmentation.
|
||||
|
||||
//4. Defragmentation
|
||||
// At the moment just one defragmentation algorithm is implemented:
|
||||
// "Stack defragmentator"
|
||||
// If you don't want some block to be moved, "Lock" it using your
|
||||
// memory handle.
|
||||
//4.1 Stack based
|
||||
// To reduce fragmentation, holes are filled up with the next used,
|
||||
// memory area. This defragmentation sheme is useful when you have
|
||||
// some long living locations as well as very short living ones.
|
||||
// At some point all long live memory will end up at the bottom of
|
||||
// the stack, while leaving empty memory areas at the top for short
|
||||
// living allocations.
|
||||
|
||||
//5. Helper
|
||||
// this should be filled up with some handy helper tools for this
|
||||
// pool suite.
|
||||
// The first tool is a wrapper for the usage with stl
|
||||
//5.1 Wrapper for STL
|
||||
// As you know, you can pass your own allocator as the last
|
||||
// parameter of stl containers, with this helper you can use a pool
|
||||
// created with this suite and wrap it for the stl.
|
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// -Building blocks
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//That's the theory, so how does it work?
|
||||
//It's pretty simple, you compose the pool of your dreams by cascading
|
||||
//templates.
|
||||
//Lets start with an exmaple
|
||||
//Per level you want to allocate a fixed amount of memory for your
|
||||
//textures.
|
||||
CMemoryDynamic
|
||||
//- They are placed in some memory you can access directly with the cpu:
|
||||
CInPlace
|
||||
//- and you don't want to defragmentate, so you prefer an allocation
|
||||
// sheme that reduces fragmentation.
|
||||
CBestFit
|
||||
//now you combine them
|
||||
typedef CBestFit<CInPlace<CMemoryDynamic>, CListItemInPlace> TMyOwnPool;
|
||||
|
||||
//Yes, it's that simple.
|
||||
//ok, ok, texture memory is usually nothing you want to access directly
|
||||
//with your cpu, so let's create a referencing pool. Therefor you need
|
||||
//to also specify how many nodes that can reference your pool will have.
|
||||
//We won't have more than 4000 textures, so let's start with
|
||||
{
|
||||
enum TEXTURE_NODE_COUNT = 4096
|
||||
};
|
||||
//and now our referencing pool
|
||||
typedef CBestFit < CReferenced<CMemoryDynamic, TEXTURE_NODE_COUNT> TMyOwnPool;
|
||||
|
||||
//But yeah, you're right, texture memory has also a fixed size, lets
|
||||
//assume it's 128MB.
|
||||
{
|
||||
enum TEXTURE_MEMORY_SIZE = 128 * 1024 * 1024
|
||||
};
|
||||
//and our fixed sized memory pool
|
||||
typedef CBestFit < CReferenced<CMemoryStatic<TEXTURE_MEMORY_SIZE>, TEXTURE_NODE_COUNT> TMyOwnPool;
|
||||
|
||||
//ok, but you don't trust the best fit allocator in all cases, you prefer
|
||||
//a fast one and you accept the slow down for defragmentation incase the
|
||||
//allocation fails.
|
||||
//So lets created a straight First Fit allocator with defragmentation:
|
||||
typedef CDefragStacked < CFirstFit<CReferenced<CMemoryStatic<TEXTURE_MEMORY_SIZE>, TEXTURE_NODE_COUNT> > TMyOwnPool;
|
||||
|
||||
//here you see how simple you can add defragmentation, but be careful, it
|
||||
//works of course just on Reference based memory containers, if you have
|
||||
//Direct pointers to In Place allocation, we cannot shuffle them around.
|
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// -Usage
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
//it all starts by including the meain header
|
||||
#include "PoolAlloc.h"
|
||||
|
||||
//Define your dream allocator, preferably using a typedef (or macro)
|
||||
typedef CBestFit<CInPlace<CMemoryDynamic>, CListItemInPlace> TMyOwnPool;
|
||||
//also typedef (or macro) your handle
|
||||
typedef uint8* TMyHandle; //in case of "In Place" allocations
|
||||
typedef uint32 TMyHandle; //in case of "Referenced"
|
||||
|
||||
//Instantiate it
|
||||
TMyOwnPool g_MyMemory;
|
||||
|
||||
//now you need to initialize it,
|
||||
g_MyMemory.InitMem(pMemoryArea, MemorySize); //in case you use "CMemoryDynamic"
|
||||
g_MyMemory.InitMem(); //in case you use "CmemoryStatic,
|
||||
//altough you could pass the same
|
||||
//parameters, they'd be ignored.
|
||||
//Use this also to flush the pool
|
||||
//quickly
|
||||
|
||||
|
||||
//now allocate
|
||||
TMyHandle MemID = g_MyMemory.Allocate<TMyHandle>(Size);
|
||||
//optionally alignment can be passed as 2nd parameter
|
||||
TMyHandle MemID = g_MyMemory.Allocate<TMyHandle>(Size, Align);
|
||||
|
||||
//free it simply by calling
|
||||
g_Memory.Free(MemID);
|
||||
|
||||
//you might want to call the beat function to defragment the memory
|
||||
//on regular base
|
||||
g_Memory.Beat();
|
||||
//you might also want to call it just when an allocation failed to
|
||||
//defragmentate the memory as good as possible
|
||||
if (!(MemID = g_Memoery.Allocate<TMyHandle>(Size)))
|
||||
{
|
||||
while (g_Memory.Beat())
|
||||
{
|
||||
;
|
||||
}
|
||||
MemID = g_Memoery.Allocate<TMyHandle>(Size);
|
||||
}
|
||||
|
||||
//To acquire the pointer to your data, you need to resolve the handle
|
||||
MyObject* pObject = g_Memory.Resolve<MyOBject*>(MemID);
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// -Realloc/Resize
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// The Containers provide a "resize" function. This one does nothing else
|
||||
// than the name suggest, it is freeing some memory at the end of your
|
||||
// allocation or, if free memory is available, allocates some memory to
|
||||
// the end of your buffer. But it may also fail, if not enough memory
|
||||
// available to allocate.
|
||||
// "Realloc" on the other side requires an extra template that you wrap
|
||||
// around your existing one like:
|
||||
typedef CReallocator<TMyOwnPool> TMyOwnPoolWithReallocation;
|
||||
// This one will first try to use resize, but in case it fails, it will
|
||||
// allocate a seperate memory area, copy the data and free the old one.
|
||||
//
|
||||
// But this may fail as well, therefor the result is not a pointer to the
|
||||
// allocation, but true/false.
|
||||
// There for you need to pass a pointer to your pointer to the memory area
|
||||
// or handle you deal with.
|
||||
Handle = rMemory.Allocate<TPtr>(10, 1);
|
||||
if (!rMemory.Reallocate<TPtr>(&Handles, 11, 1))
|
||||
{
|
||||
//handle realloc failure
|
||||
}
|
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
// -FAQ
|
||||
/////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//"DO I HAVE TO ALWAYS RESOLVE?"
|
||||
//if you use "In Place" memory, not at all, all resolve does is to
|
||||
//cast your handle to your object ptr and returns it.
|
||||
//if you use "Referenced" memory and you don't defragmentate, you
|
||||
//can do it once and keep the ptr, but you also need to keep the
|
||||
//handle to free the memory later on.
|
||||
|
||||
//"any reason I should resolve?"
|
||||
//Yes, first of all, it makes it very easy to switch between various
|
||||
//pool configuration for testing, you simply change some params of
|
||||
//your typedef (or macro) and it should work out of the box.
|
||||
//second, for defragmentation it's the only way to go and for future
|
||||
//things it might be needed as well
|
||||
|
||||
//"but isn't resolving just overhead?"
|
||||
//in case of "In Place": no, the resolve function just returns the
|
||||
//pointer, casting to your wanted type
|
||||
//in case of "Referenced": it cost you one indirection.
|
||||
|
||||
|
||||
//"How do I flush the whole pool without freeing all items?"
|
||||
g_Memory.InitMem()
|
||||
//yes, you can call "InitMem" once again, you need to pass the mem
|
||||
//ptr and size if using CMemoryDynamic e.g.
|
||||
g_Memory.Init(g_Memory.Size(), g_Memory.Data());
|
||||
|
||||
//"How do I lock the allocated memory to avoid any reallocation"
|
||||
g_Memory.Item(ptr)->Lock();
|
||||
|
||||
|
||||
//"How do I get the size of a memory block?"
|
||||
g_Memory.Item(ptr)->MemSize();
|
||||
|
||||
|
||||
|
||||
|
||||
//"Is there any example?"
|
||||
//for a real life example check PAUnitTest.cpp used to validate all
|
||||
//functions of this pool.
|
||||
|
||||
|
||||
//bug reports? questions? support?
|
||||
//just ask me :) (michael kopietz)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_CRYPOOL_EXAMPLE_H
|
||||
|
||||
@ -1,202 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_CRYCOMMON_GEOMCACHEFILEFORMAT_H
|
||||
#define CRYINCLUDE_CRYCOMMON_GEOMCACHEFILEFORMAT_H
|
||||
#pragma once
|
||||
|
||||
#include "CryExtension/CryGUID.h"
|
||||
|
||||
#if !defined(LINUX)
|
||||
#pragma pack(push)
|
||||
#pragma pack(1)
|
||||
#define PACK_GCC
|
||||
#else
|
||||
#define PACK_GCC __attribute__ ((packed))
|
||||
#endif
|
||||
|
||||
namespace GeomCacheFile
|
||||
{
|
||||
// Important: The enums are serialized, don't change the values
|
||||
// without increasing the file version, conversion code etc!
|
||||
|
||||
typedef Vec3_tpl<uint16> Position;
|
||||
typedef Vec2_tpl<int16> Texcoords;
|
||||
typedef Vec4_tpl<int16> QTangent;
|
||||
typedef uint8 Color;
|
||||
|
||||
// ASCII "CAXCACHE"
|
||||
const uint64 kFileSignature = 0x4548434143584143ull;
|
||||
|
||||
// The smallest 'UVmax' we'll support - this avoids division by zero when encoding/decoding UVs
|
||||
const float kMinUVrange = .01f;
|
||||
|
||||
// Bit Precision of tangents quaternions
|
||||
const uint kTangentQuatPrecision = 10;
|
||||
|
||||
// Current file version GUID. Files with other GUIDs will not be loaded by the engine.
|
||||
const CryGUID kCurrentVersion = MAKE_CRYGUID(0x1641defe440af501, 0x7ec5e9164c8c2d1c);
|
||||
|
||||
// Mesh prediction look back array size
|
||||
const uint kMeshPredictorLookBackMaxDist = 4096;
|
||||
|
||||
// Number of frames between index frames. Needs to be <= g_kMaxBufferedFrames.
|
||||
const uint kMaxIFrameDistance = 30;
|
||||
|
||||
enum EFileHeaderFlags
|
||||
{
|
||||
eFileHeaderFlags_PlaybackFromMemory = BIT(0),
|
||||
eFileHeaderFlags_32BitIndices = BIT(1)
|
||||
};
|
||||
|
||||
enum EBlockCompressionFormat
|
||||
{
|
||||
eBlockCompressionFormat_None = 0,
|
||||
eBlockCompressionFormat_Deflate = 1, // zlib
|
||||
eBlockCompressionFormat_LZ4HC = 2, // LZ4 HC
|
||||
eBlockCompressionFormat_ZSTD = 3, //ZStandard
|
||||
};
|
||||
|
||||
enum EStreams
|
||||
{
|
||||
eStream_Indices = BIT(0),
|
||||
eStream_Positions = BIT(1),
|
||||
eStream_Texcoords = BIT(2),
|
||||
eStream_QTangents = BIT(3),
|
||||
eStream_Colors = BIT(4)
|
||||
};
|
||||
|
||||
enum ETransformType
|
||||
{
|
||||
eTransformType_Constant,
|
||||
eTransformType_Animated
|
||||
};
|
||||
|
||||
enum ENodeType
|
||||
{
|
||||
eNodeType_Transform = 0, // Transforms all sub nodes
|
||||
eNodeType_Mesh = 1,
|
||||
eNodeType_PhysicsGeometry = 2,
|
||||
};
|
||||
|
||||
// Common frame
|
||||
enum EFrameType
|
||||
{
|
||||
eFrameType_IFrame = 0,
|
||||
eFrameType_BFrame = 1
|
||||
};
|
||||
|
||||
// Common frame flags
|
||||
enum EFrameFlags
|
||||
{
|
||||
eFrameFlags_Hidden = BIT(0)
|
||||
};
|
||||
|
||||
// Flags for mesh index frames
|
||||
enum EMeshIFrameFlags
|
||||
{
|
||||
eMeshIFrameFlags_UsePredictor = BIT(1)
|
||||
};
|
||||
|
||||
struct SHeader
|
||||
{
|
||||
SHeader()
|
||||
: m_signature(0)
|
||||
, m_version(kCurrentVersion)
|
||||
, m_blockCompressionFormat(0)
|
||||
, m_flags(0)
|
||||
, m_numFrames(0) {}
|
||||
|
||||
uint64 m_signature;
|
||||
CryGUID m_version;
|
||||
uint16 m_blockCompressionFormat;
|
||||
uint32 m_flags;
|
||||
uint32 m_numFrames;
|
||||
uint64 m_totalUncompressedAnimationSize;
|
||||
float m_aabbMin[3];
|
||||
float m_aabbMax[3];
|
||||
} PACK_GCC;
|
||||
|
||||
struct SFrameInfo
|
||||
{
|
||||
uint32 m_frameType;
|
||||
uint32 m_frameSize;
|
||||
uint64 m_frameOffset;
|
||||
float m_frameTime;
|
||||
} PACK_GCC;
|
||||
|
||||
struct SCompressedBlockHeader
|
||||
{
|
||||
uint32 m_uncompressedSize;
|
||||
uint32 m_compressedSize;
|
||||
} PACK_GCC;
|
||||
|
||||
struct SFrameHeader
|
||||
{
|
||||
uint32 m_nodeDataOffset;
|
||||
float m_frameAABBMin[3];
|
||||
float m_frameAABBMax[3];
|
||||
uint32 m_padding;
|
||||
} PACK_GCC;
|
||||
|
||||
struct STemporalPredictorControl
|
||||
{
|
||||
uint8 m_acceleration;
|
||||
uint8 m_indexFrameLerpFactor;
|
||||
uint8 m_combineFactor;
|
||||
uint8 m_padding;
|
||||
} PACK_GCC;
|
||||
|
||||
struct SMeshFrameHeader
|
||||
{
|
||||
uint32 m_flags;
|
||||
STemporalPredictorControl m_positionStreamPredictorControl;
|
||||
STemporalPredictorControl m_texcoordStreamPredictorControl;
|
||||
STemporalPredictorControl m_qTangentStreamPredictorControl;
|
||||
STemporalPredictorControl m_colorStreamPredictorControl[4];
|
||||
} PACK_GCC;
|
||||
|
||||
struct SMeshInfo
|
||||
{
|
||||
uint8 m_constantStreams;
|
||||
uint8 m_animatedStreams;
|
||||
uint8 m_positionPrecision[3];
|
||||
float m_uvMax;
|
||||
uint8 m_padding;
|
||||
uint16 m_numMaterials;
|
||||
uint32 m_numVertices;
|
||||
uint32 m_flags;
|
||||
float m_aabbMin[3];
|
||||
float m_aabbMax[3];
|
||||
uint32 m_nameLength;
|
||||
uint64 m_hash;
|
||||
} PACK_GCC;
|
||||
|
||||
struct SNodeInfo
|
||||
{
|
||||
uint8 m_type;
|
||||
uint8 m_bVisible;
|
||||
uint16 m_transformType;
|
||||
uint32 m_meshIndex;
|
||||
uint32 m_numChildren;
|
||||
uint32 m_nameLength;
|
||||
} PACK_GCC;
|
||||
}
|
||||
|
||||
#undef PACK_GCC
|
||||
|
||||
#if !defined(LINUX)
|
||||
#pragma pack(pop)
|
||||
#endif
|
||||
|
||||
#endif // CRYINCLUDE_CRYCOMMON_GEOMCACHEFILEFORMAT_H
|
||||
@ -1,286 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
// Description : Interface to the Mini GUI subsystem
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYCOMMON_ICRYMINIGUI_H
|
||||
#define CRYINCLUDE_CRYCOMMON_ICRYMINIGUI_H
|
||||
#pragma once
|
||||
|
||||
|
||||
#include <smartptr.h>
|
||||
#include <Cry_Color.h>
|
||||
#include <CryExtension/ICryUnknown.h>
|
||||
|
||||
namespace minigui
|
||||
{
|
||||
struct IMiniCtrl;
|
||||
|
||||
// Rectangle class
|
||||
struct Rect
|
||||
{
|
||||
float left;
|
||||
float top;
|
||||
float right;
|
||||
float bottom;
|
||||
|
||||
Rect()
|
||||
: left(0)
|
||||
, top(0)
|
||||
, right(0)
|
||||
, bottom(0) {}
|
||||
Rect(float l, float t, float r, float b)
|
||||
: left(l)
|
||||
, top(t)
|
||||
, right(r)
|
||||
, bottom(b) {}
|
||||
Rect(const Rect& rc) { left = rc.left; top = rc.top; right = rc.right; bottom = rc.bottom; }
|
||||
bool IsPointInside(float x, float y) const { return x >= left && x <= right && y >= top && y <= bottom; }
|
||||
float Width() const { return right - left; }
|
||||
float Height() const { return bottom - top; }
|
||||
};
|
||||
|
||||
typedef void(* ClickCallback)(void* data, bool onOff);
|
||||
typedef void(* RenderCallback)(float x, float y);
|
||||
|
||||
enum EMiniCtrlStatus
|
||||
{
|
||||
eCtrl_Hidden = BIT(0), // Control is hidden.
|
||||
eCtrl_Highlight = BIT(1), // Control is highlight (probably mouse over).
|
||||
eCtrl_Focus = BIT(2), // Control have focus (from keyboard).
|
||||
eCtrl_Checked = BIT(3), // Control have checked mark.
|
||||
eCtrl_NoBorder = BIT(4), // Control have no border.
|
||||
eCtrl_CheckButton = BIT(5), // Button control behave as a check button.
|
||||
eCtrl_TextAlignCentre = BIT(6), // Draw text aligned centre
|
||||
eCtrl_AutoResize = BIT(7), // Auto resize depending on text length
|
||||
eCtrl_Moveable = BIT(8), // Dynamically reposition ctrl
|
||||
eCtrl_CloseButton = BIT(9), // Control has close button
|
||||
};
|
||||
enum EMiniCtrlEvent
|
||||
{
|
||||
eCtrlEvent_LButtonDown = BIT(0),
|
||||
eCtrlEvent_LButtonUp = BIT(1),
|
||||
eCtrlEvent_LButtonPressed = BIT(2),
|
||||
eCtrlEvent_MouseOver = BIT(3),
|
||||
eCtrlEvent_MouseOff = BIT(4),
|
||||
eCtrlEvent_DPadLeft = BIT(5),
|
||||
eCtrlEvent_DPadRight = BIT(6),
|
||||
eCtrlEvent_DPadUp = BIT(7),
|
||||
eCtrlEvent_DPadDown = BIT(8),
|
||||
};
|
||||
|
||||
// Types of the supported controls
|
||||
enum EMiniCtrlType
|
||||
{
|
||||
eCtrlType_Unknown = 0,
|
||||
eCtrlType_Button,
|
||||
eCtrlType_Menu,
|
||||
eCtrlType_InfoBox,
|
||||
eCtrlType_Table,
|
||||
};
|
||||
|
||||
struct SMetrics
|
||||
{
|
||||
float fTextSize;
|
||||
float fTitleSize;
|
||||
|
||||
// Colors.
|
||||
ColorB clrFrameBorder;
|
||||
ColorB clrFrameBorderHighlight;
|
||||
ColorB clrFrameBorderOutOfFocus;
|
||||
ColorB clrChecked;
|
||||
ColorB clrBackground;
|
||||
ColorB clrBackgroundHighlight;
|
||||
ColorB clrBackgroundSelected;
|
||||
ColorB clrTitle;
|
||||
ColorB clrText;
|
||||
ColorB clrTextSelected;
|
||||
|
||||
uint8 outOfFocusAlpha;
|
||||
};
|
||||
|
||||
enum ECommand
|
||||
{
|
||||
eCommand_ButtonPress,
|
||||
eCommand_ButtonChecked,
|
||||
eCommand_ButtonUnchecked,
|
||||
};
|
||||
// Command sent from the control.
|
||||
struct SCommand
|
||||
{
|
||||
ECommand command;
|
||||
IMiniCtrl* pCtrl;
|
||||
int nCtrlID;
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// Event listener interface for the MiniGUI
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
struct IMiniGUIEventListener
|
||||
{
|
||||
// <interfuscator:shuffle>
|
||||
virtual ~IMiniGUIEventListener(){}
|
||||
virtual void OnCommand(SCommand& cmd) = 0;
|
||||
// </interfuscator:shuffle>
|
||||
};
|
||||
|
||||
// Interface to the GUI
|
||||
struct IMiniGUI
|
||||
: public ICryUnknown
|
||||
{
|
||||
public:
|
||||
CRYINTERFACE_DECLARE(IMiniGUI, 0xea09d34268814f2a, 0xaf1034e04b076011);
|
||||
|
||||
// <interfuscator:shuffle>
|
||||
virtual void Init() = 0;
|
||||
virtual void Done() = 0;
|
||||
virtual void Draw() = 0;
|
||||
virtual void Reset() = 0;
|
||||
|
||||
virtual void SaveState() = 0;
|
||||
virtual void RestoreState() = 0;
|
||||
|
||||
virtual void SetEnabled(bool status) = 0;
|
||||
virtual void SetInFocus(bool status) = 0;
|
||||
virtual bool InFocus() = 0;
|
||||
|
||||
virtual void SetEventListener(IMiniGUIEventListener* pListener) = 0;
|
||||
|
||||
virtual SMetrics& Metrics() = 0;
|
||||
|
||||
// Makes a new control
|
||||
virtual IMiniCtrl* CreateCtrl(IMiniCtrl* pParentCtrl, int nCtrlID, EMiniCtrlType type, int nCtrlFlags, const Rect& rc, const char* title) = 0;
|
||||
|
||||
// Remove all controls.
|
||||
virtual void RemoveAllCtrl() = 0;
|
||||
|
||||
virtual void OnCommand(SCommand& cmd) = 0;
|
||||
|
||||
virtual IMiniCtrl* GetCtrlFromPoint(float x, float y) const = 0;
|
||||
|
||||
virtual void SetMovingCtrl(IMiniCtrl* pCtrl) = 0;
|
||||
// </interfuscator:shuffle>
|
||||
};
|
||||
|
||||
DECLARE_SMART_POINTERS(IMiniGUI);
|
||||
|
||||
struct IMiniCtrl
|
||||
: public _reference_target_t
|
||||
{
|
||||
// <interfuscator:shuffle>
|
||||
virtual void Reset() = 0;
|
||||
|
||||
virtual void SaveState() = 0;
|
||||
virtual void RestoreState() = 0;
|
||||
|
||||
// For system call only.
|
||||
virtual void SetGUI(IMiniGUI* pGUI) = 0;
|
||||
virtual IMiniGUI* GetGUI() const = 0;
|
||||
|
||||
virtual EMiniCtrlType GetType() const = 0;
|
||||
|
||||
virtual int GetId() const = 0;
|
||||
virtual void SetId(int id) = 0;
|
||||
|
||||
virtual const char* GetTitle() const = 0;
|
||||
virtual void SetTitle(const char* title) = 0;
|
||||
|
||||
virtual Rect GetRect() const = 0;
|
||||
virtual void SetRect(const Rect& rc) = 0;
|
||||
|
||||
virtual void SetFlag(uint32 flag) = 0;
|
||||
virtual void ClearFlag(uint32 flag) = 0;
|
||||
virtual bool CheckFlag(uint32 flag) const = 0;
|
||||
|
||||
// Sub Controls handling.
|
||||
virtual void AddSubCtrl(IMiniCtrl* pCtrl) = 0;
|
||||
virtual void RemoveSubCtrl(IMiniCtrl* pCtrl) = 0;
|
||||
virtual void RemoveAllSubCtrl() = 0;
|
||||
virtual int GetSubCtrlCount() const = 0;
|
||||
virtual IMiniCtrl* GetSubCtrl(int nIndex) const = 0;
|
||||
virtual IMiniCtrl* GetParent() const = 0;
|
||||
|
||||
// Check if point is inside any of the sub controls.
|
||||
virtual IMiniCtrl* GetCtrlFromPoint(float x, float y) = 0;
|
||||
|
||||
virtual void OnPaint(class CDrawContext& dc) = 0;
|
||||
|
||||
virtual void SetVisible(bool state) = 0;
|
||||
|
||||
// Events from GUI
|
||||
virtual void OnEvent([[maybe_unused]] float x, [[maybe_unused]] float y, EMiniCtrlEvent) {};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// When set, this control will be enabling/disabling specified cvar
|
||||
// when button not checked fOffValue will be set on cvar, when checked fOnValue will be set.
|
||||
virtual bool SetControlCVar(const char* sCVarName, float fOffValue, float fOnValue) = 0;
|
||||
|
||||
virtual bool SetClickCallback(ClickCallback callback, void* pCallbackData) = 0;
|
||||
|
||||
virtual bool SetRenderCallback(RenderCallback callback) = 0;
|
||||
|
||||
virtual bool SetConnectedCtrl(IMiniCtrl* pConnectedCtrl) = 0;
|
||||
|
||||
//resize text box based what text is present
|
||||
virtual void AutoResize() = 0;
|
||||
|
||||
//Create close 'X' button for control
|
||||
virtual void CreateCloseButton() = 0;
|
||||
|
||||
//Move control
|
||||
virtual void Move(float x, float y) = 0;
|
||||
// </interfuscator:shuffle>
|
||||
};
|
||||
typedef _smart_ptr<IMiniCtrl> IMiniCtrlPtr;
|
||||
|
||||
class IMiniGuiCommon
|
||||
{
|
||||
public:
|
||||
// <interfuscator:shuffle>
|
||||
virtual ~IMiniGuiCommon(){}
|
||||
virtual bool IsHidden() = 0;
|
||||
virtual void Hide(bool stat) = 0;
|
||||
// </interfuscator:shuffle>
|
||||
};
|
||||
|
||||
class IMiniTable
|
||||
: public IMiniGuiCommon
|
||||
{
|
||||
public:
|
||||
// <interfuscator:shuffle>
|
||||
virtual int AddColumn(const char* name) = 0;
|
||||
virtual void RemoveColumns() = 0;
|
||||
virtual int AddData(int columnIndex, ColorB col, const char* format, ...) = 0;
|
||||
virtual void ClearTable() = 0;
|
||||
// </interfuscator:shuffle>
|
||||
};
|
||||
|
||||
class IMiniInfoBox
|
||||
: public IMiniGuiCommon
|
||||
{
|
||||
public:
|
||||
// <interfuscator:shuffle>
|
||||
virtual void SetTextIndent(float x) = 0;
|
||||
virtual void SetTextSize(float sz) = 0;
|
||||
virtual void ClearEntries() = 0;
|
||||
virtual void AddEntry(const char* str, ColorB col, float textSize) = 0;
|
||||
// </interfuscator:shuffle>
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
#define MINIGUI_BEGIN namespace minigui {
|
||||
#define MINIGUI_END }
|
||||
|
||||
#endif // CRYINCLUDE_CRYCOMMON_ICRYMINIGUI_H
|
||||
@ -1,95 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_CRYCOMMON_IDEFERREDCOLLISIONEVENT_H
|
||||
#define CRYINCLUDE_CRYCOMMON_IDEFERREDCOLLISIONEVENT_H
|
||||
#pragma once
|
||||
|
||||
|
||||
#include <IThreadTask.h>
|
||||
|
||||
struct EventPhys;
|
||||
|
||||
// Base class for all deferred physics events
|
||||
// Basically this class works like a future,
|
||||
// Start() start the computation(some in the main thread, major part in a task/job)
|
||||
// Result() will sync the task operation and return the result
|
||||
struct IDeferredPhysicsEvent
|
||||
: public IThreadTask
|
||||
{
|
||||
// enum list of all types of deferred events
|
||||
enum DeferredEventType
|
||||
{
|
||||
PhysCallBack_OnCollision
|
||||
};
|
||||
|
||||
IDeferredPhysicsEvent(){}
|
||||
// <interfuscator:shuffle>
|
||||
virtual ~IDeferredPhysicsEvent(){}
|
||||
|
||||
// == "future" like interface == //
|
||||
|
||||
// start the execution of the event
|
||||
virtual void Start() = 0;
|
||||
|
||||
// sync the event and do all necessary post-processing, then return the result
|
||||
virtual int Result(EventPhys* pOrigEvent = 0) = 0;
|
||||
|
||||
// just wait for the event to finish
|
||||
virtual void Sync() = 0;
|
||||
|
||||
// check if the async computation part has finished
|
||||
virtual bool HasFinished() = 0;
|
||||
|
||||
// Get the concrete Type of this deferred event
|
||||
virtual DeferredEventType GetType() const = 0;
|
||||
|
||||
// returns a ptr to the original physics event
|
||||
virtual EventPhys* PhysicsEvent() = 0;
|
||||
// </interfuscator:shuffle>
|
||||
};
|
||||
|
||||
|
||||
// Manager class for deferred physics events
|
||||
struct IDeferredPhysicsEventManager
|
||||
{
|
||||
// type of create function used to create needed deferred events in the HandleEvent function
|
||||
typedef IDeferredPhysicsEvent*(* CreateEventFunc)(const EventPhys* pEvent);
|
||||
|
||||
IDeferredPhysicsEventManager(){}
|
||||
// <interfuscator:shuffle>
|
||||
virtual ~IDeferredPhysicsEventManager(){}
|
||||
|
||||
// dispatch an deferred event to the task thread
|
||||
virtual void DispatchDeferredEvent(IDeferredPhysicsEvent* pEvent) = 0;
|
||||
|
||||
// Encapsulates common logic for deferred events, should be called from the physics callbacks
|
||||
// handles the cvar management as well as deferred event creating
|
||||
virtual int HandleEvent(const EventPhys* pEvent, IDeferredPhysicsEventManager::CreateEventFunc, IDeferredPhysicsEvent::DeferredEventType) = 0;
|
||||
|
||||
// Register and Unregister Deferred events in the manager to allow
|
||||
virtual void RegisterDeferredEvent(IDeferredPhysicsEvent* pDeferredEvent) = 0;
|
||||
virtual void UnRegisterDeferredEvent(IDeferredPhysicsEvent* pDeferredEvent) = 0;
|
||||
|
||||
// Delete all Deferred Events in flight, use only when also clearing the physics event queue
|
||||
// or else this call results in dangling points, mostly used for save/load
|
||||
virtual void ClearDeferredEvents() = 0;
|
||||
|
||||
virtual void Update() = 0;
|
||||
|
||||
virtual IDeferredPhysicsEvent* GetLastCollisionEventForEntity(IPhysicalEntity* pPhysEnt) = 0;
|
||||
// </interfuscator:shuffle>
|
||||
};
|
||||
|
||||
|
||||
#endif // CRYINCLUDE_CRYCOMMON_IDEFERREDCOLLISIONEVENT_H
|
||||
@ -1,155 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_CRYCOMMON_IDEFRAGALLOCATOR_H
|
||||
#define CRYINCLUDE_CRYCOMMON_IDEFRAGALLOCATOR_H
|
||||
#pragma once
|
||||
|
||||
|
||||
struct IDefragAllocatorStats
|
||||
{
|
||||
size_t nCapacity;
|
||||
size_t nInUseSize;
|
||||
uint32 nInUseBlocks;
|
||||
uint32 nFreeBlocks;
|
||||
uint32 nPinnedBlocks;
|
||||
uint32 nMovingBlocks;
|
||||
uint32 nLargestFreeBlockSize;
|
||||
uint32 nSmallestFreeBlockSize;
|
||||
uint32 nMeanFreeBlockSize;
|
||||
uint32 nCancelledMoveCount;
|
||||
};
|
||||
|
||||
struct IDefragAllocatorCopyNotification
|
||||
{
|
||||
IDefragAllocatorCopyNotification()
|
||||
: bDstIsValid(false)
|
||||
, bSrcIsUnneeded(false)
|
||||
, bCancel(false)
|
||||
{
|
||||
}
|
||||
|
||||
bool bDstIsValid;
|
||||
bool bSrcIsUnneeded;
|
||||
|
||||
// Flag to indicate that the copy can't be initiated after all - currently only cancelling before a relocate
|
||||
// is begun is supported, and the destination region must be stable
|
||||
bool bCancel;
|
||||
};
|
||||
|
||||
class IDefragAllocatorPolicy
|
||||
{
|
||||
public:
|
||||
enum
|
||||
{
|
||||
InvalidUserMoveId = 0xffffffff
|
||||
};
|
||||
|
||||
public:
|
||||
// <interfuscator:shuffle>
|
||||
virtual uint32 BeginCopy(void* pContext, UINT_PTR dstOffset, UINT_PTR srcOffset, UINT_PTR size, IDefragAllocatorCopyNotification* pNotification) = 0;
|
||||
virtual void Relocate(uint32 userMoveId, void* pContext, UINT_PTR newOffset, UINT_PTR oldOffset, UINT_PTR size) = 0;
|
||||
virtual void CancelCopy(uint32 userMoveId, void* pContext, bool bSync) = 0;
|
||||
|
||||
// Perform the copy and relocate immediately - will only be called when UnAppendSegment is
|
||||
virtual void SyncCopy(void* pContext, UINT_PTR dstOffset, UINT_PTR srcOffset, UINT_PTR size) = 0;
|
||||
// </interfuscator:shuffle>
|
||||
|
||||
protected:
|
||||
virtual ~IDefragAllocatorPolicy() {}
|
||||
};
|
||||
|
||||
class IDefragAllocator
|
||||
{
|
||||
public:
|
||||
typedef uint32 Hdl;
|
||||
enum
|
||||
{
|
||||
InvalidHdl = 0,
|
||||
};
|
||||
|
||||
struct AllocatePinnedResult
|
||||
{
|
||||
Hdl hdl;
|
||||
UINT_PTR offs;
|
||||
UINT_PTR usableSize;
|
||||
};
|
||||
|
||||
enum EBlockSearchKind
|
||||
{
|
||||
eBSK_BestFit,
|
||||
eBSK_FirstFit
|
||||
};
|
||||
|
||||
struct Policy
|
||||
{
|
||||
Policy()
|
||||
: pDefragPolicy(NULL)
|
||||
, maxAllocs(0)
|
||||
, maxSegments(1)
|
||||
, blockSearchKind(eBSK_BestFit)
|
||||
{
|
||||
}
|
||||
|
||||
IDefragAllocatorPolicy* pDefragPolicy;
|
||||
size_t maxAllocs;
|
||||
size_t maxSegments;
|
||||
EBlockSearchKind blockSearchKind;
|
||||
};
|
||||
|
||||
public:
|
||||
// <interfuscator:shuffle>
|
||||
virtual void Release(bool bDiscard = false) = 0;
|
||||
|
||||
virtual void Init(UINT_PTR capacity, UINT_PTR alignment, const Policy& policy = Policy()) = 0;
|
||||
|
||||
virtual bool AppendSegment(UINT_PTR capacity) = 0;
|
||||
virtual void UnAppendSegment() = 0;
|
||||
|
||||
virtual Hdl Allocate(size_t sz, const char* source, void* pContext = NULL) = 0;
|
||||
virtual Hdl AllocateAligned(size_t sz, size_t alignment, const char* source, void* pContext = NULL) = 0;
|
||||
virtual AllocatePinnedResult AllocatePinned(size_t sz, const char* source, void* pContext = NULL) = 0;
|
||||
virtual bool Free(Hdl hdl) = 0;
|
||||
|
||||
virtual void ChangeContext(Hdl hdl, void* pNewContext) = 0;
|
||||
|
||||
virtual size_t GetAllocated() const = 0;
|
||||
virtual IDefragAllocatorStats GetStats() = 0;
|
||||
|
||||
virtual void DisplayMemoryUsage(const char* title, unsigned int allocatorDisplayOffset = 0) = 0;
|
||||
|
||||
virtual size_t DefragmentTick(size_t maxMoves, size_t maxAmount, bool bForce = false) = 0;
|
||||
|
||||
virtual UINT_PTR UsableSize(Hdl hdl) = 0;
|
||||
|
||||
// Pin the chunk until the next defrag tick, when it will be automatically unpinned
|
||||
virtual UINT_PTR WeakPin(Hdl hdl) = 0;
|
||||
|
||||
// Pin the chunk until Unpin is called
|
||||
virtual UINT_PTR Pin(Hdl hdl) = 0;
|
||||
|
||||
virtual void Unpin(Hdl hdl) = 0;
|
||||
|
||||
virtual const char* GetSourceOf(Hdl hdl) = 0;
|
||||
// </interfuscator:shuffle>
|
||||
|
||||
#ifndef _RELEASE
|
||||
virtual void DumpState(const char* filename) = 0;
|
||||
virtual void RestoreState(const char* filename) = 0;
|
||||
#endif
|
||||
|
||||
protected:
|
||||
virtual ~IDefragAllocator() {}
|
||||
};
|
||||
|
||||
#endif // CRYINCLUDE_CRYCOMMON_IDEFRAGALLOCATOR_H
|
||||
@ -1,53 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
// Description : Defines the extension interface for the CryEngine modules.
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYCOMMON_IENGINEMODULE_H
|
||||
#define CRYINCLUDE_CRYCOMMON_IENGINEMODULE_H
|
||||
#pragma once
|
||||
|
||||
#include <CryExtension/ICryUnknown.h>
|
||||
#include <AzCore/Interface/Interface.h>
|
||||
#include <AzCore/Console/Console.h>
|
||||
#include <AzCore/Console/ConsoleFunctor.h>
|
||||
|
||||
struct SSystemInitParams;
|
||||
|
||||
// Base Interface for all engine module extensions
|
||||
struct IEngineModule
|
||||
: public ICryUnknown
|
||||
{
|
||||
CRYINTERFACE_DECLARE(IEngineModule, 0xf899cf661df04f61, 0xa341a8a7ffdf9de4);
|
||||
|
||||
// <interfuscator:shuffle>
|
||||
// Retrieve name of the extension module.
|
||||
virtual const char* GetName() const = 0;
|
||||
|
||||
// Retrieve category for the extension module (CryEngine for standard modules).
|
||||
virtual const char* GetCategory() const = 0;
|
||||
|
||||
// This is called to initialize the new module.
|
||||
virtual bool Initialize(SSystemGlobalEnvironment& env, const SSystemInitParams& initParams) = 0;
|
||||
// </interfuscator:shuffle>
|
||||
|
||||
// This is called to register any AZ console vars declared within this engine module
|
||||
virtual void RegisterConsoleVars()
|
||||
{
|
||||
AZ::ConsoleFunctorBase*& deferredHead = AZ::ConsoleFunctorBase::GetDeferredHead();
|
||||
AZ::Interface<AZ::IConsole>::Get()->LinkDeferredFunctors(deferredHead);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // CRYINCLUDE_CRYCOMMON_IENGINEMODULE_H
|
||||
@ -1,56 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
#ifndef CRYINCLUDE_CRYCOMMON_IFILECHANGEMONITOR_H
|
||||
#define CRYINCLUDE_CRYCOMMON_IFILECHANGEMONITOR_H
|
||||
#pragma once
|
||||
|
||||
struct IFileChangeListener
|
||||
{
|
||||
enum EChangeType
|
||||
{
|
||||
//! error or unknown change type
|
||||
eChangeType_Unknown,
|
||||
//! the file was created
|
||||
eChangeType_Created,
|
||||
//! the file was deleted
|
||||
eChangeType_Deleted,
|
||||
//! the file was modified (size changed,write)
|
||||
eChangeType_Modified,
|
||||
//! this is the old name of a renamed file
|
||||
eChangeType_RenamedOldName,
|
||||
//! this is the new name of a renamed file
|
||||
eChangeType_RenamedNewName
|
||||
};
|
||||
|
||||
virtual ~IFileChangeListener() = default;
|
||||
|
||||
virtual void OnFileChange(const char* sFilename, EChangeType eType) = 0;
|
||||
};
|
||||
|
||||
struct IFileChangeMonitor
|
||||
{
|
||||
virtual ~IFileChangeMonitor() = default;
|
||||
|
||||
// <interfuscator:shuffle>
|
||||
// Register the path of a file or directory to monitor
|
||||
// Path is relative to game directory, e.g. "Libs/WoundSystem/" or "Libs/WoundSystem/HitLocations.xml"
|
||||
virtual bool RegisterListener(IFileChangeListener* pListener, const char* sMonitorItem) = 0;
|
||||
// This function can be used to monitor files of specific type, e.g.
|
||||
// RegisterListener(pListener, "Animations", "caf")
|
||||
virtual bool RegisterListener(IFileChangeListener* pListener, const char* sFolder, const char* sExtension) = 0;
|
||||
virtual bool UnregisterListener(IFileChangeListener* pListener) = 0;
|
||||
// </interfuscator:shuffle>
|
||||
};
|
||||
|
||||
#endif // CRYINCLUDE_CRYCOMMON_IFILECHANGEMONITOR_H
|
||||
@ -1,47 +0,0 @@
|
||||
/*
|
||||
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
||||
* its licensors.
|
||||
*
|
||||
* For complete copyright and license terms please see the LICENSE at the root of this
|
||||
* distribution (the "License"). All use of this software is governed by the License,
|
||||
* or, if provided, by the license below or the license accompanying this file. Do not
|
||||
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
*
|
||||
*/
|
||||
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
||||
|
||||
// Description : IOverloadSceneManager interface declaration.
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYCOMMON_IOVERLOADSCENEMANAGER_H
|
||||
#define CRYINCLUDE_CRYCOMMON_IOVERLOADSCENEMANAGER_H
|
||||
#pragma once
|
||||
|
||||
//==================================================================================================
|
||||
// Name: COverloadSceneManager
|
||||
// Desc: Manages overload values (eg CPU,GPU etc)
|
||||
// 1.0="everything is ok" 0.0="very bad frame rate"
|
||||
// various systems can use this information and control what is currently in the scene
|
||||
// Author: James Chilvers
|
||||
//==================================================================================================
|
||||
struct IOverloadSceneManager
|
||||
{
|
||||
public:
|
||||
// <interfuscator:shuffle>
|
||||
virtual ~IOverloadSceneManager() {}
|
||||
|
||||
virtual void Reset() = 0;
|
||||
virtual void Update() = 0;
|
||||
|
||||
// Override auto-calculated scale to reach targetfps.
|
||||
// frameScale is clamped to internal min/max values,
|
||||
// dt is the length of time in seconds to transition
|
||||
virtual void OverrideScale(float frameScale, float dt) = 0;
|
||||
|
||||
// Go back to auto-calculated scale from an overridden scale
|
||||
virtual void ResetScale(float dt) = 0;
|
||||
// </interfuscator:shuffle>
|
||||
};//------------------------------------------------------------------------------------------------
|
||||
|
||||
#endif // CRYINCLUDE_CRYCOMMON_IOVERLOADSCENEMANAGER_H
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue