Merge branch 'main' into jckand/FoundationAuto
jckand-amzn
5 years ago
commit
7d8155e46b
@ -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,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)
|
||||
@ -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,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,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
|
||||
@ -1,145 +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 Performance HUD
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYCOMMON_IPERFHUD_H
|
||||
#define CRYINCLUDE_CRYCOMMON_IPERFHUD_H
|
||||
#pragma once
|
||||
|
||||
|
||||
#include <CryExtension/ICryUnknown.h>
|
||||
#include <CryExtension/Impl/ClassWeaver.h>
|
||||
#include <ICryMiniGUI.h>
|
||||
#include <IXml.h>
|
||||
|
||||
struct ICryPerfHUDWidget
|
||||
: public _reference_target_t
|
||||
{
|
||||
//
|
||||
enum EWidgetID
|
||||
{
|
||||
eWidget_Warnings = 0,
|
||||
eWidget_RenderStats,
|
||||
eWidget_StreamingStats,
|
||||
eWidget_RenderBatchStats,
|
||||
eWidget_FpsBuckets,
|
||||
eWidget_Particles,
|
||||
eWidget_PakFile,
|
||||
eWidget_Num, //number of widgets
|
||||
};
|
||||
|
||||
ICryPerfHUDWidget(int id = -1)
|
||||
: m_id(id)
|
||||
{}
|
||||
|
||||
// <interfuscator:shuffle>
|
||||
virtual ~ICryPerfHUDWidget() {}
|
||||
|
||||
virtual void Reset() = 0;
|
||||
virtual void Update() = 0;
|
||||
virtual bool ShouldUpdate() = 0;
|
||||
virtual void LoadBudgets(XmlNodeRef perfXML) = 0;
|
||||
virtual void SaveStats(XmlNodeRef statsXML) = 0;
|
||||
virtual void Enable(int mode) = 0;
|
||||
virtual void Disable() = 0;
|
||||
// </interfuscator:shuffle>
|
||||
|
||||
int m_id;
|
||||
};
|
||||
|
||||
// Base Interface for all engine module extensions
|
||||
struct ICryPerfHUD
|
||||
: public ICryUnknown
|
||||
{
|
||||
CRYINTERFACE_DECLARE(ICryPerfHUD, 0x268d142e043d464c, 0xa0776580f81b988a);
|
||||
|
||||
struct PerfBucket
|
||||
{
|
||||
ILINE PerfBucket(float _target)
|
||||
{
|
||||
target = _target;
|
||||
timeAtTarget = 0.f;
|
||||
}
|
||||
|
||||
float target;
|
||||
float timeAtTarget;
|
||||
};
|
||||
|
||||
enum EHudState
|
||||
{
|
||||
eHudOff = 0,
|
||||
eHudInFocus,
|
||||
eHudOutOfFocus,
|
||||
eHudNumStates,
|
||||
};
|
||||
|
||||
// <interfuscator:shuffle>
|
||||
// Called once to initialize HUD.
|
||||
virtual void Init() = 0;
|
||||
virtual void Done() = 0;
|
||||
virtual void Draw() = 0;
|
||||
virtual void LoadBudgets() = 0;
|
||||
virtual void SaveStats(const char* filename = NULL) = 0;
|
||||
virtual void ResetWidgets() = 0;
|
||||
virtual void SetState(EHudState state) = 0;
|
||||
virtual void Reset() = 0;
|
||||
virtual void Destroy() = 0;
|
||||
|
||||
// Retrieve name of the extension module.
|
||||
virtual void Show(bool bRestoreState) = 0;
|
||||
|
||||
virtual void AddWidget(ICryPerfHUDWidget* pWidget) = 0;
|
||||
virtual void RemoveWidget(ICryPerfHUDWidget* pWidget) = 0;
|
||||
|
||||
virtual minigui::IMiniCtrl* CreateMenu(const char* name, minigui::IMiniCtrl* pParent = NULL) = 0;
|
||||
virtual bool CreateCVarMenuItem(minigui::IMiniCtrl* pMenu, const char* name, const char* controlVar, float controlVarOn, float controlVarOff) = 0;
|
||||
virtual bool CreateCallbackMenuItem(minigui::IMiniCtrl* pMenu, const char* name, minigui::ClickCallback clickCallback, void* pCallbackData) = 0;
|
||||
virtual minigui::IMiniInfoBox* CreateInfoMenuItem(minigui::IMiniCtrl* pMenu, const char* name, minigui::RenderCallback renderCallback, const minigui::Rect& rect, bool onAtStart = false) = 0;
|
||||
virtual minigui::IMiniTable* CreateTableMenuItem(minigui::IMiniCtrl* pMenu, const char* name) = 0;
|
||||
|
||||
virtual minigui::IMiniCtrl* GetMenu(const char* name) = 0;
|
||||
|
||||
virtual void EnableWidget(ICryPerfHUDWidget::EWidgetID id, int mode) = 0;
|
||||
virtual void DisableWidget(ICryPerfHUDWidget::EWidgetID id) = 0;
|
||||
|
||||
//Warnings - Widget Specific interface
|
||||
virtual void AddWarning(float duration, const char* fmt, va_list argList) = 0;
|
||||
virtual bool WarningsWindowEnabled() const = 0;
|
||||
|
||||
//FPS - Widget Specific interface
|
||||
virtual const std::vector<PerfBucket>* GetFpsBuckets(float& totalTime) const = 0;
|
||||
// </interfuscator:shuffle>
|
||||
};
|
||||
|
||||
DECLARE_SMART_POINTERS(ICryPerfHUD);
|
||||
|
||||
void CryPerfHUDWarning(float duration, const char*, ...) PRINTF_PARAMS(2, 3);
|
||||
inline void CryPerfHUDWarning(float duration, const char* format, ...)
|
||||
{
|
||||
if (gEnv && gEnv->pSystem)
|
||||
{
|
||||
ICryPerfHUD* pPerfHud = gEnv->pSystem->GetPerfHUD();
|
||||
|
||||
if (pPerfHud)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
pPerfHud->AddWarning(duration, format, args);
|
||||
va_end(args);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif // CRYINCLUDE_CRYCOMMON_IPERFHUD_H
|
||||
@ -1,373 +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.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <AzCore/Serialization/SerializeContext.h>
|
||||
#include <AzCore/Serialization/EditContext.h>
|
||||
#include <AzFramework/API/ApplicationAPI.h>
|
||||
|
||||
#include "LoadScreenComponent.h"
|
||||
#include <IConsole.h>
|
||||
|
||||
#if AZ_LOADSCREENCOMPONENT_ENABLED
|
||||
|
||||
namespace
|
||||
{
|
||||
// Due to issues with DLLs sometimes there can be different values of gEnv in different DLLs.
|
||||
// So we use this preferred method of getting the global environment
|
||||
SSystemGlobalEnvironment* GetGlobalEnv()
|
||||
{
|
||||
if (!GetISystem())
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return GetISystem()->GetGlobalEnvironment();
|
||||
}
|
||||
|
||||
static const char* const s_gameFixedFpsCvarName = "game_load_screen_sequence_fixed_fps";
|
||||
static const char* const s_gameMaxFpsCvarName = "game_load_screen_max_fps";
|
||||
static const char* const s_gameMinimumLoadTimeCvarName = "game_load_screen_minimum_time";
|
||||
|
||||
static const char* const s_levelFixedFpsCvarName = "level_load_screen_sequence_fixed_fps";
|
||||
static const char* const s_levelMaxFpsCvarName = "level_load_screen_max_fps";
|
||||
static const char* const s_levelMinimumLoadTimeCvarName = "level_load_screen_minimum_time";
|
||||
}
|
||||
|
||||
void LoadScreenComponent::Reflect(AZ::ReflectContext* context)
|
||||
{
|
||||
AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context);
|
||||
|
||||
if (serializeContext)
|
||||
{
|
||||
serializeContext->Class<LoadScreenComponent, AZ::Component>()
|
||||
->Version(1)
|
||||
;
|
||||
|
||||
AZ::EditContext* editContext = serializeContext->GetEditContext();
|
||||
if (editContext)
|
||||
{
|
||||
editContext->Class<LoadScreenComponent>(
|
||||
"Load screen manager", "Allows management of a load screen")
|
||||
->ClassElement(AZ::Edit::ClassElements::EditorData, "")
|
||||
->Attribute(AZ::Edit::Attributes::Category, "Game")
|
||||
->Attribute(AZ::Edit::Attributes::AppearsInAddComponentMenu, AZ_CRC("System", 0xc94d118b))
|
||||
;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void LoadScreenComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
|
||||
{
|
||||
provided.push_back(AZ_CRC("LoadScreenService", 0x901b031c));
|
||||
}
|
||||
|
||||
void LoadScreenComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
|
||||
{
|
||||
incompatible.push_back(AZ_CRC("LoadScreenService", 0x901b031c));
|
||||
}
|
||||
|
||||
void LoadScreenComponent::Reset()
|
||||
{
|
||||
m_loadScreenState = LoadScreenState::None;
|
||||
|
||||
m_fixedDeltaTimeInSeconds = -1.0f;
|
||||
m_maxDeltaTimeInSeconds = -1.0f;
|
||||
m_previousCallTimeForUpdateAndRender = CTimeValue();
|
||||
m_processingLoadScreen.store(false);
|
||||
|
||||
// Reset CVars so they're not carried over to other levels
|
||||
SSystemGlobalEnvironment* pGEnv = GetGlobalEnv();
|
||||
if (pGEnv && pGEnv->pConsole)
|
||||
{
|
||||
if (ICVar* var = pGEnv->pConsole->GetCVar(s_levelFixedFpsCvarName))
|
||||
{
|
||||
var->Set("");
|
||||
}
|
||||
if (ICVar* var = pGEnv->pConsole->GetCVar(s_levelMaxFpsCvarName))
|
||||
{
|
||||
var->Set("");
|
||||
}
|
||||
if (ICVar* var = pGEnv->pConsole->GetCVar(s_levelMinimumLoadTimeCvarName))
|
||||
{
|
||||
var->Set("");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void LoadScreenComponent::LoadConfigSettings(const char* fixedFpsVarName, const char* maxFpsVarName, const char* minimumLoadTimeVarName)
|
||||
{
|
||||
m_fixedDeltaTimeInSeconds = -1.0f;
|
||||
m_maxDeltaTimeInSeconds = -1.0f;
|
||||
m_minimumLoadTimeInSeconds = 0.0f;
|
||||
|
||||
SSystemGlobalEnvironment* pGEnv = GetGlobalEnv();
|
||||
if (pGEnv && pGEnv->pConsole)
|
||||
{
|
||||
ICVar* fixedFpsVar = pGEnv->pConsole->GetCVar(fixedFpsVarName);
|
||||
if (fixedFpsVar && fixedFpsVar->GetFVal() > 0.0f)
|
||||
{
|
||||
m_fixedDeltaTimeInSeconds = (1.0f / fixedFpsVar->GetFVal());
|
||||
}
|
||||
|
||||
ICVar* maxFpsVar = pGEnv->pConsole->GetCVar(maxFpsVarName);
|
||||
if (maxFpsVar && maxFpsVar->GetFVal() > 0.0f)
|
||||
{
|
||||
m_maxDeltaTimeInSeconds = (1.0f / maxFpsVar->GetFVal());
|
||||
}
|
||||
|
||||
if (ICVar* minimumLoadTimeVar = pGEnv->pConsole->GetCVar(minimumLoadTimeVarName))
|
||||
{
|
||||
// Never allow values below 0 seconds
|
||||
m_minimumLoadTimeInSeconds = AZStd::max<float>(minimumLoadTimeVar->GetFVal(), 0.0f);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void LoadScreenComponent::Init()
|
||||
{
|
||||
Reset();
|
||||
}
|
||||
|
||||
void LoadScreenComponent::Activate()
|
||||
{
|
||||
CrySystemEventBus::Handler::BusConnect();
|
||||
LoadScreenBus::Handler::BusConnect(GetEntityId());
|
||||
}
|
||||
|
||||
void LoadScreenComponent::Deactivate()
|
||||
{
|
||||
CrySystemEventBus::Handler::BusDisconnect();
|
||||
LoadScreenBus::Handler::BusDisconnect(GetEntityId());
|
||||
}
|
||||
|
||||
void LoadScreenComponent::OnCrySystemInitialized(ISystem& system, const SSystemInitParams&)
|
||||
{
|
||||
SSystemGlobalEnvironment* pGEnv = system.GetGlobalEnvironment();
|
||||
|
||||
// Can't use macros here because we have to use our pointer.
|
||||
if (pGEnv && pGEnv->pConsole)
|
||||
{
|
||||
pGEnv->pConsole->Register("ly_EnableLoadingThread", &m_loadingThreadEnabled, 0, VF_NULL,
|
||||
"EXPERIMENTAL. Enable fully threaded loading where the LoadingScreen is drawn on a thread that isn't loading data.");
|
||||
}
|
||||
|
||||
if (pGEnv && !pGEnv->IsEditor())
|
||||
{
|
||||
// If not running from the editor, then run GameStart
|
||||
GameStart();
|
||||
}
|
||||
}
|
||||
|
||||
void LoadScreenComponent::OnCrySystemShutdown(ISystem&)
|
||||
{
|
||||
}
|
||||
|
||||
void LoadScreenComponent::UpdateAndRender()
|
||||
{
|
||||
SSystemGlobalEnvironment* pGEnv = GetGlobalEnv();
|
||||
|
||||
if (m_loadScreenState == LoadScreenState::Showing && pGEnv && pGEnv->pTimer)
|
||||
{
|
||||
AZ_Assert(GetCurrentThreadId() == pGEnv->mMainThreadId, "UpdateAndRender should only be called from the main thread");
|
||||
|
||||
// Throttling.
|
||||
if (!m_previousCallTimeForUpdateAndRender.GetValue())
|
||||
{
|
||||
// This is the first call to UpdateAndRender().
|
||||
m_previousCallTimeForUpdateAndRender = pGEnv->pTimer->GetAsyncTime();
|
||||
}
|
||||
|
||||
const CTimeValue callTimeForUpdateAndRender = pGEnv->pTimer->GetAsyncTime();
|
||||
const float deltaTimeInSeconds = fabs((callTimeForUpdateAndRender - m_previousCallTimeForUpdateAndRender).GetSeconds());
|
||||
|
||||
// Early-out: We DON'T need to execute UpdateAndRender() at a higher frequency than 30 FPS.
|
||||
const bool shouldThrottle = m_maxDeltaTimeInSeconds > 0.0f && deltaTimeInSeconds < m_maxDeltaTimeInSeconds;
|
||||
|
||||
if (!shouldThrottle)
|
||||
{
|
||||
bool expectedValue = false;
|
||||
if (m_processingLoadScreen.compare_exchange_strong(expectedValue, true))
|
||||
{
|
||||
m_previousCallTimeForUpdateAndRender = callTimeForUpdateAndRender;
|
||||
|
||||
const float updateDeltaTime = (m_fixedDeltaTimeInSeconds == -1.0f) ? deltaTimeInSeconds : m_fixedDeltaTimeInSeconds;
|
||||
|
||||
EBUS_EVENT(LoadScreenUpdateNotificationBus, UpdateAndRender, updateDeltaTime);
|
||||
|
||||
// Some platforms (iOS, OSX) require system events to be pumped in order to update the screen
|
||||
AzFramework::ApplicationRequests::Bus::Broadcast(&AzFramework::ApplicationRequests::PumpSystemEventLoopUntilEmpty);
|
||||
|
||||
m_processingLoadScreen.store(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void LoadScreenComponent::GameStart()
|
||||
{
|
||||
if (m_loadScreenState == LoadScreenState::None)
|
||||
{
|
||||
LoadConfigSettings(s_gameFixedFpsCvarName, s_gameMaxFpsCvarName, s_gameMinimumLoadTimeCvarName);
|
||||
|
||||
const bool usingLoadingThread = IsLoadingThreadEnabled();
|
||||
|
||||
AZ::EBusLogicalResult<bool, AZStd::logical_or<bool>> anyHandled(false);
|
||||
EBUS_EVENT_RESULT(anyHandled, LoadScreenNotificationBus, NotifyGameLoadStart, usingLoadingThread);
|
||||
|
||||
if (anyHandled.value)
|
||||
{
|
||||
if (usingLoadingThread)
|
||||
{
|
||||
m_loadScreenState = LoadScreenState::ShowingMultiThreaded;
|
||||
|
||||
GetGlobalEnv()->pRenderer->StartLoadtimePlayback(this);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_loadScreenState = LoadScreenState::Showing;
|
||||
|
||||
// Kick-start the first frame.
|
||||
UpdateAndRender();
|
||||
}
|
||||
|
||||
if (ITimer* timer = GetGlobalEnv()->pTimer)
|
||||
{
|
||||
m_lastStartTime = timer->GetAsyncTime();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void LoadScreenComponent::LevelStart()
|
||||
{
|
||||
if (m_loadScreenState == LoadScreenState::None)
|
||||
{
|
||||
LoadConfigSettings(s_levelFixedFpsCvarName, s_levelMaxFpsCvarName, s_levelMinimumLoadTimeCvarName);
|
||||
|
||||
const bool usingLoadingThread = IsLoadingThreadEnabled();
|
||||
|
||||
AZ::EBusLogicalResult<bool, AZStd::logical_or<bool>> anyHandled(false);
|
||||
EBUS_EVENT_RESULT(anyHandled, LoadScreenNotificationBus, NotifyLevelLoadStart, usingLoadingThread);
|
||||
|
||||
if (anyHandled.value)
|
||||
{
|
||||
if (usingLoadingThread)
|
||||
{
|
||||
m_loadScreenState = LoadScreenState::ShowingMultiThreaded;
|
||||
|
||||
GetGlobalEnv()->pRenderer->StartLoadtimePlayback(this);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_loadScreenState = LoadScreenState::Showing;
|
||||
|
||||
// Kick-start the first frame.
|
||||
UpdateAndRender();
|
||||
}
|
||||
|
||||
if (ITimer* timer = GetGlobalEnv()->pTimer)
|
||||
{
|
||||
m_lastStartTime = timer->GetAsyncTime();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void LoadScreenComponent::Pause()
|
||||
{
|
||||
if (m_loadScreenState == LoadScreenState::Showing)
|
||||
{
|
||||
m_loadScreenState = LoadScreenState::Paused;
|
||||
}
|
||||
else if (m_loadScreenState == LoadScreenState::ShowingMultiThreaded)
|
||||
{
|
||||
m_loadScreenState = LoadScreenState::PausedMultithreaded;
|
||||
}
|
||||
}
|
||||
|
||||
void LoadScreenComponent::Resume()
|
||||
{
|
||||
if (m_loadScreenState == LoadScreenState::Paused)
|
||||
{
|
||||
m_loadScreenState = LoadScreenState::Showing;
|
||||
}
|
||||
else if (m_loadScreenState == LoadScreenState::PausedMultithreaded)
|
||||
{
|
||||
m_loadScreenState = LoadScreenState::ShowingMultiThreaded;
|
||||
}
|
||||
}
|
||||
|
||||
void LoadScreenComponent::Stop()
|
||||
{
|
||||
// If we were actually in a load screen, check if we need to wait longer.
|
||||
if (m_loadScreenState != LoadScreenState::None && m_minimumLoadTimeInSeconds > 0.0f)
|
||||
{
|
||||
if (ITimer* timer = GetGlobalEnv()->pTimer)
|
||||
{
|
||||
CTimeValue currentTime = timer->GetAsyncTime();
|
||||
float timeSinceStart = currentTime.GetDifferenceInSeconds(m_lastStartTime);
|
||||
|
||||
while (timeSinceStart < m_minimumLoadTimeInSeconds)
|
||||
{
|
||||
// Simple loop that makes sure the loading screens update but also doesn't consume the whole core.
|
||||
|
||||
if (m_loadScreenState == LoadScreenState::Showing)
|
||||
{
|
||||
EBUS_EVENT(LoadScreenBus, UpdateAndRender);
|
||||
}
|
||||
|
||||
CrySleep(0);
|
||||
|
||||
currentTime = timer->GetAsyncTime();
|
||||
timeSinceStart = currentTime.GetDifferenceInSeconds(m_lastStartTime);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (m_loadScreenState == LoadScreenState::ShowingMultiThreaded)
|
||||
{
|
||||
// This will block until the other thread completes.
|
||||
GetGlobalEnv()->pRenderer->StopLoadtimePlayback();
|
||||
}
|
||||
|
||||
if (m_loadScreenState != LoadScreenState::None)
|
||||
{
|
||||
EBUS_EVENT(LoadScreenNotificationBus, NotifyLoadEnd);
|
||||
}
|
||||
|
||||
Reset();
|
||||
|
||||
m_loadScreenState = LoadScreenState::None;
|
||||
}
|
||||
|
||||
bool LoadScreenComponent::IsPlaying()
|
||||
{
|
||||
return m_loadScreenState != LoadScreenState::None;
|
||||
}
|
||||
|
||||
void LoadScreenComponent::LoadtimeUpdate(float deltaTime)
|
||||
{
|
||||
if (m_loadScreenState == LoadScreenState::ShowingMultiThreaded)
|
||||
{
|
||||
EBUS_EVENT(LoadScreenUpdateNotificationBus, LoadThreadUpdate, deltaTime);
|
||||
}
|
||||
}
|
||||
|
||||
void LoadScreenComponent::LoadtimeRender()
|
||||
{
|
||||
if (m_loadScreenState == LoadScreenState::ShowingMultiThreaded)
|
||||
{
|
||||
EBUS_EVENT(LoadScreenUpdateNotificationBus, LoadThreadRender);
|
||||
}
|
||||
}
|
||||
|
||||
#endif // if AZ_LOADSCREENCOMPONENT_ENABLED
|
||||
@ -1,106 +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.
|
||||
*
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#include <AzCore/Component/Component.h>
|
||||
#include <AzCore/Component/EntityId.h>
|
||||
#include <AzCore/std/parallel/atomic.h>
|
||||
|
||||
#include <CrySystemBus.h>
|
||||
#include <LoadScreenBus.h>
|
||||
#include <IRenderer.h>
|
||||
|
||||
#if AZ_LOADSCREENCOMPONENT_ENABLED
|
||||
|
||||
/*
|
||||
* This component is responsible for managing the load screen.
|
||||
*/
|
||||
class LoadScreenComponent
|
||||
: public AZ::Component
|
||||
, public CrySystemEventBus::Handler
|
||||
, public LoadScreenBus::Handler
|
||||
, public ILoadtimeCallback
|
||||
{
|
||||
public:
|
||||
AZ_COMPONENT(LoadScreenComponent, "{97CDBD6C-C621-4427-87C8-10E1B8F947FF}");
|
||||
|
||||
LoadScreenComponent() = default;
|
||||
~LoadScreenComponent() = default;
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// AZ::Component interface implementation
|
||||
void Init() override;
|
||||
void Activate() override;
|
||||
void Deactivate() override;
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
// CrySystemEvents
|
||||
void OnCrySystemInitialized(ISystem&, const SSystemInitParams& params) override;
|
||||
void OnCrySystemShutdown(ISystem&) override;
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// LoadScreenBus interface implementation
|
||||
void UpdateAndRender() override;
|
||||
void GameStart() override;
|
||||
void LevelStart() override;
|
||||
void Pause() override;
|
||||
void Resume() override;
|
||||
void Stop() override;
|
||||
bool IsPlaying() override;
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// ILoadtimeCallback interface implementation
|
||||
void LoadtimeUpdate(float deltaTime) override;
|
||||
void LoadtimeRender() override;
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
inline bool IsLoadingThreadEnabled() const
|
||||
{
|
||||
return m_loadingThreadEnabled != 0;
|
||||
}
|
||||
|
||||
protected:
|
||||
static void Reflect(AZ::ReflectContext* context);
|
||||
static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided);
|
||||
static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible);
|
||||
|
||||
private:
|
||||
void Reset();
|
||||
void LoadConfigSettings(const char* fixedFpsVarName, const char* maxFpsVarName, const char* minimumLoadTimeVarName);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
enum class LoadScreenState
|
||||
{
|
||||
None,
|
||||
Showing,
|
||||
ShowingMultiThreaded,
|
||||
Paused,
|
||||
PausedMultithreaded,
|
||||
};
|
||||
LoadScreenState m_loadScreenState{ LoadScreenState::None };
|
||||
|
||||
float m_fixedDeltaTimeInSeconds{ -1.0f };
|
||||
float m_maxDeltaTimeInSeconds{ -1.0f };
|
||||
float m_minimumLoadTimeInSeconds{ 0.0f };
|
||||
|
||||
CTimeValue m_lastStartTime;
|
||||
CTimeValue m_previousCallTimeForUpdateAndRender;
|
||||
AZStd::atomic_bool m_processingLoadScreen{ false };
|
||||
|
||||
int32_t m_loadingThreadEnabled{ 0 };
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
};
|
||||
|
||||
#endif // if AZ_LOADSCREENCOMPONENT_ENABLED
|
||||
@ -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 CRYINCLUDE_CRYCOMMON_RENDELEMENT_H
|
||||
#define CRYINCLUDE_CRYCOMMON_RENDELEMENT_H
|
||||
#pragma once
|
||||
|
||||
|
||||
//=============================================================
|
||||
|
||||
#include "VertexFormats.h"
|
||||
|
||||
class CRendElementBase;
|
||||
struct CRenderChunk;
|
||||
struct PrimitiveGroup;
|
||||
class CShader;
|
||||
struct SShaderTechnique;
|
||||
class CParserBin;
|
||||
struct SParserFrame;
|
||||
|
||||
namespace AZ
|
||||
{
|
||||
namespace Vertex
|
||||
{
|
||||
class Format;
|
||||
}
|
||||
}
|
||||
|
||||
enum EDataType
|
||||
{
|
||||
eDATA_Unknown = 0,
|
||||
eDATA_Sky,
|
||||
eDATA_Beam,
|
||||
eDATA_ClientPoly,
|
||||
eDATA_Flare,
|
||||
eDATA_Terrain,
|
||||
eDATA_SkyZone,
|
||||
eDATA_Mesh,
|
||||
eDATA_Imposter,
|
||||
eDATA_LensOptics,
|
||||
eDATA_FarTreeSprites_Deprecated,
|
||||
eDATA_OcclusionQuery,
|
||||
eDATA_Particle,
|
||||
eDATA_GPUParticle,
|
||||
eDATA_PostProcess,
|
||||
eDATA_HDRProcess,
|
||||
eDATA_Cloud,
|
||||
eDATA_HDRSky,
|
||||
eDATA_FogVolume,
|
||||
eDATA_WaterVolume,
|
||||
eDATA_WaterOcean,
|
||||
eDATA_VolumeObject,
|
||||
eDATA_PrismObject, // normally this would be #if !defined(EXCLUDE_DOCUMENTATION_PURPOSE) but we keep it to get consistent numbers for serialization
|
||||
eDATA_DeferredShading,
|
||||
eDATA_GameEffect,
|
||||
eDATA_BreakableGlass,
|
||||
eDATA_GeomCache,
|
||||
eDATA_Gem,
|
||||
};
|
||||
|
||||
#include <Cry_Color.h>
|
||||
|
||||
//=======================================================
|
||||
|
||||
#define FCEF_TRANSFORM 1
|
||||
#define FCEF_DIRTY 2
|
||||
#define FCEF_NODEL 4
|
||||
#define FCEF_DELETED 8
|
||||
|
||||
#define FCEF_MODIF_TC 0x10
|
||||
#define FCEF_MODIF_VERT 0x20
|
||||
#define FCEF_MODIF_COL 0x40
|
||||
#define FCEF_MODIF_MASK 0xf0
|
||||
|
||||
#define FCEF_UPDATEALWAYS 0x100
|
||||
#define FCEF_ALLOC_CUST_FLOAT_DATA 0x200
|
||||
#define FCEF_MERGABLE 0x400
|
||||
|
||||
#define FCEF_SKINNED 0x800
|
||||
#define FCEF_PRE_DRAW_DONE 0x1000
|
||||
|
||||
#define FGP_NOCALC 1
|
||||
#define FGP_SRC 2
|
||||
#define FGP_REAL 4
|
||||
#define FGP_WAIT 8
|
||||
|
||||
#define FGP_STAGE_SHIFT 0x10
|
||||
|
||||
#define MAX_CUSTOM_TEX_BINDS_NUM 2
|
||||
|
||||
struct SGeometryInfo;
|
||||
class CRendElement;
|
||||
|
||||
struct IRenderElementDelegate
|
||||
{
|
||||
virtual void mfPrepare(bool bCheckOverflow) = 0;
|
||||
virtual bool mfDraw(CShader* shader, SShaderPass* pass) = 0;
|
||||
virtual bool mfSetSampler([[maybe_unused]] int customId, [[maybe_unused]] int nTUnit, [[maybe_unused]] int nTState, [[maybe_unused]] int nTexMaterialSlot, [[maybe_unused]] int nSUnit) { return true; };
|
||||
};
|
||||
|
||||
struct IRenderElement
|
||||
{
|
||||
virtual int mfGetMatId() = 0;
|
||||
virtual uint16 mfGetFlags() = 0;
|
||||
virtual void mfSetFlags(uint16 fl) = 0;
|
||||
virtual void mfUpdateFlags(uint16 fl) = 0;
|
||||
virtual void mfClearFlags(uint16 fl) = 0;
|
||||
virtual void mfPrepare(bool bCheckOverflow) = 0;
|
||||
virtual void mfCenter(Vec3& centr, CRenderObject* pObj) = 0;
|
||||
virtual void mfGetBBox(Vec3& vMins, Vec3& vMaxs) = 0;
|
||||
virtual void mfReset() = 0;
|
||||
virtual void mfGetPlane(Plane_tpl<f32>& pl) = 0;
|
||||
virtual void mfExport(struct SShaderSerializeContext& SC) = 0;
|
||||
virtual void mfImport(struct SShaderSerializeContext& SC, uint32& offset) = 0;
|
||||
virtual void mfPrecache(const SShaderItem& SH) = 0;
|
||||
virtual bool mfIsHWSkinned() = 0;
|
||||
virtual bool mfCheckUpdate(int Flags, uint16 nFrame, bool bTessellation = false) = 0;
|
||||
virtual bool mfUpdate(int Flags, bool bTessellation = false) = 0;
|
||||
virtual bool mfCompile(CParserBin& Parser, SParserFrame& Frame) = 0;
|
||||
virtual bool mfDraw(CShader* ef, SShaderPass* sfm) = 0;
|
||||
virtual bool mfPreDraw(SShaderPass* sl) = 0;
|
||||
virtual bool mfSetSampler(int customId, int nTUnit, int nTState, int nTexMaterialSlot, int nSUnit) = 0;
|
||||
virtual void mfSetDelegate(IRenderElementDelegate* pDelegate) = 0;
|
||||
virtual IRenderElementDelegate* mfGetDelegate() = 0;
|
||||
virtual CRenderChunk* mfGetMatInfo() = 0;
|
||||
virtual TRenderChunkArray* mfGetMatInfoList() = 0;
|
||||
virtual void* mfGetPointer(ESrcPointer ePT, int* Stride, EParamType Type, ESrcPointer Dst, int Flags) = 0;
|
||||
virtual AZ::Vertex::Format GetVertexFormat() const = 0;
|
||||
virtual void* GetCustomData() const = 0;
|
||||
virtual int GetCustomTexBind(int i) const = 0;
|
||||
virtual CRendElementBase* mfCopyConstruct() = 0;
|
||||
virtual EDataType mfGetType() = 0;
|
||||
virtual int Size() = 0;
|
||||
virtual void GetMemoryUsage(ICrySizer* pSizer) const = 0;
|
||||
|
||||
};
|
||||
|
||||
class CRendElement
|
||||
{
|
||||
public:
|
||||
static CRendElement m_RootGlobal;
|
||||
static CRendElement m_RootRelease[];
|
||||
CRendElement* m_NextGlobal;
|
||||
CRendElement* m_PrevGlobal;
|
||||
|
||||
EDataType m_Type;
|
||||
|
||||
protected:
|
||||
virtual void UnlinkGlobal()
|
||||
{
|
||||
if (!m_NextGlobal || !m_PrevGlobal)
|
||||
{
|
||||
return;
|
||||
}
|
||||
m_NextGlobal->m_PrevGlobal = m_PrevGlobal;
|
||||
m_PrevGlobal->m_NextGlobal = m_NextGlobal;
|
||||
m_NextGlobal = m_PrevGlobal = NULL;
|
||||
}
|
||||
|
||||
virtual void LinkGlobal(CRendElement* Before)
|
||||
{
|
||||
if (m_NextGlobal || m_PrevGlobal)
|
||||
{
|
||||
return;
|
||||
}
|
||||
m_NextGlobal = Before->m_NextGlobal;
|
||||
Before->m_NextGlobal->m_PrevGlobal = this;
|
||||
Before->m_NextGlobal = this;
|
||||
m_PrevGlobal = Before;
|
||||
}
|
||||
|
||||
public:
|
||||
CRendElement();
|
||||
virtual ~CRendElement();
|
||||
virtual void Release(bool bForce = false);
|
||||
virtual const char* mfTypeString();
|
||||
virtual void mfSetType(EDataType t) { m_Type = t; }
|
||||
virtual void GetMemoryUsage([[maybe_unused]] ICrySizer* pSizer) const {}
|
||||
virtual int Size() { return 0; }
|
||||
|
||||
static void ShutDown();
|
||||
static void Tick();
|
||||
static void Cleanup();
|
||||
};
|
||||
|
||||
class CRendElementBase
|
||||
: public CRendElement
|
||||
, public IRenderElement
|
||||
{
|
||||
public:
|
||||
uint16 m_Flags;
|
||||
uint16 m_nFrameUpdated;
|
||||
|
||||
public:
|
||||
void* m_CustomData;
|
||||
int m_CustomTexBind[MAX_CUSTOM_TEX_BINDS_NUM];
|
||||
|
||||
struct SGeometryStreamInfo
|
||||
{
|
||||
const void* pStream;
|
||||
int nOffset;
|
||||
int nStride;
|
||||
};
|
||||
struct SGeometryInfo
|
||||
{
|
||||
uint32 bonesRemapGUID; // Input paremeter to fetch correct skinning stream.
|
||||
|
||||
int primitiveType; //!< \see eRenderPrimitiveType
|
||||
AZ::Vertex::Format vertexFormat;
|
||||
uint32 streamMask;
|
||||
|
||||
int32 nFirstIndex;
|
||||
int32 nNumIndices;
|
||||
uint32 nFirstVertex;
|
||||
uint32 nNumVertices;
|
||||
|
||||
uint32 nMaxVertexStreams;
|
||||
|
||||
SGeometryStreamInfo indexStream;
|
||||
SGeometryStreamInfo vertexStream[VSF_NUM];
|
||||
|
||||
void* pTessellationAdjacencyBuffer;
|
||||
void* pSkinningExtraBonesBuffer;
|
||||
};
|
||||
|
||||
public:
|
||||
CRendElementBase();
|
||||
virtual ~CRendElementBase();
|
||||
|
||||
|
||||
virtual void mfPrepare(bool bCheckOverflow) override
|
||||
{
|
||||
if (m_delegate)
|
||||
{
|
||||
m_delegate->mfPrepare(bCheckOverflow);
|
||||
}
|
||||
}
|
||||
bool mfDraw(CShader* ef, SShaderPass* sfm) override { return m_delegate ? m_delegate->mfDraw(ef, sfm) : true; }
|
||||
bool mfSetSampler(int customId, int nTUnit, int nTState, int nTexMaterialSlot, int nSUnit) override { return m_delegate ? m_delegate->mfSetSampler(customId, nTUnit, nTState, nTexMaterialSlot, nSUnit) : false; }
|
||||
void mfSetDelegate(IRenderElementDelegate* pDelegate) override { m_delegate = pDelegate; }
|
||||
IRenderElementDelegate* mfGetDelegate() { return m_delegate; }
|
||||
|
||||
EDataType mfGetType() override { return m_Type; };
|
||||
|
||||
CRenderChunk* mfGetMatInfo() override { return nullptr; }
|
||||
TRenderChunkArray* mfGetMatInfoList() override { return nullptr; }
|
||||
int mfGetMatId() override { return -1; }
|
||||
void mfReset() override {};
|
||||
CRendElementBase* mfCopyConstruct() override;
|
||||
void mfCenter(Vec3& centr, CRenderObject* pObj) override;
|
||||
|
||||
bool mfCompile([[maybe_unused]] CParserBin& Parser, [[maybe_unused]] SParserFrame& Frame) override { return false; }
|
||||
bool mfPreDraw([[maybe_unused]] SShaderPass* sl) override { return true; }
|
||||
bool mfUpdate([[maybe_unused]] int Flags, [[maybe_unused]] bool bTessellation = false) override { return true; }
|
||||
void mfPrecache([[maybe_unused]] const SShaderItem& SH) override {}
|
||||
void mfExport([[maybe_unused]] struct SShaderSerializeContext& SC) override { CryFatalError("mfExport has not been implemented for this render element type"); }
|
||||
void mfImport([[maybe_unused]] struct SShaderSerializeContext& SC, [[maybe_unused]] uint32& offset) override { CryFatalError("mfImport has not been implemented for this render element type"); }
|
||||
void mfGetPlane(Plane_tpl<f32>& pl) override;
|
||||
void* mfGetPointer([[maybe_unused]] ESrcPointer ePT, [[maybe_unused]] int* Stride, [[maybe_unused]] EParamType Type, [[maybe_unused]] ESrcPointer Dst, [[maybe_unused]] int Flags) override { return nullptr; }
|
||||
|
||||
uint16 mfGetFlags() override { return m_Flags; }
|
||||
void mfSetFlags(uint16 fl) override { m_Flags = fl; }
|
||||
void mfUpdateFlags(uint16 fl) override { m_Flags |= fl; }
|
||||
void mfClearFlags(uint16 fl) override { m_Flags &= ~fl; }
|
||||
bool mfCheckUpdate(int Flags, uint16 nFrame, bool bTessellation = false) override
|
||||
{
|
||||
if (nFrame != m_nFrameUpdated || (m_Flags & (FCEF_DIRTY | FCEF_SKINNED | FCEF_UPDATEALWAYS)))
|
||||
{
|
||||
m_nFrameUpdated = nFrame;
|
||||
return mfUpdate(Flags, bTessellation);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
void mfGetBBox(Vec3& vMins, Vec3& vMaxs) override
|
||||
{
|
||||
vMins.Set(0, 0, 0);
|
||||
vMaxs.Set(0, 0, 0);
|
||||
}
|
||||
bool mfIsHWSkinned() override { return false; }
|
||||
int Size() override { return 0; }
|
||||
void GetMemoryUsage([[maybe_unused]] ICrySizer* pSizer) const override {}
|
||||
AZ::Vertex::Format GetVertexFormat() const override { return AZ::Vertex::Format(eVF_Unknown); };
|
||||
virtual bool GetGeometryInfo([[maybe_unused]] SGeometryInfo& streams) { return false; }
|
||||
void Draw([[maybe_unused]] CRenderObject* pObj, [[maybe_unused]] const struct SGraphicsPiplinePassContext& ctx) {};
|
||||
void* GetCustomData() const { return m_CustomData; }
|
||||
int GetCustomTexBind(int index) const { return m_CustomTexBind[index]; }
|
||||
|
||||
protected:
|
||||
IRenderElementDelegate * m_delegate = nullptr;
|
||||
};
|
||||
|
||||
#include "CREMesh.h"
|
||||
#include "CRESky.h"
|
||||
#include "CREOcclusionQuery.h"
|
||||
#include "CREImposter.h"
|
||||
#include "CREBaseCloud.h"
|
||||
#include "CREPostProcess.h"
|
||||
#include "CREFogVolume.h"
|
||||
#include "CREWaterVolume.h"
|
||||
#include "CREWaterOcean.h"
|
||||
#include "CREVolumeObject.h"
|
||||
#include "CREGameEffect.h"
|
||||
#include "CREGeomCache.h"
|
||||
|
||||
#if !defined(EXCLUDE_DOCUMENTATION_PURPOSE)
|
||||
#include "CREPrismObject.h"
|
||||
#endif // EXCLUDE_DOCUMENTATION_PURPOSE
|
||||
|
||||
//==========================================================
|
||||
|
||||
#endif // CRYINCLUDE_CRYCOMMON_RENDELEMENT_H
|
||||
@ -1,512 +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_TYPELIBRARY_H
|
||||
#define CRYINCLUDE_CRYCOMMON_TYPELIBRARY_H
|
||||
#pragma once
|
||||
|
||||
#include <ISoftCodeMgr.h> // <> required for Interfuscator
|
||||
|
||||
#include <AzCore/std/containers/map.h>
|
||||
#include <AzCore/std/string/string.h>
|
||||
|
||||
#ifdef SOFTCODE_ENABLED
|
||||
|
||||
// Internal: Used by SC types to auto-remove themselves from their TypeRegistrar on destruction.
|
||||
struct InstanceTracker
|
||||
{
|
||||
InstanceTracker()
|
||||
: m_pRegistrar()
|
||||
{}
|
||||
|
||||
~InstanceTracker()
|
||||
{
|
||||
if (m_pRegistrar)
|
||||
{
|
||||
m_pRegistrar->RemoveInstance(this);
|
||||
}
|
||||
}
|
||||
|
||||
void SetRegistrar(ITypeRegistrar* pRegistrar)
|
||||
{
|
||||
m_pRegistrar = pRegistrar;
|
||||
}
|
||||
|
||||
ITypeRegistrar* m_pRegistrar; // Valid if created by a registrar, otherwise NULL
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef SOFTCODE_ENABLED
|
||||
|
||||
// Include this for SEH support
|
||||
#include <excpt.h>
|
||||
|
||||
/*
|
||||
Used to declare the interface as having an associated TypeLibrary.
|
||||
Usage:
|
||||
struct IMyInterface
|
||||
{
|
||||
DECLARE_TYPELIB(IMyInterface);
|
||||
*/
|
||||
#define DECLARE_TYPELIB(IName) \
|
||||
static void VisitMembers(IExchanger & ex) {} \
|
||||
typedef CTypeLibrary<IName> TLibrary
|
||||
|
||||
/*
|
||||
Exposes a class to a TypeLibrary for registration.
|
||||
Usage:
|
||||
class MyThing : public IThing
|
||||
{
|
||||
DECLARE_TYPE(MyThing, IThing);
|
||||
...
|
||||
*/
|
||||
#define DECLARE_TYPE(TName, TSuperType) \
|
||||
public: \
|
||||
void VisitMembers(IExchanger & ex) { TSuperType::VisitMembers(ex); VisitMember<__START_MEMBERS>(ex); } \
|
||||
private: \
|
||||
friend class TypeRegistrar<TName>; \
|
||||
static const size_t __START_MEMBERS = __COUNTER__ + 1; \
|
||||
template <size_t IDX> \
|
||||
void VisitMember(IExchanger & exchanger) {} \
|
||||
InstanceTracker __instanceTracker
|
||||
|
||||
#ifdef SOFTCODE
|
||||
#define _EXPORT_TYPE_LIB(Interface) \
|
||||
extern "C" ITypeLibrary * GetTypeLibrary() { return CTypeLibrary<Interface>::Instance(); }
|
||||
#else
|
||||
#define _EXPORT_TYPE_LIB(Interface)
|
||||
#endif
|
||||
|
||||
// Internal: Outputs the specialized method template for the member at index
|
||||
#define _SOFT_MEMBER_VISITOR(member, index) \
|
||||
template <> \
|
||||
void VisitMember<index>(IExchanger & ex) { ex.Visit(#member, member); VisitMember<index + 1>(ex); }
|
||||
|
||||
/*
|
||||
Used to expose a class member to SoftCoding (to allow run-time member exchange)
|
||||
If SoftCode is disabled this does nothing and simple emits the member.
|
||||
For array types, use SOFT_ARRAY() instead or use AZStd::array which allows assignment.
|
||||
Usage: std::vector<string> SOFT(m_myStrings);
|
||||
*/
|
||||
#define SOFT(member) \
|
||||
member; \
|
||||
_SOFT_MEMBER_VISITOR(member, __COUNTER__)
|
||||
|
||||
/*
|
||||
Used to expose a primitive array type to SoftCoding.
|
||||
Declare it directly after the member.
|
||||
NOTE: It's cleaner to convert the member to AZStd::array as
|
||||
this avoid having to use this special case while preserving semantics.
|
||||
Usage:
|
||||
ColorB m_colors[20];
|
||||
SOFT_ARRAY(m_colors);
|
||||
*/
|
||||
#define SOFT_ARRAY(arrayMember) _SOFT_MEMBER_VISITOR(arrayMember, __COUNTER__)
|
||||
|
||||
// Internal: Executes given lambda in an SEH try block.
|
||||
template <typename TLambda>
|
||||
void SoftCodeTry(TLambda& lambda)
|
||||
{
|
||||
__try
|
||||
{
|
||||
lambda();
|
||||
}
|
||||
__except (EXCEPTION_EXECUTE_HANDLER)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
// Internal: Used by TypeRegistry. Use SOFTCODE_RETRY() for user code.
|
||||
#define SOFTCODE_TRY(exp) SoftCodeTry([&](){ exp; })
|
||||
#define SOFTCODE_TRY_BLOCK SoftCodeTry([&]() {
|
||||
#define SOFTCODE_TRY_END });
|
||||
|
||||
/*
|
||||
Internal: Attempt a given lambda functor. In the even on an exception execution will pause
|
||||
to allow the user to provide a replacement implementation for the failing instance.
|
||||
Usage: See SOFTCODE_RETRY & SOFTCODE_RETRY_BLOCK below.
|
||||
*/
|
||||
template <typename TPtr, typename TLambda>
|
||||
void SoftCodeRetry(TPtr& pointer, TLambda& lambda)
|
||||
{
|
||||
bool complete = false;
|
||||
while (pointer && !complete)
|
||||
{
|
||||
__try
|
||||
{
|
||||
lambda();
|
||||
complete = true;
|
||||
}
|
||||
__except (EXCEPTION_EXECUTE_HANDLER)
|
||||
{
|
||||
if (gEnv->pSoftCodeMgr)
|
||||
{
|
||||
pointer = reinterpret_cast<TPtr>(gEnv->pSoftCodeMgr->WaitForUpdate(pointer));
|
||||
}
|
||||
}
|
||||
}
|
||||
;
|
||||
}
|
||||
|
||||
/*
|
||||
Attempts to call an expression based the given pointer.
|
||||
If a Structured Exception is raised the thread will wait for a replacement of
|
||||
the pointer to be provided via the SoftCodeMgr. This will repeat until no exception is raised.
|
||||
|
||||
Usage: SOFTCODE_RETRY(pThing, (pThing->Update(frameTime))); // Same as pThing->Update(frameTime);
|
||||
*/
|
||||
#define SOFTCODE_RETRY(pointer, exp) SoftCodeRetry(pointer, [&](){ exp; })
|
||||
|
||||
/*
|
||||
Attempts to call an expression based the given pointer.
|
||||
If a Structured Exception is raised the thread will wait for a replacement of
|
||||
the pointer to be provided via the SoftCodeMgr. This will repeat until no exception is raised.
|
||||
|
||||
Usage:
|
||||
SOFTCODE_RETRY_BLOCK(pThing)
|
||||
{
|
||||
pSomething = pThing->GetSomething();
|
||||
}
|
||||
SOFTCODE_RETRY_END
|
||||
*/
|
||||
#define SOFTCODE_RETRY_BLOCK(pointer) SoftCodeRetry(pointer, [&]() {
|
||||
#define SOFTCODE_RETRY_END });
|
||||
|
||||
#else // !SOFTCODE_ENABLED ...
|
||||
|
||||
// IMPORTANT: Docs for these macros are found above.
|
||||
|
||||
#define DECLARE_TYPELIB(IName) \
|
||||
typedef CTypeLibrary<IName> TLibrary
|
||||
|
||||
#define DECLARE_TYPE(TName, TSuperType) \
|
||||
private: \
|
||||
friend class TypeRegistrar<TName>;
|
||||
|
||||
#define _EXPORT_TYPE_LIB(Interface)
|
||||
|
||||
#define SOFT(member) member
|
||||
#define SOFT_ARRAY(arrayMember)
|
||||
|
||||
#define SOFTCODE_TRY(exp) (exp)
|
||||
#define SOFTCODE_TRY_BLOCK {
|
||||
#define SOFTCODE_TRY_END };
|
||||
|
||||
#define SOFTCODE_RETRY(pointer, exp) (exp)
|
||||
#define SOFTCODE_RETRY_BLOCK(pointer) {
|
||||
#define SOFTCODE_RETRY_END };
|
||||
|
||||
#endif // !SOFTCODE_ENABLED
|
||||
|
||||
/*
|
||||
Implements registration for a type to a TypeLibrary.
|
||||
Usage:
|
||||
// MyThing.cpp
|
||||
DECLARE_TYPE(MyThing);
|
||||
*/
|
||||
#define IMPLEMENT_TYPE(TName) \
|
||||
static TypeRegistrar<TName> s_register##TName(#TName)
|
||||
|
||||
/*
|
||||
Provides the singleton for the TypeLibrary implementation.
|
||||
Also exports the accessors function for SoftCode builds.
|
||||
Usage:
|
||||
// ThingLibrary.cpp
|
||||
IMPLEMENT_TYPELIB(IThing, "Things")
|
||||
*/
|
||||
#define IMPLEMENT_TYPELIB(Interface, Name) \
|
||||
_EXPORT_TYPE_LIB(Interface) \
|
||||
template <> \
|
||||
CTypeLibrary<Interface>* CTypeLibrary<Interface>::Instance() \
|
||||
{ \
|
||||
static CTypeLibrary<Interface> s_instance(Name); \
|
||||
return &s_instance; \
|
||||
}
|
||||
|
||||
/*
|
||||
Internal: Used to register a type with a TypeLibrary.
|
||||
Also provides instance construction (factory) access.
|
||||
For SC builds it also provides copying and instance tracking.
|
||||
*/
|
||||
template <typename T>
|
||||
class TypeRegistrar
|
||||
: public ITypeRegistrar
|
||||
{
|
||||
public:
|
||||
TypeRegistrar(const char* name)
|
||||
: m_name(name)
|
||||
{
|
||||
typedef typename T::TLibrary TLib;
|
||||
TLib::Instance()->RegisterType(this);
|
||||
}
|
||||
|
||||
virtual const char* GetName() const { return m_name; }
|
||||
|
||||
virtual void* CreateInstance()
|
||||
{
|
||||
T* pInstance = NULL;
|
||||
|
||||
SOFTCODE_TRY_BLOCK
|
||||
{
|
||||
pInstance = ConstructInstance();
|
||||
}
|
||||
SOFTCODE_TRY_END
|
||||
|
||||
if (pInstance)
|
||||
{
|
||||
RegisterInstance(pInstance);
|
||||
}
|
||||
|
||||
return pInstance;
|
||||
}
|
||||
|
||||
#ifdef SOFTCODE_ENABLED
|
||||
virtual size_t InstanceCount() const
|
||||
{
|
||||
return m_instances.size();
|
||||
}
|
||||
|
||||
virtual void RemoveInstance(InstanceTracker* pTracker)
|
||||
{
|
||||
T* pInstance = GetInstanceFromTracker(pTracker);
|
||||
TInstanceVec::iterator iter(std::find(m_instances.begin(), m_instances.end(), pInstance));
|
||||
std::swap(*iter, m_instances.back());
|
||||
m_instances.pop_back();
|
||||
}
|
||||
|
||||
virtual bool ExchangeInstances(IExchanger& exchanger)
|
||||
{
|
||||
if (exchanger.IsLoading())
|
||||
{
|
||||
const size_t instanceCount = exchanger.InstanceCount();
|
||||
|
||||
// Ensure we have the correct number of instances
|
||||
if (m_instances.size() != instanceCount)
|
||||
{
|
||||
// TODO: Destroy any existing instances
|
||||
for (size_t i = 0; i < instanceCount; ++i)
|
||||
{
|
||||
if (!CreateInstance())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool complete = false;
|
||||
SOFTCODE_TRY_BLOCK
|
||||
{
|
||||
for (std::vector<T*>::iterator iter(m_instances.begin()); iter != m_instances.end(); ++iter)
|
||||
{
|
||||
T* pInstance = *iter;
|
||||
if (exchanger.BeginInstance(pInstance))
|
||||
{
|
||||
// Exchanges the members of pInstance as defined in T
|
||||
// Should also exchange members of parent types
|
||||
pInstance->VisitMembers(exchanger);
|
||||
}
|
||||
}
|
||||
complete = true;
|
||||
}
|
||||
SOFTCODE_TRY_END
|
||||
|
||||
return complete;
|
||||
}
|
||||
|
||||
virtual bool DestroyInstances()
|
||||
{
|
||||
bool complete = false;
|
||||
SOFTCODE_TRY_BLOCK
|
||||
{
|
||||
while (!m_instances.empty())
|
||||
{
|
||||
delete m_instances.back();
|
||||
// NOTE: No need to pop_back() as already done by the InstanceTracker via RemoveInstance()
|
||||
}
|
||||
complete = true;
|
||||
}
|
||||
SOFTCODE_TRY_END
|
||||
|
||||
return complete;
|
||||
}
|
||||
|
||||
|
||||
virtual bool HasInstance(void* pInstance) const
|
||||
{
|
||||
return std::find(m_instances.begin(), m_instances.end(), pInstance) != m_instances.end();
|
||||
}
|
||||
#endif
|
||||
|
||||
private:
|
||||
void RegisterInstance(T* pInstance)
|
||||
{
|
||||
#ifdef SOFTCODE_ENABLED
|
||||
pInstance->__instanceTracker.SetRegistrar(this);
|
||||
m_instances.push_back(pInstance);
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef SOFTCODE_ENABLED
|
||||
// Util: Avoids having to redundantly store the instance address in the tracker
|
||||
T* GetInstanceFromTracker(InstanceTracker* pTracker)
|
||||
{
|
||||
ptrdiff_t trackerOffset = reinterpret_cast<ptrdiff_t>(&((static_cast<T*>(0))->__instanceTracker));
|
||||
return reinterpret_cast<T*>(reinterpret_cast<char*>(pTracker) - trackerOffset);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Needed to avoid C2712 due to lack of stack unwind within SEH try blocks
|
||||
T* ConstructInstance()
|
||||
{
|
||||
return new T();
|
||||
}
|
||||
|
||||
private:
|
||||
const char* m_name; // Name of the type
|
||||
|
||||
#ifdef SOFTCODE_ENABLED
|
||||
typedef std::vector<T*> TInstanceVec;
|
||||
TInstanceVec m_instances; // Tracks the active instances (SC only)
|
||||
#endif
|
||||
};
|
||||
|
||||
/*
|
||||
Provides factory creation support for a set of types that
|
||||
derive from a single interface T. Users need to provide a
|
||||
specialization of the static CTypeLibrary<T>* Instance() member
|
||||
in a cpp file to provide the singleton instance.
|
||||
*/
|
||||
template <typename T>
|
||||
class CTypeLibrary
|
||||
#ifdef SOFTCODE_ENABLED
|
||||
: public ITypeLibrary
|
||||
#endif
|
||||
{
|
||||
public:
|
||||
CTypeLibrary(const char* name)
|
||||
: m_name(name)
|
||||
#ifdef SOFTCODE_ENABLED
|
||||
, m_pOverrideLib()
|
||||
, m_overrideActive()
|
||||
, m_registered()
|
||||
#endif
|
||||
{
|
||||
}
|
||||
|
||||
// Implemented in the export cpp
|
||||
static CTypeLibrary<T>* Instance();
|
||||
|
||||
void RegisterType(ITypeRegistrar* pType)
|
||||
{
|
||||
m_typeMap[pType->GetName()] = pType;
|
||||
}
|
||||
|
||||
// The global identifier for this library module
|
||||
/*virtual*/ const char* GetName() { return m_name; }
|
||||
|
||||
#ifdef SOFTCODE_ENABLED
|
||||
virtual void* CreateInstanceVoid(const char* typeName)
|
||||
{
|
||||
return CreateInstance(typeName);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Generic creation function
|
||||
T* CreateInstance(const char* typeName)
|
||||
{
|
||||
#ifdef SOFTCODE_ENABLED
|
||||
RegisterWithSoftCode();
|
||||
|
||||
// If override is enabled, use it
|
||||
if (m_pOverrideLib)
|
||||
{
|
||||
return reinterpret_cast<T*>(m_pOverrideLib->CreateInstanceVoid(typeName));
|
||||
}
|
||||
#endif
|
||||
|
||||
TTypeMap::const_iterator typeIter(m_typeMap.find(typeName));
|
||||
if (typeIter != m_typeMap.end())
|
||||
{
|
||||
ITypeRegistrar* pRegistrar = typeIter->second;
|
||||
return reinterpret_cast<T*>(pRegistrar->CreateInstance());
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#ifdef SOFTCODE_ENABLED
|
||||
// Indicates CreateInstance requests should be forwarded to the specified lib
|
||||
virtual void SetOverride(ITypeLibrary* pOverrideLib)
|
||||
{
|
||||
m_pOverrideLib = pOverrideLib;
|
||||
}
|
||||
|
||||
virtual size_t GetTypes(ITypeRegistrar** ppTypes, size_t& count) const
|
||||
{
|
||||
size_t returnedCount = 0;
|
||||
|
||||
if (ppTypes && count >= m_typeMap.size())
|
||||
{
|
||||
for (TTypeMap::const_iterator iter(m_typeMap.begin()); iter != m_typeMap.end(); ++iter)
|
||||
{
|
||||
*ppTypes = iter->second;
|
||||
++ppTypes;
|
||||
++returnedCount;
|
||||
}
|
||||
}
|
||||
|
||||
count = m_typeMap.size();
|
||||
return returnedCount;
|
||||
}
|
||||
|
||||
// Inform the Mgr of this Library and allow it to set an override
|
||||
inline void RegisterWithSoftCode()
|
||||
{
|
||||
// Only register built-in types, SC types are handled directly by
|
||||
// the SoftCodeMgr, so there's no need to auto-register.
|
||||
#ifndef SOFTCODE
|
||||
if (!m_registered)
|
||||
{
|
||||
if (ISoftCodeMgr* pSoftCodeMgr = gEnv->pSoftCodeMgr)
|
||||
{
|
||||
pSoftCodeMgr->RegisterLibrary(this);
|
||||
}
|
||||
|
||||
m_registered = true;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
private:
|
||||
typedef AZStd::basic_string<char, AZStd::char_traits<char>, AZ::AZStdAlloc<CryLegacySTLAllocator>> TypeString;
|
||||
typedef AZStd::map<TypeString, ITypeRegistrar*, AZStd::less<TypeString>, AZ::AZStdAlloc<CryLegacySTLAllocator>> TTypeMap;
|
||||
TTypeMap m_typeMap;
|
||||
|
||||
// The name for this TypeLibrary used during SC registration
|
||||
const char* m_name;
|
||||
|
||||
#ifdef SOFTCODE_ENABLED
|
||||
// Used to patch in a new TypeLib at run-time
|
||||
ITypeLibrary* m_pOverrideLib;
|
||||
// True when the owning object system enables the override
|
||||
bool m_overrideActive;
|
||||
// True when registration with SoftCodeMgr has been attempted
|
||||
bool m_registered;
|
||||
#endif
|
||||
};
|
||||
|
||||
#endif // CRYINCLUDE_CRYCOMMON_TYPELIBRARY_H
|
||||
@ -1,251 +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.
|
||||
|
||||
#include "CrySystem_precompiled.h"
|
||||
#include <ITimer.h>
|
||||
#include <CrySizer.h>
|
||||
#include "CrySizerImpl.h"
|
||||
|
||||
CrySizerImpl::CrySizerImpl()
|
||||
: m_pResourceCollector(0)
|
||||
{
|
||||
m_nFlags = 0;
|
||||
m_nTotalSize = 0;
|
||||
// to avoid reallocations during walk through the memory tree, reserve the space for the names
|
||||
clear();
|
||||
}
|
||||
|
||||
CrySizerImpl::~CrySizerImpl()
|
||||
{
|
||||
}
|
||||
|
||||
void CrySizerImpl::Push (const char* szComponentName)
|
||||
{
|
||||
m_stackNames.push_back (getNameIndex(getCurrentName(), szComponentName));
|
||||
// if the depth is too deep, something is wrong, perhaps an infinite loop
|
||||
assert (m_stackNames.size() < 128);
|
||||
}
|
||||
|
||||
void CrySizerImpl::PushSubcomponent (const char* szSubcomponentName)
|
||||
{
|
||||
Push (szSubcomponentName);
|
||||
}
|
||||
|
||||
|
||||
void CrySizerImpl::Pop ()
|
||||
{
|
||||
if (!m_stackNames.empty())
|
||||
{
|
||||
m_stackNames.pop_back();
|
||||
}
|
||||
else
|
||||
{
|
||||
assert (0);
|
||||
}
|
||||
}
|
||||
|
||||
// returns the index of the current name on the top of the name stack
|
||||
size_t CrySizerImpl::getCurrentName() const
|
||||
{
|
||||
assert(!m_stackNames.empty());
|
||||
return m_stackNames.empty() ? 0 : m_stackNames.back();
|
||||
}
|
||||
|
||||
|
||||
|
||||
// searches for the name in the name array; adds the name if it's not there and returns the index
|
||||
size_t CrySizerImpl::getNameIndex(size_t nParent, const char* szComponentName)
|
||||
{
|
||||
NameArray::const_iterator it = m_arrNames.begin(), itEnd = it + m_arrNames.size();
|
||||
for (; it != itEnd; ++it)
|
||||
{
|
||||
#if defined(LINUX)
|
||||
if (!strcasecmp(it->strName.c_str(), szComponentName) && it->nParent == nParent)
|
||||
#else
|
||||
if (!strcmp(it->strName.c_str(), szComponentName) && it->nParent == nParent)
|
||||
#endif
|
||||
{
|
||||
return (size_t)(it - m_arrNames.begin());//it-m_arrNames.begin();
|
||||
}
|
||||
}
|
||||
|
||||
size_t nNewName = m_arrNames.size();
|
||||
m_arrNames.resize(nNewName + 1);
|
||||
|
||||
m_arrNames[nNewName].assign(szComponentName, nParent);
|
||||
|
||||
m_arrNames[nParent].arrChildren.push_back(nParent);
|
||||
|
||||
return nNewName;
|
||||
}
|
||||
|
||||
static NullResCollector s_nullCollector;
|
||||
|
||||
IResourceCollector* CrySizerImpl::GetResourceCollector()
|
||||
{
|
||||
return m_pResourceCollector != 0 ? m_pResourceCollector : &s_nullCollector;
|
||||
}
|
||||
|
||||
void CrySizerImpl::Reset()
|
||||
{
|
||||
clear();
|
||||
|
||||
m_nTotalSize = 0;
|
||||
|
||||
//m_arrNames.resize(0);
|
||||
//m_arrNames.push_back("TOTAL"); // the default name, with index 0
|
||||
//m_LastObject.clear();
|
||||
////m_nFlags;
|
||||
//m_nTotalSize=0;
|
||||
//if (m_pResourceCollector)
|
||||
//{
|
||||
// m_pResourceCollector->Reset();
|
||||
//}
|
||||
//m_setObjects->clear();
|
||||
//m_stackNames.resize(0);
|
||||
//m_stackNames.push_back(0);
|
||||
}
|
||||
|
||||
|
||||
// adds an object identified by the unique pointer (it needs not be
|
||||
// the actual object position in the memory, though it would be nice,
|
||||
// but it must be unique throughout the system and unchanging for this object)
|
||||
// RETURNS: true if the object has actually been added (for the first time)
|
||||
// and calculated
|
||||
bool CrySizerImpl::AddObject (const void* pIdentifier, size_t sizeBytes, int nCount)
|
||||
{
|
||||
if (!pIdentifier || !sizeBytes)
|
||||
{
|
||||
return false; // we don't add the NULL objects
|
||||
}
|
||||
Object NewObject(pIdentifier, sizeBytes, getCurrentName());
|
||||
|
||||
// check if the last object was the same
|
||||
if (NewObject == m_LastObject)
|
||||
{
|
||||
assert (m_LastObject.nSize == sizeBytes);
|
||||
return false;
|
||||
}
|
||||
|
||||
ObjectSet& rSet = m_setObjects[getHash(pIdentifier)];
|
||||
ObjectSet::iterator it = rSet.find (NewObject);
|
||||
if (it == rSet.end())
|
||||
{
|
||||
// there's no such object in the map, add it
|
||||
rSet.insert (NewObject);
|
||||
ComponentName& CompName = m_arrNames[getCurrentName()];
|
||||
CompName.numObjects += nCount;
|
||||
CompName.sizeObjects += sizeBytes;
|
||||
|
||||
m_nTotalSize += sizeBytes;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
Object* pObj = const_cast<Object*>(&(*it));
|
||||
|
||||
// if we do an heap check, don't accept the same object twice
|
||||
if (sizeBytes != pObj->nSize)
|
||||
{
|
||||
// if the following assert fails:
|
||||
// assert (0);
|
||||
// .. it means we have one object that's added two times with different sizes; that's screws up the whole idea
|
||||
// we assume there are two different objects that are for some reason assigned the same id
|
||||
pObj->nSize += sizeBytes; // anyway it's an invalid situation
|
||||
ComponentName& CompName = m_arrNames[getCurrentName()];
|
||||
CompName.sizeObjects += sizeBytes;
|
||||
return true; // yes we added the object, though there were an error condition
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
size_t CrySizerImpl::GetObjectCount()
|
||||
{
|
||||
size_t count = m_stackNames.size();
|
||||
for (int i = 0; i < g_nHashSize; i++)
|
||||
{
|
||||
count += m_setObjects[i].size();
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
|
||||
// finalizes data collection, should be called after all objects have been added
|
||||
void CrySizerImpl::End()
|
||||
{
|
||||
// clean up the totals of each name
|
||||
int i;
|
||||
for (i = 0; i < m_arrNames.size(); ++i)
|
||||
{
|
||||
assert (i == 0 || ((int)m_arrNames[i].nParent < i && m_arrNames[i].nParent >= 0));
|
||||
m_arrNames[i].sizeObjectsTotal = m_arrNames[i].sizeObjects;
|
||||
}
|
||||
|
||||
// add the component's size to the total size of the parent.
|
||||
// for every component, all their children are put after them in the name array
|
||||
// we don't include the root because it doesn't belong to any other parent (nowhere further to add)
|
||||
for (i = m_arrNames.size() - 1; i > 0; --i)
|
||||
{
|
||||
// the parent's total size is increased by the _total_ size (already calculated) of this object
|
||||
m_arrNames[m_arrNames[i].nParent].sizeObjectsTotal += m_arrNames[i].sizeObjectsTotal;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CrySizerImpl::clear()
|
||||
{
|
||||
for (unsigned i = 0; i < g_nHashSize; ++i)
|
||||
{
|
||||
m_setObjects[i].clear();
|
||||
}
|
||||
|
||||
m_arrNames.clear();
|
||||
m_arrNames.push_back("TOTAL"); // the default name, with index 0
|
||||
m_stackNames.clear();
|
||||
m_stackNames.push_back(0);
|
||||
m_LastObject.pId = NULL;
|
||||
|
||||
if (m_pResourceCollector)
|
||||
{
|
||||
m_pResourceCollector->Reset();
|
||||
}
|
||||
}
|
||||
|
||||
// hash function for an address; returns value 0..1<<g_nHashSize
|
||||
unsigned CrySizerImpl::getHash (const void* pId)
|
||||
{
|
||||
//return (((unsigned)pId) >> 4) & (g_nHashSize-1);
|
||||
|
||||
// pseudorandomizing transform
|
||||
ldiv_t Qrem = (ldiv_t)ldiv(((uint32)(UINT_PTR)pId >> 2), 127773);
|
||||
Qrem.rem = 16807 * Qrem.rem - 2836 * Qrem.quot;
|
||||
if (Qrem.rem < 0)
|
||||
{
|
||||
Qrem.rem += 2147483647; // 0x7FFFFFFF
|
||||
}
|
||||
return ((unsigned)Qrem.rem) & (g_nHashSize - 1);
|
||||
}
|
||||
unsigned CrySizerImpl::GetDepthLevel(unsigned nCurrent)
|
||||
{
|
||||
uint32 nDepth = 0;
|
||||
nCurrent = m_arrNames[nCurrent].nParent;
|
||||
while (nCurrent != 0)
|
||||
{
|
||||
nDepth++;
|
||||
nCurrent = m_arrNames[nCurrent].nParent;
|
||||
}
|
||||
return nDepth;
|
||||
}
|
||||
|
||||
@ -1,184 +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 : Implementation of the ICrySizer interface, which is used to
|
||||
// calculate the memory usage by the subsystems and components, to help
|
||||
// the artists keep the memory budged low.
|
||||
|
||||
|
||||
#ifndef CRYINCLUDE_CRYSYSTEM_CRYSIZERIMPL_H
|
||||
#define CRYINCLUDE_CRYSYSTEM_CRYSIZERIMPL_H
|
||||
#pragma once
|
||||
|
||||
|
||||
|
||||
// prerequisities
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// implementation of interface ICrySizer
|
||||
// ICrySizer is passed to all subsystems and has a lot of helper functions that
|
||||
// are compiled in the appropriate subsystems. CrySizerImpl is created in CrySystem
|
||||
// and is passed to all the other subsystems
|
||||
class CrySizerImpl
|
||||
: public ICrySizer
|
||||
{
|
||||
public:
|
||||
CrySizerImpl();
|
||||
~CrySizerImpl();
|
||||
|
||||
virtual void Release() { delete this; }
|
||||
virtual size_t GetTotalSize() { return m_nTotalSize; };
|
||||
virtual size_t GetObjectCount();
|
||||
|
||||
void Reset();
|
||||
|
||||
// adds an object identified by the unique pointer (it needs not be
|
||||
// the actual object position in the memory, though it would be nice,
|
||||
// but it must be unique throughout the system and unchanging for this object)
|
||||
// RETURNS: true if the object has actually been added (for the first time)
|
||||
// and calculated
|
||||
virtual bool AddObject (const void* pIdentifier, size_t nSizeBytes, int nCount = 1);
|
||||
|
||||
virtual IResourceCollector* GetResourceCollector();
|
||||
|
||||
// finalizes data collection, should be called after all objects have been added
|
||||
void End();
|
||||
|
||||
void clear();
|
||||
|
||||
// Arguments:
|
||||
// pColl - can be 0
|
||||
void SetResourceCollector(IResourceCollector* pColl) { m_pResourceCollector = pColl; }
|
||||
|
||||
protected:
|
||||
|
||||
IResourceCollector* m_pResourceCollector; //
|
||||
|
||||
// these functions must operate on the component name stack
|
||||
// they are to be only accessible from within class CrySizerComponentNameHelper
|
||||
// which should be used through macro SIZER_COMPONENT_NAME
|
||||
virtual void Push (const char* szComponentName);
|
||||
virtual void PushSubcomponent (const char* szSubcomponentName);
|
||||
virtual void Pop ();
|
||||
|
||||
// searches for the name in the name array; adds the name if it's not there and returns the index
|
||||
size_t getNameIndex (size_t nParent, const char* szComponentName);
|
||||
|
||||
// returns the index of the current name on the top of the name stack
|
||||
size_t getCurrentName() const;
|
||||
|
||||
protected:
|
||||
friend class CrySizerStatsBuilder;
|
||||
|
||||
// the stack of subsystem names; the indices in the name array are kept, not the names themselves
|
||||
typedef DynArray<size_t> NameStack;
|
||||
NameStack m_stackNames;
|
||||
|
||||
// the array of names; each name ever pushed on the stack is present here
|
||||
struct ComponentName
|
||||
{
|
||||
ComponentName (){}
|
||||
ComponentName (const char* szName, size_t parent = 0)
|
||||
: strName (szName)
|
||||
, nParent (parent)
|
||||
, numObjects(0)
|
||||
, sizeObjects (0)
|
||||
, sizeObjectsTotal (0)
|
||||
{
|
||||
}
|
||||
|
||||
void assign (const char* szName, size_t parent = 0)
|
||||
{
|
||||
strName = szName;
|
||||
nParent = parent;
|
||||
numObjects = 0;
|
||||
sizeObjects = 0;
|
||||
sizeObjectsTotal = 0;
|
||||
arrChildren.clear();
|
||||
}
|
||||
|
||||
// the component name, not including the parents' names
|
||||
string strName;
|
||||
// the index of the parent, 0 being the root
|
||||
size_t nParent;
|
||||
// the number of objects within this component
|
||||
size_t numObjects;
|
||||
// the size of the objects belonging to this component, in bytes
|
||||
size_t sizeObjects;
|
||||
// the total size of all objects; gets filled by the end() method of the CrySizerImpl
|
||||
size_t sizeObjectsTotal;
|
||||
// the children components
|
||||
DynArray<size_t> arrChildren;
|
||||
};
|
||||
typedef DynArray<ComponentName> NameArray;
|
||||
NameArray m_arrNames;
|
||||
|
||||
|
||||
|
||||
// the set of objects and their sizes: the key is the object address/id,
|
||||
// the value is the size of the object and its name (the index of the name actually)
|
||||
struct Object
|
||||
{
|
||||
const void* pId; // unique pointer identifying the object in memory
|
||||
size_t nSize; // the size of the object in bytes
|
||||
size_t nName; // the index of the name in the name array
|
||||
|
||||
Object ()
|
||||
{clear(); }
|
||||
|
||||
Object (const void* id, size_t size = 0, size_t name = 0)
|
||||
: pId(id)
|
||||
, nSize(size)
|
||||
, nName(name) {}
|
||||
|
||||
// the objects are sorted by their Id
|
||||
bool operator < (const Object& right) const {return (UINT_PTR)pId < (UINT_PTR)right.pId; }
|
||||
bool operator < (const void* right) const {return (UINT_PTR)pId < (UINT_PTR)right; }
|
||||
//friend bool operator < (const void* left, const Object& right);
|
||||
|
||||
bool operator == (const Object& right) const {return pId == right.pId; }
|
||||
|
||||
void clear()
|
||||
{
|
||||
pId = NULL;
|
||||
nSize = 0;
|
||||
nName = 0;
|
||||
}
|
||||
};
|
||||
typedef std::set <Object> ObjectSet;
|
||||
// 2^g_nHashPower == the number of subsets comprising the hash
|
||||
|
||||
enum
|
||||
{
|
||||
g_nHashPower = 12
|
||||
};
|
||||
|
||||
// hash size (number of subsets)
|
||||
enum
|
||||
{
|
||||
g_nHashSize = 1 << g_nHashPower
|
||||
};
|
||||
// hash function for an address; returns value 0..1<<g_nHashSize
|
||||
unsigned getHash (const void* pId);
|
||||
unsigned GetDepthLevel(unsigned nCurrent);
|
||||
|
||||
ObjectSet m_setObjects[g_nHashSize];
|
||||
|
||||
// the last object inserted; this is a small optimization for our template implementaiton
|
||||
// that often can add two times the same object
|
||||
Object m_LastObject;
|
||||
|
||||
size_t m_nTotalSize;
|
||||
};
|
||||
|
||||
#endif // CRYINCLUDE_CRYSYSTEM_CRYSIZERIMPL_H
|
||||
@ -1,484 +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.
|
||||
|
||||
#include "CrySystem_precompiled.h"
|
||||
#include "ILog.h"
|
||||
#include "ITimer.h"
|
||||
#include "ISystem.h"
|
||||
#include "IConsole.h"
|
||||
#include "IRenderer.h"
|
||||
#include "CrySizerImpl.h"
|
||||
#include "CrySizerStats.h"
|
||||
#include "ITextModeConsole.h"
|
||||
|
||||
CrySizerStatsBuilder::CrySizerStatsBuilder (CrySizerImpl* pSizer, int nMinSubcomponentBytes)
|
||||
: m_pSizer (pSizer)
|
||||
, m_nMinSubcomponentBytes (nMinSubcomponentBytes < 0 || nMinSubcomponentBytes > 0x10000000 ? 0 : nMinSubcomponentBytes)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
// creates the map of names from old (in the sizer Impl) to new (in the Stats)
|
||||
void CrySizerStatsBuilder::processNames()
|
||||
{
|
||||
size_t numCompNames = m_pSizer->m_arrNames.size();
|
||||
m_pStats->m_arrComponents.reserve (numCompNames);
|
||||
m_pStats->m_arrComponents.clear();
|
||||
|
||||
m_mapNames.resize (numCompNames, (size_t)-1);
|
||||
|
||||
// add all root objects
|
||||
addNameSubtree(0, 0);
|
||||
}
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// given the name in the old system, adds the subtree of names to the
|
||||
// name map and components. In case all the subtree is empty, returns false and
|
||||
// adds nothing
|
||||
size_t CrySizerStatsBuilder::addNameSubtree (unsigned nDepth, size_t nName)
|
||||
{
|
||||
assert ((int)nName < m_pSizer->m_arrNames.size());
|
||||
|
||||
CrySizerImpl::ComponentName& rCompName = m_pSizer->m_arrNames[nName];
|
||||
size_t sizeObjectsTotal = rCompName.sizeObjectsTotal;
|
||||
|
||||
if (sizeObjectsTotal <= m_nMinSubcomponentBytes)
|
||||
{
|
||||
return sizeObjectsTotal; // the subtree didn't pass
|
||||
}
|
||||
// the index of the component in the stats object (sorted by the depth-first traverse order)
|
||||
size_t nNewName = m_pStats->m_arrComponents.size();
|
||||
m_pStats->m_arrComponents.resize (nNewName + 1);
|
||||
|
||||
Component& rNewComp = m_pStats->m_arrComponents[nNewName];
|
||||
rNewComp.strName = rCompName.strName;
|
||||
rNewComp.nDepth = nDepth;
|
||||
rNewComp.numObjects = rCompName.numObjects;
|
||||
rNewComp.sizeBytes = rCompName.sizeObjects;
|
||||
rNewComp.sizeBytesTotal = sizeObjectsTotal;
|
||||
m_mapNames[nName] = nNewName;
|
||||
|
||||
// find the immediate children and sort them by their total size
|
||||
typedef std::map<size_t, size_t> UintUintMap;
|
||||
UintUintMap mapSizeName; // total size -> child index (name in old indexation)
|
||||
|
||||
for (int i = nName + 1; i < m_pSizer->m_arrNames.size(); ++i)
|
||||
{
|
||||
CrySizerImpl::ComponentName& rChild = m_pSizer->m_arrNames[i];
|
||||
if (rChild.nParent == nName && rChild.sizeObjectsTotal > m_nMinSubcomponentBytes)
|
||||
{
|
||||
mapSizeName.insert (UintUintMap::value_type(rChild.sizeObjectsTotal, i));
|
||||
}
|
||||
}
|
||||
|
||||
// add the sorted components
|
||||
/*
|
||||
for (unsigned i = nName + 1; i < m_pSizer->m_arrNames.size(); ++i)
|
||||
if (m_pSizer->m_arrNames[i].nParent == nName)
|
||||
addNameSubtree(nDepth+1,i);
|
||||
*/
|
||||
|
||||
for (UintUintMap::reverse_iterator it = mapSizeName.rbegin(); it != mapSizeName.rend(); ++it)
|
||||
{
|
||||
addNameSubtree(nDepth + 1, it->second);
|
||||
}
|
||||
|
||||
return sizeObjectsTotal;
|
||||
}
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// creates the statistics out of the given CrySizerImpl into the given CrySizerStats
|
||||
// Maps the old to new names according to the depth-walk tree rule
|
||||
void CrySizerStatsBuilder::build (CrySizerStats* pStats)
|
||||
{
|
||||
m_pStats = pStats;
|
||||
|
||||
m_mapNames.clear();
|
||||
|
||||
processNames();
|
||||
|
||||
m_pSizer->clear();
|
||||
pStats->refresh();
|
||||
pStats->m_nAgeFrames = 0;
|
||||
}
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// constructs the statistics based on the given cry sizer
|
||||
CrySizerStats::CrySizerStats (CrySizerImpl* pCrySizer)
|
||||
{
|
||||
CrySizerStatsBuilder builder (pCrySizer);
|
||||
builder.build(this);
|
||||
}
|
||||
|
||||
CrySizerStats::CrySizerStats ()
|
||||
: m_nStartRow(0)
|
||||
{
|
||||
}
|
||||
|
||||
void CrySizerStats::updateKeys()
|
||||
{
|
||||
const unsigned int statSize = size();
|
||||
//assume 10 pixels for font
|
||||
unsigned int height = gEnv->pRenderer->GetHeight() / 12;
|
||||
if (CryGetAsyncKeyState(VK_UP))
|
||||
{
|
||||
if (m_nStartRow > 0)
|
||||
{
|
||||
--m_nStartRow;
|
||||
}
|
||||
}
|
||||
if (CryGetAsyncKeyState(VK_DOWN))
|
||||
{
|
||||
if (statSize > height + m_nStartRow)
|
||||
{
|
||||
++m_nStartRow;
|
||||
}
|
||||
}
|
||||
if (CryGetAsyncKeyState(VK_RIGHT) & 1)
|
||||
{
|
||||
//assume 10 pixels for font
|
||||
if (statSize > height)
|
||||
{
|
||||
m_nStartRow = statSize - height;
|
||||
}
|
||||
}
|
||||
if (CryGetAsyncKeyState(VK_LEFT) & 1)
|
||||
{
|
||||
m_nStartRow = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// if there is already such name in the map, then just returns the index
|
||||
// of the compoentn in the component array; otherwise adds an entry to themap
|
||||
// and to the component array nad returns its index
|
||||
CrySizerStatsBuilder::Component& CrySizerStatsBuilder::mapName (unsigned nName)
|
||||
{
|
||||
assert (m_mapNames[nName] != -1);
|
||||
return m_pStats->m_arrComponents[m_mapNames[nName]];
|
||||
/*
|
||||
IdToIdMap::iterator it = m_mapNames.find (nName);
|
||||
if (it == m_mapNames.end())
|
||||
{
|
||||
unsigned nNewName = m_arrComponents.size();
|
||||
m_mapNames.insert (IdToIdMap::value_type(nName, nNewName));
|
||||
m_arrComponents.resize(nNewName + 1);
|
||||
m_arrComponents[nNewName].strName.swap(m_pSizer->m_arrNames[nName]);
|
||||
return m_arrComponents.back();
|
||||
}
|
||||
else
|
||||
{
|
||||
assert (it->second < m_arrComponents.size());
|
||||
return m_arrComponents[it->second];
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
// refreshes the statistics built after the component array is built
|
||||
void CrySizerStats::refresh()
|
||||
{
|
||||
m_nMaxNameLength = 0;
|
||||
for (size_t i = 0; i < m_arrComponents.size(); ++i)
|
||||
{
|
||||
size_t nLength = m_arrComponents[i].strName.length() + m_arrComponents[i].nDepth;
|
||||
if (nLength > m_nMaxNameLength)
|
||||
{
|
||||
m_nMaxNameLength = nLength;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool CrySizerStats::Component::GenericOrder::operator () (const Component& left, const Component& right) const
|
||||
{
|
||||
return left.strName < right.strName;
|
||||
}
|
||||
|
||||
|
||||
CrySizerStatsRenderer::CrySizerStatsRenderer (ISystem* pSystem, CrySizerStats* pStats, unsigned nMaxSubcomponentDepth, int nMinSubcomponentBytes)
|
||||
: m_pStats(pStats)
|
||||
, m_pRenderer(pSystem->GetIRenderer())
|
||||
, m_pLog (pSystem->GetILog())
|
||||
, m_pTextModeConsole(pSystem->GetITextModeConsole())
|
||||
, m_nMinSubcomponentBytes (nMinSubcomponentBytes < 0 || nMinSubcomponentBytes > 0x10000000 ? 0x8000 : nMinSubcomponentBytes)
|
||||
, m_nMaxSubcomponentDepth (nMaxSubcomponentDepth)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
static void DrawStatsText(float x, float y, float fScale, float color[4], const char* format, ...)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
SDrawTextInfo ti;
|
||||
ti.xscale = fScale;
|
||||
ti.yscale = fScale;
|
||||
ti.color[0] = color[0];
|
||||
ti.color[1] = color[1];
|
||||
ti.color[2] = color[2];
|
||||
ti.color[3] = color[3];
|
||||
ti.flags = eDrawText_2D | eDrawText_FixedSize | eDrawText_Monospace;
|
||||
gEnv->pRenderer->DrawTextQueued(Vec3(x, y, 0.5f), ti, format, args);
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
void CrySizerStatsRenderer::render(bool bRefreshMark)
|
||||
{
|
||||
if (!m_pStats->size())
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
int x, y, dx, dy;
|
||||
m_pRenderer->GetViewport(&x, &y, &dx, &dy);
|
||||
|
||||
// left coordinate of the text
|
||||
unsigned nNameWidth = (unsigned)(m_pStats->getMaxNameLength() + 1);
|
||||
if (nNameWidth < 25)
|
||||
{
|
||||
nNameWidth = 25;
|
||||
}
|
||||
float fCharScaleX = 1.2f;
|
||||
float fLeft = 0;
|
||||
float fTop = 8;
|
||||
float fVStep = 9;
|
||||
|
||||
#ifdef _DEBUG
|
||||
const char* szCountStr1 = "count";
|
||||
const char* szCountStr2 = "_____";
|
||||
#else // _DEBUG
|
||||
const char* szCountStr1 = "", * szCountStr2 = "";
|
||||
#endif // _DEBUG
|
||||
|
||||
float fTextColor[4] = {0.9f, 0.85f, 1, 0.85f};
|
||||
DrawStatsText(fLeft, fTop, fCharScaleX, fTextColor,
|
||||
"%-*s total partial %s", nNameWidth, bRefreshMark ? "Memory usage (refresh*)" : "Memory usage (refresh )", szCountStr1);
|
||||
DrawStatsText(fLeft, fTop + fVStep * 0.25f, fCharScaleX, fTextColor,
|
||||
"%*s _____ _______ %s", nNameWidth, "", szCountStr2);
|
||||
|
||||
unsigned nSubgroupDepth = 1;
|
||||
|
||||
// different colors used to paint the statistics subgroups
|
||||
// a new statistic subgroup starts with a new subtree of depth <= specified
|
||||
float fGray = 0;//0.45f;
|
||||
float fLightGray = 0.5f;//0.8f;
|
||||
float fColors[] =
|
||||
{
|
||||
fLightGray, fLightGray, fGray, 1,
|
||||
1, 1, 1, 1,
|
||||
fGray, 1, 1, 1,
|
||||
1, fGray, 1, 1,
|
||||
1, 1, fGray, 1,
|
||||
fGray, fLightGray, 1, 1,
|
||||
fGray, 1, fGray, 1,
|
||||
1, fGray, fGray, 1
|
||||
};
|
||||
float* pColor = fColors;
|
||||
|
||||
unsigned statSize = m_pStats->size();
|
||||
unsigned startRow = m_pStats->row();
|
||||
unsigned i = 0;
|
||||
for (; i < startRow; ++i)
|
||||
{
|
||||
const Component& rComp = (*m_pStats)[i];
|
||||
if (rComp.nDepth <= nSubgroupDepth)
|
||||
{
|
||||
//switch the color
|
||||
pColor += 4;
|
||||
if (pColor >= fColors + sizeof(fColors) / sizeof(fColors[0]))
|
||||
{
|
||||
pColor = fColors;
|
||||
}
|
||||
|
||||
fTop += fVStep * (0.333333f + (nSubgroupDepth - rComp.nDepth) * 0.15f);
|
||||
}
|
||||
}
|
||||
|
||||
for (unsigned r = startRow; i < statSize; ++i)
|
||||
{
|
||||
const Component& rComp = (*m_pStats)[i];
|
||||
if (rComp.nDepth <= nSubgroupDepth)
|
||||
{
|
||||
//switch the color
|
||||
pColor += 4;
|
||||
if (pColor >= fColors + sizeof(fColors) / sizeof(fColors[0]))
|
||||
{
|
||||
pColor = fColors;
|
||||
}
|
||||
|
||||
fTop += fVStep * (0.333333f + (nSubgroupDepth - rComp.nDepth) * 0.15f);
|
||||
}
|
||||
|
||||
if (rComp.sizeBytesTotal <= m_nMinSubcomponentBytes || rComp.nDepth > m_nMaxSubcomponentDepth)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
fTop += fVStep;
|
||||
|
||||
char szDepth[32] = " ..............................";
|
||||
if (rComp.nDepth < sizeof(szDepth))
|
||||
{
|
||||
szDepth[rComp.nDepth] = '\0';
|
||||
}
|
||||
|
||||
char szSize[32];
|
||||
if (rComp.sizeBytes > 0)
|
||||
{
|
||||
if (rComp.sizeBytesTotal > rComp.sizeBytes)
|
||||
{
|
||||
azsprintf(szSize, "%7.3f %7.3f", rComp.getTotalSizeMBytes(), rComp.getSizeMBytes());
|
||||
}
|
||||
else
|
||||
{
|
||||
azsprintf(szSize, " %7.3f", rComp.getSizeMBytes());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
assert (rComp.sizeBytesTotal > 0);
|
||||
azsprintf(szSize, "%7.3f ", rComp.getTotalSizeMBytes());
|
||||
}
|
||||
char szCount[16];
|
||||
#ifdef _DEBUG
|
||||
if (rComp.numObjects)
|
||||
{
|
||||
azsprintf(szCount, "%zd" PRIu64 "", rComp.numObjects);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
szCount[0] = '\0';
|
||||
|
||||
DrawStatsText(fLeft, fTop, fCharScaleX, pColor,
|
||||
"%s%-*s:%s%s", szDepth, nNameWidth - rComp.nDepth, rComp.strName.c_str(), szSize, szCount);
|
||||
|
||||
if (m_pTextModeConsole)
|
||||
{
|
||||
string text;
|
||||
text.Format("%s%-*s:%s%s", szDepth, nNameWidth - rComp.nDepth, rComp.strName.c_str(), szSize, szCount);
|
||||
m_pTextModeConsole->PutText(0, r++, text.c_str());
|
||||
}
|
||||
}
|
||||
|
||||
float fLTGrayColor[4] = {fLightGray, fLightGray, fLightGray, 1.0f};
|
||||
fTop += 0.25f * fVStep;
|
||||
DrawStatsText(fLeft, fTop, fCharScaleX, fLTGrayColor,
|
||||
"%-*s %s", nNameWidth, "___________________________", "________________");
|
||||
fTop += fVStep;
|
||||
|
||||
const char* szOverheadNames[CrySizerStats::g_numTimers] =
|
||||
{
|
||||
".Collection",
|
||||
".Transformation",
|
||||
".Cleanup"
|
||||
};
|
||||
bool bOverheadsHeaderPrinted = false;
|
||||
for (i = 0; i < CrySizerStats::g_numTimers; ++i)
|
||||
{
|
||||
float fTime = m_pStats->getTime(i);
|
||||
if (fTime < 20)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
// print the header
|
||||
if (!bOverheadsHeaderPrinted)
|
||||
{
|
||||
DrawStatsText(fLeft, fTop, fCharScaleX, fTextColor,
|
||||
"%-*s", nNameWidth, "Overheads");
|
||||
fTop += fVStep;
|
||||
bOverheadsHeaderPrinted = true;
|
||||
}
|
||||
|
||||
DrawStatsText(fLeft, fTop, fCharScaleX, fTextColor,
|
||||
"%-*s:%7.1f ms", nNameWidth, szOverheadNames[i], fTime);
|
||||
fTop += fVStep;
|
||||
}
|
||||
}
|
||||
|
||||
void CrySizerStatsRenderer::dump(bool bUseKB)
|
||||
{
|
||||
if (!m_pStats->size())
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
unsigned nNameWidth = (unsigned)(m_pStats->getMaxNameLength() + 1);
|
||||
|
||||
// left coordinate of the text
|
||||
m_pLog->LogToFile ("Memory Statistics: %s", bUseKB ? "KB" : "MB");
|
||||
m_pLog->LogToFile("%-*s TOTAL partial count", nNameWidth, "");
|
||||
|
||||
// different colors used to paint the statistics subgroups
|
||||
// a new statistic subgroup starts with a new subtree of depth <= specified
|
||||
|
||||
for (unsigned i = 0; i < m_pStats->size(); ++i)
|
||||
{
|
||||
const Component& rComp = (*m_pStats)[i];
|
||||
|
||||
if (rComp.sizeBytesTotal <= m_nMinSubcomponentBytes || rComp.nDepth > m_nMaxSubcomponentDepth)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
char szDepth[32] = " ..............................";
|
||||
if (rComp.nDepth < sizeof(szDepth))
|
||||
{
|
||||
szDepth[rComp.nDepth] = '\0';
|
||||
}
|
||||
|
||||
char szSize[32];
|
||||
if (rComp.sizeBytes > 0)
|
||||
{
|
||||
if (rComp.sizeBytesTotal > rComp.sizeBytes)
|
||||
{
|
||||
azsprintf(szSize, bUseKB ? "%7.2f %7.2f" : "%7.3f %7.3f", bUseKB ? rComp.getTotalSizeKBytes() : rComp.getTotalSizeMBytes(), bUseKB ? rComp.getSizeKBytes() : rComp.getSizeMBytes());
|
||||
}
|
||||
else
|
||||
{
|
||||
azsprintf(szSize, bUseKB ? " %7.2f" : " %7.3f", bUseKB ? rComp.getSizeKBytes() : rComp.getSizeMBytes());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
assert (rComp.sizeBytesTotal > 0);
|
||||
azsprintf(szSize, bUseKB ? "%7.2f " : "%7.3f ", bUseKB ? rComp.getTotalSizeKBytes() : rComp.getTotalSizeMBytes());
|
||||
}
|
||||
char szCount[16];
|
||||
|
||||
if (rComp.numObjects)
|
||||
{
|
||||
azsprintf(szCount, "%8u", (unsigned int)rComp.numObjects);
|
||||
}
|
||||
else
|
||||
{
|
||||
szCount[0] = '\0';
|
||||
}
|
||||
|
||||
m_pLog->LogToFile ("%s%-*s:%s%s", szDepth, nNameWidth - rComp.nDepth, rComp.strName.c_str(), szSize, szCount);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CrySizerStats::startTimer(unsigned nTimer, ITimer* pTimer)
|
||||
{
|
||||
assert (nTimer < g_numTimers);
|
||||
m_fTime[nTimer] = pTimer->GetAsyncCurTime();
|
||||
}
|
||||
|
||||
void CrySizerStats::stopTimer(unsigned nTimer, ITimer* pTimer)
|
||||
{
|
||||
assert (nTimer < g_numTimers);
|
||||
m_fTime[nTimer] = 1000 * (pTimer->GetAsyncCurTime() - m_fTime[nTimer]);
|
||||
}
|
||||
@ -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.
|
||||
|
||||
// Description : Declaration of the CrySizerStats class, which is used to
|
||||
// calculate the memory usage by the subsystems and components, to help
|
||||
// the artists keep the memory budged low.
|
||||
|
||||
#ifndef CRYINCLUDE_CRYSYSTEM_CRYSIZERSTATS_H
|
||||
#define CRYINCLUDE_CRYSYSTEM_CRYSIZERSTATS_H
|
||||
#pragma once
|
||||
|
||||
|
||||
class CrySizerImpl;
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// This class holds only the necessary statistics data, which can be carried
|
||||
// over a few frames without significant impact on memory usage
|
||||
// CrySizerImpl is an implementation of ICrySizer, which is used to collect
|
||||
// those data; it must be destructed immediately after constructing the Stats
|
||||
// object to avoid excessive memory usage.
|
||||
class CrySizerStats
|
||||
{
|
||||
public:
|
||||
// constructs the statistics based on the given cry sizer
|
||||
CrySizerStats (CrySizerImpl* pCrySizer);
|
||||
|
||||
CrySizerStats ();
|
||||
|
||||
// this structure describes one component of the memory size statistics
|
||||
struct Component
|
||||
{
|
||||
Component() {clear(); }
|
||||
Component (const string& name, unsigned size = 0, unsigned num = 0)
|
||||
: strName(name)
|
||||
, sizeBytes(size)
|
||||
, numObjects(num)
|
||||
, nDepth(0) {}
|
||||
void clear()
|
||||
{
|
||||
strName = "";
|
||||
sizeBytes = 0;
|
||||
numObjects = 0;
|
||||
nDepth = 0;
|
||||
}
|
||||
|
||||
// the name of the component, as it appeared in the push() call
|
||||
string strName;
|
||||
// the total size, in bytes, of objects in the component
|
||||
size_t sizeBytes;
|
||||
// the total size including the subcomponents
|
||||
size_t sizeBytesTotal;
|
||||
// the number of objects allocated
|
||||
size_t numObjects;
|
||||
unsigned nDepth;
|
||||
|
||||
float getSizeKBytes() const {return sizeBytes / float(1 << 10); }
|
||||
|
||||
float getTotalSizeKBytes () const {return sizeBytesTotal / float(1 << 10); }
|
||||
|
||||
float getSizeMBytes() const {return sizeBytes / float(1 << 20); }
|
||||
|
||||
float getTotalSizeMBytes () const {return sizeBytesTotal / float(1 << 20); }
|
||||
|
||||
struct NameOrder
|
||||
{
|
||||
bool operator () (const Component& left, const Component& right) const {return left.strName < right.strName; }
|
||||
};
|
||||
|
||||
struct SizeOrder
|
||||
{
|
||||
bool operator () (const Component& left, const Component& right) const {return left.sizeBytes < right.sizeBytes; }
|
||||
};
|
||||
|
||||
struct GenericOrder
|
||||
{
|
||||
bool operator () (const Component& left, const Component& right) const;
|
||||
};
|
||||
};
|
||||
|
||||
// returns the number of different subsystems/components used
|
||||
unsigned numComponents() const {return (unsigned)m_arrComponents.size(); }
|
||||
// returns the name of the i-th component
|
||||
const Component& getComponent(unsigned nComponent) const {return m_arrComponents[nComponent]; }
|
||||
|
||||
unsigned size() const {return numComponents(); }
|
||||
const Component& operator [] (unsigned i) const {return getComponent(i); }
|
||||
const Component& operator [] (signed i) const {return getComponent(i); }
|
||||
|
||||
unsigned row() const {return m_nStartRow; }
|
||||
void updateKeys();
|
||||
|
||||
size_t getMaxNameLength() const {return m_nMaxNameLength; }
|
||||
enum
|
||||
{
|
||||
g_numTimers = 3
|
||||
};
|
||||
|
||||
void startTimer(unsigned nTimer, ITimer* pTimer);
|
||||
void stopTimer(unsigned nTimer, ITimer* pTimer);
|
||||
float getTime(unsigned nTimer) const {assert (nTimer < g_numTimers); return m_fTime[nTimer]; }
|
||||
int getAgeFrames() const {return m_nAgeFrames; }
|
||||
void incAgeFrames() {++m_nAgeFrames; }
|
||||
protected:
|
||||
// refreshes the statistics built after the component array is built
|
||||
void refresh();
|
||||
protected:
|
||||
// the names of the components
|
||||
typedef std::vector<Component> ComponentArray;
|
||||
ComponentArray m_arrComponents;
|
||||
|
||||
// the maximum length of the component name, in characters
|
||||
size_t m_nMaxNameLength;
|
||||
|
||||
// the timer that counts the time spent on statistics gathering
|
||||
float m_fTime[g_numTimers];
|
||||
|
||||
// the age of the statistics, in frames
|
||||
int m_nAgeFrames;
|
||||
|
||||
//current row offset inc/dec by cursor keys
|
||||
unsigned m_nStartRow;
|
||||
|
||||
friend class CrySizerStatsBuilder;
|
||||
};
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// this is the constructor for the CrySizerStats
|
||||
class CrySizerStatsBuilder
|
||||
{
|
||||
public:
|
||||
CrySizerStatsBuilder (CrySizerImpl* pSizer, int nMinSubcomponentBytes = 0);
|
||||
|
||||
void build (CrySizerStats* pStats);
|
||||
|
||||
protected:
|
||||
typedef CrySizerStats::Component Component;
|
||||
// if there is already such name in the map, then just returns the index
|
||||
// of the compoentn in the component array; otherwise adds an entry to themap
|
||||
// and to the component array nad returns its index
|
||||
Component& mapName (unsigned nName);
|
||||
|
||||
// creates the map of names from old to new, and initializes the components themselves
|
||||
void processNames();
|
||||
|
||||
// given the name in the old system, adds the subtree of names to the
|
||||
// name map and components. In case all the subtree is empty, returns 0 and
|
||||
// adds nothing. Otherwise, returns the total size of objects belonging to the
|
||||
// subtree
|
||||
size_t addNameSubtree (unsigned nDepth, size_t nName);
|
||||
|
||||
protected:
|
||||
CrySizerStats* m_pStats;
|
||||
CrySizerImpl* m_pSizer;
|
||||
|
||||
// this is the mapping from the old names into the new componentn indices
|
||||
typedef std::vector<size_t> IdToIdMap;
|
||||
// from old to new
|
||||
IdToIdMap m_mapNames;
|
||||
|
||||
// this is the threshold: if the total number of bytes in the subcomponent
|
||||
// is less than this, the subcomponent isn't shown
|
||||
unsigned m_nMinSubcomponentBytes;
|
||||
};
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// Renders the given usage stats; gets created upon every rendering
|
||||
class CrySizerStatsRenderer
|
||||
{
|
||||
public:
|
||||
// constructor
|
||||
CrySizerStatsRenderer (ISystem* pSystem, CrySizerStats* pStats, unsigned nMaxDepth = 2, int nMinSubcomponentBytes = -1);
|
||||
void render(bool bRefreshMark = false);
|
||||
// dumps it to log. uses MB as default
|
||||
void dump (bool bUseKB = false);
|
||||
|
||||
protected: // -------------------------------------------------
|
||||
|
||||
typedef CrySizerStats::Component Component;
|
||||
|
||||
IRenderer* m_pRenderer; //
|
||||
ILog* m_pLog; //
|
||||
CrySizerStats* m_pStats; //
|
||||
|
||||
ITextModeConsole* m_pTextModeConsole;
|
||||
|
||||
// this is the threshold: if the total number of bytes in the subcomponent
|
||||
// is less than this, the subcomponent isn't shown
|
||||
unsigned m_nMinSubcomponentBytes;
|
||||
|
||||
// the max depth of the branch to output
|
||||
unsigned m_nMaxSubcomponentDepth;
|
||||
};
|
||||
|
||||
#endif // CRYINCLUDE_CRYSYSTEM_CRYSIZERSTATS_H
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,712 +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_CRYSYSTEM_DEFRAGALLOCATOR_H
|
||||
#define CRYINCLUDE_CRYSYSTEM_DEFRAGALLOCATOR_H
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "IDefragAllocator.h"
|
||||
|
||||
#include "System.h"
|
||||
|
||||
#ifndef _RELEASE
|
||||
#define CDBA_DEBUG
|
||||
#endif
|
||||
|
||||
//#define CDBA_MORE_DEBUG
|
||||
|
||||
#ifdef CDBA_DEBUG
|
||||
#define CDBA_ASSERT(x) do { assert(x); if (!(x)) {__debugbreak(); } \
|
||||
} while (0)
|
||||
#else
|
||||
#define CDBA_ASSERT(x) assert(x)
|
||||
#endif
|
||||
|
||||
union SDefragAllocChunkAttr
|
||||
{
|
||||
enum
|
||||
{
|
||||
SizeWidth = 27,
|
||||
SizeMask = (1 << SizeWidth) - 1,
|
||||
BusyMask = 1 << 27,
|
||||
MovingMask = 1 << 28,
|
||||
MaxPinCount = 7,
|
||||
PinnedCountShift = 29,
|
||||
PinnedIncMask = 1 << PinnedCountShift,
|
||||
PinnedCountMask = MaxPinCount << PinnedCountShift,
|
||||
};
|
||||
|
||||
uint32 ui;
|
||||
|
||||
ILINE unsigned int GetSize() const { return ui & SizeMask; }
|
||||
ILINE void SetSize(unsigned int size) { ui = (ui & ~SizeMask) | size; }
|
||||
ILINE void AddSize(int size) { ui += size; }
|
||||
ILINE bool IsBusy() const { return (ui & BusyMask) != 0; }
|
||||
ILINE void SetBusy(bool b) { ui = b ? (ui | BusyMask) : (ui & ~BusyMask); }
|
||||
ILINE bool IsMoving() const { return (ui & MovingMask) != 0; }
|
||||
ILINE void SetMoving(bool m) { ui = m ? (ui | MovingMask) : (ui & ~MovingMask); }
|
||||
ILINE void IncPinCount() { ui += PinnedIncMask; }
|
||||
ILINE void DecPinCount() { ui -= PinnedIncMask; }
|
||||
ILINE bool IsPinned() const { return (ui & PinnedCountMask) != 0; }
|
||||
ILINE unsigned int GetPinCount() const { return (ui & PinnedCountMask) >> PinnedCountShift; }
|
||||
ILINE void SetPinCount(unsigned int p) { ui = (ui & ~PinnedCountMask) | (p << PinnedCountShift); }
|
||||
};
|
||||
|
||||
struct SDefragAllocChunk
|
||||
{
|
||||
enum
|
||||
{
|
||||
AlignBitCount = 4,
|
||||
};
|
||||
typedef IDefragAllocator::Hdl Index;
|
||||
|
||||
Index addrPrevIdx;
|
||||
Index addrNextIdx;
|
||||
|
||||
union
|
||||
{
|
||||
struct
|
||||
{
|
||||
UINT_PTR ptr : sizeof(UINT_PTR) * 8 - AlignBitCount;
|
||||
UINT_PTR logAlign: AlignBitCount;
|
||||
};
|
||||
UINT_PTR packedPtr;
|
||||
};
|
||||
SDefragAllocChunkAttr attr;
|
||||
|
||||
union
|
||||
{
|
||||
void* pContext;
|
||||
struct
|
||||
{
|
||||
Index freePrevIdx;
|
||||
Index freeNextIdx;
|
||||
};
|
||||
};
|
||||
|
||||
#ifndef _RELEASE
|
||||
const char* source;
|
||||
#endif
|
||||
|
||||
void SwapEndian()
|
||||
{
|
||||
::SwapEndian(addrPrevIdx, true);
|
||||
::SwapEndian(addrNextIdx, true);
|
||||
::SwapEndian(packedPtr, true);
|
||||
::SwapEndian(attr.ui, true);
|
||||
|
||||
if (attr.IsBusy())
|
||||
{
|
||||
::SwapEndian(pContext, true);
|
||||
}
|
||||
else
|
||||
{
|
||||
::SwapEndian(freePrevIdx, true);
|
||||
::SwapEndian(freeNextIdx, true);
|
||||
}
|
||||
|
||||
#ifndef _RELEASE
|
||||
::SwapEndian(source, true);
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
struct SDefragAllocSegment
|
||||
{
|
||||
uint32 address;
|
||||
uint32 capacity;
|
||||
SDefragAllocChunk::Index headSentinalChunkIdx;
|
||||
|
||||
void SwapEndian()
|
||||
{
|
||||
::SwapEndian(address, true);
|
||||
::SwapEndian(capacity, true);
|
||||
::SwapEndian(headSentinalChunkIdx, true);
|
||||
}
|
||||
};
|
||||
|
||||
class CDefragAllocator;
|
||||
|
||||
class CDefragAllocatorWalker
|
||||
{
|
||||
public:
|
||||
explicit CDefragAllocatorWalker(CDefragAllocator& alloc);
|
||||
~CDefragAllocatorWalker();
|
||||
|
||||
const SDefragAllocChunk* Next();
|
||||
|
||||
private:
|
||||
CDefragAllocatorWalker(const CDefragAllocatorWalker&);
|
||||
CDefragAllocatorWalker& operator = (const CDefragAllocatorWalker&);
|
||||
|
||||
private:
|
||||
CDefragAllocator* m_pAlloc;
|
||||
SDefragAllocChunk::Index m_nChunkIdx;
|
||||
};
|
||||
|
||||
class CDefragAllocator
|
||||
: public IDefragAllocator
|
||||
{
|
||||
friend class CDefragAllocatorWalker;
|
||||
typedef SDefragAllocChunk::Index Index;
|
||||
|
||||
public:
|
||||
CDefragAllocator();
|
||||
|
||||
void Release(bool bDiscard);
|
||||
|
||||
void Init(UINT_PTR capacity, UINT_PTR minAlignment, const Policy& policy);
|
||||
|
||||
#ifndef _RELEASE
|
||||
void DumpState(const char* filename);
|
||||
void RestoreState(const char* filename);
|
||||
#endif
|
||||
|
||||
// allocatorDisplayOffset will offset the statistics for the allocator depending on the index.
|
||||
// 0 means no offset and default location, 1 means bar will be rendered above the 0th bar and stats to the right of the 0th stats
|
||||
void DisplayMemoryUsage(const char* title, unsigned int allocatorDisplayOffset = 0);
|
||||
|
||||
bool AppendSegment(UINT_PTR capacity);
|
||||
void UnAppendSegment();
|
||||
|
||||
Hdl Allocate(size_t sz, const char* source, void* pContext = NULL);
|
||||
Hdl AllocateAligned(size_t sz, size_t alignment, const char* source, void* pContext = NULL);
|
||||
AllocatePinnedResult AllocatePinned(size_t sz, const char* source, void* pContext = NULL);
|
||||
bool Free(Hdl hdl);
|
||||
|
||||
void ChangeContext(Hdl hdl, void* pNewContext);
|
||||
|
||||
size_t GetAllocated() const { return (size_t)(m_capacity - m_available) << m_logMinAlignment; }
|
||||
IDefragAllocatorStats GetStats();
|
||||
|
||||
size_t DefragmentTick(size_t maxMoves, size_t maxAmount, bool bForce);
|
||||
|
||||
ILINE UINT_PTR UsableSize(Hdl hdl)
|
||||
{
|
||||
Index chunkIdx = ChunkIdxFromHdl(hdl);
|
||||
CDBA_ASSERT(chunkIdx < m_chunks.size());
|
||||
|
||||
SDefragAllocChunk& chunk = m_chunks[chunkIdx];
|
||||
SDefragAllocChunkAttr attr = chunk.attr;
|
||||
|
||||
CDBA_ASSERT(attr.IsBusy());
|
||||
return (UINT_PTR)attr.GetSize() << m_logMinAlignment;
|
||||
}
|
||||
|
||||
// Pin the chunk until the next defrag tick, when it will be automatically unpinned
|
||||
ILINE UINT_PTR WeakPin(Hdl hdl)
|
||||
{
|
||||
Index chunkIdx = ChunkIdxFromHdl(hdl);
|
||||
CDBA_ASSERT(chunkIdx < m_chunks.size());
|
||||
|
||||
SDefragAllocChunk& chunk = m_chunks[chunkIdx];
|
||||
SDefragAllocChunkAttr attr = chunk.attr;
|
||||
CDBA_ASSERT(attr.IsBusy());
|
||||
|
||||
if (attr.IsMoving())
|
||||
{
|
||||
CancelMove(chunkIdx, true);
|
||||
}
|
||||
|
||||
return chunk.ptr << m_logMinAlignment;
|
||||
}
|
||||
|
||||
// Pin the chunk until Unpin is called
|
||||
ILINE UINT_PTR Pin(Hdl hdl)
|
||||
{
|
||||
Index chunkIdx = ChunkIdxFromHdl(hdl);
|
||||
|
||||
SDefragAllocChunk& chunk = m_chunks[chunkIdx];
|
||||
SDefragAllocChunkAttr attr;
|
||||
SDefragAllocChunkAttr newAttr;
|
||||
|
||||
do
|
||||
{
|
||||
attr.ui = const_cast<volatile uint32&>(chunk.attr.ui);
|
||||
newAttr.ui = attr.ui;
|
||||
|
||||
CDBA_ASSERT(attr.GetPinCount() < SDefragAllocChunkAttr::MaxPinCount);
|
||||
CDBA_ASSERT(attr.IsBusy());
|
||||
|
||||
newAttr.IncPinCount();
|
||||
}
|
||||
while (CryInterlockedCompareExchange(alias_cast<volatile LONG*>(&chunk.attr.ui), newAttr.ui, attr.ui) != attr.ui);
|
||||
|
||||
// Potentially a Relocate could be in progress here. Either the Relocate is mid-way, in which case 'IsMoving()' will
|
||||
// still be set, and CancelMove will sync and all is well.
|
||||
|
||||
// If 'IsMoving()' is not set, the Relocate should have just completed, in which case ptr should validly point
|
||||
// to the new location.
|
||||
|
||||
if (attr.IsMoving())
|
||||
{
|
||||
CancelMove(chunkIdx, true);
|
||||
}
|
||||
|
||||
return chunk.ptr << m_logMinAlignment;
|
||||
}
|
||||
|
||||
ILINE void Unpin(Hdl hdl)
|
||||
{
|
||||
SDefragAllocChunk& chunk = m_chunks[ChunkIdxFromHdl(hdl)];
|
||||
SDefragAllocChunkAttr attr;
|
||||
SDefragAllocChunkAttr newAttr;
|
||||
do
|
||||
{
|
||||
attr.ui = const_cast<volatile uint32&>(chunk.attr.ui);
|
||||
newAttr.ui = attr.ui;
|
||||
|
||||
CDBA_ASSERT(attr.IsPinned());
|
||||
CDBA_ASSERT(attr.IsBusy());
|
||||
|
||||
newAttr.DecPinCount();
|
||||
}
|
||||
while (CryInterlockedCompareExchange(alias_cast<volatile LONG*>(&chunk.attr.ui), newAttr.ui, attr.ui) != attr.ui);
|
||||
}
|
||||
|
||||
ILINE const char* GetSourceOf([[maybe_unused]] Hdl hdl)
|
||||
{
|
||||
#ifndef _RELEASE
|
||||
return m_chunks[ChunkIdxFromHdl(hdl)].source;
|
||||
#else
|
||||
return "";
|
||||
#endif
|
||||
}
|
||||
|
||||
private:
|
||||
enum
|
||||
{
|
||||
NumBuckets = 31, // 2GB
|
||||
MaxPendingMoves = 64,
|
||||
|
||||
AddrStartSentinal = 0,
|
||||
AddrEndSentinal = 1,
|
||||
};
|
||||
|
||||
struct SplitResult
|
||||
{
|
||||
bool bSuccessful;
|
||||
Index nLeftSplitChunkIdx;
|
||||
Index nRightSplitChunkIdx;
|
||||
};
|
||||
|
||||
struct PendingMove
|
||||
{
|
||||
PendingMove()
|
||||
: srcChunkIdx(InvalidChunkIdx)
|
||||
, dstChunkIdx(InvalidChunkIdx)
|
||||
, userMoveId(0)
|
||||
, relocated(false)
|
||||
, cancelled(false)
|
||||
{
|
||||
}
|
||||
|
||||
Index srcChunkIdx;
|
||||
Index dstChunkIdx;
|
||||
uint32 userMoveId;
|
||||
IDefragAllocatorCopyNotification notify;
|
||||
bool relocated;
|
||||
bool cancelled;
|
||||
|
||||
void SwapEndian()
|
||||
{
|
||||
::SwapEndian(srcChunkIdx, true);
|
||||
::SwapEndian(dstChunkIdx, true);
|
||||
::SwapEndian(userMoveId, true);
|
||||
}
|
||||
};
|
||||
|
||||
struct PendingMoveSrcChunkPredicate
|
||||
{
|
||||
PendingMoveSrcChunkPredicate(Index ci)
|
||||
: m_ci(ci) {}
|
||||
bool operator () (const PendingMove& pm) const { return pm.srcChunkIdx == m_ci; }
|
||||
Index m_ci;
|
||||
};
|
||||
|
||||
typedef DynArray<PendingMove> PendingMoveVec;
|
||||
typedef std::vector<SDefragAllocSegment> SegmentVec;
|
||||
|
||||
static const Index InvalidChunkIdx = (Index) - 1;
|
||||
|
||||
private:
|
||||
static ILINE Index ChunkIdxFromHdl(Hdl id) { return id - 1; }
|
||||
static ILINE Hdl ChunkHdlFromIdx(Index idx) { return idx + 1; }
|
||||
|
||||
private:
|
||||
~CDefragAllocator();
|
||||
|
||||
Index AllocateChunk();
|
||||
void ReleaseChunk(Index idx);
|
||||
|
||||
ILINE void MarkAsInUse(SDefragAllocChunk& chunk)
|
||||
{
|
||||
CDBA_ASSERT(!chunk.attr.IsBusy());
|
||||
|
||||
chunk.attr.SetBusy(true);
|
||||
m_available -= chunk.attr.GetSize();
|
||||
++m_numAllocs;
|
||||
|
||||
// m_available is unsigned, so check for underflow
|
||||
CDBA_ASSERT(m_available <= m_capacity);
|
||||
}
|
||||
|
||||
ILINE void MarkAsFree(SDefragAllocChunk& chunk)
|
||||
{
|
||||
CDBA_ASSERT(chunk.attr.IsBusy());
|
||||
|
||||
chunk.attr.SetPinCount(0);
|
||||
chunk.attr.SetMoving(false);
|
||||
chunk.attr.SetBusy(0);
|
||||
m_available += chunk.attr.GetSize();
|
||||
--m_numAllocs;
|
||||
|
||||
// m_available is unsigned, so check for underflow
|
||||
CDBA_ASSERT(m_available <= m_capacity);
|
||||
}
|
||||
|
||||
void LinkFreeChunk(Index idx);
|
||||
void UnlinkFreeChunk(Index idx)
|
||||
{
|
||||
SDefragAllocChunk& chunk = m_chunks[idx];
|
||||
m_chunks[chunk.freePrevIdx].freeNextIdx = chunk.freeNextIdx;
|
||||
m_chunks[chunk.freeNextIdx].freePrevIdx = chunk.freePrevIdx;
|
||||
}
|
||||
|
||||
void LinkAddrChunk(Index idx, Index afterIdx)
|
||||
{
|
||||
SDefragAllocChunk& chunk = m_chunks[idx];
|
||||
SDefragAllocChunk& afterChunk = m_chunks[afterIdx];
|
||||
|
||||
chunk.addrNextIdx = afterChunk.addrNextIdx;
|
||||
chunk.addrPrevIdx = afterIdx;
|
||||
m_chunks[chunk.addrNextIdx].addrPrevIdx = idx;
|
||||
afterChunk.addrNextIdx = idx;
|
||||
}
|
||||
|
||||
void UnlinkAddrChunk(Index id)
|
||||
{
|
||||
SDefragAllocChunk& chunk = m_chunks[id];
|
||||
|
||||
m_chunks[chunk.addrPrevIdx].addrNextIdx = chunk.addrNextIdx;
|
||||
m_chunks[chunk.addrNextIdx].addrPrevIdx = chunk.addrPrevIdx;
|
||||
}
|
||||
|
||||
void PrepareMergePopNext(Index* pLists)
|
||||
{
|
||||
for (int bucketIdx = 0; bucketIdx < NumBuckets; ++bucketIdx)
|
||||
{
|
||||
Index hdrChunkId = m_freeBuckets[bucketIdx];
|
||||
Index nextId = m_chunks[hdrChunkId].freeNextIdx;
|
||||
if (nextId != hdrChunkId)
|
||||
{
|
||||
pLists[bucketIdx] = nextId;
|
||||
}
|
||||
else
|
||||
{
|
||||
pLists[bucketIdx] = InvalidChunkIdx;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
size_t MergePeekNextChunk(Index* pLists)
|
||||
{
|
||||
size_t farList = (size_t)-1;
|
||||
UINT_PTR farPtr = (UINT_PTR)-1;
|
||||
|
||||
for (size_t listIdx = 0; listIdx < NumBuckets; ++listIdx)
|
||||
{
|
||||
Index chunkIdx = pLists[listIdx];
|
||||
if (chunkIdx != InvalidChunkIdx)
|
||||
{
|
||||
SDefragAllocChunk& chunk = m_chunks[chunkIdx];
|
||||
if (chunk.ptr < farPtr)
|
||||
{
|
||||
farPtr = chunk.ptr;
|
||||
farList = listIdx;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return farList;
|
||||
}
|
||||
|
||||
void MergePopNextChunk(Index* pLists, size_t list)
|
||||
{
|
||||
using std::swap;
|
||||
|
||||
Index fni = m_chunks[pLists[list]].freeNextIdx;
|
||||
pLists[list] = fni;
|
||||
if (m_chunks[fni].attr.IsBusy())
|
||||
{
|
||||
// End of the list
|
||||
pLists[list] = InvalidChunkIdx;
|
||||
}
|
||||
}
|
||||
|
||||
void MergePatchNextRemove(Index* pLists, Index removeIdx)
|
||||
{
|
||||
for (int bucketIdx = 0; bucketIdx < NumBuckets; ++bucketIdx)
|
||||
{
|
||||
if (pLists[bucketIdx] == removeIdx)
|
||||
{
|
||||
Index nextIdx = m_chunks[removeIdx].freeNextIdx;
|
||||
if (!m_chunks[nextIdx].attr.IsBusy())
|
||||
{
|
||||
pLists[bucketIdx] = nextIdx;
|
||||
}
|
||||
else
|
||||
{
|
||||
pLists[bucketIdx] = InvalidChunkIdx;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MergePatchNextInsert(Index* pLists, Index insertIdx)
|
||||
{
|
||||
SDefragAllocChunk& insertChunk = m_chunks[insertIdx];
|
||||
int bucket = BucketForSize(insertChunk.attr.GetSize());
|
||||
|
||||
if (pLists[bucket] != InvalidChunkIdx)
|
||||
{
|
||||
SDefragAllocChunk& listChunk = m_chunks[pLists[bucket]];
|
||||
if (listChunk.ptr > insertChunk.ptr)
|
||||
{
|
||||
pLists[bucket] = insertIdx;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void PrepareMergePopPrev(Index* pLists)
|
||||
{
|
||||
for (int bucketIdx = 0; bucketIdx < NumBuckets; ++bucketIdx)
|
||||
{
|
||||
Index hdrChunkId = m_freeBuckets[bucketIdx];
|
||||
Index prevIdx = m_chunks[hdrChunkId].freePrevIdx;
|
||||
if (prevIdx != hdrChunkId)
|
||||
{
|
||||
pLists[bucketIdx] = prevIdx;
|
||||
}
|
||||
else
|
||||
{
|
||||
pLists[bucketIdx] = InvalidChunkIdx;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
size_t MergePeekPrevChunk(Index* pLists)
|
||||
{
|
||||
size_t farList = (size_t)-1;
|
||||
UINT_PTR farPtr = 0;
|
||||
|
||||
for (size_t listIdx = 0; listIdx < NumBuckets; ++listIdx)
|
||||
{
|
||||
Index chunkIdx = pLists[listIdx];
|
||||
if (chunkIdx != InvalidChunkIdx)
|
||||
{
|
||||
SDefragAllocChunk& chunk = m_chunks[chunkIdx];
|
||||
if (chunk.ptr >= farPtr)
|
||||
{
|
||||
farPtr = chunk.ptr;
|
||||
farList = listIdx;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return farList;
|
||||
}
|
||||
|
||||
void MergePopPrevChunk(Index* pLists, size_t list)
|
||||
{
|
||||
using std::swap;
|
||||
|
||||
Index fpi = m_chunks[pLists[list]].freePrevIdx;
|
||||
pLists[list] = fpi;
|
||||
if (m_chunks[fpi].attr.IsBusy())
|
||||
{
|
||||
// End of the list
|
||||
pLists[list] = InvalidChunkIdx;
|
||||
}
|
||||
}
|
||||
|
||||
void MergePatchPrevInsert(Index* pLists, Index insertIdx)
|
||||
{
|
||||
SDefragAllocChunk& insertChunk = m_chunks[insertIdx];
|
||||
int bucket = BucketForSize(insertChunk.attr.GetSize());
|
||||
|
||||
if (pLists[bucket] != InvalidChunkIdx)
|
||||
{
|
||||
SDefragAllocChunk& listChunk = m_chunks[pLists[bucket]];
|
||||
if (listChunk.ptr < insertChunk.ptr)
|
||||
{
|
||||
pLists[bucket] = insertIdx;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MergePatchPrevRemove(Index* pLists, Index removeIdx)
|
||||
{
|
||||
for (int bucketIdx = 0; bucketIdx < NumBuckets; ++bucketIdx)
|
||||
{
|
||||
if (pLists[bucketIdx] == removeIdx)
|
||||
{
|
||||
Index nextIdx = m_chunks[removeIdx].freePrevIdx;
|
||||
if (!m_chunks[nextIdx].attr.IsBusy())
|
||||
{
|
||||
pLists[bucketIdx] = nextIdx;
|
||||
}
|
||||
else
|
||||
{
|
||||
pLists[bucketIdx] = InvalidChunkIdx;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MarkAsMoving(SDefragAllocChunk& src)
|
||||
{
|
||||
SDefragAllocChunkAttr srcAttr, srcNewAttr;
|
||||
do
|
||||
{
|
||||
srcAttr.ui = const_cast<volatile uint32&>(src.attr.ui);
|
||||
srcNewAttr.ui = srcAttr.ui;
|
||||
srcNewAttr.SetMoving(true);
|
||||
}
|
||||
while (CryInterlockedCompareExchange(alias_cast<volatile LONG*>(&src.attr.ui), srcNewAttr.ui, srcAttr.ui) != srcAttr.ui);
|
||||
}
|
||||
|
||||
void MarkAsNotMoving(SDefragAllocChunk& src)
|
||||
{
|
||||
SDefragAllocChunkAttr srcAttr, srcNewAttr;
|
||||
do
|
||||
{
|
||||
srcAttr.ui = const_cast<volatile uint32&>(src.attr.ui);
|
||||
srcNewAttr.ui = srcAttr.ui;
|
||||
srcNewAttr.SetMoving(false);
|
||||
}
|
||||
while (CryInterlockedCompareExchange(alias_cast<volatile LONG*>(&src.attr.ui), srcNewAttr.ui, srcAttr.ui) != srcAttr.ui);
|
||||
}
|
||||
|
||||
ILINE bool IsMoveableCandidate(const SDefragAllocChunkAttr& a, uint32 sizeUpperBound)
|
||||
{
|
||||
return a.IsBusy() && !a.IsPinned() && !a.IsMoving() && (0 < a.GetSize()) && (a.GetSize() <= sizeUpperBound);
|
||||
}
|
||||
|
||||
bool TryMarkAsMoving(SDefragAllocChunk& src, uint32 sizeUpperBound)
|
||||
{
|
||||
SDefragAllocChunkAttr srcAttr, srcNewAttr;
|
||||
do
|
||||
{
|
||||
srcAttr.ui = const_cast<volatile uint32&>(src.attr.ui);
|
||||
srcNewAttr.ui = srcAttr.ui;
|
||||
if (!IsMoveableCandidate(srcAttr, sizeUpperBound))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
srcNewAttr.SetMoving(true);
|
||||
}
|
||||
while (CryInterlockedCompareExchange(alias_cast<volatile LONG*>(&src.attr.ui), srcNewAttr.ui, srcAttr.ui) != srcAttr.ui);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TryScheduleCopy(SDefragAllocChunk& srcChunk, SDefragAllocChunk& dstChunk, PendingMove* pPM, bool bLowHalf)
|
||||
{
|
||||
UINT_PTR dstChunkBase = dstChunk.ptr;
|
||||
UINT_PTR dstChunkEnd = dstChunkBase + dstChunk.attr.GetSize();
|
||||
#if AZ_LEGACY_CRYSYSTEM_TRAIT_USE_BIT64
|
||||
UINT_PTR allocAlign = BIT64(srcChunk.logAlign);
|
||||
#else
|
||||
UINT_PTR allocAlign = BIT(srcChunk.logAlign);
|
||||
#endif
|
||||
UINT_PTR allocSize = srcChunk.attr.GetSize();
|
||||
UINT_PTR dstAllocBase = bLowHalf
|
||||
? Align(dstChunkBase, allocAlign)
|
||||
: ((dstChunkEnd - allocSize) & ~(allocAlign - 1));
|
||||
|
||||
uint32 userId = m_policy.pDefragPolicy->BeginCopy(
|
||||
srcChunk.pContext,
|
||||
dstAllocBase << m_logMinAlignment,
|
||||
srcChunk.ptr << m_logMinAlignment,
|
||||
allocSize << m_logMinAlignment,
|
||||
&pPM->notify);
|
||||
pPM->userMoveId = userId;
|
||||
|
||||
return userId != 0;
|
||||
}
|
||||
|
||||
Hdl Allocate_Locked(size_t sz, size_t alignment, const char* source, void* pContext);
|
||||
SplitResult SplitFreeBlock(Index fbId, size_t sz, size_t alignment, bool allocateInLowHalf);
|
||||
Index MergeFreeBlock(Index fbId);
|
||||
|
||||
#ifdef CDBA_MORE_DEBUG
|
||||
void Defrag_ValidateFreeBlockIteration();
|
||||
#endif
|
||||
|
||||
Index BestFit_FindFreeBlockForSegment(size_t sz, size_t alignment, uint32 nSegment);
|
||||
Index BestFit_FindFreeBlockFor(size_t sz, size_t alignment, UINT_PTR addressMin, UINT_PTR addressMax, bool allocateInLowHalf);
|
||||
Index FirstFit_FindFreeBlockFor(size_t sz, size_t alignment, UINT_PTR addressMin, UINT_PTR addressMax, bool allocateInLowHalf);
|
||||
|
||||
size_t Defrag_FindMovesBwd(PendingMove** pMoves, size_t maxMoves, size_t& curAmount, size_t maxAmount);
|
||||
size_t Defrag_FindMovesFwd(PendingMove** pMoves, size_t maxMoves, size_t& curAmount, size_t maxAmount);
|
||||
bool Defrag_CompletePendingMoves();
|
||||
Index Defrag_Bwd_FindFreeBlockFor(size_t sz, size_t alignment, UINT_PTR addressLimit);
|
||||
Index Defrag_Fwd_FindFreeBlockFor(size_t sz, size_t alignment, UINT_PTR addressLimit);
|
||||
|
||||
PendingMove* AllocPendingMove();
|
||||
void FreePendingMove(PendingMove* pMove);
|
||||
|
||||
void CancelMove(Index srcChunkIdx, bool bIsContentNeeded);
|
||||
void CancelMove_Locked(Index srcChunkIdx, bool bIsContentNeeded);
|
||||
void Relocate(uint32 userMoveId, Index srcChunkIdx, Index dstChunkIdx);
|
||||
|
||||
void SyncMoveSegment(uint32 seg);
|
||||
|
||||
void RebuildFreeLists();
|
||||
void ValidateAddressChain();
|
||||
void ValidateFreeLists();
|
||||
|
||||
int BucketForSize(size_t sz) const
|
||||
{
|
||||
return sz > 0
|
||||
? static_cast<int>(IntegerLog2(sz))
|
||||
: 0;
|
||||
}
|
||||
|
||||
private:
|
||||
bool m_isThreadSafe;
|
||||
bool m_chunksAreFixed;
|
||||
|
||||
CryCriticalSection m_lock;
|
||||
|
||||
uint32 m_capacity;
|
||||
uint32 m_available;
|
||||
Index m_numAllocs;
|
||||
|
||||
uint16 m_minAlignment;
|
||||
uint16 m_logMinAlignment;
|
||||
|
||||
Index m_freeBuckets[NumBuckets];
|
||||
|
||||
std::vector<SDefragAllocChunk> m_chunks;
|
||||
std::vector<Index> m_unusedChunks;
|
||||
PendingMoveVec m_pendingMoves;
|
||||
SegmentVec m_segments;
|
||||
|
||||
uint32 m_nCancelledMoves;
|
||||
|
||||
Policy m_policy;
|
||||
};
|
||||
|
||||
#endif // CRYINCLUDE_CRYSYSTEM_DEFRAGALLOCATOR_H
|
||||
@ -1,102 +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.
|
||||
|
||||
#include "CrySystem_precompiled.h"
|
||||
#include "HMDCVars.h"
|
||||
#include <HMDBus.h>
|
||||
#include <sstream>
|
||||
|
||||
namespace AZ
|
||||
{
|
||||
namespace VR
|
||||
{
|
||||
|
||||
void HMDCVars::OnHMDRecenter([[maybe_unused]] IConsoleCmdArgs* args)
|
||||
{
|
||||
EBUS_EVENT(AZ::VR::HMDDeviceRequestBus, RecenterPose);
|
||||
}
|
||||
|
||||
void HMDCVars::OnHMDTrackingLevelChange(IConsoleCmdArgs* args)
|
||||
{
|
||||
if (args->GetArgCount() != 2)
|
||||
{
|
||||
// First arg should be the command itself, second arg should be the requested tracking level.
|
||||
return;
|
||||
}
|
||||
|
||||
// Read the new tracking level.
|
||||
int argVal = 0;
|
||||
std::stringstream stream(args->GetArg(1));
|
||||
stream >> argVal;
|
||||
|
||||
AZ::VR::HMDTrackingLevel level = static_cast<AZ::VR::HMDTrackingLevel>(argVal);
|
||||
EBUS_EVENT(AZ::VR::HMDDeviceRequestBus, SetTrackingLevel, level);
|
||||
}
|
||||
|
||||
void HMDCVars::OnOutputToHMDChanged(ICVar* var)
|
||||
{
|
||||
// Set the necessary cvars for turning on/off output to an HMD.
|
||||
ICVar* mode = gEnv->pConsole->GetCVar("r_StereoMode");
|
||||
ICVar* output = gEnv->pConsole->GetCVar("r_StereoOutput");
|
||||
ICVar* height = gEnv->pConsole->GetCVar("r_height");
|
||||
ICVar* width = gEnv->pConsole->GetCVar("r_width");
|
||||
|
||||
if (!mode || !output || !height || !width)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
bool enable = (var->GetIVal() == 1);
|
||||
if (enable)
|
||||
{
|
||||
// Auto-set the resolution.
|
||||
{
|
||||
const AZ::VR::HMDDeviceInfo* deviceInfo = nullptr;
|
||||
EBUS_EVENT_RESULT(deviceInfo, AZ::VR::HMDDeviceRequestBus, GetDeviceInfo);
|
||||
|
||||
// If the device info exists then there is a VR device connected and working.
|
||||
if (deviceInfo)
|
||||
{
|
||||
mode->Set(EStereoMode::STEREO_MODE_DUAL_RENDERING);
|
||||
output->Set(EStereoOutput::STEREO_OUTPUT_HMD);
|
||||
|
||||
width->Set(static_cast<int>(deviceInfo->renderWidth));
|
||||
height->Set(static_cast<int>(deviceInfo->renderHeight));
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mode->Set(EStereoMode::STEREO_MODE_NO_STEREO);
|
||||
output->Set(EStereoOutput::STEREO_OUTPUT_STANDARD);
|
||||
}
|
||||
}
|
||||
|
||||
void HMDCVars::OnHMDDebugInfo(ICVar* var)
|
||||
{
|
||||
bool enable = (var->GetIVal() == 1);
|
||||
EBUS_EVENT(AZ::VR::HMDDebuggerRequestBus, EnableInfo, enable);
|
||||
}
|
||||
|
||||
void HMDCVars::OnHMDDebugCamera(ICVar* var)
|
||||
{
|
||||
bool enable = (var->GetIVal() == 1);
|
||||
EBUS_EVENT(AZ::VR::HMDDebuggerRequestBus, EnableCamera, enable);
|
||||
}
|
||||
|
||||
int HMDCVars::hmd_social_screen = static_cast<int>(HMDSocialScreen::UndistortedLeftEye);
|
||||
int HMDCVars::hmd_debug_info = 0;
|
||||
int HMDCVars::hmd_debug_camera = 0;
|
||||
|
||||
} // namespace VR
|
||||
} // namespace AZ
|
||||
@ -1,71 +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 <IConsole.h>
|
||||
#include <ISystem.h>
|
||||
|
||||
namespace AZ
|
||||
{
|
||||
namespace VR
|
||||
{
|
||||
class HMDCVars
|
||||
{
|
||||
public:
|
||||
|
||||
static int hmd_social_screen;
|
||||
static int hmd_debug_info;
|
||||
static int hmd_debug_camera;
|
||||
|
||||
static void Register()
|
||||
{
|
||||
REGISTER_CVAR2("hmd_social_screen", &hmd_social_screen, hmd_social_screen,
|
||||
VF_NULL, "Selects the social screen mode: \n"
|
||||
"-1- Off\n"
|
||||
"0 - Undistorted left eye\n"
|
||||
"1 - Undistorted right eye\n"
|
||||
);
|
||||
|
||||
REGISTER_INT_CB("hmd_debug_info", 0, VF_ALWAYSONCHANGE,
|
||||
"Enable/disable HMD and VR controller debug info/rendering",
|
||||
OnHMDDebugInfo);
|
||||
|
||||
REGISTER_INT_CB("hmd_debug_camera", 0, VF_ALWAYSONCHANGE,
|
||||
"Enable/disable HMD debug camera",
|
||||
OnHMDDebugCamera);
|
||||
|
||||
REGISTER_COMMAND("hmd_tracking_level", &OnHMDTrackingLevelChange,
|
||||
VF_NULL, "Set the HMD center reference point.\n"
|
||||
"0 - Camera (Actor's head)\n"
|
||||
"1 - Actor's feet (floor)\n");
|
||||
|
||||
REGISTER_COMMAND("hmd_recenter_pose", &OnHMDRecenter,
|
||||
VF_NULL, "Re-centers sensor orientation of the HMD.");
|
||||
|
||||
REGISTER_INT_CB("output_to_hmd", 0, VF_ALWAYSONCHANGE,
|
||||
"Enable/disable output to any connected HMD (for VR)",
|
||||
OnOutputToHMDChanged);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
static void OnHMDRecenter(IConsoleCmdArgs* args);
|
||||
static void OnHMDTrackingLevelChange(IConsoleCmdArgs* args);
|
||||
static void OnOutputToHMDChanged(ICVar* var);
|
||||
static void OnHMDDebugInfo(ICVar* var);
|
||||
static void OnHMDDebugCamera(ICVar* var);
|
||||
};
|
||||
} // namespace VR
|
||||
} // namespace AZ
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue