birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin' into MultiplayerComponents

Browse Source
This commit is contained in:
karlberg
2021-05-11 13:43:17 -07:00
parent 5440d0926d ab8738b7c3
commit 74385a575f
1119 changed files with 28174 additions and 131365 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Code/CryEngine/CryCommon/AnimTime.h
-173
View File
@@ -1,173 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef __animtime_h__
#define __animtime_h__
#include <IXml.h>
#include <AzCore/Casting/numeric_cast.h>
#include <Serialization/IArchive.h>
struct SAnimTime
{
static const uint numTicksPerSecond = 6000;
// List of possible frame rates (dividers of 6000). Most commonly used ones first.
enum EFrameRate
{
// Common
eFrameRate_30fps, eFrameRate_60fps, eFrameRate_120fps,
// Possible
eFrameRate_10fps, eFrameRate_12fps, eFrameRate_15fps, eFrameRate_24fps,
eFrameRate_25fps, eFrameRate_40fps, eFrameRate_48fps, eFrameRate_50fps,
eFrameRate_75fps, eFrameRate_80fps, eFrameRate_100fps, eFrameRate_125fps,
eFrameRate_150fps, eFrameRate_200fps, eFrameRate_240fps, eFrameRate_250fps,
eFrameRate_300fps, eFrameRate_375fps, eFrameRate_400fps, eFrameRate_500fps,
eFrameRate_600fps, eFrameRate_750fps, eFrameRate_1000fps, eFrameRate_1200fps,
eFrameRate_1500fps, eFrameRate_2000fps, eFrameRate_3000fps, eFrameRate_6000fps,
eFrameRate_Num
};
SAnimTime()
: m_ticks(0) {}
explicit SAnimTime(int32 ticks)
: m_ticks(ticks) {}
explicit SAnimTime(float time)
: m_ticks(aznumeric_caster(std::lround(static_cast<double>(time) * numTicksPerSecond))) {}
static uint GetFrameRateValue(EFrameRate frameRate)
{
const uint frameRateValues[eFrameRate_Num] =
{
// Common
30, 60, 120,
// Possible
10, 12, 15, 24, 25, 40, 48, 50, 75, 80, 100, 125,
150, 200, 240, 250, 300, 375, 400, 500, 600, 750,
1000, 1200, 1500, 2000, 3000, 6000
};
return frameRateValues[frameRate];
}
static const char* GetFrameRateName(EFrameRate frameRate)
{
const char* frameRateNames[eFrameRate_Num] =
{
// Common
"30 fps", "60 fps", "120 fps",
// Possible
"10 fps", "12 fps", "15 fps", "24 fps",
"25 fps", "40 fps", "48 fps", "50 fps",
"75 fps", "80 fps", "100 fps", "125 fps",
"150 fps", "200 fps", "240 fps", "250 fps",
"300 fps", "375 fps", "400 fps", "500 fps",
"600 fps", "750 fps", "1000 fps", "1200 fps",
"1500 fps", "2000 fps", "3000 fps", "6000 fps"
};
return frameRateNames[frameRate];
}
float ToFloat() const { return static_cast<float>(m_ticks) / numTicksPerSecond; }
void Serialize(Serialization::IArchive& ar)
{
ar(m_ticks, "ticks", "Ticks");
}
// Helper to serialize from ticks or old float time
void Serialize(XmlNodeRef keyNode, bool bLoading, const char* pName, const char* pLegacyName)
{
if (bLoading)
{
int32 ticks;
if (!keyNode->getAttr(pName, ticks))
{
// Backwards compatibility
float time = 0.0f;
keyNode->getAttr(pLegacyName, time);
*this = SAnimTime(time);
}
else
{
m_ticks = ticks;
}
}
else if (m_ticks > 0)
{
keyNode->setAttr(pName, m_ticks);
}
}
int32 GetTicks() const { return m_ticks; }
static SAnimTime Min() { SAnimTime minTime; minTime.m_ticks = std::numeric_limits<int32>::lowest(); return minTime; }
static SAnimTime Max() { SAnimTime maxTime; maxTime.m_ticks = (std::numeric_limits<int32>::max)(); return maxTime; }
SAnimTime operator-() const { return SAnimTime(-m_ticks); }
SAnimTime operator-(SAnimTime r) const { SAnimTime temp = *this; temp.m_ticks -= r.m_ticks; return temp; }
SAnimTime operator+(SAnimTime r) const { SAnimTime temp = *this; temp.m_ticks += r.m_ticks; return temp; }
SAnimTime operator*(SAnimTime r) const { SAnimTime temp = *this; temp.m_ticks *= r.m_ticks; return temp; }
SAnimTime operator/(SAnimTime r) const { SAnimTime temp; temp.m_ticks = static_cast<int32>((static_cast<int64>(m_ticks) * numTicksPerSecond) / r.m_ticks); return temp; }
SAnimTime operator%(SAnimTime r) const { SAnimTime temp = *this; temp.m_ticks %= r.m_ticks; return temp; }
SAnimTime operator*(float r) const { SAnimTime temp; temp.m_ticks = aznumeric_caster(std::lround(static_cast<double>(m_ticks) * r)); return temp; }
SAnimTime operator/(float r) const { SAnimTime temp; temp.m_ticks = aznumeric_caster(std::lround(static_cast<double>(m_ticks) / r)); return temp; }
SAnimTime& operator+=(SAnimTime r) { *this = *this + r; return *this; }
SAnimTime& operator-=(SAnimTime r) { *this = *this - r; return *this; }
SAnimTime& operator*=(SAnimTime r) { *this = *this * r; return *this; }
SAnimTime& operator/=(SAnimTime r) { *this = *this / r; return *this; }
SAnimTime& operator%=(SAnimTime r) { *this = *this % r; return *this; }
SAnimTime& operator*=(float r) { *this = *this * r; return *this; }
SAnimTime& operator/=(float r) { *this = *this / r; return *this; }
bool operator<(SAnimTime r) const { return m_ticks < r.m_ticks; }
bool operator<=(SAnimTime r) const { return m_ticks <= r.m_ticks; }
bool operator>(SAnimTime r) const { return m_ticks > r.m_ticks; }
bool operator>=(SAnimTime r) const { return m_ticks >= r.m_ticks; }
bool operator==(SAnimTime r) const { return m_ticks == r.m_ticks; }
bool operator!=(SAnimTime r) const { return m_ticks != r.m_ticks; }
// Snap to nearest multiple of given frame rate
SAnimTime SnapToNearest(const EFrameRate frameRate)
{
const int sign = sgn(m_ticks);
const int32 absTicks = abs(m_ticks);
const int framesMod = numTicksPerSecond / GetFrameRateValue(frameRate);
const int32 remainder = absTicks % framesMod;
const bool bNextMultiple = remainder >= (framesMod / 2);
return SAnimTime(sign * ((absTicks - remainder) + (bNextMultiple ? framesMod : 0)));
}
private:
int32 m_ticks;
friend bool Serialize(Serialization::IArchive& ar, SAnimTime& animTime, const char* name, const char* label);
};
inline bool Serialize(Serialization::IArchive& ar, SAnimTime& animTime, const char* name, const char* label)
{
return ar(animTime.m_ticks, name, label);
}
inline SAnimTime abs(SAnimTime time)
{
return (time >= SAnimTime(0)) ? time : -time;
}
#endif
Code/CryEngine/CryCommon/Bezier.h
-321
View File
@@ -1,321 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef __BEZIER_H__
#define __BEZIER_H__
#include <AnimTime.h>
#include <Serialization/IArchive.h>
#include <Serialization/Math.h>
struct SBezierControlPoint
{
SBezierControlPoint()
: m_value(0.0f)
, m_inTangent(ZERO)
, m_outTangent(ZERO)
, m_inTangentType(eTangentType_Auto)
, m_outTangentType(eTangentType_Auto)
, m_bBreakTangents(false)
{
}
enum ETangentType
{
eTangentType_Custom,
eTangentType_Auto,
eTangentType_Zero,
eTangentType_Step,
eTangentType_Linear,
};
void Serialize(Serialization::IArchive& ar)
{
ar(m_value, "value", "Value");
if (ar.IsOutput())
{
bool breakTangents = m_bBreakTangents;
ar(breakTangents, "breakTangents", "Break Tangents");
}
else
{
bool breakTangents = false;
ar(breakTangents, "breakTangents", "Break Tangents");
m_bBreakTangents = breakTangents;
}
if (ar.IsOutput())
{
ETangentType inTangentType = m_inTangentType;
ar(inTangentType, "inTangentType", "Incoming tangent type");
}
else
{
ETangentType inTangentType = eTangentType_Auto;
ar(inTangentType, "inTangentType", "Incoming tangent type");
m_inTangentType = inTangentType;
}
ar(m_inTangent, "inTangent", (m_inTangentType == eTangentType_Custom) ? "Incoming Tangent" : NULL);
if (ar.IsOutput())
{
ETangentType outTangentType = m_outTangentType;
ar(outTangentType, "outTangentType", "Outgoing tangent type");
}
else
{
ETangentType outTangentType = eTangentType_Auto;
ar(outTangentType, "outTangentType", "Outgoing tangent type");
m_outTangentType = outTangentType;
}
ar(m_outTangent, "outTangent", (m_outTangentType == eTangentType_Custom) ? "Outgoing Tangent" : NULL);
}
float m_value;
// For 1D Bezier only the Y component is used
Vec2 m_inTangent;
Vec2 m_outTangent;
ETangentType m_inTangentType : 4;
ETangentType m_outTangentType : 4;
bool m_bBreakTangents : 1;
};
struct SBezierKey
{
SBezierKey()
: m_time(0) {}
void Serialize(Serialization::IArchive& ar)
{
ar(m_time, "time", "Time");
ar(m_controlPoint, "controlPoint", "Control Point");
}
SAnimTime m_time;
SBezierControlPoint m_controlPoint;
};
namespace Bezier
{
inline float Evaluate(float t, float p0, float p1, float p2, float p3)
{
const float a = 1 - t;
const float aSq = a * a;
const float tSq = t * t;
return (aSq * a * p0) + (3.0f * aSq * t * p1) + (3.0f * a * tSq * p2) + (tSq * t * p3);
}
inline float EvaluateDeriv(float t, float p0, float p1, float p2, float p3)
{
const float a = 1 - t;
const float ta = t * a;
const float aSq = a * a;
const float tSq = t * t;
return 3.0f * ((-p2 * tSq) + (p3 * tSq) - (p0 * aSq) + (p1 * aSq) + 2.0f * ((-p1 * ta) + (p2 * ta)));
}
inline float EvaluateX(const float t, const float duration, const SBezierControlPoint& start, const SBezierControlPoint& end)
{
const float p0 = 0.0f;
const float p1 = p0 + start.m_outTangent.x;
const float p3 = duration;
const float p2 = p3 + end.m_inTangent.x;
return Evaluate(t, p0, p1, p2, p3);
}
inline float EvaluateY(const float t, const SBezierControlPoint& start, const SBezierControlPoint& end)
{
const float p0 = start.m_value;
const float p1 = p0 + start.m_outTangent.y;
const float p3 = end.m_value;
const float p2 = p3 + end.m_inTangent.y;
return Evaluate(t, p0, p1, p2, p3);
}
// Duration = (time at end key) - (time at start key)
inline float EvaluateDerivX(const float t, const float duration, const SBezierControlPoint& start, const SBezierControlPoint& end)
{
const float p0 = 0.0f;
const float p1 = p0 + start.m_outTangent.x;
const float p3 = duration;
const float p2 = p3 + end.m_inTangent.x;
return EvaluateDeriv(t, p0, p1, p2, p3);
}
inline float EvaluateDerivY(const float t, const SBezierControlPoint& start, const SBezierControlPoint& end)
{
const float p0 = start.m_value;
const float p1 = p0 + start.m_outTangent.y;
const float p3 = end.m_value;
const float p2 = p3 + end.m_inTangent.y;
return EvaluateDeriv(t, p0, p1, p2, p3);
}
// Find interpolation factor where 2D bezier curve has the given x value. Works only for curves where x is monotonically increasing.
// The passed x must be in range [0, duration]. Uses the Newton-Raphson root finding method. Usually takes 2 or 3 iterations.
//
// Note: This is for "1D" 2D bezier curves as used in TrackView. The curves are restricted by the curve editor to be monotonically increasing.
//
inline float InterpolationFactorFromX(const float x, const float duration, const SBezierControlPoint& start, const SBezierControlPoint& end)
{
float t = (x / duration);
const float epsilon = 0.00001f;
const uint maxSteps = 10;
for (uint i = 0; i < maxSteps; ++i)
{
const float currentX = EvaluateX(t, duration, start, end) - x;
if (fabs(currentX) <= epsilon)
{
break;
}
const float currentXDeriv = EvaluateDerivX(t, duration, start, end);
t -= currentX / currentXDeriv;
}
return t;
}
inline SBezierControlPoint CalculateInTangent(
float time, const SBezierControlPoint& point,
float leftTime, const SBezierControlPoint* pLeftPoint,
float rightTime, const SBezierControlPoint* pRightPoint)
{
SBezierControlPoint newPoint = point;
// In tangent X can never be positive
newPoint.m_inTangent.x = std::min(point.m_inTangent.x, 0.0f);
if (pLeftPoint)
{
switch (point.m_inTangentType)
{
case SBezierControlPoint::eTangentType_Custom:
{
// Need to clamp tangent if it is reaching over last point
const float deltaTime = time - leftTime;
if (deltaTime < -newPoint.m_inTangent.x)
{
if (newPoint.m_inTangent.x == 0)
{
newPoint.m_inTangent = Vec2(ZERO);
}
else
{
float scaleFactor = deltaTime / -newPoint.m_inTangent.x;
newPoint.m_inTangent.x = -deltaTime;
newPoint.m_inTangent.y *= scaleFactor;
}
}
}
break;
case SBezierControlPoint::eTangentType_Zero:
// Fall through. Zero for y is same as Auto, x is set to 0.0f
case SBezierControlPoint::eTangentType_Auto:
{
const SBezierControlPoint& rightPoint = pRightPoint ? *pRightPoint : point;
const float deltaTime = (pRightPoint ? rightTime : time) - leftTime;
if (deltaTime > 0.0f)
{
const float ratio = (time - leftTime) / deltaTime;
const float deltaValue = rightPoint.m_value - pLeftPoint->m_value;
const bool bIsZeroTangent = (point.m_inTangentType == SBezierControlPoint::eTangentType_Zero);
newPoint.m_inTangent = Vec2(-(deltaTime * ratio) / 3.0f, bIsZeroTangent ? 0.0f : -(deltaValue * ratio) / 3.0f);
}
else
{
newPoint.m_inTangent = Vec2(ZERO);
}
}
break;
case SBezierControlPoint::eTangentType_Linear:
newPoint.m_inTangent = Vec2((leftTime - time) / 3.0f,
(pLeftPoint->m_value - point.m_value) / 3.0f);
break;
}
}
return newPoint;
}
inline SBezierControlPoint CalculateOutTangent(
float time, const SBezierControlPoint& point,
float leftTime, const SBezierControlPoint* pLeftPoint,
float rightTime, const SBezierControlPoint* pRightPoint)
{
SBezierControlPoint newPoint = point;
// Out tangent X can never be negative
newPoint.m_outTangent.x = std::max(point.m_outTangent.x, 0.0f);
if (pRightPoint)
{
switch (point.m_outTangentType)
{
case SBezierControlPoint::eTangentType_Custom:
{
// Need to clamp tangent if it is reaching over next point
const float deltaTime = rightTime - time;
if (deltaTime < newPoint.m_outTangent.x)
{
if (newPoint.m_outTangent.x == 0)
{
newPoint.m_outTangent = Vec2(ZERO);
}
else
{
float scaleFactor = deltaTime / newPoint.m_outTangent.x;
newPoint.m_outTangent.x = deltaTime;
newPoint.m_outTangent.y *= scaleFactor;
}
}
}
break;
case SBezierControlPoint::eTangentType_Zero:
// Fall through. Zero for y is same as Auto, x is set to 0.0f
case SBezierControlPoint::eTangentType_Auto:
{
const SBezierControlPoint& leftPoint = pLeftPoint ? *pLeftPoint : point;
const float deltaTime = rightTime - (pLeftPoint ? leftTime : time);
if (deltaTime > 0.0f)
{
const float ratio = (rightTime - time) / deltaTime;
const float deltaValue = pRightPoint->m_value - leftPoint.m_value;
const bool bIsZeroTangent = (point.m_outTangentType == SBezierControlPoint::eTangentType_Zero);
newPoint.m_outTangent = Vec2((deltaTime * ratio) / 3.0f, bIsZeroTangent ? 0.0f : (deltaValue * ratio) / 3.0f);
}
else
{
newPoint.m_outTangent = Vec2(ZERO);
}
}
break;
case SBezierControlPoint::eTangentType_Linear:
newPoint.m_outTangent = Vec2((rightTime - time) / 3.0f,
(pRightPoint->m_value - point.m_value) / 3.0f);
break;
}
}
return newPoint;
}
}
#endif
Code/CryEngine/CryCommon/CREBaseCloud.h
-158
View File
@@ -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__
Code/CryEngine/CryCommon/CREFogVolume.h
-66
View File
@@ -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_
Code/CryEngine/CryCommon/CREGameEffect.h
-63
View File
@@ -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_
Code/CryEngine/CryCommon/CREGeomCache.h
-95
View File
@@ -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
Code/CryEngine/CryCommon/CREImposter.h
-194
View File
@@ -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; }
};
Code/CryEngine/CryCommon/CREMesh.h
-57
View File
@@ -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__
Code/CryEngine/CryCommon/CREOcclusionQuery.h
-116
View File
@@ -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
Code/CryEngine/CryCommon/CREPostProcess.h
-56
View File
@@ -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
Code/CryEngine/CryCommon/CREPrismObject.h
-40
View File
@@ -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_
Code/CryEngine/CryCommon/CRESky.h
-92
View File
@@ -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__
Code/CryEngine/CryCommon/CREVolumeObject.h
-70
View File
@@ -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_
Code/CryEngine/CryCommon/CREWaterOcean.h
-57
View File
@@ -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
Code/CryEngine/CryCommon/CREWaterVolume.h
-110
View File
@@ -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_
Code/CryEngine/CryCommon/CryAssert_Mac.h
-37
View File
@@ -45,43 +45,6 @@ void CryAssertTrace(const char* szFormat, ...)
}
}
}
/*
bool CryAssert(const char* szCondition, const char* szFile,unsigned int line, bool *pIgnore)
{
if (!gEnv) return false;
gEnv->pSystem->OnAssert(szCondition, gs_szMessage, szFile, line);
if (!gEnv->bNoAssertDialog && !gEnv->bIgnoreAllAsserts)
{
EDialogAction action = MacOSXHandleAssert(szCondition, szFile, line, gs_szMessage, gEnv->pRenderer != NULL);
switch (action) {
case eDAStop:
raise(SIGABRT);
exit(-1);
case eDABreak:
return true;
case eDAIgnoreAll:
gEnv->bIgnoreAllAsserts = true;
break;
case eDAIgnore:
*pIgnore = true;
break;
case eDAReportAsBug:
if ( gEnv && gEnv->pSystem)
{
gEnv->pSystem->ReportBug("Assert: %s - %s", szCondition,gs_szMessage);
}
case eDAContinue:
default:
break;
}
}
return false;
}*/
bool CryAssert(const char* szCondition, const char* szFile, unsigned int line, bool* pIgnore)
{
Code/CryEngine/CryCommon/CryExtension/CryCreateClassInstance.h
-96
View File
@@ -1,96 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Part of CryEngine's extension framework.
#ifndef CRYINCLUDE_CRYEXTENSION_CRYCREATECLASSINSTANCE_H
#define CRYINCLUDE_CRYEXTENSION_CRYCREATECLASSINSTANCE_H
#pragma once
#include "ICryUnknown.h"
#include "ICryFactory.h"
#include "ICryFactoryRegistry.h"
#include <ISystem.h> // <> required for Interfuscator
template <class T>
bool CryCreateClassInstance(const CryClassID& cid, AZStd::shared_ptr<T>& p)
{
p = AZStd::shared_ptr<T>();
ICryFactoryRegistry* pFactoryReg = gEnv->pSystem->GetCryFactoryRegistry();
if (pFactoryReg)
{
ICryFactory* pFactory = pFactoryReg->GetFactory(cid);
if (pFactory && pFactory->ClassSupports(cryiidof<T>()))
{
ICryUnknownPtr pUnk = pFactory->CreateClassInstance();
AZStd::shared_ptr<T> pT = cryinterface_cast<T>(pUnk);
if (pT)
{
p = pT;
}
}
}
return p.get() != NULL;
}
template <class T>
bool CryCreateClassInstance(const char* cname, AZStd::shared_ptr<T>& p)
{
p = AZStd::shared_ptr<T>();
ICryFactoryRegistry* pFactoryReg = gEnv->pSystem->GetCryFactoryRegistry();
if (pFactoryReg)
{
ICryFactory* pFactory = pFactoryReg->GetFactory(cname);
if (pFactory != NULL && pFactory->ClassSupports(cryiidof<T>()))
{
ICryUnknownPtr pUnk = pFactory->CreateClassInstance();
AZStd::shared_ptr<T> pT = cryinterface_cast<T>(pUnk);
if (pT)
{
p = pT;
}
}
}
return p.get() != NULL;
}
template <class T>
bool CryCreateClassInstanceForInterface(const CryInterfaceID& iid, AZStd::shared_ptr<T>& p)
{
p = AZStd::shared_ptr<T>();
ICryFactoryRegistry* pFactoryReg = gEnv->pSystem->GetCryFactoryRegistry();
if (pFactoryReg)
{
size_t numFactories = 1;
ICryFactory* pFactory = 0;
pFactoryReg->IterateFactories(iid, &pFactory, numFactories);
if (numFactories == 1 && pFactory)
{
ICryUnknownPtr pUnk = pFactory->CreateClassInstance();
AZStd::shared_ptr<T> pT = cryinterface_cast<T>(pUnk);
if (pT)
{
p = pT;
}
}
}
return p.get() != NULL;
}
#endif // CRYINCLUDE_CRYEXTENSION_CRYCREATECLASSINSTANCE_H
Code/CryEngine/CryCommon/CryExtension/CryGUID.h
-123
View File
@@ -1,123 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Part of CryEngine's extension framework.
#ifndef CRYINCLUDE_CRYEXTENSION_CRYGUID_H
#define CRYINCLUDE_CRYEXTENSION_CRYGUID_H
#pragma once
#include "Serialization/IArchive.h"
#include "Random.h"
#include <functional>
struct CryGUID
{
uint64 hipart;
uint64 lopart;
// !!! Do NOT turn CryGUID into a non-aggregate !!!
// It will prevent inlining and type list unrolling opportunities within
// cryinterface_cast<T>() and cryiidof<T>(). As such prevent constructors,
// non-public members, base classes and virtual functions!
//CryGUID() : hipart(0), lopart(0) {}
//CryGUID(uint64 h, uint64 l) : hipart(h), lopart(l) {}
static CryGUID Construct(const uint64& hipart, const uint64& lopart)
{
CryGUID guid = {hipart, lopart};
return guid;
}
static CryGUID Create()
{
uint64 lopart = 0;
uint64 hipart = 0;
while (lopart == 0 || hipart == 0)
{
const uint32 a = cry_random_uint32();
const uint32 b = cry_random_uint32();
const uint32 c = cry_random_uint32();
const uint32 d = cry_random_uint32();
lopart = (uint64)a | ((uint64)b << 32);
hipart = (uint64)c | ((uint64)d << 32);
}
return Construct(lopart, hipart);
}
static CryGUID Null()
{
return Construct(0, 0);
}
bool operator ==(const CryGUID& rhs) const {return hipart == rhs.hipart && lopart == rhs.lopart; }
bool operator !=(const CryGUID& rhs) const {return hipart != rhs.hipart || lopart != rhs.lopart; }
bool operator <(const CryGUID& rhs) const {return hipart == rhs.hipart ? lopart < rhs.lopart : hipart < rhs.hipart; }
void Serialize(Serialization::IArchive& ar)
{
if (ar.IsInput())
{
uint32 dwords[4];
ar(dwords, "guid");
lopart = (((uint64)dwords[1]) << 32) | (uint64)dwords[0];
hipart = (((uint64)dwords[3]) << 32) | (uint64)dwords[2];
}
else
{
uint32 guid[4] = {
(uint32)(lopart & 0xFFFFFFFF), (uint32)((lopart >> 32) & 0xFFFFFFFF),
(uint32)(hipart & 0xFFFFFFFF), (uint32)((hipart >> 32) & 0xFFFFFFFF)
};
ar(guid, "guid");
}
}
};
// This is only used by the editor where we use C++ 11.
namespace std
{
template<>
struct hash<CryGUID>
{
public:
size_t operator()(const CryGUID& guid) const
{
std::hash<uint64> hasher;
return hasher(guid.lopart) ^ hasher(guid.hipart);
}
};
}
namespace AZStd
{
template<>
struct hash<CryGUID>
{
public:
size_t operator()(const CryGUID& guid) const
{
std::hash<CryGUID> hasher;
return hasher(guid);
}
};
}
#define MAKE_CRYGUID(high, low) CryGUID::Construct((uint64) high##LL, (uint64) low##LL)
#endif // CRYINCLUDE_CRYEXTENSION_CRYGUID_H
Code/CryEngine/CryCommon/CryExtension/CryTypeID.h
-29
View File
@@ -1,29 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Part of CryEngine's extension framework.
#ifndef CRYINCLUDE_CRYEXTENSION_CRYTYPEID_H
#define CRYINCLUDE_CRYEXTENSION_CRYTYPEID_H
#pragma once
#include "CryGUID.h"
typedef CryGUID CryInterfaceID;
typedef CryGUID CryClassID;
#endif // CRYINCLUDE_CRYEXTENSION_CRYTYPEID_H
Code/CryEngine/CryCommon/CryExtension/ICryFactory.h
-41
View File
@@ -1,41 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Part of CryEngine's extension framework.
#ifndef CRYINCLUDE_CRYEXTENSION_ICRYFACTORY_H
#define CRYINCLUDE_CRYEXTENSION_ICRYFACTORY_H
#pragma once
#include "CryTypeID.h"
#include <SmartPointersHelpers.h>
struct ICryUnknown;
DECLARE_SMART_POINTERS(ICryUnknown);
struct ICryFactory
{
virtual const char* GetName() const = 0;
virtual const CryClassID& GetClassID() const = 0;
virtual bool ClassSupports(const CryInterfaceID& iid) const = 0;
virtual void ClassSupports(const CryInterfaceID*& pIIDs, size_t& numIIDs) const = 0;
virtual ICryUnknownPtr CreateClassInstance() const = 0;
protected:
// prevent explicit destruction from client side (delete, shared_ptr, etc)
virtual ~ICryFactory() {}
};
#endif // CRYINCLUDE_CRYEXTENSION_ICRYFACTORY_H
Code/CryEngine/CryCommon/CryExtension/ICryFactoryRegistry.h
-56
View File
@@ -1,56 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Part of CryEngine's extension framework.
#ifndef CRYINCLUDE_CRYEXTENSION_ICRYFACTORYREGISTRY_H
#define CRYINCLUDE_CRYEXTENSION_ICRYFACTORYREGISTRY_H
#pragma once
#include "CryTypeID.h"
struct ICryFactory;
struct ICryFactoryRegistry
{
virtual ICryFactory* GetFactory(const char* cname) const = 0;
virtual ICryFactory* GetFactory(const CryClassID& cid) const = 0;
/**
* Iterates all factories implementing the interface specified by \p iid.
* \param[in] iid ID of the interface to iterate. Often procured using cryiidof<...>().
* \param[out] pFactories A pointer of the array of factories to fill in. May be nullptr (see below).
* \param[in] Size (in elements) of the pFactories array [out] Number of elements actually written to pFactories or, when pFactories is null, the number of elements that would be written if sufficient storage was available.
*
* Example:
* \code{.cpp}
* size_t factoryCount = 0;
* // Assigns the number of found factories to factoryCount
* factoryRegistry->IterateFactories(cryiidof<TPointer>(), 0, factoryCount);
* // Allocate an array of the proper length on the stack
* ICryFactory** factories = static_cast<ICryFactory**>(alloca(sizeof(ICryFactory*) * factoryCount);
* // Fill in factories with factoryCount results.
* factoryRegistry->IterateFactories(cryiidof<TPointer>(), factories, factoryCount);
* \endcode
*/
virtual void IterateFactories(const CryInterfaceID& iid, ICryFactory** pFactories, size_t& numFactories) const = 0;
protected:
// prevent explicit destruction from client side (delete, shared_ptr, etc)
virtual ~ICryFactoryRegistry() {}
};
#endif // CRYINCLUDE_CRYEXTENSION_ICRYFACTORYREGISTRY_H
Code/CryEngine/CryCommon/CryExtension/ICryUnknown.h
-224
View File
@@ -1,224 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Part of CryEngine's extension framework.
#ifndef CRYINCLUDE_CRYEXTENSION_ICRYUNKNOWN_H
#define CRYINCLUDE_CRYEXTENSION_ICRYUNKNOWN_H
#pragma once
#include "CryTypeID.h"
#include <SmartPointersHelpers.h>
struct ICryFactory;
struct ICryUnknown;
namespace InterfaceCastSemantics
{
template <class T>
const CryInterfaceID& cryiidof()
{
return T::IID();
}
#define _BEFRIEND_CRYIIDOF() \
template <class T> \
friend const CryInterfaceID&InterfaceCastSemantics::cryiidof();
template <class Dst, class Src>
Dst* cryinterface_cast(Src* p)
{
return static_cast<Dst*>(p ? p->QueryInterface(cryiidof<Dst>()) : 0);
}
template <class Dst, class Src>
Dst* cryinterface_cast(const Src* p)
{
return static_cast<const Dst*>(p ? p->QueryInterface(cryiidof<Dst>()) : 0);
}
namespace Internal
{
template <class Dst, class Src>
struct cryinterface_cast_shared_ptr_helper;
template <class Dst, class Src>
struct cryinterface_cast_shared_ptr_helper
{
static AZStd::shared_ptr<Dst> Op(const AZStd::shared_ptr<Src>& p)
{
Dst* dp = cryinterface_cast<Dst>(p.get());
return dp ? AZStd::shared_ptr<Dst>(p, dp) : AZStd::shared_ptr<Dst>();
}
};
template <class Src>
struct cryinterface_cast_shared_ptr_helper<ICryUnknown, Src>
{
static AZStd::shared_ptr<ICryUnknown> Op(const AZStd::shared_ptr<Src>& p)
{
ICryUnknown* dp = cryinterface_cast<ICryUnknown>(p.get());
return dp ? AZStd::shared_ptr<ICryUnknown>(*((const AZStd::shared_ptr<ICryUnknown>*) & p), dp) : AZStd::shared_ptr<ICryUnknown>();
}
};
template <class Src>
struct cryinterface_cast_shared_ptr_helper<const ICryUnknown, Src>
{
static AZStd::shared_ptr<const ICryUnknown> Op(const AZStd::shared_ptr<Src>& p)
{
const ICryUnknown* dp = cryinterface_cast<const ICryUnknown>(p.get());
return dp ? AZStd::shared_ptr<const ICryUnknown>(*((const AZStd::shared_ptr<const ICryUnknown>*) & p), dp) : AZStd::shared_ptr<const ICryUnknown>();
}
};
} // namespace Internal
template <class Dst, class Src>
AZStd::shared_ptr<Dst> cryinterface_cast(const AZStd::shared_ptr<Src>& p)
{
return Internal::cryinterface_cast_shared_ptr_helper<Dst, Src>::Op(p);
}
#define _BEFRIEND_CRYINTERFACE_CAST() \
template <class Dst, class Src> \
friend Dst * InterfaceCastSemantics::cryinterface_cast(Src*); \
template <class Dst, class Src> \
friend Dst * InterfaceCastSemantics::cryinterface_cast(const Src*); \
template <class Dst, class Src> \
friend AZStd::shared_ptr<Dst> InterfaceCastSemantics::cryinterface_cast(const AZStd::shared_ptr<Src>&);
} // namespace InterfaceCastSemantics
using InterfaceCastSemantics::cryiidof;
using InterfaceCastSemantics::cryinterface_cast;
template <class S, class T>
bool CryIsSameClassInstance(S* p0, T* p1)
{
return static_cast<const void*>(p0) == static_cast<const void*>(p1) || cryinterface_cast<const ICryUnknown>(p0) == cryinterface_cast<const ICryUnknown>(p1);
}
template <class S, class T>
bool CryIsSameClassInstance(const AZStd::shared_ptr<S>& p0, T* p1)
{
return CryIsSameClassInstance(p0.get(), p1);
}
template <class S, class T>
bool CryIsSameClassInstance(S* p0, const AZStd::shared_ptr<T>& p1)
{
return CryIsSameClassInstance(p0, p1.get());
}
template <class S, class T>
bool CryIsSameClassInstance(const AZStd::shared_ptr<S>& p0, const AZStd::shared_ptr<T>& p1)
{
return CryIsSameClassInstance(p0.get(), p1.get());
}
namespace CompositeQuerySemantics
{
template <class Src>
AZStd::shared_ptr<ICryUnknown> crycomposite_query(Src* p, const char* name, bool* pExposed = 0)
{
void* pComposite = p ? p->QueryComposite(name) : 0;
pExposed ? *pExposed = pComposite != 0 : 0;
return pComposite ? *static_cast<AZStd::shared_ptr<ICryUnknown>*>(pComposite) : AZStd::shared_ptr<ICryUnknown>();
}
template <class Src>
AZStd::shared_ptr<const ICryUnknown> crycomposite_query(const Src* p, const char* name, bool* pExposed = 0)
{
void* pComposite = p ? p->QueryComposite(name) : 0;
pExposed ? *pExposed = pComposite != 0 : 0;
return pComposite ? *static_cast<AZStd::shared_ptr<const ICryUnknown>*>(pComposite) : AZStd::shared_ptr<const ICryUnknown>();
}
template <class Src>
AZStd::shared_ptr<ICryUnknown> crycomposite_query(const AZStd::shared_ptr<Src>& p, const char* name, bool* pExposed = 0)
{
return crycomposite_query(p.get(), name, pExposed);
}
template <class Src>
AZStd::shared_ptr<const ICryUnknown> crycomposite_query(const AZStd::shared_ptr<const Src>& p, const char* name, bool* pExposed = 0)
{
return crycomposite_query(p.get(), name, pExposed);
}
#define _BEFRIEND_CRYCOMPOSITE_QUERY() \
template <class Src> \
friend AZStd::shared_ptr<ICryUnknown> CompositeQuerySemantics::crycomposite_query(Src*, const char*, bool*); \
template <class Src> \
friend AZStd::shared_ptr<const ICryUnknown> CompositeQuerySemantics::crycomposite_query(const Src*, const char*, bool*); \
template <class Src> \
friend AZStd::shared_ptr<ICryUnknown> CompositeQuerySemantics::crycomposite_query(const AZStd::shared_ptr<Src>&, const char*, bool*); \
template <class Src> \
friend AZStd::shared_ptr<const ICryUnknown> CompositeQuerySemantics::crycomposite_query(const AZStd::shared_ptr<const Src>&, const char*, bool*);
} // namespace CompositeQuerySemantics
using CompositeQuerySemantics::crycomposite_query;
#define _BEFRIEND_MAKE_SHARED() \
template <class T> \
friend class AZStd::Internal::sp_ms_deleter; \
template <class T> \
friend AZStd::shared_ptr<T> AZStd::make_shared(); \
template <class T, class A> \
friend AZStd::shared_ptr<T> AZStd::allocate_shared(A const& a);
// prevent explicit destruction from client side
#define _PROTECTED_DTOR(iname) \
protected: \
virtual ~iname() {}
// Befriending cryinterface_cast<T>() and crycomposite_query() via CRYINTERFACE_DECLARE is actually only needed for ICryUnknown
// since QueryInterface() and QueryComposite() are usually not redeclared in derived interfaces but it doesn't hurt either
#define CRYINTERFACE_DECLARE(iname, iidHigh, iidLow) \
_BEFRIEND_CRYIIDOF() \
_BEFRIEND_CRYINTERFACE_CAST() \
_BEFRIEND_CRYCOMPOSITE_QUERY() \
_BEFRIEND_MAKE_SHARED() \
_PROTECTED_DTOR(iname) \
\
private: \
static const CryInterfaceID& IID() \
{ \
static const CryInterfaceID iid = {(uint64) iidHigh##LL, (uint64) iidLow##LL}; \
return iid; \
} \
public:
struct ICryUnknown
{
CRYINTERFACE_DECLARE(ICryUnknown, 0x1000000010001000, 0x1000100000000000)
virtual ICryFactory * GetFactory() const = 0;
protected:
virtual void* QueryInterface(const CryInterfaceID& iid) const = 0;
virtual void* QueryComposite(const char* name) const = 0;
};
DECLARE_SMART_POINTERS(ICryUnknown);
#endif // CRYINCLUDE_CRYEXTENSION_ICRYUNKNOWN_H
Code/CryEngine/CryCommon/CryExtension/Impl/ClassWeaver.h
-461
View File
@@ -1,461 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Part of CryEngine's extension framework.
#ifndef CRYINCLUDE_CRYEXTENSION_IMPL_CLASSWEAVER_H
#define CRYINCLUDE_CRYEXTENSION_IMPL_CLASSWEAVER_H
#pragma once
#include "TypeList.h"
#include "Conversion.h"
#include "RegFactoryNode.h"
#include "../ICryUnknown.h"
#include "../ICryFactory.h"
#include <AzCore/Memory/Memory.h>
namespace CW
{
namespace Internal
{
template <class Dst>
struct InterfaceCast;
template <class Dst>
struct InterfaceCast
{
template <class T>
static void* Op(T* p)
{
return (Dst*) p;
}
};
template <>
struct InterfaceCast<ICryUnknown>
{
template <class T>
static void* Op(T* p)
{
return const_cast<ICryUnknown*>(static_cast<const ICryUnknown*>(static_cast<const void*>(p)));
}
};
}
template <class TList>
struct InterfaceCast;
template <>
struct InterfaceCast<TL::NullType>
{
template <class T>
static void* Op(T*, const CryInterfaceID&)
{
return 0;
}
};
template <class Head, class Tail>
struct InterfaceCast<TL::Typelist<Head, Tail> >
{
template <class T>
static void* Op(T* p, const CryInterfaceID& iid)
{
if (cryiidof<Head>() == iid)
{
return Internal::InterfaceCast<Head>::Op(p);
}
return InterfaceCast<Tail>::Op(p, iid);
}
};
template <class TList>
struct FillIIDs;
template <>
struct FillIIDs<TL::NullType>
{
static void Op(CryInterfaceID*)
{
}
};
template <class Head, class Tail>
struct FillIIDs<TL::Typelist<Head, Tail> >
{
static void Op(CryInterfaceID* p)
{
*p++ = cryiidof<Head>();
FillIIDs<Tail>::Op(p);
}
};
namespace Internal
{
template <bool, typename S>
struct PickList;
template <bool, typename S>
struct PickList
{
typedef TL::BuildTypelist<>::Result Result;
};
template <typename S>
struct PickList<true, S>
{
typedef typename S::FullCompositeList Result;
};
}
template <typename T>
struct ProbeFullCompositeList
{
private:
typedef char y[1];
typedef char n[2];
template <typename S>
static y& test(typename S::FullCompositeList*);
template <typename>
static n& test(...);
public:
enum
{
listFound = sizeof(test<T>(0)) == sizeof(y)
};
typedef typename Internal::PickList<listFound, T>::Result ListType;
};
namespace Internal
{
template <class TList>
struct CompositeQuery;
template <>
struct CompositeQuery<TL::NullType>
{
template<typename T>
static void* Op(const T&, const char*)
{
return 0;
}
};
template <class Head, class Tail>
struct CompositeQuery<TL::Typelist<Head, Tail> >
{
template<typename T>
static void* Op(const T& ref, const char* name)
{
void* p = ref.Head::CompositeQueryImpl(name);
return p ? p : CompositeQuery<Tail>::Op(ref, name);
}
};
}
struct CompositeQuery
{
template <typename T>
static void* Op(const T& ref, const char* name)
{
return Internal::CompositeQuery<typename ProbeFullCompositeList<T>::ListType>::Op(ref, name);
}
};
inline bool NameMatch(const char* name, const char* compositeName)
{
if (!name || !compositeName)
{
return false;
}
size_t i = 0;
for (; name[i] && name[i] == compositeName[i]; ++i)
{
}
return name[i] == compositeName[i];
}
template <typename T>
void* CheckCompositeMatch(const char* name, const AZStd::shared_ptr<T>& composite, const char* compositeName)
{
typedef TC::SuperSubClass<ICryUnknown, T> Rel;
COMPILE_TIME_ASSERT(Rel::exists);
return NameMatch(name, compositeName) ? const_cast<void*>(static_cast<const void*>(&composite)) : 0;
}
} // namespace CW
#define CRYINTERFACE_BEGIN() \
private: \
typedef TL::BuildTypelist < ICryUnknown
#define CRYINTERFACE_ADD(iname) , iname
#define CRYINTERFACE_END() > ::Result _UserDefinedPartialInterfaceList; \
protected: \
typedef TL::NoDuplicates<_UserDefinedPartialInterfaceList>::Result FullInterfaceList;
#define _CRY_TPL_APPEND0(base) TL::Append<base::FullInterfaceList, _UserDefinedPartialInterfaceList>::Result
#define _CRY_TPL_APPEND(base, intermediate) TL::Append<base::FullInterfaceList, intermediate>::Result
#define CRYINTERFACE_ENDWITHBASE(base) > ::Result _UserDefinedPartialInterfaceList; \
protected: \
typedef TL::NoDuplicates<_CRY_TPL_APPEND0(base)>::Result FullInterfaceList;
#define CRYINTERFACE_ENDWITHBASE2(base0, base1) > ::Result _UserDefinedPartialInterfaceList; \
protected: \
typedef TL::NoDuplicates<_CRY_TPL_APPEND(base0, _CRY_TPL_APPEND0(base1))>::Result FullInterfaceList;
#define CRYINTERFACE_ENDWITHBASE3(base0, base1, base2) > ::Result _UserDefinedPartialInterfaceList; \
protected: \
typedef TL::NoDuplicates<_CRY_TPL_APPEND(base0, _CRY_TPL_APPEND(base1, _CRY_TPL_APPEND0(base2)))>::Result FullInterfaceList;
#define CRYINTERFACE_SIMPLE(iname) \
CRYINTERFACE_BEGIN() \
CRYINTERFACE_ADD(iname) \
CRYINTERFACE_END()
#define CRYCOMPOSITE_BEGIN() \
private: \
void* CompositeQueryImpl(const char* name) const \
{ \
(void)(name); \
void* res = 0; (void)(res); \
#define CRYCOMPOSITE_ADD(member, membername) \
COMPILE_TIME_ASSERT((sizeof(membername) / sizeof(membername[0])) > 1); \
if ((res = CW::CheckCompositeMatch(name, member, membername)) != 0) { \
return res; }
#define _CRYCOMPOSITE_END(implclassname) \
return 0; \
}; \
protected: \
typedef TL::BuildTypelist<implclassname>::Result _PartialCompositeList; \
\
template <bool, typename S> \
friend struct CW::Internal::PickList;
#define CRYCOMPOSITE_END(implclassname) \
_CRYCOMPOSITE_END(implclassname) \
protected: \
typedef _PartialCompositeList FullCompositeList;
#define _CRYCOMPOSITE_APPEND0(base) TL::Append<_PartialCompositeList, CW::ProbeFullCompositeList<base>::ListType>::Result
#define _CRYCOMPOSITE_APPEND(base, intermediate) TL::Append<intermediate, CW::ProbeFullCompositeList<base>::ListType>::Result
#define CRYCOMPOSITE_ENDWITHBASE(implclassname, base) \
_CRYCOMPOSITE_END(implclassname) \
protected: \
typedef _CRYCOMPOSITE_APPEND0 (base) FullCompositeList;
#define CRYCOMPOSITE_ENDWITHBASE2(implclassname, base0, base1) \
_CRYCOMPOSITE_END(implclassname) \
protected: \
typedef TL::NoDuplicates<_CRYCOMPOSITE_APPEND(base1, _CRYCOMPOSITE_APPEND0(base0))>::Result FullCompositeList;
#define CRYCOMPOSITE_ENDWITHBASE3(implclassname, base0, base1, base2) \
_CRYCOMPOSITE_END(implclassname) \
protected: \
typedef TL::NoDuplicates<_CRYCOMPOSITE_APPEND(base2, _CRYCOMPOSITE_APPEND(base1, _CRYCOMPOSITE_APPEND0(base0)))>::Result FullCompositeList;
template<typename T>
class CFactory
: public ICryFactory
{
public:
virtual const char* GetName() const
{
return T::GetCName();
}
virtual const CryClassID& GetClassID() const
{
return T::GetCID();
}
virtual bool ClassSupports(const CryInterfaceID& iid) const
{
for (size_t i = 0; i < m_numIIDs; ++i)
{
if (iid == m_pIIDs[i])
{
return true;
}
}
return false;
}
virtual void ClassSupports(const CryInterfaceID*& pIIDs, size_t& numIIDs) const
{
pIIDs = m_pIIDs;
numIIDs = m_numIIDs;
}
public:
virtual ICryUnknownPtr CreateClassInstance() const
{
AZStd::shared_ptr<T> p = AZStd::make_shared<T>();
return cryinterface_cast<ICryUnknown> (p);
}
CFactory<T>()
: m_numIIDs(0)
, m_pIIDs(0)
, m_regFactory()
{
static CryInterfaceID supportedIIDs[TL::Length < typename T::FullInterfaceList > ::value];
CW::FillIIDs<typename T::FullInterfaceList>::Op(supportedIIDs);
m_pIIDs = &supportedIIDs[0];
m_numIIDs = TL::Length<typename T::FullInterfaceList>::value;
new(&m_regFactory)SRegFactoryNode(this);
}
protected:
CFactory(const CFactory&);
CFactory& operator =(const CFactory&);
size_t m_numIIDs;
CryInterfaceID* m_pIIDs;
SRegFactoryNode m_regFactory;
};
template<typename T>
class CSingletonFactory
: public CFactory<T>
{
public:
CSingletonFactory()
: CFactory<T>()
, m_csCreateClassInstance()
{
}
virtual ICryUnknownPtr CreateClassInstance() const
{
CryAutoLock<CryCriticalSection> lock(m_csCreateClassInstance);
// override the allocator. These function static instances are being destroyed after the AZ alloctor has been deleted.
// On win, TerminateProcess() prevents these destructors from being called, but that is not the case on OSX.
static typename AZStd::aligned_storage<sizeof(AZStd::Internal::sp_counted_impl_pda<T*, AZStd::Internal::sp_ms_deleter<T>,SingletonAllocator>), AZStd::alignment_of<T>::value>::type m_storage;
static ICryUnknownPtr p = AZStd::allocate_shared<T>(SingletonAllocator(AZStd::addressof(m_storage)));
return p;
}
mutable CryCriticalSection m_csCreateClassInstance;
struct SingletonAllocator
{
SingletonAllocator(void* ptr) :
m_data(ptr)
{}
void* allocate(size_t /*byteSize*/, size_t /*alignment*/, int /*flags*/ = 0)
{
return m_data;
}
void deallocate(void* /*ptr*/, size_t /*byteSize*/, size_t /*alignment*/)
{
// nothing to see here
}
void* m_data;
};
};
#define _CRYFACTORY_DECLARE(implclassname) \
private: \
friend class CFactory<implclassname>; \
static CFactory<implclassname> s_factory;
#define _CRYFACTORY_DECLARE_SINGLETON(implclassname) \
private: \
friend class CFactory<implclassname>; \
friend void* Get##implclassname##Factory(); \
static CSingletonFactory<implclassname> s_factory;
#define _IMPLEMENT_ICRYUNKNOWN() \
public: \
virtual ICryFactory* GetFactory() const \
{ \
return &s_factory; \
} \
\
protected: \
virtual void* QueryInterface(const CryInterfaceID&iid) const \
{ \
return CW::InterfaceCast<FullInterfaceList>::Op(this, iid); \
} \
\
template <class TList> \
friend struct CW::Internal::CompositeQuery; \
\
virtual void* QueryComposite(const char* name) const \
{ \
return CW::CompositeQuery::Op(*this, name); \
}
#define _ENFORCE_CRYFACTORY_USAGE(implclassname, cname, cidHigh, cidLow) \
public: \
static const char* GetCName() \
{ \
return cname; \
} \
static const CryClassID& GetCID() \
{ \
static const CryClassID cid = {(uint64) cidHigh##LL, (uint64) cidLow##LL}; \
return cid; \
} \
static AZStd::shared_ptr<implclassname> CreateClassInstance() \
{ \
ICryUnknownPtr p = s_factory.CreateClassInstance(); \
return AZStd::shared_ptr<implclassname>(*static_cast<AZStd::shared_ptr<implclassname>*>(static_cast<void*>(&p))); \
} \
\
protected: \
implclassname(); \
virtual ~implclassname();
#define _BEFRIEND_OPS() \
_BEFRIEND_CRYINTERFACE_CAST() \
_BEFRIEND_CRYCOMPOSITE_QUERY() \
_BEFRIEND_MAKE_SHARED()
#define CRYGENERATE_CLASS(implclassname, cname, cidHigh, cidLow) \
_CRYFACTORY_DECLARE(implclassname) \
_BEFRIEND_OPS() \
_IMPLEMENT_ICRYUNKNOWN() \
_ENFORCE_CRYFACTORY_USAGE(implclassname, cname, cidHigh, cidLow)
#define CRYGENERATE_SINGLETONCLASS(implclassname, cname, cidHigh, cidLow) \
_CRYFACTORY_DECLARE_SINGLETON(implclassname) \
_BEFRIEND_OPS() \
_IMPLEMENT_ICRYUNKNOWN() \
_ENFORCE_CRYFACTORY_USAGE(implclassname, cname, cidHigh, cidLow)
#define CRYREGISTER_CLASS(implclassname) \
CFactory<implclassname> implclassname::s_factory;
#define DECLARE_CRYREGISTER_SINGLETON_CLASS(implclassname) \
void* Get##implclassname##Factory();
#define CRYREGISTER_SINGLETON_CLASS(implclassname) \
CSingletonFactory<implclassname> implclassname::s_factory; \
void* Get##implclassname##Factory() { \
return &implclassname::s_factory; \
}
#endif // CRYINCLUDE_CRYEXTENSION_IMPL_CLASSWEAVER_H
Code/CryEngine/CryCommon/CryExtension/Impl/Conversion.h
-109
View File
@@ -1,109 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Part of CryEngine's extension framework.
#ifndef CRYINCLUDE_CRYEXTENSION_IMPL_CONVERSION_H
#define CRYINCLUDE_CRYEXTENSION_IMPL_CONVERSION_H
#pragma once
namespace TC
{
//template <class T, class U>
//struct Conversion
//{
//private:
// typedef char y[1];
// typedef char n[2];
// static y& Test(U);
// static n& Test(...);
// static T MakeT();
//public:
// enum
// {
// exists = sizeof(Test(MakeT())) == sizeof(y),
// sameType = false
// };
//};
//template <class T>
//struct Conversion<T, T>
//{
//public:
// enum
// {
// exists = true,
// sameType = true
// };
//};
//template<typename Base, typename Derived>
//struct CheckInheritance
//{
// enum
// {
// exists = Conversion<const Derived*, const Base*>::exists && !Conversion<const Base*, const void*>::sameType
// };
//};
//template<typename Base, typename Derived>
//struct CheckStrictInheritance
//{
// enum
// {
// exists = CheckInheritance<Base, Derived>::exists && !Conversion<const Base*, const Derived*>::sameType
// };
//};
template <typename Base, typename Derived>
struct SuperSubClass
{
private:
typedef char y[1];
typedef char n[2];
template<typename T>
static y& check(const volatile Derived&, T);
static n& check(const volatile Base&, int);
struct C
{
operator const volatile Base&() const;
operator const volatile Derived&();
};
static C getC();
public:
enum
{
exists = sizeof(check(getC(), 0)) == sizeof(y),
sameType = false
};
};
template <typename T>
struct SuperSubClass<T, T>
{
enum
{
exists = true
};
};
} // namespace TC
#endif // CRYINCLUDE_CRYEXTENSION_IMPL_CONVERSION_H
Code/CryEngine/CryCommon/CryExtension/Impl/CryGUIDHelper.h
-67
View File
@@ -1,67 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Part of CryEngine's extension framework.
#ifndef CRYINCLUDE_CRYEXTENSION_IMPL_CRYGUIDHELPER_H
#define CRYINCLUDE_CRYEXTENSION_IMPL_CRYGUIDHELPER_H
#pragma once
#include "../CryGUID.h"
#include "../../CryString.h"
namespace CryGUIDHelper
{
string Print(const CryGUID& val)
{
char buf[39]; // sizeof("{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}")
static const char hex[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
char* p = buf;
*p++ = '{';
for (int i = 15; i >= 8; --i)
{
*p++ = hex[(unsigned char) ((val.hipart >> (i << 2)) & 0xF)];
}
*p++ = '-';
for (int i = 7; i >= 4; --i)
{
*p++ = hex[(unsigned char) ((val.hipart >> (i << 2)) & 0xF)];
}
*p++ = '-';
for (int i = 3; i >= 0; --i)
{
*p++ = hex[(unsigned char) ((val.hipart >> (i << 2)) & 0xF)];
}
*p++ = '-';
for (int i = 15; i >= 12; --i)
{
*p++ = hex[(unsigned char) ((val.lopart >> (i << 2)) & 0xF)];
}
*p++ = '-';
for (int i = 11; i >= 0; --i)
{
*p++ = hex[(unsigned char) ((val.lopart >> (i << 2)) & 0xF)];
}
*p++ = '}';
*p++ = '\0';
return string(buf);
}
}
#endif // CRYINCLUDE_CRYEXTENSION_IMPL_CRYGUIDHELPER_H
Code/CryEngine/CryCommon/CryExtension/Impl/ICryFactoryRegistryImpl.h
-58
View File
@@ -1,58 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Part of CryEngine's extension framework.
#ifndef CRYINCLUDE_CRYEXTENSION_IMPL_ICRYFACTORYREGISTRYIMPL_H
#define CRYINCLUDE_CRYEXTENSION_IMPL_ICRYFACTORYREGISTRYIMPL_H
#pragma once
#include "../ICryFactoryRegistry.h"
struct SRegFactoryNode;
struct ICryFactoryRegistryCallback
{
virtual void OnNotifyFactoryRegistered(ICryFactory* pFactory) = 0;
virtual void OnNotifyFactoryUnregistered(ICryFactory* pFactory) = 0;
protected:
virtual ~ICryFactoryRegistryCallback() {}
};
struct ICryFactoryRegistryImpl
: public ICryFactoryRegistry
{
virtual ICryFactory* GetFactory(const char* cname) const = 0;
virtual ICryFactory* GetFactory(const CryClassID& cid) const = 0;
virtual void IterateFactories(const CryInterfaceID& iid, ICryFactory** pFactories, size_t& numFactories) const = 0;
virtual void RegisterCallback(ICryFactoryRegistryCallback* pCallback) = 0;
virtual void UnregisterCallback(ICryFactoryRegistryCallback* pCallback) = 0;
virtual void RegisterFactories(const SRegFactoryNode* pFactories) = 0;
virtual void UnregisterFactories(const SRegFactoryNode* pFactories) = 0;
virtual void UnregisterFactory(ICryFactory* const pFactory) = 0;
protected:
// prevent explicit destruction from client side (delete, shared_ptr, etc)
virtual ~ICryFactoryRegistryImpl() {}
};
#endif // CRYINCLUDE_CRYEXTENSION_IMPL_ICRYFACTORYREGISTRYIMPL_H
Code/CryEngine/CryCommon/CryExtension/Impl/RegFactoryNode.h
-52
View File
@@ -1,52 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Part of CryEngine's extension framework.
#ifndef CRYINCLUDE_CRYEXTENSION_IMPL_REGFACTORYNODE_H
#define CRYINCLUDE_CRYEXTENSION_IMPL_REGFACTORYNODE_H
#pragma once
struct ICryFactory;
struct SRegFactoryNode;
extern SRegFactoryNode* g_pHeadToRegFactories;
struct SRegFactoryNode
{
SRegFactoryNode()
{
}
SRegFactoryNode(ICryFactory* pFactory)
: m_pFactory(pFactory)
, m_pNext(g_pHeadToRegFactories)
{
g_pHeadToRegFactories = this;
}
static void* operator new(size_t, void* p)
{
return p;
}
static void operator delete(void*, void*)
{
}
ICryFactory* m_pFactory;
SRegFactoryNode* m_pNext;
};
#endif // CRYINCLUDE_CRYEXTENSION_IMPL_REGFACTORYNODE_H
Code/CryEngine/CryCommon/CryExtension/Impl/TypeList.h
-236
View File
@@ -1,236 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Part of CryEngine's extension framework.
#ifndef CRYINCLUDE_CRYEXTENSION_TYPELIST_H
#define CRYINCLUDE_CRYEXTENSION_TYPELIST_H
#pragma once
namespace TL
{
// typelist terminator
class NullType
{
};
// structure for typelist generation
template <class T, class U = NullType>
struct Typelist
{
typedef T Head;
typedef U Tail;
};
// helper structure to automatically build typelists containing n types
template
<
typename T0 = NullType, typename T1 = NullType, typename T2 = NullType, typename T3 = NullType, typename T4 = NullType,
typename T5 = NullType, typename T6 = NullType, typename T7 = NullType, typename T8 = NullType, typename T9 = NullType,
typename T10 = NullType, typename T11 = NullType, typename T12 = NullType, typename T13 = NullType, typename T14 = NullType,
typename T15 = NullType, typename T16 = NullType, typename T17 = NullType, typename T18 = NullType, typename T19 = NullType
>
struct BuildTypelist
{
private:
typedef typename BuildTypelist<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>::Result TailResult;
public:
typedef Typelist<T0, TailResult> Result;
};
template <>
struct BuildTypelist<>
{
typedef NullType Result;
};
// typelist operation : Length
template <class TList>
struct Length;
template <>
struct Length<NullType>
{
enum
{
value = 0
};
};
template <class T, class U>
struct Length<Typelist<T, U> >
{
enum
{
value = 1 + Length<U>::value
};
};
// typelist operation : TypeAt
template <class TList, unsigned int index>
struct TypeAt;
template <class Head, class Tail>
struct TypeAt<Typelist<Head, Tail>, 0>
{
typedef Head Result;
};
template <class Head, class Tail, unsigned int index>
struct TypeAt<Typelist<Head, Tail>, index>
{
typedef typename TypeAt<Tail, index - 1>::Result Result;
};
// typelist operation : IndexOf
template <class TList, class T>
struct IndexOf;
template <class T>
struct IndexOf<NullType, T>
{
enum
{
value = -1
};
};
template <class T, class Tail>
struct IndexOf<Typelist<T, Tail>, T>
{
enum
{
value = 0
};
};
template <class Head, class Tail, class T>
struct IndexOf<Typelist<Head, Tail>, T>
{
private:
enum
{
temp = IndexOf<Tail, T>::value
};
public:
enum
{
value = temp == -1 ? -1 : 1 + temp
};
};
// typelist operation : Append
template <class TList, class T>
struct Append;
template <>
struct Append<NullType, NullType>
{
typedef NullType Result;
};
template <class T>
struct Append<NullType, T>
{
typedef Typelist<T, NullType> Result;
};
template <class Head, class Tail>
struct Append<NullType, Typelist<Head, Tail> >
{
typedef Typelist<Head, Tail> Result;
};
template <class Head, class Tail, class T>
struct Append<Typelist<Head, Tail>, T>
{
typedef Typelist<Head, typename Append<Tail, T>::Result> Result;
};
// typelist operation : Erase
template <class TList, class T>
struct Erase;
template <class T>
struct Erase<NullType, T>
{
typedef NullType Result;
};
template <class T, class Tail>
struct Erase<Typelist<T, Tail>, T>
{
typedef Tail Result;
};
template <class Head, class Tail, class T>
struct Erase<Typelist<Head, Tail>, T>
{
typedef Typelist<Head, typename Erase<Tail, T>::Result> Result;
};
// typelist operation : Erase All
template <class TList, class T>
struct EraseAll;
template <class T>
struct EraseAll<NullType, T>
{
typedef NullType Result;
};
template <class T, class Tail>
struct EraseAll<Typelist<T, Tail>, T>
{
typedef typename EraseAll<Tail, T>::Result Result;
};
template <class Head, class Tail, class T>
struct EraseAll<Typelist<Head, Tail>, T>
{
typedef Typelist<Head, typename EraseAll<Tail, T>::Result> Result;
};
// typelist operation : NoDuplicates
template <class TList>
struct NoDuplicates;
template <>
struct NoDuplicates<NullType>
{
typedef NullType Result;
};
template <class Head, class Tail>
struct NoDuplicates<Typelist<Head, Tail> >
{
private:
typedef typename NoDuplicates<Tail>::Result L1;
typedef typename Erase<L1, Head>::Result L2;
public:
typedef Typelist<Head, L2> Result;
};
} // namespace TL
#endif // CRYINCLUDE_CRYEXTENSION_TYPELIST_H
Code/CryEngine/CryCommon/CryMemoryManager.h
-3
View File
@@ -116,7 +116,6 @@ namespace CryMemory
struct ICustomMemoryHeap;
class IGeneralMemoryHeap;
class IPageMappingHeap;
class IDefragAllocator;
class IMemoryAddressRange;
// Description:
@@ -180,8 +179,6 @@ struct IMemoryManager
virtual IMemoryAddressRange* ReserveAddressRange(size_t capacity, const char* sName) = 0;
virtual IPageMappingHeap* CreatePageMappingHeap(size_t addressSpace, const char* sName) = 0;
virtual IDefragAllocator* CreateDefragAllocator() = 0;
};
// Global function implemented in CryMemoryManager_impl.h
Code/CryEngine/CryCommon/CryPool/Allocator.h
-207
View File
@@ -1,207 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYPOOL_ALLOCATOR_H
#define CRYINCLUDE_CRYPOOL_ALLOCATOR_H
#pragma once
namespace NCryPoolAlloc
{
template<class TPool, class TItem>
class CFirstFit
: public TPool
{
public:
ILINE CFirstFit()
{
}
template<class T>
ILINE T Allocate(size_t Size, size_t Align = 1)
{
//fastpath?
if (TPool::m_pEmpty && TPool::m_pEmpty->Available(Size, Align))
{
TItem* pItem = TPool::Split(TPool::m_pEmpty, Size, Align);
if (!pItem)
{
return 0;
}
pItem->InUse(Align);
TPool::AllocatedMemory(pItem->MemSize());
//not fully occupied empty space?
TPool::m_pEmpty = pItem != TPool::m_pEmpty ? TPool::m_pEmpty : 0;
return TPool::Handle(pItem);
}
TItem* pBestItem;
for (pBestItem = TPool::m_Items.First(); pBestItem; pBestItem = pBestItem->Next())
{
if (pBestItem->Available(Size, Align)) // && (!pBestItem || pItem->MemSize()<pBestItem->MemSize()))
{
break;
}
}
if (!pBestItem)
{
return 0; //out of mem
}
TItem* pItem = TPool::Split(pBestItem, Size, Align);
if (!pItem) //no free node
{
return 0;
}
pItem->InUse(Align);
TPool::AllocatedMemory(pItem->MemSize());
//not fully occupied empty space?
TPool::m_pEmpty = pItem != pBestItem ? pBestItem : 0;
return TPool::Handle(pItem);
}
template<class T>
ILINE bool Free(T Handle, bool ForceBoundsCheck = false)
{
return Handle ? TPool::Free(Handle, ForceBoundsCheck) : false;
}
};
template<class TPool, class TItem>
class CWorstFit
: public TPool
{
public:
ILINE CWorstFit()
{
}
template<class T>
ILINE T Allocate(size_t Size, size_t Align = 1)
{
TItem* pBestItem = 0;
for (TItem* pItem = TPool::m_Items.First(); pItem; pItem = pItem->Next())
{
if (pItem->IsFree() && (!pBestItem || pItem->MemSize() > pBestItem->MemSize()))
{
pBestItem = pItem;
}
}
if (!pBestItem || !pBestItem->Available(Size, Align))
{
return 0; //out of mem
}
TItem* pItem = Split(pBestItem, Size, Align);
if (!pItem) //no free node
{
return 0;
}
pItem->InUse(Align);
AllocatedMemory(pItem->MemSize());
return Handle(pItem);
}
};
template<class TPool, class TItem>
class CBestFit
: public TPool
{
public:
ILINE CBestFit()
{
}
template<class T>
ILINE T Allocate(size_t Size, size_t Align = 1)
{
TItem* pBestItem = 0;
for (TItem* pItem = TPool::m_Items.First(); pItem; pItem = pItem->Next())
{
if ((!pBestItem || pItem->MemSize() < pBestItem->MemSize()) && pItem->Available(Size, Align))
{
if (pItem->MemSize() == Size)
{
pItem->InUse(Align);
AllocatedMemory(pItem->MemSize());
return (T)Handle(pItem);
}
pBestItem = pItem;
}
}
if (!pBestItem)
{
return 0; //out of mem
}
TItem* pItem = Split(pBestItem, Size, Align);
if (!pItem) //no free node
{
return 0;
}
pItem->InUse(Align);
AllocatedMemory(pItem->MemSize());
return (T)Handle(pItem);
}
};
template<class TAllocator>
class CReallocator
: public TAllocator
{
public:
template<class T>
ILINE bool Reallocate(T* pData, size_t Size, size_t Alignment)
{
//special cases
if (!Size) //just free?
{
TAllocator::Free(*pData);
*pData = 0;
return true;
}
if (!*pData) //just alloc?
{
*pData = TAllocator::template Allocate<T>(Size, Alignment);
return *pData != 0;
}
//same size, nothing to do at all?
if (TAllocator::Item(*pData)->MemSize() == Size)
{
return true;
}
if (TAllocator::ReSize(pData, Size))
{
return true;
}
T pNewData = TAllocator::template Allocate<T>(Size, Alignment);
if (!pNewData)
{
return false;
}
memcpy(TAllocator::template Resolve<uint8*>(pNewData),
TAllocator::template Resolve<uint8*>(*pData), min(TAllocator::Item(*pData)->MemSize(), Size));
TAllocator::template Free(*pData);
*pData = pNewData;
return true;
}
};
}
#endif // CRYINCLUDE_CRYPOOL_ALLOCATOR_H
Code/CryEngine/CryCommon/CryPool/Container.h
-655
View File
@@ -1,655 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYPOOL_CONTAINER_H
#define CRYINCLUDE_CRYPOOL_CONTAINER_H
#pragma once
namespace NCryPoolAlloc
{
template<size_t TElementCount, class TElement>
class CPool
: public CMemoryStatic<TElementCount* sizeof(TElement)>
{
class CPoolNode;
class CPoolNode
: public CListItem<CPoolNode>
{
};
CList<CPoolNode> m_List;
public:
ILINE CPool()
{
CPoolNode* pPrev = 0;
CPoolNode* pNode = 0;
for (size_t a = 1; a < TElementCount; a++) //skip first element as it would be counted as zero ptr
{
uint8* pData = &CMemoryStatic<TElementCount* sizeof(TElement)>::Data()[a * sizeof(TElement)];
pNode = reinterpret_cast<CPoolNode*>(pData);
pNode->Prev(pPrev);
if (pPrev)
{
pPrev->Next(pNode);
}
else
{
m_List.First(pNode);
}
pPrev = pNode;
// m_List.AddLast(pNode);
}
if (pPrev)
{
pPrev->Next(0);
m_List.Last(pPrev);
}
}
ILINE uint8* Allocate([[maybe_unused]] size_t Size, [[maybe_unused]] size_t Align = 1)
{
CPoolNode* pNode = m_List.PopFirst();
return reinterpret_cast<uint8*>(pNode);
}
template<class T>
ILINE void Free(T* pData)
{
if (pData)
{
CPoolNode* pNode = reinterpret_cast<CPoolNode*>(pData);
m_List.AddLast(pNode);
}
}
ILINE TElement& operator[](uint32 Idx)
{
uint8* pData = &CMemoryStatic<TElementCount* sizeof(TElement)>::Data()[Idx * sizeof(TElement)];
return *reinterpret_cast<TElement*>(pData);
}
ILINE const TElement& operator[](uint32 Idx) const
{
const uint8* pData = &CMemoryStatic<TElementCount* sizeof(TElement)>::Data()[Idx * sizeof(TElement)];
return *reinterpret_cast<const TElement*>(pData);
}
};
template<class TMemory, bool BoundsCheck = false>
class CInPlace
: public TMemory
{
protected:
CList<CListItemInPlace> m_Items;
size_t m_Allocated;
CListItemInPlace* m_pEmpty;
ILINE void AllocatedMemory(size_t S)
{
m_Allocated += S + sizeof(CListItemInPlace);
}
ILINE void FreedMemory(size_t S)
{
m_Allocated -= S + sizeof(CListItemInPlace);
}
ILINE void Stack(CListItemInPlace* pItem)
{
}
public:
ILINE CInPlace()
: m_Allocated(0)
{
}
ILINE void InitMem(const size_t S = 0, uint8* pData = 0)
{
TMemory::InitMem(S, pData);
if (!TMemory::MemSize())
{
return;
}
pData = TMemory::Data();
CListItemInPlace* pFirst = reinterpret_cast<CListItemInPlace*>(pData);
CListItemInPlace* pFree = pFirst + 1;
CListItemInPlace* pLast = reinterpret_cast<CListItemInPlace*>(pData + TMemory::MemSize()) - 1;
m_Items.~CList<CListItemInPlace>();
new (&m_Items)CList<CListItemInPlace>();
m_Items.AddLast(pFirst);
m_Items.AddLast(pFree);
m_Items.AddLast(pLast);
pFirst->InUse(0); //static first item
pFree->Free();
pLast->InUse(0); //static last item
m_pEmpty = pFree;
m_Allocated = 0;
}
ILINE size_t FragmentCount() const
{
return m_Items.Count();
}
ILINE CListItemInPlace* Split(CListItemInPlace* pItem, size_t Size, size_t Align)
{
size_t Offset = reinterpret_cast<size_t>(pItem->Data());
Offset += pItem->MemSize(); //ptr to end
Offset -= Size; //minus size
Size += Offset & (Align - 1); //adjust size to fit required alignment
Offset -= Offset & (Align - 1);
size_t TSize = sizeof(CListItemInPlace);
Offset -= TSize; //header
if (Offset <= reinterpret_cast<size_t>(pItem + 1)) //not enough space for splitting?
{
return pItem;
}
CListItemInPlace* pItemNext = reinterpret_cast<CListItemInPlace*>(Offset);
const size_t Offset2 = reinterpret_cast<size_t>(pItemNext->Data());
CPA_ASSERT(!(Offset2 & (Align - 1)));
m_Items.AddBehind(pItemNext, pItem);
//pItemNext->Prev(pItem);
//pItemNext->Next(pItem->Next());
// if(pItem->Next())
// pItem->Next()->Prev(pItemNext);
// pItem->Next(pItemNext);
pItemNext->Free();
return pItemNext;
}
ILINE void Merge(CListItemInPlace* pItem)
{
//merge with next if possible
CListItemInPlace* pItemNext = pItem->Next();
if (pItemNext->IsFree())
{
if (m_pEmpty == pItemNext)
{
m_pEmpty = pItem;
}
m_Items.Remove(pItemNext);
//pItem->Next(pItemNext->Next());
//pItem->Next()->Prev(pItem);
}
//merge with prev if possible
CListItemInPlace* pItemPrev = pItem->Prev();
if (pItemPrev->IsFree())
{
if (m_pEmpty == pItem)
{
m_pEmpty = pItemPrev;
}
m_Items.Remove(pItem);
//pItemPrev->Next(pItem->Next());
//pItem->Next()->Prev(pItemPrev);
pItem = pItemPrev;
}
}
template<class T>
ILINE T Resolve(void* rItem) const
{
return reinterpret_cast<T>(rItem);
}
template<class T>
ILINE size_t Size(const T* pData) const
{
const CListItemInPlace* pItem = Item(pData);
return pItem->MemSize();
}
bool InBounds(const void* pData, const bool Check) const
{
return !Check || (
reinterpret_cast<size_t>(pData) >= reinterpret_cast<size_t>(TMemory::Data()) &&
reinterpret_cast<size_t>(pData) < reinterpret_cast<size_t>(TMemory::Data()) + TMemory::MemSize());
}
template<class T>
ILINE bool Free(T* pData, bool ForceBoundsCheck = false)
{
if (pData && InBounds(pData, BoundsCheck | ForceBoundsCheck))
{
CListItemInPlace* pItem = Item(pData);
FreedMemory(pItem->MemSize());
pItem->Free();
Merge(pItem);
return true;
}
return false;
}
ILINE bool Beat(){return false; }//dummy beat in case no defragmentator is wraping
ILINE size_t MemFree() const{return TMemory::MemSize() - m_Allocated; }
ILINE size_t MemSize() const{return TMemory::MemSize(); }
ILINE uint8* Handle(CListItemInPlace* pItem) const
{
return pItem->Data();
}
template<class T>
ILINE CListItemInPlace* Item(T* pData)
{
return reinterpret_cast<CListItemInPlace*>(pData) - 1;
}
template<class T>
ILINE const CListItemInPlace* Item(const T* pData) const
{
return reinterpret_cast<const CListItemInPlace*>(pData) - 1;
}
ILINE static bool Defragmentable(){return false; }
template<class T>
ILINE bool ReSize(T* pData, size_t SizeNew)
{
//special cases
CListItemInPlace* pItem = Item(*pData);
const size_t SizeOld = pItem->MemSize();
//reduction
if (SizeOld > SizeNew)
{
if (pItem->Next()->IsFree())
{
CListItemInPlace* pNextNext = pItem->Next()->Next();
size_t Offset = reinterpret_cast<size_t>(pItem->Data());
Offset += SizeNew; //Offset to next
CListItemInPlace* pItemNext = reinterpret_cast<CListItemInPlace*>(Offset);
pItem->Next(pItemNext);
pNextNext->Prev(pItemNext);
pItemNext->Prev(pItem);
pItemNext->Next(pNextNext);
pItemNext->Free();
return true;
}
if (SizeOld - SizeNew <= sizeof(CListItemInPlace))
{
return true; //header is bigger than the amount of freed memory
}
//split
size_t Offset = reinterpret_cast<size_t>(pItem->Data());
Offset += SizeNew; //Offset to next
CListItemInPlace* pItemNext = reinterpret_cast<CListItemInPlace*>(Offset);
m_Items.AddBehind(pItemNext, pItem);
pItemNext->Free();
return true;
}
//SizeOld<SizeNew grow
CListItemInPlace* pNext = pItem->Next();
CListItemInPlace* pNextNext = pNext->Next();
const size_t SizeNext = pNext->IsFree() ? pNext->MemSize() + sizeof(CListItemInPlace) : 0;
if (SizeNew <= SizeNext + SizeOld)
{
if (SizeNew + sizeof(CListItemInPlace) + 1 < SizeNext + SizeOld)
{
size_t Offset = reinterpret_cast<size_t>(pItem->Data());
Offset += SizeNew; //Offset to next
CListItemInPlace* pItemNext = reinterpret_cast<CListItemInPlace*>(Offset);
pItem->Next(pItemNext);
pNextNext->Prev(pItemNext);
pItemNext->Prev(pItem);
pItemNext->Next(pNextNext);
pItemNext->Free();
}
else
{
pItem->Next(pNextNext);
pNextNext->Prev(pItem);
}
return true;
}
return false; //no further in-place realloc possible
}
};
template<class TMemory, size_t TNodeCount, bool BoundsCheck = false>
class CReferenced
: public TMemory
{
typedef CPool<TNodeCount, CListItemReference> tdNodePool;
protected:
tdNodePool m_NodePool;
CList<CListItemReference> m_Items;
size_t m_Allocated;
CListItemReference* m_pEmpty;
ILINE void AllocatedMemory(size_t S)
{
m_Allocated += S;
}
ILINE void FreedMemory(size_t S)
{
m_Allocated -= S;
}
ILINE void Stack(CListItemReference* pItem)
{
m_Items.Validate(pItem);
CListItemReference* pItem2 = 0;
CListItemReference* pNext = pItem->Next();
uint8* pData = pItem->Data(pNext->Align());
if (pData != pItem->Data()) //needs splitting 'cause of alignment?
{
pItem2 = reinterpret_cast<CListItemReference*>(m_NodePool.Allocate(1, 1));
if (!pItem2) //no free node found for splitting?
{
return; //failed to stack -> return
}
}
memmove(pData, pNext->Data(), pNext->MemSize());
if (pItem2) //was not aligned?
{
//then keep the current ITem
const size_t SizeItem = pItem->MemSize();
const size_t SizeNext = pNext->MemSize();
m_Items.AddBehind(pItem2, pNext);
pItem2->Data(pData + SizeNext);
pNext->Data(pData);
pItem2->MemSize(pItem2->Next()->Data() - pItem2->Data());
pNext->MemSize(SizeNext);
pItem->MemSize(pNext->Data() - pItem->Data());
m_Items.Validate(pItem);
m_Items.Validate(pItem2);
m_Items.Validate(pNext);
}
else
{
const size_t SizeItem = pItem->MemSize();
const size_t SizeNext = pNext->MemSize();
m_Items.Remove(pItem);
m_Items.AddBehind(pItem, pNext);
pItem->Data(pNext->Data());
pNext->Data(pData);
pNext->MemSize(SizeItem);
pItem->MemSize(SizeNext);
m_Items.Validate(pItem);
m_Items.Validate(pNext);
}
}
public:
ILINE CReferenced()
: m_Allocated(0)
{
}
ILINE void InitMem(const size_t S = 0, uint8* pData = 0)
{
TMemory::InitMem(S, pData);
if (!TMemory::MemSize())
{
return;
}
pData = TMemory::Data();
CListItemReference* pItem = reinterpret_cast<CListItemReference*>(m_NodePool.Allocate(1, 1));
CListItemReference* pLast = reinterpret_cast<CListItemReference*>(m_NodePool.Allocate(1, 1));
m_Items.AddFirst(pItem);
m_Items.AddLast(pLast);
pLast->Init(pData + TMemory::MemSize(), 0, pItem, 0);
pLast->InUse(0);
pItem->Init(pData, TMemory::MemSize(), 0, pLast);
pItem->Free();
m_pEmpty = pItem;
m_Allocated = 0;
}
ILINE size_t FragmentCount() const
{
return m_Items.Count();
}
ILINE CListItemReference* Split(CListItemReference* pItem, size_t Size, size_t Align)
{
size_t Offset = reinterpret_cast<size_t>(pItem->Data());
if (!(Offset & (Align - 1))) //perfectly aligned?
{
if (pItem->MemSize() != Size) //not perfectly fitting?
{ //then split
CListItemReference* pItemPrev = reinterpret_cast<CListItemReference*>(m_NodePool.Allocate(1, 1));
if (!pItemPrev)
{
return 0;
}
const size_t OrgSize = pItem->MemSize();
m_Items.AddBefore(pItemPrev, pItem);
pItemPrev->Data(pItem->Data());
pItem->Data(pItem->Data() + Size);
pItem->MemSize(OrgSize - Size);
pItemPrev->MemSize(Size);
pItem = pItemPrev;
}
return pItem;
}
//not aligned to block start
//then lets try to align to block end
Offset += pItem->MemSize(); //ptr to end
Offset -= Size; //minus size
if (!(Offset & (Align - 1))) //perfectly aligned?
{
CListItemReference* pItemPrev = reinterpret_cast<CListItemReference*>(m_NodePool.Allocate(1, 1));
if (!pItemPrev)
{
return 0;
}
const size_t OrgSize = pItem->MemSize();
m_Items.AddBefore(pItemPrev, pItem);
pItemPrev->Data(pItem->Data());
pItem->Data(reinterpret_cast<uint8*>(Offset));
pItemPrev->MemSize(OrgSize - Size);
pItem->MemSize(Size);
pItemPrev->Free();
return pItem;
}
//last resort, fragment it into 3 parts
//Size +=Offset&(Align-1); //adjust size to fit required alignment
Offset -= Offset & (Align - 1);
CListItemReference* pItemPrev = reinterpret_cast<CListItemReference*>(m_NodePool.Allocate(1, 1));
CListItemReference* pItemNext = reinterpret_cast<CListItemReference*>(m_NodePool.Allocate(1, 1));
if (!pItemPrev || !pItemNext)
{
return 0;
}
const size_t OrgSize = pItem->MemSize();
m_Items.AddBefore(pItemPrev, pItem);
m_Items.AddBehind(pItemNext, pItem);
pItemPrev->Data(pItem->Data());
pItem->Data(reinterpret_cast<uint8*>(Offset));
pItemNext->Data(pItem->Data() + Size);
pItemPrev->MemSize(pItem->Data() - pItemPrev->Data());
pItemNext->MemSize(OrgSize - pItemPrev->MemSize() - Size);
pItem->MemSize(Size);
pItemPrev->Free();
pItemNext->Free();
return pItem;
}
ILINE void Merge(CListItemReference* pItem)
{
m_Items.Validate(pItem);
//merge with next if possible
CListItemReference* pItemNext = pItem->Next();
if (pItemNext && pItemNext->IsFree())
{
if (m_pEmpty == pItemNext)
{
m_pEmpty = pItem;
}
const size_t OrgSize = pItem->MemSize();
const size_t NextSize = pItemNext->MemSize();
m_Items.Remove(pItemNext);
pItem->MemSize(OrgSize + NextSize);
m_NodePool.Free(pItemNext);
}
//merge with prev if possible
CListItemReference* pItemPrev = pItem->Prev();
if (pItemPrev && pItemPrev->IsFree())
{
if (m_pEmpty == pItem)
{
m_pEmpty = pItemPrev;
}
const size_t OrgSize = pItem->MemSize();
const size_t PrevSize = pItemPrev->MemSize();
m_Items.Remove(pItem);
pItemPrev->MemSize(PrevSize + OrgSize);
m_NodePool.Free(pItem);
}
}
template<class T>
ILINE T Resolve(const uint32 ID)
{
CPA_ASSERT(ID); //0 is invalid
return reinterpret_cast<T>(Item(ID)->Data());
}
ILINE uint32 AddressToHandle(void* pData)
{
for (CListItemReference* pItem = m_Items.First(); pItem; pItem = pItem->Next())
{
if (pItem->Data() == pData)
{
return Handle(pItem);
}
}
return 0;
}
template<class T>
ILINE size_t Size(T ID) const
{
CPA_ASSERT(ID); //0 is invalid
return Item(ID)->MemSize();
}
template<class T>
bool InBounds([[maybe_unused]] T ID, [[maybe_unused]] const bool Check) const
{
//boundscheck doesn't work for Referenced containers
return true;
}
template<class T>
ILINE bool Free(T ID, bool ForceBoundsCheck = false)
{
IF (!ID, false)
{
return true;
}
IF (!InBounds(ID, BoundsCheck | ForceBoundsCheck), false)
{
return false;
}
CListItemReference* pItem = Item(ID);
FreedMemory(pItem->MemSize());
pItem->Free();
Merge(pItem);
return true;
}
ILINE bool Beat(){return false; }//dummy beat in case no defragmentator is wraping
ILINE size_t MemFree() const{return TMemory::MemSize() - m_Allocated; }
ILINE size_t MemSize() const{return TMemory::MemSize(); }
ILINE uint32 Handle(CListItemReference* pItem) const
{
return static_cast<uint32>(pItem - &m_NodePool[0]);
}
ILINE CListItemReference* Item(uint32 ID)
{
return &m_NodePool[ID];
}
ILINE const CListItemReference* Item(uint32 ID) const
{
return &m_NodePool[ID];
}
ILINE static bool Defragmentable(){return true; }
template<class T>
ILINE bool ReSize(T* pData, size_t SizeNew)
{
CListItemReference* pItem = Item(*pData);
const size_t SizeOld = pItem->MemSize();
//reduction
if (SizeOld > SizeNew)
{
if (pItem->Next()->IsFree())
{
CListItemReference* pNext = pItem->Next();
const size_t NextSize = pNext->MemSize();
pNext->Data(pNext->Data() + SizeNew - SizeOld);
pNext->MemSize(NextSize - SizeNew + SizeOld);
pItem->MemSize(SizeNew);
return true;
}
//split
CListItemReference* pItemNext = reinterpret_cast<CListItemReference*>(m_NodePool.Allocate(1, 1));
m_Items.AddBehind(pItemNext, pItem);
pItemNext->Data(pItem->Data() + SizeNew);
pItem->MemSize(SizeNew);
pItemNext->MemSize(SizeOld - SizeNew);
pItemNext->Free();
return true;
}
//SizeOld<SizeNew grow
CListItemReference* pNext = pItem->Next();
const size_t SizeNext = pNext->IsFree() ? pNext->MemSize() : 0;
if (SizeNew <= SizeNext + SizeOld)
{
if (SizeNew == SizeNext + SizeOld)
{
m_Items.Remove(pNext);
m_NodePool.Free(pNext);
}
else
{
pNext->Data(pNext->Data() + SizeNew - SizeOld);
pNext->MemSize(SizeNext - SizeNew + SizeOld);
}
pItem->MemSize(SizeNew);
return true;
}
return false; //no further in-place realloc possible
}
};
}
#endif // CRYINCLUDE_CRYPOOL_CONTAINER_H
Code/CryEngine/CryCommon/CryPool/Defrag.h
-65
View File
@@ -1,65 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYPOOL_DEFRAG_H
#define CRYINCLUDE_CRYPOOL_DEFRAG_H
#pragma once
namespace NCryPoolAlloc
{
template<class T>
class CDefragStacked
: public T
{
template<class TItem>
ILINE bool DefragElement(TItem* pItem)
{
T::m_Items.Validate();
if (pItem)
{
for (; pItem->Next(); pItem = pItem->Next())
{
if (!pItem->IsFree())
{
continue;
}
if (pItem->Next()->Locked())
{
continue;
}
if (!pItem->Available(pItem->Next()->Align(), pItem->Next()->Align()))
{
continue;
}
T::m_Items.Validate(pItem);
Stack(pItem);
T::m_Items.Validate(pItem);
Merge(pItem);
T::m_Items.Validate();
return true;
}
}
return false;
}
public:
ILINE bool Beat()
{
return T::Defragmentable() && DefragElement(T::m_Items.First());
};
};
}
#endif // CRYINCLUDE_CRYPOOL_DEFRAG_H
Code/CryEngine/CryCommon/CryPool/Fallback.h
-81
View File
@@ -1,81 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYPOOL_FALLBACK_H
#define CRYINCLUDE_CRYPOOL_FALLBACK_H
#pragma once
namespace NCryPoolAlloc
{
enum EFallbackMode
{
EFM_DISABLED,
EFM_ENABLED,
EFM_ALWAYS
};
template<class TAllocator>
class CFallback
: public TAllocator
{
EFallbackMode m_Fallback;
public:
ILINE CFallback()
: m_Fallback(EFM_DISABLED)
{
}
template<class T>
ILINE T Allocate(size_t Size, size_t Align = 1)
{
if (EFM_ALWAYS == m_Fallback)
{
return reinterpret_cast<T>(CPA_ALLOC(Align, Size));
}
T pRet = TAllocator::template Allocate<T>(Size, Align);
if (!pRet && EFM_ENABLED == m_Fallback)
{
return reinterpret_cast<T>(CPA_ALLOC(Align, Size));
}
return pRet;
}
template<class T>
ILINE bool Free(T Handle)
{
if (!Handle)
{
return true;
}
if (EFM_ALWAYS == m_Fallback)
{
CPA_FREE(Handle);
return true;
}
if (EFM_ENABLED == m_Fallback && TAllocator::InBounds(Handle, true))
{
CPA_FREE(Handle);
return true;
}
return TAllocator::template Free<T>(Handle);
}
void FallbackMode(EFallbackMode M){m_Fallback = M; }
EFallbackMode FallbaclMode() const{return m_Fallback; }
};
}
#endif // CRYINCLUDE_CRYPOOL_FALLBACK_H
Code/CryEngine/CryCommon/CryPool/Inspector.h
-203
View File
@@ -1,203 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYPOOL_INSPECTOR_H
#define CRYINCLUDE_CRYPOOL_INSPECTOR_H
#pragma once
namespace NCryPoolAlloc
{
template<class TAllocator>
class CInspector
: public TAllocator
{
enum
{
EITableSize = 30
};
size_t m_Allocations[EITableSize];
size_t m_Alignment[EITableSize];
char m_LogFileName[1024];
size_t m_AllocCount;
size_t m_FreeCount;
size_t m_ResizeCount;
size_t m_FailAllocCount;
size_t m_FailFreeCount;
size_t m_FailResizeCount;
void WriteOut(const char* pFileName, uint32 Stack, const char* pFormat, ...) const
{
/*
if(!pFileName)
{
if(!*m_LogFileName)
return;
pFileName = m_LogFileName;
}
FILE* File = fopen(pFileName,"a");
if(File)
{
char Buffer[1024];
for(uint32 a=0;a<Stack;a++)
Buffer[a]=' ';
va_list args;
va_start(args,pFormat);
vsprintf(Buffer+Stack,pFormat,args);
fwrite(Buffer,1,strlen(Buffer),File);
fclose(File);
va_end(args);
}
*/
}
size_t Bit(size_t C) const
{
size_t Count = 0;
C >>= 1;
while (C)
{
Count++;
C >>= 1;
}
return Count >= EITableSize ? EITableSize - 1 : Count;
}
public:
CInspector()
{
for (size_t a = 0; a < EITableSize; a++)
{
m_Allocations[a] = m_Alignment[a] = 0;
}
m_LogFileName[0] = 0;
m_AllocCount = 0;
m_FreeCount = 0;
m_ResizeCount = 0;
m_FailAllocCount = 0;
m_FailFreeCount = 0;
m_FailResizeCount = 0;
}
bool LogFileName(const char* pFileName)
{
const size_t Size = strlen(pFileName) + 1;
if (Size > sizeof(m_LogFileName))
{
m_LogFileName[0] = 0;
return false;
}
memcpy(m_LogFileName, pFileName, Size);
WriteOut(0, "[log start]\n");
return true;
}
void SaveStats(const char* pFileName) const
{
WriteOut(pFileName, 0, "stats:\n");
WriteOut(pFileName, 1, "Counter calls|fails\n");
WriteOut(pFileName, 2, "Alloc: %6d|%6d\n", m_AllocCount, m_FailAllocCount);
WriteOut(pFileName, 2, "Free: %6d|%6d\n", m_FreeCount, m_FailFreeCount);
WriteOut(pFileName, 2, "Resize:%6d|%6d\n", m_ResizeCount, m_FailResizeCount);
WriteOut(pFileName, 1, "Allocations:\n");
for (size_t a = 0; a < EITableSize; a++)
{
WriteOut(pFileName, 2, "%9dByte: %8d\n", 1 << a, m_Allocations[a]);
}
WriteOut(pFileName, 1, "Alignment:\n");
for (size_t a = 0; a < EITableSize; a++)
{
WriteOut(pFileName, 2, "%9dByte: %8d\n", 1 << a, m_Alignment[a]);
}
}
template<class T>
ILINE T Allocate(size_t Size, size_t Align = 1)
{
m_AllocCount++;
m_Allocations[Bit(Size)]++;
m_Alignment[Bit(Align)]++;
T pData = TAllocator::template Allocate<T>(Size, Align);
WriteOut(0, 0, "[A|%d|%d|%d]", (int)pData, Size, Align);
if (!pData)
{
m_FailAllocCount++;
WriteOut(0, 0, "[failed]", Size, Align);
}
return pData;
}
template<class T>
ILINE bool Free(T pData, bool ForceBoundsCheck = false)
{
m_FreeCount++;
const bool Ret = TAllocator::Free(pData, ForceBoundsCheck);
WriteOut(0, 0, "[F|%d|%d|%d]", (int)pData, (int)ForceBoundsCheck, (int)Ret);
m_FailFreeCount += !Ret;
return Ret;
}
//template<class T>
//ILINE bool Free(T pData)
// {
// m_FreeCount++;
// const bool Ret = TAllocator::Free(pData);
// WriteOut(0,0,"[F|%d|%d|%d]",(int)pData,(int)-1,(int)Ret);
// m_FailFreeCount+=!Ret;
// return Ret;
// }
template<class T>
ILINE bool Resize(T** pData, size_t Size, size_t Alignment)
{
m_ResizeCount++;
const bool Ret = TAllocator::Resize(pData, Size, Alignment);
WriteOut(0, 0, "[R|%d|%d|%d]", (int)*pData, (int)-1, (int)Ret);
m_FailResizeCount += !Ret;
return Ret;
}
template<class T>
ILINE size_t FindBiggest(const T* pItem)
{
size_t Biggest = 0;
while (pItem)
{
if (pItem->IsFree() && pItem->MemSize() > Biggest)
{
Biggest = pItem->MemSize();
}
pItem = pItem->Next();
}
return Biggest;
}
ILINE size_t BiggestFreeBlock()
{
return FindBiggest(TAllocator::m_Items.First());
}
ILINE uint8* FirstItem()
{
return TAllocator::m_Items.First()->Data();
}
};
}
#endif // CRYINCLUDE_CRYPOOL_INSPECTOR_H
Code/CryEngine/CryCommon/CryPool/List.h
-366
View File
@@ -1,366 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYPOOL_LIST_H
#define CRYINCLUDE_CRYPOOL_LIST_H
#pragma once
namespace NCryPoolAlloc
{
class CListItemInPlace;
class CListItemReference;
template<typename TItem>
class CListItem
{
TItem* m_pPrev;
TItem* m_pNext;
public:
ILINE TItem* Prev(){return m_pPrev; }
ILINE TItem* Next(){return m_pNext; }
ILINE const TItem* Prev() const{return m_pPrev; }
ILINE const TItem* Next() const{return m_pNext; }
ILINE void Prev(TItem* pPrev){ m_pPrev = pPrev; }
ILINE void Next(TItem* pNext){ m_pNext = pNext; }
//debugging
void Validate();
};
template<typename TItem>
class CListItemFlagged
: public CListItem<TItem>
{
enum
{
ELIF_INUSE = (1 << 0),
ELIF_LOCKED = (1 << 1),
};
uint32 m_Flags : 8;
uint32 m_Align : 24;
public:
ILINE CListItemFlagged()
: m_Flags(0)
{
}
ILINE bool IsFree() const{return (m_Flags & ELIF_INUSE) != ELIF_INUSE; }
ILINE void Free(){m_Flags &= ~ELIF_INUSE; }
ILINE void InUse(uint32 A){m_Flags |= ELIF_INUSE; m_Align = A; }
ILINE bool Locked() const{return ELIF_LOCKED == (m_Flags & ELIF_LOCKED); }
ILINE void Lock(){m_Flags |= ELIF_LOCKED; }
ILINE void Unlock(){m_Flags &= ~ELIF_LOCKED; }
ILINE uint32 Align() const{return m_Align; }
};
class CListItemInPlace
: public CListItemFlagged<CListItemInPlace>
{
public:
ILINE void Init([[maybe_unused]] uint8* pData, [[maybe_unused]] size_t Size, CListItemInPlace* pPrev, CListItemInPlace* pNext)
{
Prev(pPrev);
Next(pNext);
CPA_ASSERT(Size == MemSize());
}
ILINE bool Available(size_t Size, size_t Align) const
{
size_t Offset = reinterpret_cast<size_t>(Data());
if (Offset & (Align - 1)) //not aligned?
{
Size += sizeof(CListItemInPlace) + Align - 1; //then an intermedian node needs to fit
}
return Size <= MemSize() && IsFree();
}
ILINE uint8* Data(){return reinterpret_cast<uint8*>(this) + sizeof(CListItemInPlace); }
ILINE const uint8* Data() const{return reinterpret_cast<const uint8*>(this) + sizeof(CListItemInPlace); }
ILINE size_t MemSize() const
{
const uint8* pNext = reinterpret_cast<const uint8*>(Next());
const uint8* pThis = reinterpret_cast<const uint8*>(this);
const size_t ESize = sizeof(CListItemInPlace);
size_t Delta = pNext - pThis;
Delta -= ESize;
return Delta;
}
};
class CListItemReference
: public CListItemFlagged<CListItemReference>
{
uint8* m_pData;
// size_t m_Size;
public:
ILINE void Init(uint8* pData, size_t Size, CListItemReference* pPrev, CListItemReference* pNext)
{
Data(pData);
Prev(pPrev);
Next(pNext);
MemSize(Size);
}
ILINE bool Available(size_t Size, size_t Align) const
{
size_t Offset = reinterpret_cast<size_t>(Data());
if ((Offset & (Align - 1)))
{
Size += Align - (Offset & (Align - 1));
}
return Size <= MemSize() && IsFree();
}
ILINE void Data(uint8* pData){m_pData = pData; }
ILINE uint8* Data(size_t Align)
{
Align--;
size_t Offset = reinterpret_cast<size_t>(m_pData);
Offset = (Offset + Align) & ~Align;
return reinterpret_cast<uint8*>(Offset);
}
ILINE uint8* Data(){return m_pData; }
ILINE const uint8* Data() const{return m_pData; }
ILINE void MemSize([[maybe_unused]] size_t Size) { }
ILINE size_t MemSize() const
{
const size_t T = reinterpret_cast<size_t>(Data());
const size_t N = Next() ? reinterpret_cast<size_t>(Next()->Data()) : T;
return N - T;
}
//ILINE void MemSize(size_t Size){m_Size=Size;}
//ILINE size_t MemSize()const{return m_Size;}
};
template<class TItem, bool VALIDATE = false>
class CList
{
TItem* m_pFirst;
TItem* m_pLast;
size_t m_Count;
public:
ILINE CList()
: m_pFirst(0)
, m_pLast(0)
, m_Count(0)
{
}
ILINE void First(TItem* pItem){m_pFirst = pItem; }
ILINE TItem* First(){return m_pFirst; }
ILINE void Last(TItem* pItem){m_pLast = pItem; }
ILINE TItem* Last(){return m_pLast; }
ILINE bool Empty() const{return m_pFirst == 0; }
ILINE TItem* PopFirst()
{
Validate();
if (!m_pFirst)
{
return 0;
}
TItem* pRet = m_pFirst;
m_pFirst = m_pFirst->Next();
if (m_pFirst) //if any element exists
{
m_pFirst->Prev(0); //set prev ptr of this element to 0
}
else
{
m_pLast = 0; //set ptr to last element to 0 if ptr to first is zero as well
}
Validate();
m_Count--;
return pRet;
}
ILINE TItem* PopLast()
{
Validate();
if (!m_pLast)
{
return 0;
}
TItem* pRet = m_pLast;
m_pLast = m_pLast->Prev();
if (m_pLast) //if any element exists
{
m_pLast->Next(0); //set prev ptr of this element to 0
}
else
{
m_pFirst = 0; //set ptr to last element to 0 if ptr to first is zero as well
}
Validate();
m_Count--;
return pRet;
}
ILINE void AddFirst(TItem* pItem)
{
CPA_ASSERT(pItem); //ERROR AddFirst got 0 pointer
Validate();
pItem->Prev(0);
pItem->Next(m_pFirst);
if (!m_pFirst)
{
m_pLast = pItem;
}
else
{
m_pFirst->Prev(pItem);
}
m_pFirst = pItem;
m_Count++;
Validate();
}
ILINE void AddLast(TItem* pItem)
{
CPA_ASSERT(pItem); //ERROR AddLast got 0 pointer
Validate();
pItem->Prev(m_pLast);
pItem->Next(0);
if (!m_pLast)
{
m_pFirst = pItem;
}
else
{
m_pLast->Next(pItem);
}
m_pLast = pItem;
m_Count++;
Validate();
}
ILINE void AddBefore(TItem* pItem, TItem* pItemSuccessor)
{
CPA_ASSERT(pItem);
CPA_ASSERT(pItemSuccessor);
Validate();
pItem->Next(pItemSuccessor);
pItem->Prev(pItemSuccessor->Prev());
pItemSuccessor->Prev(pItem);
if (pItemSuccessor == m_pFirst)
{
m_pFirst = pItem;
}
else
{
pItem->Prev()->Next(pItem);
}
m_Count++;
Validate();
}
ILINE void AddBehind(TItem* pItem, TItem* pItemPredecessor)
{
CPA_ASSERT(pItem);
CPA_ASSERT(pItemPredecessor);
Validate();
pItem->Next(pItemPredecessor->Next());
pItem->Prev(pItemPredecessor);
pItemPredecessor->Next(pItem);
if (pItemPredecessor == m_pLast)
{
m_pLast = pItem;
}
else
{
pItem->Next()->Prev(pItem);
}
m_Count++;
Validate();
}
ILINE void Remove(TItem* pItem)
{
CPA_ASSERT(pItem); //ERROR releasing empty item
if (pItem == m_pFirst)
{
PopFirst();
return;
}
if (pItem == m_pLast)
{
PopLast();
return;
}
Validate(pItem);
pItem->Prev()->Next(pItem->Next());
pItem->Next()->Prev(pItem->Prev());
m_Count--;
Validate();
}
//debug
ILINE void Validate(TItem* pReferenceItem = 0)
{
if (!VALIDATE)
{
return;
}
//one-sided empty?
CPA_ASSERT((!First() && !Last()) || (First() && Last())); //ERROR validating item-list, just one end is 0
// endles linking?
TItem* pPrev = 0;
TItem* pItem = First();
while (pItem)
{
if (pReferenceItem == pItem)
{
pReferenceItem = 0;
}
CPA_ASSERT(pPrev == pItem->Prev()); //ERROR validating item-list, endless linking NULL
pPrev = pItem;
pItem = pItem->Next();
}
CPA_ASSERT(pPrev == Last()); //ERROR validating item-list, broken list, does not end at specified Last item
CPA_ASSERT(!pReferenceItem); //ERROR reference item not found in the item-list
}
ILINE size_t Count() const{return m_Count; }
};
}
#endif // CRYINCLUDE_CRYPOOL_LIST_H
Code/CryEngine/CryCommon/CryPool/Memory.h
-70
View File
@@ -1,70 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYPOOL_MEMORY_H
#define CRYINCLUDE_CRYPOOL_MEMORY_H
#pragma once
namespace NCryPoolAlloc
{
class CMemoryDynamic
{
size_t m_Size;
uint8* m_pData;
protected:
ILINE CMemoryDynamic()
: m_Size(0)
, m_pData(0){}
public:
ILINE void InitMem(const size_t S, uint8* pData)
{
m_Size = S;
m_pData = pData;
CPA_ASSERT(S);
CPA_ASSERT(pData);
}
ILINE size_t MemSize() const{return m_Size; }
ILINE uint8* Data(){return m_pData; }
ILINE const uint8* Data() const{return m_pData; }
};
template<size_t TSize>
class CMemoryStatic
{
uint8 m_Data[TSize];
protected:
ILINE CMemoryStatic()
{
}
public:
ILINE void InitMem(const size_t S, uint8* pData)
{
}
ILINE size_t MemSize() const{return TSize; }
ILINE uint8* Data(){return m_Data; }
ILINE const uint8* Data() const{return m_Data; }
};
}
#endif // CRYINCLUDE_CRYPOOL_MEMORY_H
Code/CryEngine/CryCommon/CryPool/PoolAlloc.h
-55
View File
@@ -1,55 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#pragma once
#if defined(POOLALLOCTESTSUIT)
//cheat just for unit testing on windows
#include "BaseTypes.h"
#define ILINE inline
#endif
// Traits
#if defined(AZ_RESTRICTED_PLATFORM)
#include AZ_RESTRICTED_FILE(CryPool/PoolAlloc_h)
#elif defined(APPLE) || defined(LINUX)
#define POOLALLOC_H_TRAIT_USE_MEMALIGN 1
#endif
#if POOLALLOC_H_TRAIT_USE_MEMALIGN
#define CPA_ALLOC memalign
#define CPA_FREE free
#else
#define CPA_ALLOC _aligned_malloc
#define CPA_FREE _aligned_free
#endif
#define CPA_ASSERT assert
#define CPA_ASSERT_STATIC(X) {uint8 assertdata[(X) ? 0 : 1]; }
#define CPA_BREAK __debugbreak()
#include "List.h"
#include "Memory.h"
#include "Container.h"
#include "Allocator.h"
#include "Defrag.h"
#include "STLWrapper.h"
#include "Inspector.h"
#include "Fallback.h"
#if !defined(POOLALLOCTESTSUIT)
#include "ThreadSafe.h"
#endif
#undef CPA_ASSERT
#undef CPA_ASSERT_STATIC
#undef CPA_BREAK
Code/CryEngine/CryCommon/CryPool/STLWrapper.h
-148
View File
@@ -1,148 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYPOOL_STLWRAPPER_H
#define CRYINCLUDE_CRYPOOL_STLWRAPPER_H
#pragma once
namespace NCryPoolAlloc
{
//namespace CSTLPoolAllocWrapperHelper
//{
// inline void destruct(char *) {}
// inline void destruct(wchar_t*) {}
// template <typename T>
// inline void destruct(T *t) {t->~T();}
//}
//template <size_t S, class L, size_t A, typename T>
//struct CSTLPoolAllocWrapperStatic
//{
// static PoolAllocator<S, L, A> * allocator;
//};
//template <class T, class L, size_t A>
//struct CSTLPoolAllocWrapperKungFu : public CSTLPoolAllocWrapperStatic<sizeof(T),L,A,T>
//{
//};
template <class T, class TCont>
class CSTLPoolAllocWrapper
{
private:
static TCont* m_pContainer;
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef T value_type;
static TCont* Container(){return m_pContainer; }
static void Container(TCont* pContainer){m_pContainer = pContainer; }
template <class U>
struct rebind
{
typedef CSTLPoolAllocWrapper<T, TCont> other;
};
CSTLPoolAllocWrapper() throw()
{
}
CSTLPoolAllocWrapper(const CSTLPoolAllocWrapper&) throw()
{
}
template <class TTemp, class TTempCont>
CSTLPoolAllocWrapper(const CSTLPoolAllocWrapper<TTemp, TTempCont>&) throw()
{
}
~CSTLPoolAllocWrapper() throw()
{
}
pointer address(reference x) const
{
return &x;
}
const_pointer address(const_reference x) const
{
return &x;
}
pointer allocate(size_type n = 1, const_pointer hint = 0)
{
TCont* pContainer = Container();
uint8* pData = pContainer->TCont::template Allocate<uint8*>(n * sizeof(T), sizeof(T));
return pContainer->TCont::template Resolve<pointer>(pData);
// return Container()?Container()->Allocate<void*>(n*sizeof(T),sizeof(T)):0
}
void deallocate(pointer p, size_type n = 1)
{
if (Container())
{
Container()->Free(p);
}
}
size_type max_size() const throw()
{
return Container() ? Container()->MemSize() : 0;
}
void construct(pointer p, const T& val)
{
new(static_cast<void*>(p))T(val);
}
void construct(pointer p)
{
new(static_cast<void*>(p))T();
}
void destroy(pointer p)
{
p->~T();
}
pointer new_pointer()
{
return new(allocate())T();
}
pointer new_pointer(const T& val)
{
return new(allocate())T(val);
}
void delete_pointer(pointer p)
{
p->~T();
deallocate(p);
}
bool operator==(const CSTLPoolAllocWrapper&) {return true; }
bool operator!=(const CSTLPoolAllocWrapper&) {return false; }
};
}
#endif // CRYINCLUDE_CRYPOOL_STLWRAPPER_H
Code/CryEngine/CryCommon/CryPool/ThreadSafe.h
-58
View File
@@ -1,58 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYPOOL_THREADSAFE_H
#define CRYINCLUDE_CRYPOOL_THREADSAFE_H
#pragma once
#include <CryThread.h>
namespace NCryPoolAlloc
{
template<class TAllocator>
class CThreadSafe
: public TAllocator
{
CryCriticalSection m_Mutex;
public:
template<class T>
ILINE T Allocate(size_t Size, size_t Align = 1)
{
CryAutoLock<CryCriticalSection> lock(m_Mutex);
return TAllocator::template Allocate<T>(Size, Align);
}
template<class T>
ILINE bool Free(T pData, bool ForceBoundsCheck = false)
{
CryAutoLock<CryCriticalSection> lock(m_Mutex);
return TAllocator::Free(pData, ForceBoundsCheck);
}
template<class T>
ILINE bool Resize(T** pData, size_t Size, size_t Alignment)
{
CryAutoLock<CryCriticalSection> lock(m_Mutex);
return TAllocator::Resize(pData, Size, Alignment);
}
};
}
#endif // CRYINCLUDE_CRYPOOL_THREADSAFE_H
Code/CryEngine/CryCommon/CryPool/example.h
-287
View File
@@ -1,287 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYPOOL_EXAMPLE_H
#define CRYINCLUDE_CRYPOOL_EXAMPLE_H
#pragma once
//The documentation is split up into 3 main parts, so strg+f for
// -Theory
// -Building blocks
// -Usage
// -FAQ
// -Realloc/Resize
/////////////////////////////////////////////////////////////////////////
// -Theory
/////////////////////////////////////////////////////////////////////////
//this includes the 3 major parts of the allocate suite
//1. the memory location templates
//2. container types
//3. some allocator version
//addtional you get
//4. a simple stack based defragmentation template
//5. helper
//1. memory location templates
// There are two types of them, static and dynamic
//1.1 CMemoryStatic<size> allows you do define on compile time what size
// it should have, suitable for pool you know that they won't grow or
// shrink
//1.2 CMemoryDynamic, this one has no template parameter, it has just one
// indirection via ptr to the memory location and size, that you will
// set during initialization.
//2. Container types
// We have also two container types, one so called "In Place"
// and one "Referenced".
//2.1 "In Place" means that a header is placed above every allocation,
// this is the usual way most allocators work.
//2.2 "Referenced", has an extra pool of headers that point to the actual
// memory. This is suitable for
// - external memory locations that are not directly accessable by the
// cpu. E.g. pools on disk, networks, rsx memory..
// - defragmentation, because you don't save a ptr to the real memory
// location, just a "handle" of the referencing item.
// - big alignments, having 4kb of alignment would waste also
// - 4kb for ever "In Place" header, you might not want that.
//3. Allocators
// This time we have 3 of them, "BestFit", "WorstFit" and "FirstFit"
//3.1 FirstFit just seeks for any location big enought to fit your
// requested size of memory. Internally it also saves the last used
// free memory area to speed up allocations.
// Use this also if you have just one particular allocation size.
//3.2 WorstFit, although it might sound illogical, WorstFit can reduce
// memory fragmentation in a cases with very random allocation sizes,
// because it gives smaller free blocks the chance to concatenate to
// bigger free blocks again while filling up those previously
// generated big blocks. The bad side is that it takes quite some time
// to find the biggest block as this needs to be done every time you
// allocate, so use this just when having a low amount of allocations
// or you're really desperately looking for mem.
//3.3 BestFit, it's best used if you don't have just one allocation size,
// but still very few varying sizes. Previously released blocks of
// the currently allocating sizes will be seeked and reused, this
// strongly helps to reduce fragmentation. While this might be slow
// in some cases, it can save you from doing any defragmentation.
//4. Defragmentation
// At the moment just one defragmentation algorithm is implemented:
// "Stack defragmentator"
// If you don't want some block to be moved, "Lock" it using your
// memory handle.
//4.1 Stack based
// To reduce fragmentation, holes are filled up with the next used,
// memory area. This defragmentation sheme is useful when you have
// some long living locations as well as very short living ones.
// At some point all long live memory will end up at the bottom of
// the stack, while leaving empty memory areas at the top for short
// living allocations.
//5. Helper
// this should be filled up with some handy helper tools for this
// pool suite.
// The first tool is a wrapper for the usage with stl
//5.1 Wrapper for STL
// As you know, you can pass your own allocator as the last
// parameter of stl containers, with this helper you can use a pool
// created with this suite and wrap it for the stl.
/////////////////////////////////////////////////////////////////////////
// -Building blocks
/////////////////////////////////////////////////////////////////////////
//That's the theory, so how does it work?
//It's pretty simple, you compose the pool of your dreams by cascading
//templates.
//Lets start with an exmaple
//Per level you want to allocate a fixed amount of memory for your
//textures.
CMemoryDynamic
//- They are placed in some memory you can access directly with the cpu:
CInPlace
//- and you don't want to defragmentate, so you prefer an allocation
// sheme that reduces fragmentation.
CBestFit
//now you combine them
typedef CBestFit<CInPlace<CMemoryDynamic>, CListItemInPlace> TMyOwnPool;
//Yes, it's that simple.
//ok, ok, texture memory is usually nothing you want to access directly
//with your cpu, so let's create a referencing pool. Therefor you need
//to also specify how many nodes that can reference your pool will have.
//We won't have more than 4000 textures, so let's start with
{
enum TEXTURE_NODE_COUNT = 4096
};
//and now our referencing pool
typedef CBestFit < CReferenced<CMemoryDynamic, TEXTURE_NODE_COUNT> TMyOwnPool;
//But yeah, you're right, texture memory has also a fixed size, lets
//assume it's 128MB.
{
enum TEXTURE_MEMORY_SIZE = 128 * 1024 * 1024
};
//and our fixed sized memory pool
typedef CBestFit < CReferenced<CMemoryStatic<TEXTURE_MEMORY_SIZE>, TEXTURE_NODE_COUNT> TMyOwnPool;
//ok, but you don't trust the best fit allocator in all cases, you prefer
//a fast one and you accept the slow down for defragmentation incase the
//allocation fails.
//So lets created a straight First Fit allocator with defragmentation:
typedef CDefragStacked < CFirstFit<CReferenced<CMemoryStatic<TEXTURE_MEMORY_SIZE>, TEXTURE_NODE_COUNT> > TMyOwnPool;
//here you see how simple you can add defragmentation, but be careful, it
//works of course just on Reference based memory containers, if you have
//Direct pointers to In Place allocation, we cannot shuffle them around.
/////////////////////////////////////////////////////////////////////////
// -Usage
/////////////////////////////////////////////////////////////////////////
//it all starts by including the meain header
#include "PoolAlloc.h"
//Define your dream allocator, preferably using a typedef (or macro)
typedef CBestFit<CInPlace<CMemoryDynamic>, CListItemInPlace> TMyOwnPool;
//also typedef (or macro) your handle
typedef uint8* TMyHandle; //in case of "In Place" allocations
typedef uint32 TMyHandle; //in case of "Referenced"
//Instantiate it
TMyOwnPool g_MyMemory;
//now you need to initialize it,
g_MyMemory.InitMem(pMemoryArea, MemorySize); //in case you use "CMemoryDynamic"
g_MyMemory.InitMem(); //in case you use "CmemoryStatic,
//altough you could pass the same
//parameters, they'd be ignored.
//Use this also to flush the pool
//quickly
//now allocate
TMyHandle MemID = g_MyMemory.Allocate<TMyHandle>(Size);
//optionally alignment can be passed as 2nd parameter
TMyHandle MemID = g_MyMemory.Allocate<TMyHandle>(Size, Align);
//free it simply by calling
g_Memory.Free(MemID);
//you might want to call the beat function to defragment the memory
//on regular base
g_Memory.Beat();
//you might also want to call it just when an allocation failed to
//defragmentate the memory as good as possible
if (!(MemID = g_Memoery.Allocate<TMyHandle>(Size)))
{
while (g_Memory.Beat())
{
;
}
MemID = g_Memoery.Allocate<TMyHandle>(Size);
}
//To acquire the pointer to your data, you need to resolve the handle
MyObject* pObject = g_Memory.Resolve<MyOBject*>(MemID);
/////////////////////////////////////////////////////////////////////////
// -Realloc/Resize
/////////////////////////////////////////////////////////////////////////
// The Containers provide a "resize" function. This one does nothing else
// than the name suggest, it is freeing some memory at the end of your
// allocation or, if free memory is available, allocates some memory to
// the end of your buffer. But it may also fail, if not enough memory
// available to allocate.
// "Realloc" on the other side requires an extra template that you wrap
// around your existing one like:
typedef CReallocator<TMyOwnPool> TMyOwnPoolWithReallocation;
// This one will first try to use resize, but in case it fails, it will
// allocate a seperate memory area, copy the data and free the old one.
//
// But this may fail as well, therefor the result is not a pointer to the
// allocation, but true/false.
// There for you need to pass a pointer to your pointer to the memory area
// or handle you deal with.
Handle = rMemory.Allocate<TPtr>(10, 1);
if (!rMemory.Reallocate<TPtr>(&Handles, 11, 1))
{
//handle realloc failure
}
/////////////////////////////////////////////////////////////////////////
// -FAQ
/////////////////////////////////////////////////////////////////////////
//"DO I HAVE TO ALWAYS RESOLVE?"
//if you use "In Place" memory, not at all, all resolve does is to
//cast your handle to your object ptr and returns it.
//if you use "Referenced" memory and you don't defragmentate, you
//can do it once and keep the ptr, but you also need to keep the
//handle to free the memory later on.
//"any reason I should resolve?"
//Yes, first of all, it makes it very easy to switch between various
//pool configuration for testing, you simply change some params of
//your typedef (or macro) and it should work out of the box.
//second, for defragmentation it's the only way to go and for future
//things it might be needed as well
//"but isn't resolving just overhead?"
//in case of "In Place": no, the resolve function just returns the
//pointer, casting to your wanted type
//in case of "Referenced": it cost you one indirection.
//"How do I flush the whole pool without freeing all items?"
g_Memory.InitMem()
//yes, you can call "InitMem" once again, you need to pass the mem
//ptr and size if using CMemoryDynamic e.g.
g_Memory.Init(g_Memory.Size(), g_Memory.Data());
//"How do I lock the allocated memory to avoid any reallocation"
g_Memory.Item(ptr)->Lock();
//"How do I get the size of a memory block?"
g_Memory.Item(ptr)->MemSize();
//"Is there any example?"
//for a real life example check PAUnitTest.cpp used to validate all
//functions of this pool.
//bug reports? questions? support?
//just ask me :) (michael kopietz)
#endif // CRYINCLUDE_CRYPOOL_EXAMPLE_H
Code/CryEngine/CryCommon/GeomCacheFileFormat.h
-202
View File
@@ -1,202 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_GEOMCACHEFILEFORMAT_H
#define CRYINCLUDE_CRYCOMMON_GEOMCACHEFILEFORMAT_H
#pragma once
#include "CryExtension/CryGUID.h"
#if !defined(LINUX)
#pragma pack(push)
#pragma pack(1)
#define PACK_GCC
#else
#define PACK_GCC __attribute__ ((packed))
#endif
namespace GeomCacheFile
{
// Important: The enums are serialized, don't change the values
// without increasing the file version, conversion code etc!
typedef Vec3_tpl<uint16> Position;
typedef Vec2_tpl<int16> Texcoords;
typedef Vec4_tpl<int16> QTangent;
typedef uint8 Color;
// ASCII "CAXCACHE"
const uint64 kFileSignature = 0x4548434143584143ull;
// The smallest 'UVmax' we'll support - this avoids division by zero when encoding/decoding UVs
const float kMinUVrange = .01f;
// Bit Precision of tangents quaternions
const uint kTangentQuatPrecision = 10;
// Current file version GUID. Files with other GUIDs will not be loaded by the engine.
const CryGUID kCurrentVersion = MAKE_CRYGUID(0x1641defe440af501, 0x7ec5e9164c8c2d1c);
// Mesh prediction look back array size
const uint kMeshPredictorLookBackMaxDist = 4096;
// Number of frames between index frames. Needs to be <= g_kMaxBufferedFrames.
const uint kMaxIFrameDistance = 30;
enum EFileHeaderFlags
{
eFileHeaderFlags_PlaybackFromMemory = BIT(0),
eFileHeaderFlags_32BitIndices = BIT(1)
};
enum EBlockCompressionFormat
{
eBlockCompressionFormat_None = 0,
eBlockCompressionFormat_Deflate = 1, // zlib
eBlockCompressionFormat_LZ4HC = 2, // LZ4 HC
eBlockCompressionFormat_ZSTD = 3, //ZStandard
};
enum EStreams
{
eStream_Indices = BIT(0),
eStream_Positions = BIT(1),
eStream_Texcoords = BIT(2),
eStream_QTangents = BIT(3),
eStream_Colors = BIT(4)
};
enum ETransformType
{
eTransformType_Constant,
eTransformType_Animated
};
enum ENodeType
{
eNodeType_Transform = 0, // Transforms all sub nodes
eNodeType_Mesh = 1,
eNodeType_PhysicsGeometry = 2,
};
// Common frame
enum EFrameType
{
eFrameType_IFrame = 0,
eFrameType_BFrame = 1
};
// Common frame flags
enum EFrameFlags
{
eFrameFlags_Hidden = BIT(0)
};
// Flags for mesh index frames
enum EMeshIFrameFlags
{
eMeshIFrameFlags_UsePredictor = BIT(1)
};
struct SHeader
{
SHeader()
: m_signature(0)
, m_version(kCurrentVersion)
, m_blockCompressionFormat(0)
, m_flags(0)
, m_numFrames(0) {}
uint64 m_signature;
CryGUID m_version;
uint16 m_blockCompressionFormat;
uint32 m_flags;
uint32 m_numFrames;
uint64 m_totalUncompressedAnimationSize;
float m_aabbMin[3];
float m_aabbMax[3];
} PACK_GCC;
struct SFrameInfo
{
uint32 m_frameType;
uint32 m_frameSize;
uint64 m_frameOffset;
float m_frameTime;
} PACK_GCC;
struct SCompressedBlockHeader
{
uint32 m_uncompressedSize;
uint32 m_compressedSize;
} PACK_GCC;
struct SFrameHeader
{
uint32 m_nodeDataOffset;
float m_frameAABBMin[3];
float m_frameAABBMax[3];
uint32 m_padding;
} PACK_GCC;
struct STemporalPredictorControl
{
uint8 m_acceleration;
uint8 m_indexFrameLerpFactor;
uint8 m_combineFactor;
uint8 m_padding;
} PACK_GCC;
struct SMeshFrameHeader
{
uint32 m_flags;
STemporalPredictorControl m_positionStreamPredictorControl;
STemporalPredictorControl m_texcoordStreamPredictorControl;
STemporalPredictorControl m_qTangentStreamPredictorControl;
STemporalPredictorControl m_colorStreamPredictorControl[4];
} PACK_GCC;
struct SMeshInfo
{
uint8 m_constantStreams;
uint8 m_animatedStreams;
uint8 m_positionPrecision[3];
float m_uvMax;
uint8 m_padding;
uint16 m_numMaterials;
uint32 m_numVertices;
uint32 m_flags;
float m_aabbMin[3];
float m_aabbMax[3];
uint32 m_nameLength;
uint64 m_hash;
} PACK_GCC;
struct SNodeInfo
{
uint8 m_type;
uint8 m_bVisible;
uint16 m_transformType;
uint32 m_meshIndex;
uint32 m_numChildren;
uint32 m_nameLength;
} PACK_GCC;
}
#undef PACK_GCC
#if !defined(LINUX)
#pragma pack(pop)
#endif
#endif // CRYINCLUDE_CRYCOMMON_GEOMCACHEFILEFORMAT_H
Code/CryEngine/CryCommon/ICryMiniGUI.h
-286
View File
@@ -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
Code/CryEngine/CryCommon/IDeferredCollisionEvent.h
-95
View File
@@ -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
Code/CryEngine/CryCommon/IDefragAllocator.h
-155
View File
@@ -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
Code/CryEngine/CryCommon/IEngineModule.h
-53
View File
@@ -1,53 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Defines the extension interface for the CryEngine modules.
#ifndef CRYINCLUDE_CRYCOMMON_IENGINEMODULE_H
#define CRYINCLUDE_CRYCOMMON_IENGINEMODULE_H
#pragma once
#include <CryExtension/ICryUnknown.h>
#include <AzCore/Interface/Interface.h>
#include <AzCore/Console/Console.h>
#include <AzCore/Console/ConsoleFunctor.h>
struct SSystemInitParams;
// Base Interface for all engine module extensions
struct IEngineModule
: public ICryUnknown
{
CRYINTERFACE_DECLARE(IEngineModule, 0xf899cf661df04f61, 0xa341a8a7ffdf9de4);
// <interfuscator:shuffle>
// Retrieve name of the extension module.
virtual const char* GetName() const = 0;
// Retrieve category for the extension module (CryEngine for standard modules).
virtual const char* GetCategory() const = 0;
// This is called to initialize the new module.
virtual bool Initialize(SSystemGlobalEnvironment& env, const SSystemInitParams& initParams) = 0;
// </interfuscator:shuffle>
// This is called to register any AZ console vars declared within this engine module
virtual void RegisterConsoleVars()
{
AZ::ConsoleFunctorBase*& deferredHead = AZ::ConsoleFunctorBase::GetDeferredHead();
AZ::Interface<AZ::IConsole>::Get()->LinkDeferredFunctors(deferredHead);
}
};
#endif // CRYINCLUDE_CRYCOMMON_IENGINEMODULE_H
Code/CryEngine/CryCommon/IFileChangeMonitor.h
-56
View File
@@ -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
Code/CryEngine/CryCommon/IFont.h
-5
View File
@@ -33,8 +33,6 @@ struct ICryFont;
struct IFFont;
struct FontFamily;
struct IRenderer;
struct SVF_P2F_C4B_T2F_F4B;
extern "C"
@@ -100,9 +98,6 @@ struct ICryFont
//! \param glyphSizeY Height (in pixels) of the characters to be rendered at in the font texture.
virtual void AddCharsToFontTextures(FontFamilyPtr pFontFamily, const char* pChars, int glyphSizeX = defaultGlyphSizeX, int glyphSizeY = defaultGlyphSizeY) = 0;
// Summary:
// Globally sets common font render properties based on the initialized renderer
virtual void SetRendererProperties(IRenderer* pRenderer) = 0;
// Summary:
// Puts the objects used in this module into the sizer interface
virtual void GetMemoryUsage(ICrySizer* pSizer) const = 0;
Code/CryEngine/CryCommon/IMemory.h
-1
View File
@@ -16,7 +16,6 @@
#pragma once
#include <smartptr.h>
#include <IDefragAllocator.h> // <> required for Interfuscator
#include <IGeneralMemoryHeap.h> // <> required for Interfuscator
#include <smartptr.h>
Code/CryEngine/CryCommon/IOverloadSceneManager.h
-47
View File
@@ -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
Code/CryEngine/CryCommon/IPerfHud.h
-145
View File
@@ -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
Code/CryEngine/CryCommon/IRemoteCommand.h
-763
View File
@@ -1,763 +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 : Service network interface
#ifndef CRYINCLUDE_CRYCOMMON_IREMOTECOMMAND_H
#define CRYINCLUDE_CRYCOMMON_IREMOTECOMMAND_H
#pragma once
#include <CryString.h>
#include <BaseTypes.h>
//-----------------------------------------------------------------------------
// Helpers for writing/reading command data stream from network message packets.
// Those interfaces automatically handle byteswapping for big endian systems.
// The native format for data inside the messages is little endian.
//-----------------------------------------------------------------------------
/// Write stream interface
struct IDataWriteStream
{
public:
virtual ~IDataWriteStream() {};
public:
// Virtualized write method for general data buffer
virtual void Write(const void* pData, const uint32 size) = 0;
// Virtualized write method for types with size 8 (support byteswapping, a little bit faster than general case)
virtual void Write8(const void* pData) = 0;
// Virtualized write method for types with size 4 (support byteswapping, a little bit faster than general case)
virtual void Write4(const void* pData) = 0;
// Virtualized write method for types with size 2 (support byteswapping, a little bit faster than general case)
virtual void Write2(const void* pData) = 0;
// Virtualized write method for types with size 1 (a little bit faster than general case)
virtual void Write1(const void* pData) = 0;
// Get number of bytes written
virtual const uint32 GetSize() const = 0;
// Convert to service network message
virtual struct IServiceNetworkMessage* BuildMessage() const = 0;
// Save the data from this writer stream to the provided buffer
virtual void CopyToBuffer(void* pData) const = 0;
// Destroy object (if dynamically created)
virtual void Delete() = 0;
public:
IDataWriteStream& operator<<(const uint8& val)
{
Write1(&val);
return *this;
}
IDataWriteStream& operator<<(const uint16& val)
{
Write2(&val);
return *this;
}
IDataWriteStream& operator<<(const uint32& val)
{
Write4(&val);
return *this;
}
IDataWriteStream& operator<<(const uint64& val)
{
Write8(&val);
return *this;
}
IDataWriteStream& operator<<(const int8& val)
{
Write1(&val);
return *this;
}
IDataWriteStream& operator<<(const int16& val)
{
Write2(&val);
return *this;
}
IDataWriteStream& operator<<(const int32& val)
{
Write4(&val);
return *this;
}
IDataWriteStream& operator<<(const int64& val)
{
Write8(&val);
return *this;
}
IDataWriteStream& operator<<(const float& val)
{
Write4(&val);
return *this;
}
// Bool is saved by writing an 8 bit value to make it portable
IDataWriteStream& operator<<(const bool& val)
{
const uint8 uVal = val ? 1 : 0;
Write1(&uVal);
return *this;
}
public:
// Write C string to stream
void WriteString(const char* str);
// Write string to stream
void WriteString(const string& str);
// Write int8 value to stream
void WriteInt8(const int8 val)
{
Write1(&val);
}
// Write int16 value to stream
void WriteInt16(const int16 val)
{
Write2(&val);
}
// Write int32 value to stream
void WriteInt32(const int32 val)
{
Write4(&val);
}
// Write int64 value to stream
void WriteInt64(const int64 val)
{
Write8(&val);
}
// Write uint8 value to stream
void WriteUint8(const uint8 val)
{
Write1(&val);
}
// Write uint16 value to stream
void WriteUint16(const uint16 val)
{
Write2(&val);
}
// Write uint32 value to stream
void WriteUint32(const uint32 val)
{
Write4(&val);
}
// Write uint64 value to stream
void WriteUint64(const uint64 val)
{
Write8(&val);
}
// Write float value to stream
void WriteFloat(const float val)
{
Write4(&val);
}
};
//-----------------------------------------------------------------------------
/// Read stream interface
/// This interface should support endianess swapping
struct IDataReadStream
{
public:
virtual ~IDataReadStream() {};
public:
// Destroy object (if dynamically created)
virtual void Delete() = 0;
// Skip given amount of data without reading it
virtual void Skip(const uint32 size) = 0;
// Virtualized read method (for general buffers)
virtual void Read(void* pData, const uint32 size) = 0;
// Virtualized read method for types with size 8 (a little bit faster than general method, supports byte swapping for BE systems)
virtual void Read8(void* pData) = 0;
// Virtualized read method for types with size 4 (a little bit faster than general method, supports byte swapping for BE systems)
virtual void Read4(void* pData) = 0;
// Virtualized read method for types with size 2 (a little bit faster than general method, supports byte swapping for BE systems)
virtual void Read2(void* pData) = 0;
// Virtualized read method for types with size 1 (a little bit faster than general method, supports byte swapping for BE systems)
virtual void Read1(void* pData) = 0;
// Optimization case - get direct pointer to the underlying buffer
virtual const void* GetPointer() = 0;
public:
IDataReadStream& operator<<(uint8& val)
{
Read1(&val);
return *this;
}
IDataReadStream& operator<<(uint16& val)
{
Read2(&val);
return *this;
}
IDataReadStream& operator<<(uint32& val)
{
Read4(&val);
return *this;
}
IDataReadStream& operator<<(uint64& val)
{
Read8(&val);
return *this;
}
IDataReadStream& operator<<(int8& val)
{
Read1(&val);
return *this;
}
IDataReadStream& operator<<(int16& val)
{
Read2(&val);
return *this;
}
IDataReadStream& operator<<(int32& val)
{
Read4(&val);
return *this;
}
IDataReadStream& operator<<(int64& val)
{
Read8(&val);
return *this;
}
IDataReadStream& operator<<(float& val)
{
Read4(&val);
return *this;
}
// Bool is saved by writing an 8 bit value to make it portable
IDataReadStream& operator<<(bool& val)
{
uint8 uVal = 0;
Read1(&uVal);
val = (uVal != 0);
return *this;
}
public:
// Read string from stream
string ReadString();
// Skip string data in a stream without loading the data
void SkipString();
// Read int8 from stream
int8 ReadInt8()
{
int8 val = 0;
Read1(&val);
return val;
}
// Read int16 from stream
int16 ReadInt16()
{
int16 val = 0;
Read2(&val);
return val;
}
// Read int32 from stream
int32 ReadInt32()
{
int32 val = 0;
Read4(&val);
return val;
}
// Read int64 from stream
int64 ReadInt64()
{
int64 val = 0;
Read8(&val);
return val;
}
// Read uint8 from stream
uint8 ReadUint8()
{
uint8 val = 0;
Read1(&val);
return val;
}
// Read uint16 from stream
uint16 ReadUint16()
{
uint16 val = 0;
Read2(&val);
return val;
}
// Read uint32 from stream
uint32 ReadUint32()
{
uint32 val = 0;
Read4(&val);
return val;
}
// Read int64 from stream
uint64 ReadUint64()
{
uint64 val = 0;
Read8(&val);
return val;
}
// Read float from stream
float ReadFloat()
{
float val = 0.0f;
Read4(&val);
return val;
}
};
//-----------------------------------------------------------------------------
/// Remote command class info (simple RTTI)
struct IRemoteCommandClass
{
public:
virtual ~IRemoteCommandClass() {};
// Get class name
virtual const char* GetName() const = 0;
// Create command instance
virtual struct IRemoteCommand* CreateObject() = 0;
};
/// Remote command interface
struct IRemoteCommand
{
protected:
virtual ~IRemoteCommand() {};
public:
// Get command class
virtual IRemoteCommandClass* GetClass() const = 0;
// Save to data stream
virtual void SaveToStream(struct IDataWriteStream& writeStream) const = 0;
// Load from data stream
virtual void LoadFromStream(struct IDataReadStream& readStream) = 0;
// Execute (remote call) = 0;
virtual void Execute() = 0;
// Delete the command object (can be allocated from different heap)
virtual void Delete() = 0;
};
//-----------------------------------------------------------------------------
// This is a implementation of a synchronous listener (limited to the engine tick rate)
// that processes and responds to the raw messages received from clients.
struct IRemoteCommandListenerSync
{
public:
virtual ~IRemoteCommandListenerSync() {};
// Process a raw message and optionally provide an answer to the request, return true if you have processed the message.
// Messages is accessible via the data reader. Response can be written to a data writer.
virtual bool OnRawMessageSync(const class ServiceNetworkAddress& remoteAddress, struct IDataReadStream& msg, struct IDataWriteStream& response) = 0;
};
//-----------------------------------------------------------------------------
// This is a implementation of a asynchronous listener (called from network thread)
// that processes and responds to the raw messages received from clients.
struct IRemoteCommandListenerAsync
{
public:
virtual ~IRemoteCommandListenerAsync() {};
// Process a raw message and optionally provide an answer to the request, return true if you have processed the message.
// Messages is accessible via the data reader. Response can be written to a data writer.
virtual bool OnRawMessageAsync(const class ServiceNetworkAddress& remoteAddress, struct IDataReadStream& msg, struct IDataWriteStream& response) = 0;
};
//-----------------------------------------------------------------------------
/// Remote command server
struct IRemoteCommandServer
{
protected:
virtual ~IRemoteCommandServer() {};
public:
// Execute all of the received pending commands
// This should be called from a safe place (main thread)
virtual void FlushCommandQueue() = 0;
// Suppress command execution
virtual void SuppressCommands() = 0;
// Resume command execution
virtual void ResumeCommands() = 0;
// Register/Unregister synchronous message listener (limited to tick rate)
virtual void RegisterSyncMessageListener(IRemoteCommandListenerSync* pListener) = 0;
virtual void UnregisterSyncMessageListener(IRemoteCommandListenerSync* pListener) = 0;
// Register/Unregister asynchronous message listener (called from network thread)
virtual void RegisterAsyncMessageListener(IRemoteCommandListenerAsync* pListener) = 0;
virtual void UnregisterAsyncMessageListener(IRemoteCommandListenerAsync* pListener) = 0;
// Broadcast a message to all connected clients
virtual void Broadcast(IServiceNetworkMessage* pMessage) = 0;
// Do we have any clients connected ?
virtual bool HasConnectedClients() const = 0;
// Delete the client
virtual void Delete() = 0;
};
//-----------------------------------------------------------------------------
/// Connection to remote command server
struct IRemoteCommandConnection
{
protected:
virtual ~IRemoteCommandConnection() {};
public:
// Are we connected ?
// This returns false when the underlying network connection has failed (sockets error).
// Also, this returns false if the remote connection was closed by remote peer.
virtual bool IsAlive() const = 0;
// Get address of remote command server
// This returns the full address of the endpoint (with valid port)
virtual const ServiceNetworkAddress& GetRemoteAddress() const = 0;
// Send raw message to the other side of this connection.
// Raw messages are not buffer and are sent right away,
// they also have precedence over internal command traffic.
// The idea is that you need some kind of bidirectional signaling
// channel to extend the rather one-directional nature of commands.
// Returns true if message was added to the send queue.
virtual bool SendRawMessage(IServiceNetworkMessage* pMessage) = 0;
// See if there's a raw message waiting for us and if it is, get it
// Be aware that messages are reference counted.
virtual IServiceNetworkMessage* ReceiveRawMessage() = 0;
// Close connection
// - pending commands are not sent
// - pending raw messages are sent or not (depending on the flag)
virtual void Close(bool bFlushQueueBeforeClosing = false) = 0;
// Add internal reference to object (Refcounting interface)
virtual void AddRef() = 0;
// Release internal reference to object (Refcounting interface)
virtual void Release() = 0;
};
//-----------------------------------------------------------------------------
/// Remote command client
struct IRemoteCommandClient
{
protected:
virtual ~IRemoteCommandClient() {};
public:
// Connect to remote server, returns true on success, false on failure
virtual IRemoteCommandConnection* ConnectToServer(const class ServiceNetworkAddress& serverAddress) = 0;
// Schedule command to be executed on the all of the remote servers
virtual bool Schedule(const IRemoteCommand& command) = 0;
// Delete the client object
virtual void Delete() = 0;
};
//-----------------------------------------------------------------------------
/// Remote command manager
struct IRemoteCommandManager
{
public:
virtual ~IRemoteCommandManager() {};
// Set debug message verbose level
virtual void SetVerbosityLevel(const uint32 level) = 0;
// Create local server for executing remote commands on given local port
virtual IRemoteCommandServer* CreateServer(uint16 localPort) = 0;
// Create client interface for executing remote commands on remote servers
virtual IRemoteCommandClient* CreateClient() = 0;
// Register command class (will be accessible by both clients and server)
virtual void RegisterCommandClass(IRemoteCommandClass& commandClass) = 0;
};
//-----------------------------------------------------------------------------
/// Class RTTI wrapper for remote command classes
template< typename T >
class CRemoteCommandClass
: public IRemoteCommandClass
{
private:
const char* m_szName;
public:
CRemoteCommandClass(const char* szName)
: m_szName(szName)
{}
virtual const char* GetName() const
{
return m_szName;
}
virtual struct IRemoteCommand* CreateObject()
{
return new T();
}
};
#define DECLARE_REMOTE_COMMAND(x) \
public: static IRemoteCommandClass& GetStaticClass() { \
static IRemoteCommandClass* theClass = new CRemoteCommandClass<x>(#x); return *theClass; } \
public: virtual IRemoteCommandClass* GetClass() const { return &GetStaticClass(); } \
public: virtual void Delete() { delete this; } \
public: virtual void SaveToStream(IDataWriteStream & writeStream) const { const_cast<x*>(this)->Serialize<IDataWriteStream>(writeStream); } \
public: virtual void LoadFromStream(IDataReadStream & readStream) { Serialize<IDataReadStream>(readStream); }
//-----------------------------------------------------------------------------
/// CryString serialization helper (read)
inline IDataReadStream& operator<<(IDataReadStream& stream, string& outString)
{
const uint32 kMaxTempString = 256;
// read length
uint32 length = 0;
stream << length;
// load string
if (length > 0)
{
if (length < kMaxTempString)
{
// load the string into temporary buffer
char temp[kMaxTempString];
stream.Read(&temp, length);
temp[length] = 0;
// set the string with new value
outString = temp;
}
else
{
// allocate temporary memory and load the string
std::vector<char> temp;
temp.resize(length + 1, 0);
stream.Read(&temp[0], length);
// set the string with new value
outString = &temp[0];
}
}
else
{
// empty string
outString.clear();
}
return stream;
}
/// CryString serialization helper (write)
inline IDataWriteStream& operator<<(IDataWriteStream& stream, const string& str)
{
// write length
const uint32 length = static_cast<uint32>(str.length());
stream << length;
// write string data
if (length > 0)
{
stream.Write(str.c_str(), length);
}
return stream;
}
//------------------------------------------------------------------------
/// Vector serialization helper (reading)
template< class T >
IDataReadStream& operator<<(IDataReadStream& ar, std::vector<T>& outVector)
{
// Load item count
uint32 count = 0;
ar << count;
// Adapt the vector size (exact fit)
outVector.resize(count);
// Load items
for (uint32 i = 0; i < count; ++i)
{
ar << outVector[i];
}
return ar;
}
/// Vector serialization helper (writing)
template< class T >
IDataWriteStream& operator<<(IDataWriteStream& ar, const std::vector<T>& vec)
{
// Save item count
const uint32 count = vec.size();
ar << count;
// Save items
for (uint32 i = 0; i < count; ++i)
{
ar << const_cast<T&>(vec[i]);
}
return ar;
}
//------------------------------------------------------------------------
inline void IDataWriteStream::WriteString(const char* str)
{
string tempString(str);
*this << tempString;
}
inline void IDataWriteStream::WriteString(const string& str)
{
*this << str;
}
inline string IDataReadStream::ReadString()
{
string ret;
*this << ret;
return ret;
}
inline void IDataReadStream::SkipString()
{
// read length
uint32 length = 0;
*this << length;
Skip(length);
}
//------------------------------------------------------------------------
// Helper class for using the data reader and writer classes
// The only major differce betwen auto_ptr is that we call Delete() instead of operator delete
template<class T>
class TAutoDelete
{
public:
T* m_ptr;
public:
TAutoDelete(T* ptr)
: m_ptr(ptr)
{
}
~TAutoDelete()
{
if (NULL != m_ptr)
{
m_ptr->Delete();
m_ptr = NULL;
}
}
operator bool()
{
return (NULL != m_ptr);
}
operator T& ()
{
return *m_ptr;
}
T* operator->()
{
return m_ptr;
}
private:
TAutoDelete(const TAutoDelete& other)
: m_ptr(NULL){};
TAutoDelete& operator=(const TAutoDelete& other) { return *this; }
};
//------------------------------------------------------------------------
#endif // CRYINCLUDE_CRYCOMMON_IREMOTECOMMAND_H
Code/CryEngine/CryCommon/IRenderer.h
-25
View File
@@ -1472,7 +1472,6 @@ struct IRenderer
/////////////////////////////////////////////////////////////////////////////////
// Shaders/Shaders management /////////////////////////////////////////////////////////////////////////////////
virtual void EF_SetShaderMissCallback(ShaderCacheMissCallback callback) = 0;
virtual const char* EF_GetShaderMissLogPath() = 0;
/////////////////////////////////////////////////////////////////////////////////
@@ -1533,10 +1532,6 @@ struct IRenderer
virtual int EF_LoadLightmap (const char* name) = 0;
virtual bool EF_RenderEnvironmentCubeHDR (int size, Vec3& Pos, TArray<unsigned short>& vecData) = 0;
// Summary:
// Creates new RE (RenderElement) of type (edt).
virtual IRenderElement* EF_CreateRE (EDataType edt) = 0;
// Summary:
// Starts using of the shaders (return first index for allow recursions).
virtual void EF_StartEf (const SRenderingPassInfo& passInfo) = 0;
@@ -2385,26 +2380,6 @@ private:
virtual void EF_QueryImpl(ERenderQueryTypes eQuery, void* pInOut0, uint32 nInOutSize0, void* pInOut1, uint32 nInOutSize1) = 0;
};
// util class to change wireframe mode
class CScopedWireFrameMode
{
public:
CScopedWireFrameMode(IRenderer* pRenderer, int nMode)
: m_pRenderer(pRenderer)
, m_nMode(nMode)
{
(void) m_nMode; // removes not used warning
pRenderer->PushWireframeMode(nMode);
}
~CScopedWireFrameMode()
{
m_pRenderer->PopWireframeMode();
}
private:
IRenderer* m_pRenderer;
int m_nMode;
};
struct SShaderCacheStatistics
{
size_t m_nTotalLevelShaderCacheMisses;
Code/CryEngine/CryCommon/IServiceNetwork.h
-344
View File
@@ -1,344 +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 : Service network interface
#ifndef CRYINCLUDE_CRYCOMMON_ISERVICENETWORK_H
#define CRYINCLUDE_CRYCOMMON_ISERVICENETWORK_H
#pragma once
#include <CryExtension/CryGUID.h>
//-----------------------------------------------------------------------------
//
// Service network is a simple abstract interface for connecting between instances
// of the editor and game running on various platforms. It implements it's own
// small message based communication layer and shall not be used for raw communication
// with anything else.
//
// Features currently implemented by the service network:
// - Completely thread safe (so can be used from within other threads)
// - Completely asynchronous (only one thread)
// - Message based approach (both on the send and receive ends)
// - Automatic and transparent reconnection
// - Debug-friendly (will not time-out easily when one of the endpoints is being debugged)
// - Easy to use
//
// Usage case (server)
// - Create listener (IServiceListener) on some pre-defined port
// - Poll the incoming connections by calling Accept() method
// - Service the traffic by calling connection's ReceiveMessage()/SendMessage() methods
// - Close() and Release() connections
// - Close() and Release() listener
//
// Usage case (client)
// - Connect to a remote listener by calling Connect() method
// - Service the traffic by calling connection's ReceiveMessage()/SendMessage() methods
// - Close() and Release() connection
//
// Both sending and receiving is asynchronous. Calling the SendMessage()/ReceiveMessage() methods
// only pushes/pops the message buffers to/from the queue.
// NOTE: Message buffers are internally reference counted by the network system and they are kept around
// untill they are sent (in case of outgoing traffic) or untill they are polled by ReceiveMessage().
// Be aware that this can cause memory spikes, especially when incoming traffic is not serviced fast enough.
// There are customizable limits (around 1MB) on the amount of data that can be buffered internally by
// the service network before the new messages are rejected.
// It's up to the higher layer to ensure damage control in such situation.
//
// NOTE: connection is also a reference counted object, make sure to call Close() before calling Release().
//
//-----------------------------------------------------------------------------
/// Network address abstraction
class ServiceNetworkAddress
{
public:
struct StringAddress
{
char m_data[32];
ILINE const char* c_str() const
{
return m_data;
}
};
struct Address
{
uint8 m_ip0;
uint8 m_ip1;
uint8 m_ip2;
uint8 m_ip3;
uint16 m_port;
ILINE Address()
: m_ip0(0)
, m_ip1(0)
, m_ip2(0)
, m_ip3(0)
, m_port(0)
{}
};
private:
Address m_address;
public:
// By default creates ("invalid address")
ILINE ServiceNetworkAddress()
{
}
// Copy (with optional port change)
ILINE ServiceNetworkAddress(const ServiceNetworkAddress& other, uint16 newPort = 0)
: m_address(other.m_address)
{
if (newPort != 0)
{
m_address.m_port = newPort;
}
}
// Initialize from ip:host pattern (if you want to initialize from host name use the DebugNetwork interface)
ILINE ServiceNetworkAddress(uint8 ip0, uint8 ip1, uint8 ip2, uint8 ip3, uint16 port)
{
m_address.m_ip0 = ip0;
m_address.m_ip1 = ip1;
m_address.m_ip2 = ip2;
m_address.m_ip3 = ip3;
m_address.m_port = port;
}
// Set new port value
ILINE void SetPort(uint16 port)
{
m_address.m_port = port;
}
// Is this a valid address
ILINE bool IsValid() const
{
return (m_address.m_ip0 != 0) &&
(m_address.m_ip1 != 1) &&
(m_address.m_ip2 != 1) &&
(m_address.m_ip3 != 1) &&
(m_address.m_port != 0);
}
// Convert to human readable string
ILINE StringAddress ToString() const
{
// format the string buffer
StringAddress ret;
sprintf_s(ret.m_data, sizeof(ret.m_data),
"%d.%d.%d.%d:%d",
m_address.m_ip0, m_address.m_ip1, m_address.m_ip2, m_address.m_ip3,
m_address.m_port);
// return as managed string
return ret;
}
// Get the literal data
ILINE const Address& GetAddress() const
{
return m_address;
}
public:
// Compare base address (IP only) of two connections
static bool CompareBaseAddress(const ServiceNetworkAddress& a, const ServiceNetworkAddress& b)
{
return (a.m_address.m_ip0 == b.m_address.m_ip0) &&
(a.m_address.m_ip1 == b.m_address.m_ip1) &&
(a.m_address.m_ip2 == b.m_address.m_ip2) &&
(a.m_address.m_ip3 == b.m_address.m_ip3);
}
// Compare full address (IP+port) of two connections
static bool CompareFullAddress(const ServiceNetworkAddress& a, const ServiceNetworkAddress& b)
{
return (a.m_address.m_ip0 == b.m_address.m_ip0) &&
(a.m_address.m_ip1 == b.m_address.m_ip1) &&
(a.m_address.m_ip2 == b.m_address.m_ip2) &&
(a.m_address.m_ip3 == b.m_address.m_ip3) &&
(a.m_address.m_port == b.m_address.m_port);
}
};
//-----------------------------------------------------------------------------
/// Message buffer used by the network system
struct IServiceNetworkMessage
{
protected:
IServiceNetworkMessage() {};
virtual ~IServiceNetworkMessage() {};
public:
// Get unique message ID (message ID is used just once)
virtual uint32 GetId() const = 0;
// Get the size of message buffer
virtual uint32 GetSize() const = 0;
// Get pointer to the message data
virtual void* GetPointer() = 0;
// Get pointer to the message data
virtual const void* GetPointer() const = 0;
// Create reader interface for reading message data, returned object is not
// reference counted but it will hold a reference to the message.
virtual struct IDataReadStream* CreateReader() const = 0;
// Add reference (buffer is internally refcounted)
virtual void AddRef() = 0;
// Release reference
virtual void Release() = 0;
};
//-----------------------------------------------------------------------------
/// General network TCP/IP connection
struct IServiceNetworkConnection
{
protected:
IServiceNetworkConnection() {};
virtual ~IServiceNetworkConnection() {};
public:
static const uint32 kDefaultFlushTime = 10000; // ms
// Get the unique connection ID (is shared between host and client)
virtual const CryGUID& GetGUID() const = 0;
// Get remote endpoint address
virtual const ServiceNetworkAddress& GetRemoteAddress() const = 0;
// Get local endpoint address
virtual const ServiceNetworkAddress& GetLocalAddress() const = 0;
// Add a message buffer to the connection send queue.
// Connection can refuse to send the buffer if it's full or invalid.
// If a message is rejected this function returns false.
virtual bool SendMsg(IServiceNetworkMessage* message) = 0;
// Get a message from connection receive queue.
// If there are no pending messages a NULL is returned.
// Since message is a ref-counted you need to call Release() when you are done with the buffer.
virtual IServiceNetworkMessage* ReceiveMsg() = 0;
// Checks if connection is still alive.
// Returns false only if connection has been damaged beyond repair.
virtual bool IsAlive() const = 0;
// Get number of messages sent by this connection so far
virtual uint32 GetMessageSendCount() const = 0;
// Get number of messages received by this connection so far
virtual uint32 GetMessageReceivedCount() const = 0;
// Get size of data sent by this connection so far
virtual uint64 GetMessageSendDataSize() const = 0;
// Get size of data received by this connection so far
virtual uint64 GetMessageReceivedDataSize() const = 0;
// Request connection to be closed but not before sending out all of the pending messages. Incoming messages are ignored.
// Processing and sending the messages is done on the networking thread so this function will not block.
// As an option, connection can be forcefully closed after given amount of time (in ms).
virtual void FlushAndClose(const uint32 timeoutMs = kDefaultFlushTime) = 0;
// Synchronous wait for the connection to send all outgoing messages
virtual void FlushAndWait() = 0;
// Request connection to be closed now. All pending messages are discarded.
virtual void Close() = 0;
// Add reference (connection is an internally reference counted object)
virtual void AddRef() = 0;
// Release reference
virtual void Release() = 0;
};
//-----------------------------------------------------------------------------
/// General listening socket (async)
struct IServiceNetworkListener
{
protected:
IServiceNetworkListener() {};
virtual ~IServiceNetworkListener() {};
public:
// Get the local address
virtual const ServiceNetworkAddress& GetLocalAddress() const = 0;
// Get number of active connections handled by this listener
virtual uint GetConnectionCount() const = 0;
// Accept incoming connection (asynchronously)
// Will return NULL if there's nothing to accept
// Will return new IDebugNetworkConnection if something was received
virtual IServiceNetworkConnection* Accept() = 0;
// Is listener able to accept connections ?
virtual bool IsAlive() const = 0;
// Request listener to be closed (closes the socket)
virtual void Close() = 0;
// Add reference (listener is an internally reference counted object)
virtual void AddRef() = 0;
// Release reference
virtual void Release() = 0;
};
//-----------------------------------------------------------------------------
/// General service (background) network interface
struct IServiceNetwork
{
public:
virtual ~IServiceNetwork() {};
// Set verbosity level of debug messages that got printed to log, levels 0-3 are commonly used
virtual void SetVerbosityLevel(const uint32 level) = 0;
// Allocate empty message buffer of given size, message buffer is a reference counted object
virtual IServiceNetworkMessage* AllocMessageBuffer(const uint32 size) = 0;
// Create general message writer stream, object is not reference counted
virtual struct IDataWriteStream* CreateMessageWriter() = 0;
// Create general message reader stream and initialize it with data
virtual struct IDataReadStream* CreateMessageReader(const void* pData, const uint32 dataSize) = 0;
// Translate host address (string:port) to network address
virtual ServiceNetworkAddress GetHostAddress(const string& addressString, uint16 optionalPort = 0) const = 0;
// Create network listener on given local port, listening and accepting connections is done on network thread
virtual IServiceNetworkListener* CreateListener(uint16 localPort) = 0;
// Connect to remote address (will block until connection is made or refused)
virtual IServiceNetworkConnection* Connect(const ServiceNetworkAddress& remoteAddress) = 0;
};
//-----------------------------------------------------------------------------
#endif // CRYINCLUDE_CRYCOMMON_ISERVICENETWORK_H
Code/CryEngine/CryCommon/IShader.h
+1 -1
View File
@@ -3413,6 +3413,6 @@ struct SShaderGraphBlock
typedef std::vector<SShaderGraphBlock*> FXShaderGraphBlocks;
typedef FXShaderGraphBlocks::iterator FXShaderGraphBlocksItor;
#include "RendElement.h"
#include <CryCommon/StaticInstance.h>
#endif // CRYINCLUDE_CRYCOMMON_ISHADER_H
Code/CryEngine/CryCommon/ISystem.h
-59
View File
@@ -89,20 +89,15 @@ struct IResourceManager;
struct ITextModeConsole;
struct IAVI_Reader;
class CPNoise3;
struct IFileChangeMonitor;
struct IVisualLog;
struct ILocalizationManager;
struct ICryFactoryRegistry;
struct ISoftCodeMgr;
struct IZLibCompressor;
struct IZLibDecompressor;
struct ILZ4Decompressor;
class IZStdDecompressor;
struct IOutputPrintSink;
struct IOverloadSceneManager;
struct IThreadManager;
struct IServiceNetwork;
struct IRemoteCommandManager;
struct IWindowMessageHandler;
struct IImageHandler;
class IResourceCompilerHelper;
@@ -130,7 +125,6 @@ struct CLoadingTimeProfiler;
class ICmdLine;
struct INotificationNetwork;
struct ICryPerfHUD;
class ILyShine;
namespace JobManager {
@@ -641,14 +635,12 @@ struct SSystemInitParams
bool bDedicatedServer; // When running a dedicated server.
bool bExecuteCommandLine; // can be switched of to suppress the feature or do it later during the initialization.
bool bSkipFont; // Don't load CryFont.dll
bool bSkipRenderer; // Don't load Renderer
bool bSkipConsole; // Don't create console
bool bSkipNetwork; // Don't create Network
bool bSkipWebsocketServer; // Don't create the WebSocket server
bool bMinimal; // Don't load banks
bool bTesting; // CryUnit
bool bNoRandom; //use fixed generator init/seed
bool bShaderCacheGen; // When running in shadercache gen mode
bool bUnattendedMode; // When running as part of a build on build-machines: Prevent popping up of any dialog
bool bSkipMovie; // Don't load movie
bool bSkipAnimation; // Don't load animation
@@ -699,7 +691,6 @@ struct SSystemInitParams
bExecuteCommandLine = true;
bExecuteCommandLine = true;
bSkipFont = false;
bSkipRenderer = false;
bSkipConsole = false;
bSkipNetwork = false;
#if defined(WIN32) || defined(WIN64)
@@ -712,7 +703,6 @@ struct SSystemInitParams
bMinimal = false;
bTesting = false;
bNoRandom = false;
bShaderCacheGen = false;
bUnattendedMode = false;
bSkipMovie = false;
bSkipAnimation = false;
@@ -792,7 +782,6 @@ struct SSystemGlobalEnvironment
{
AZ::IO::IArchive* pCryPak;
AZ::IO::FileIOBase* pFileIO;
IFileChangeMonitor* pFileChangeMonitor;
IProfileLogSystem* pProfileLogSystem;
IOpticsManager* pOpticsManager;
ITimer* pTimer;
@@ -806,9 +795,6 @@ struct SSystemGlobalEnvironment
IRenderer* pRenderer;
IMaterialEffects* pMaterialEffects;
ISoftCodeMgr* pSoftCodeMgr;
IOverloadSceneManager* pOverloadSceneManager;
IServiceNetwork* pServiceNetwork;
IRemoteCommandManager* pRemoteCommandManager;
ILyShine* pLyShine;
IResourceCompilerHelper* pResourceCompilerHelper;
SharedEnvironmentInstance* pSharedEnvironment;
@@ -1127,14 +1113,6 @@ struct ISystem
// Gets number of CPUs
virtual int GetLogicalCPUCount() = 0;
// Summary:
// Return the rendering driver name. GL or Metal
virtual const char* GetRenderingDriverName() const = 0;
// Summary:
// Dumps the memory usage statistics to the logging default MB. (can be KB)
virtual void DumpMemoryUsageStatistics(bool bUseKB = false) = 0;
// Summary:
// Quits the application.
virtual void Quit() = 0;
@@ -1145,9 +1123,6 @@ struct ISystem
// Returns true if the application is in the shutdown phase.
virtual bool IsQuitting() const = 0;
// Summary:
// Returns true if the application was initialized to generate the shader cache.
virtual bool IsShaderCacheGenMode() const = 0;
// Summary:
// Tells the system in which way we are using the serialization system.
virtual void SerializingFile(int mode) = 0;
virtual int IsSerializingFile() const = 0;
@@ -1195,7 +1170,6 @@ struct ISystem
virtual IZLibDecompressor* GetIZLibDecompressor() = 0;
virtual ILZ4Decompressor* GetLZ4Decompressor() = 0;
virtual IZStdDecompressor* GetZStdDecompressor() = 0;
virtual ICryPerfHUD* GetPerfHUD() = 0;
virtual INotificationNetwork* GetINotificationNetwork() = 0;
virtual IViewSystem* GetIViewSystem() = 0;
virtual ILevelSystem* GetILevelSystem() = 0;
@@ -1217,16 +1191,10 @@ struct ISystem
virtual IProfilingSystem* GetIProfilingSystem() = 0;
virtual ISystemEventDispatcher* GetISystemEventDispatcher() = 0;
virtual IVisualLog* GetIVisualLog() = 0;
virtual IFileChangeMonitor* GetIFileChangeMonitor() = 0;
virtual WIN_HWND GetHWND() = 0;
virtual IRenderer* GetIRenderer() = 0;
virtual ITimer* GetITimer() = 0;
virtual IThreadManager* GetIThreadManager() = 0;
//irtual IThreadManager* GetIThreadManager() = 0;
virtual void SetLoadingProgressListener(ILoadingProgressListener* pListener) = 0;
virtual ISystem::ILoadingProgressListener* GetLoadingProgressListener() const = 0;
@@ -1234,7 +1202,6 @@ struct ISystem
// Game is created after System init, so has to be set explicitly.
virtual void SetIMaterialEffects(IMaterialEffects* pMaterialEffects) = 0;
virtual void SetIOpticsManager(IOpticsManager* pOpticsManager) = 0;
virtual void SetIFileChangeMonitor(IFileChangeMonitor* pFileChangeMonitor) = 0;
virtual void SetIVisualLog(IVisualLog* pVisualLog) = 0;
//virtual const char *GetGamePath()=0;
@@ -1272,10 +1239,6 @@ struct ISystem
// Retrieves access to XML utilities interface.
virtual IXmlUtils* GetXmlUtils() = 0;
// Summary:
// Interface to access different implementations of Serialization::IArchive in a centralized way.
virtual Serialization::IArchiveHost* GetArchiveHost() const = 0;
virtual void SetViewCamera(CCamera& Camera) = 0;
virtual CCamera& GetViewCamera() = 0;
@@ -1377,10 +1340,6 @@ struct ISystem
// Non-0 if the state was indeed changed, 0 if already in that state.
virtual int SetThreadState(ESubsystem subsys, bool bActive) = 0;
// Summary:
// Creates and returns a usable object implementing ICrySizer interface.
virtual ICrySizer* CreateSizer() = 0;
// Summary:
// Query if system is now paused.
// Pause flag is set when calling system update with pause mode.
@@ -1400,10 +1359,6 @@ struct ISystem
// Retrieves system update counter.
virtual uint64 GetUpdateCounter() = 0;
// Summary:
// Gets access to all registered factories.
virtual ICryFactoryRegistry* GetCryFactoryRegistry() const = 0;
//////////////////////////////////////////////////////////////////////////
// Error callback handling
@@ -1491,11 +1446,6 @@ struct ISystem
// returns zeroes if no updates happened yet
virtual void GetUpdateStats(SSystemUpdateStats& stats) = 0;
// Description:
// Useful to investigate memory fragmentation.
// Every time you call this from the console: #System.DumpMemoryCoverage()
// it adds a line to "MemoryCoverage.bmp" (generated the first time, there is a max line count).
virtual void DumpMemoryCoverage() = 0;
virtual ESystemGlobalState GetSystemGlobalState(void) = 0;
virtual void SetSystemGlobalState(ESystemGlobalState systemGlobalState) = 0;
@@ -1528,15 +1478,6 @@ struct ISystem
virtual const IImageHandler* GetImageHandler() const = 0;
// Summary:
// Loads a dynamic library, creates and initializes an instance of the module class
virtual bool InitializeEngineModule(const char* dllName, const char* moduleClassName, const SSystemInitParams& initParams) = 0;
// Summary:
// Unloads a dynamic library as well as the corresponding instance of the module class
virtual bool UnloadEngineModule(const char* dllName, const char* moduleClassName) = 0;
// Summary:
// Gets the root window message handler function
// The returned pointer is platform-specific:
Code/CryEngine/CryCommon/LoadScreenComponent.cpp
-373
View File
@@ -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
Code/CryEngine/CryCommon/LoadScreenComponent.h
-106
View File
@@ -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
Code/CryEngine/CryCommon/Mocks/IConsoleMock.h
-1
View File
@@ -13,7 +13,6 @@
#define CRYINCLUDE_CRYCOMMON_ICONSOLEMOCK_H
#pragma once
#include <IRemoteCommand.h>
#include <IConsole.h>
#include <AzTest/AzTest.h>
Code/CryEngine/CryCommon/Mocks/IMemoryManagerMock.h
-2
View File
@@ -40,6 +40,4 @@ public:
IMemoryAddressRange* (size_t capacity, const char* sName));
MOCK_METHOD2(CreatePageMappingHeap,
IPageMappingHeap* (size_t addressSpace, const char* sName));
MOCK_METHOD0(CreateDefragAllocator,
IDefragAllocator*());
};
Code/CryEngine/CryCommon/Mocks/IRendererMock.h
-4
View File
@@ -286,8 +286,6 @@ public:
CRenderObject * (SShaderItem & si, CRenderObject * obj, const SRenderingPassInfo& passInfo, int numPts, int ninds, SVF_P3F_C4B_T2F * &verts, SPipTangents * &tangs, uint16 * &inds, int nAW, const SRendItemSorter& rendItemSorter));
MOCK_METHOD0(ForceUpdateGlobalShaderParameters,
void());
MOCK_METHOD1(EF_SetShaderMissCallback,
void(ShaderCacheMissCallback callback));
MOCK_METHOD0(EF_GetShaderMissLogPath,
const char*());
MOCK_METHOD1(EF_GetShaderNames,
@@ -334,8 +332,6 @@ public:
int(const char* name));
MOCK_METHOD3(EF_RenderEnvironmentCubeHDR,
bool(int size, Vec3 & Pos, TArray<unsigned short>&vecData));
MOCK_METHOD1(EF_CreateRE,
IRenderElement * (EDataType edt));
MOCK_METHOD1(EF_StartEf,
void(const SRenderingPassInfo& passInfo));
MOCK_METHOD3(EF_GetObjData,
Code/CryEngine/CryCommon/Mocks/ISystemMock.h
-28
View File
@@ -49,18 +49,12 @@ public:
int());
MOCK_METHOD0(GetLogicalCPUCount,
int());
MOCK_CONST_METHOD0(GetRenderingDriverName,
const char*());
MOCK_METHOD1(DumpMemoryUsageStatistics,
void(bool));
MOCK_METHOD0(Quit,
void());
MOCK_METHOD1(Relaunch,
void(bool bRelaunch));
MOCK_CONST_METHOD0(IsQuitting,
bool());
MOCK_CONST_METHOD0(IsShaderCacheGenMode,
bool());
MOCK_METHOD1(SerializingFile,
void(int mode));
MOCK_CONST_METHOD0(IsSerializingFile,
@@ -90,8 +84,6 @@ public:
ILZ4Decompressor * ());
MOCK_METHOD0(GetZStdDecompressor,
IZStdDecompressor * ());
MOCK_METHOD0(GetPerfHUD,
ICryPerfHUD * ());
MOCK_METHOD0(GetINotificationNetwork,
INotificationNetwork * ());
MOCK_METHOD0(GetIViewSystem,
@@ -132,12 +124,6 @@ public:
ISystemEventDispatcher * ());
MOCK_METHOD0(GetIVisualLog,
IVisualLog * ());
MOCK_METHOD0(GetIFileChangeMonitor,
IFileChangeMonitor * ());
MOCK_METHOD0(GetHWND,
WIN_HWND());
MOCK_METHOD0(GetIRenderer,
IRenderer * ());
MOCK_METHOD0(GetITimer,
ITimer * ());
MOCK_METHOD0(GetIThreadManager,
@@ -150,8 +136,6 @@ public:
void(IMaterialEffects * pMaterialEffects));
MOCK_METHOD1(SetIOpticsManager,
void(IOpticsManager * pOpticsManager));
MOCK_METHOD1(SetIFileChangeMonitor,
void(IFileChangeMonitor * pFileChangeMonitor));
MOCK_METHOD1(SetIVisualLog,
void(IVisualLog * pVisualLog));
MOCK_METHOD2(DebugStats,
@@ -180,8 +164,6 @@ public:
XmlNodeRef(const char*, bool));
MOCK_METHOD0(GetXmlUtils,
IXmlUtils * ());
MOCK_CONST_METHOD0(GetArchiveHost,
Serialization::IArchiveHost * ());
MOCK_METHOD1(SetViewCamera,
void(CCamera & Camera));
MOCK_METHOD0(GetViewCamera,
@@ -229,8 +211,6 @@ public:
void(bool detectResolution));
MOCK_METHOD2(SetThreadState,
int(ESubsystem subsys, bool bActive));
MOCK_METHOD0(CreateSizer,
ICrySizer * ());
MOCK_CONST_METHOD0(IsPaused,
bool());
MOCK_METHOD0(GetLocalizationManager,
@@ -241,8 +221,6 @@ public:
CPNoise3 * ());
MOCK_METHOD0(GetUpdateCounter,
uint64());
MOCK_CONST_METHOD0(GetCryFactoryRegistry,
ICryFactoryRegistry * ());
MOCK_METHOD1(RegisterErrorObserver,
bool(IErrorObserver * errorObserver));
MOCK_METHOD1(UnregisterErrorObserver,
@@ -275,8 +253,6 @@ public:
void(bool));
MOCK_METHOD1(GetUpdateStats,
void(SSystemUpdateStats & stats));
MOCK_METHOD0(DumpMemoryCoverage,
void());
MOCK_METHOD0(GetSystemGlobalState,
ESystemGlobalState(void));
MOCK_METHOD1(SetSystemGlobalState,
@@ -307,10 +283,6 @@ public:
bool());
MOCK_CONST_METHOD0(GetImageHandler,
const IImageHandler * ());
MOCK_METHOD3(InitializeEngineModule,
bool(const char* dllName, const char* moduleClassName, const SSystemInitParams&initParams));
MOCK_METHOD2(UnloadEngineModule,
bool(const char* dllName, const char* moduleClassName));
MOCK_METHOD0(GetRootWindowMessageHandler,
void*());
MOCK_METHOD1(RegisterWindowMessageHandler,
Code/CryEngine/CryCommon/ProjectDefines.h
-4
View File
@@ -162,10 +162,6 @@ typedef uint32 vtx_idx;
#endif
#endif
#if defined(ENABLE_PROFILING_CODE)
#define USE_PERFHUD
#endif
#if defined(ENABLE_PROFILING_CODE)
#define ENABLE_ART_RT_TIME_ESTIMATE
#endif
Code/CryEngine/CryCommon/RendElement.h
-321
View File
@@ -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
Code/CryEngine/CryCommon/Serialization/Assert.h
-46
View File
@@ -1,46 +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_SERIALIZATION_ASSERT_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_ASSERT_H
#pragma once
#ifdef SERIALIZATION_STANDALONE
#include <assert.h>
#else
#include <platform.h>
#endif
#ifdef YASLI_ASSERT
# undef YASLI_ASSERT
#endif
#ifdef YASLI_VERIFY
# undef YASLI_VERIFY
#endif
#ifdef YASLI_ESCAPE
# undef YASLI_ESCAPE
#endif
#ifdef SERIALIZATION_STANDALONE
#define YASLI_ASSERT(x) assert(x)
#define YASLI_ASSERT_STR(x, str) assert(x && str)
#define YASLI_ESCAPE(x, action) if (!(x)) { YASLI_ASSERT(0 && #x); action; };
#else
#define YASLI_ASSERT(x) CRY_ASSERT(x)
#define YASLI_ASSERT_STR(x, str) CRY_ASSERT_MESSAGE(x, str)
#define YASLI_ESCAPE(x, action) if (!(x)) { YASLI_ASSERT(0 && #x); action; };
#endif // SERIALIZATION_STANDALONE
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_ASSERT_H
Code/CryEngine/CryCommon/Serialization/BitVector.h
-39
View File
@@ -1,39 +0,0 @@
// Copyright (c) 2012 Crytek GmbH
// Authors: Evgeny Andreeshchev, Alexander Kotliar
// Based on: Yasli - the serialization library.
// Modifications copyright Amazon.com, Inc. or its affiliates
#ifndef CRYINCLUDE_CRYCOMMON_SERIALIZATION_BITVECTOR_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_BITVECTOR_H
#pragma once
namespace Serialization{
class IArchive;
template<class Enum>
class BitVector
{
public:
BitVector(int value = 0) : value_(value) {}
operator int&() { return value_; }
operator int() const { return value_; }
BitVector& operator|= (Enum value) { value_ |= value; return *this; }
BitVector& operator|= (int value) { value_ |= value; return *this; }
BitVector& operator&= (int value) { value_ &= value; return *this; }
void Serialize(IArchive& ar);
private:
int value_;
};
template<class Enum>
bool Serialize(Serialization::IArchive& ar, Serialization::BitVector<Enum>& value, const char* name, const char* label);
}
#include "BitVectorImpl.h"
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_BITVECTOR_H
Code/CryEngine/CryCommon/Serialization/BitVectorImpl.h
-88
View File
@@ -1,88 +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_SERIALIZATION_BITVECTORIMPL_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_BITVECTORIMPL_H
#pragma once
#include "Serialization/BitVector.h"
#include "Serialization/IArchive.h"
#include "Serialization/Enum.h"
namespace Serialization {
struct BitVectorWrapper
{
int* valuePointer;
int value;
const CEnumDescription* description;
explicit BitVectorWrapper(int* _value = 0, const CEnumDescription* _description = 0)
: valuePointer(_value)
, description(_description)
{
if (valuePointer)
{
value = *valuePointer;
}
}
BitVectorWrapper(const BitVectorWrapper& _rhs)
: value(_rhs.value)
, description(0)
, valuePointer(0)
{
}
~BitVectorWrapper()
{
if (valuePointer)
{
* valuePointer = value;
}
}
BitVectorWrapper& operator=(const BitVectorWrapper& rhs)
{
value = rhs.value;
return *this;
}
void Serialize(IArchive& ar)
{
ar(value, "value", "Value");
}
};
template<class Enum>
void BitVector<Enum>::Serialize(IArchive& ar)
{
ar(value_, "value", "Value");
}
}
template<class Enum>
bool Serialize(Serialization::IArchive& ar, Serialization::BitVector<Enum>& value, const char* name, const char* label)
{
using namespace Serialization;
CEnumDescription& desc = getEnumDescription<Enum>();
if (ar.IsEdit())
{
return ar(BitVectorWrapper(&static_cast<int&>(value), &desc), name, label);
}
else
{
return desc.serializeBitVector(ar, static_cast<int&>(value), name, label);
}
}
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_BITVECTORIMPL_H
Code/CryEngine/CryCommon/Serialization/BlackBox.h
-93
View File
@@ -1,93 +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_SERIALIZATION_BLACKBOX_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_BLACKBOX_H
#pragma once
#include <stdlib.h> // for malloc and free
namespace Serialization
{
// Black box is used to store opaque data blobs in a format internal to
// specific Archive. For example it can be used to store sections of the JSON
// or binary archive.
//
// This is useful for the Editor to store portions of files with unfamiliar
// structure.
//
// We store deallocation function here so we can safely pass the blob
// across DLLs with different memory allocators.
struct SBlackBox
{
const char* format;
void* data;
size_t size;
typedef void(* FreeFunction)(void*);
FreeFunction freeFunction;
SBlackBox()
: format("")
, data(0)
, size(0)
, freeFunction(0)
{
}
SBlackBox(const SBlackBox& rhs)
: format("")
, data(0)
, size(0)
, freeFunction(0)
{
*this = rhs;
}
void set(const char* _format, const void* _data, size_t _size)
{
if (_data && freeFunction)
{
freeFunction(this->data);
this->data = 0;
this->size = 0;
freeFunction = 0;
}
this->format = _format;
if (_data && _size)
{
this->data = CryModuleMalloc(_size);
memcpy(this->data, _data, _size);
this->size = _size;
freeFunction = &Free;
}
}
SBlackBox& operator=(const SBlackBox& rhs)
{
set(rhs.format, rhs.data, rhs.size);
return *this;
}
~SBlackBox()
{
set("", 0, 0);
}
static void Free(void* ptr)
{
CryModuleFree(ptr);
}
};
}
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_BLACKBOX_H
Code/CryEngine/CryCommon/Serialization/BoostSharedPtr.h
-102
View File
@@ -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.
#pragma once
#include <Serialization/Serializer.h>
#include "ClassFactory.h"
template <class T>
class BoostSharedPtrSerializer
: public Serialization::IPointer
{
public:
BoostSharedPtrSerializer(AZStd::shared_ptr<T>& ptr)
: m_ptr(ptr)
{
}
const char* registeredTypeName() const override
{
if (m_ptr)
{
return factoryOverride().getRegisteredTypeName(m_ptr.get());
}
else
{
return "";
}
}
void create(const char* registeredTypeName) const override
{
CRY_ASSERT(!m_ptr || m_ptr.use_count() == 1);
if (registeredTypeName && registeredTypeName[0] != '\0')
{
m_ptr.reset(factoryOverride().create(registeredTypeName));
}
else
{
m_ptr.reset();
}
}
Serialization::TypeID baseType() const override
{
return Serialization::TypeID::get<T>();
}
virtual Serialization::SStruct serializer() const override
{
return Serialization::SStruct(*m_ptr);
}
void* get() const
{
return reinterpret_cast<void*>(m_ptr.get());
}
const void* handle() const
{
return &m_ptr;
}
Serialization::TypeID pointerType() const override
{
return Serialization::TypeID::get<AZStd::shared_ptr<T> >();
}
Serialization::ClassFactory<T>* factory() const override
{
return &factoryOverride();
}
virtual Serialization::ClassFactory<T>& factoryOverride() const
{
return Serialization::ClassFactory<T>::the();
}
protected:
AZStd::shared_ptr<T>& m_ptr;
};
namespace AZStd
{
template <class T>
bool Serialize(Serialization::IArchive& ar, AZStd::shared_ptr<T>& ptr, const char* name, const char* label)
{
BoostSharedPtrSerializer<T> serializer(ptr);
return ar(static_cast<Serialization::IPointer&>(serializer), name, label);
}
}
Code/CryEngine/CryCommon/Serialization/CRCRef.h
-30
View File
@@ -1,30 +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_SERIALIZATION_CRCREF_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_CRCREF_H
#pragma once
template <uint32 StoreStrings, typename THash>
struct SCRCRef;
namespace Serialization
{
class IArchive;
}
template <uint32 StoreStrings, typename THash>
bool Serialize(Serialization::IArchive& ar, SCRCRef<StoreStrings, THash>& crcRef, const char* name, const char* label);
#include "CRCRefImpl.h"
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_CRCREF_H
Code/CryEngine/CryCommon/Serialization/CRCRefImpl.h
-100
View File
@@ -1,100 +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_SERIALIZATION_CRCREFIMPL_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_CRCREFIMPL_H
#pragma once
#include "IArchive.h"
#include "Serializer.h"
template <typename TCRCRef>
class CRCRefSerializer
: public Serialization::IString
{
public:
CRCRefSerializer(TCRCRef& crcRef)
: m_crcRef(crcRef)
{
}
virtual void set(const char* value)
{
m_crcRef.SetByString(value);
}
virtual const char* get() const
{
return m_crcRef.c_str();
}
const void* handle() const
{
return &m_crcRef;
}
Serialization::TypeID type() const
{
return Serialization::TypeID::get<TCRCRef>();
}
TCRCRef& m_crcRef;
};
template <uint32 StoreStrings, typename THash>
class CCRCRefSerializerNoStrings
{
public:
CCRCRefSerializerNoStrings(struct SCRCRef<StoreStrings, THash>& crcRef)
: crc(crcRef.crc)
{
}
bool Serialize(Serialization::IArchive& ar)
{
return ar(crc, "CRC", "CRC");
}
typedef typename THash::TInt TInt;
TInt& crc;
};
template <uint32 StoreStrings, typename THash>
bool Serialize(Serialization::IArchive& ar, struct SCRCRef<StoreStrings, THash>& crcRef, const char* name, const char* label)
{
if (StoreStrings == 0)
{
if (ar.IsInput())
{
SCRCRef<StoreStrings, THash> crcCopy;
ar(CCRCRefSerializerNoStrings<StoreStrings, THash>(crcCopy), name, label);
if (crcCopy.crc != THash::INVALID)
{
crcRef = crcCopy;
return true;
}
}
else if (ar.IsOutput())
{
return ar(CCRCRefSerializerNoStrings<StoreStrings, THash>(crcRef), name, label);
}
}
CRCRefSerializer<SCRCRef<StoreStrings, THash> > crcRefSerializer(crcRef);
return ar(static_cast<Serialization::IString&>(crcRefSerializer), name, label);
}
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_CRCREFIMPL_H
Code/CryEngine/CryCommon/Serialization/Callback.h
-184
View File
@@ -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.
#ifndef CRYINCLUDE_CRYCOMMON_SERIALIZATION_CALLBACK_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_CALLBACK_H
#pragma once
#include <AzCore/std/functional.h>
namespace Serialization
{
struct ICallback
{
virtual bool SerializeValue(IArchive& ar, const char* name, const char* value) = 0;
virtual ICallback* Clone() = 0;
virtual void Release() = 0;
virtual TypeID Type() const = 0;
typedef AZStd::function<void(void*, const TypeID&)> ApplyFunction;
virtual void Call(const ApplyFunction&) = 0;
};
template<class T, class Decorator = T>
struct CallbackSimple
: ICallback
{
typedef AZStd::function<void(const T&)> CallbackFunction;
T* value;
T oldValue;
CallbackFunction callback;
CallbackSimple(T* value, const T& oldValue, const AZStd::function<void(const T&)>& callback)
: value(value)
, oldValue(oldValue)
, callback(callback)
{
}
ICallback* Clone() { return new CallbackSimple<T>(0, oldValue, callback); }
void Release() { delete this; }
bool SerializeValue(IArchive& ar, const char* name, const char* label) { return ar(*value, name, label); }
TypeID Type() const{ return TypeID::get<T>(); }
void Call(const ApplyFunction& applyFunction)
{
T newValue;
applyFunction((void*)&newValue, TypeID::get<T>());
if (oldValue != newValue)
{
callback(newValue);
oldValue = newValue;
}
}
};
template<class T, class Decorator = T>
struct CallbackWithDecorator
: ICallback
{
typedef AZStd::function<void(const T&)> CallbackFunction;
typedef AZStd::function<Decorator (T&)> DecoratorFunction;
T oldValue;
T* value;
CallbackFunction callback;
DecoratorFunction decorator;
CallbackWithDecorator(T* value,
const T& oldValue,
const CallbackFunction& callback,
const DecoratorFunction& decorator)
: value(value)
, oldValue(oldValue)
, callback(callback)
, decorator(decorator)
{
}
ICallback* Clone() { return new CallbackWithDecorator<T, Decorator>(0, oldValue, callback, decorator); }
void Release() { delete this; }
bool SerializeValue(IArchive& ar, const char* name, const char* label) { return ar(decorator(*value), name, label); }
TypeID Type() const{ return TypeID::get<Decorator>(); }
void Call(const ApplyFunction& applyFunction)
{
T newValue;
Decorator dec = decorator(newValue);
applyFunction((void*)&dec, TypeID::get<Decorator>());
if (oldValue != newValue)
{
callback(newValue);
oldValue = newValue;
}
}
};
namespace Detail
{
template <typename T>
struct MethodReturnType
{
typedef void type;
};
template <typename ClassType, typename ReturnType, typename Arg0>
struct MethodReturnType<ReturnType(ClassType::*)(Arg0) const>
{
typedef ReturnType type;
};
template<class T>
struct OperatorBracketsReturnType
{
typedef typename MethodReturnType<decltype(& T::operator())>::type Type;
};
}
template<class T, class CallbackFunc>
CallbackSimple<T>
Callback(T& value, const CallbackFunc& callback)
{
return CallbackSimple<T>(&value, value, AZStd::function<void(const T&)>(callback));
}
template<class T, class CallbackFunc, class DecoratorFunc>
CallbackWithDecorator<T, typename Detail::OperatorBracketsReturnType<DecoratorFunc>::Type>
Callback(T& value, const CallbackFunc& callback, const DecoratorFunc& decorator)
{
typedef typename Detail::OperatorBracketsReturnType<DecoratorFunc>::Type Decorator;
return CallbackWithDecorator<T, Decorator>(&value, value,
AZStd::function<void(const T&)>(callback),
AZStd::function<Decorator(T&)>(decorator));
}
template<class T>
bool Serialize(IArchive& ar, CallbackSimple<T>& callback, const char* name, const char* label)
{
if (ar.IsEdit())
{
return ar(static_cast<ICallback&>(callback), name, label);
}
else
{
if (!ar(*callback.value, name, label))
{
return false;
}
return true;
}
}
template<class T, class Decorator>
bool Serialize(IArchive& ar, CallbackWithDecorator<T, Decorator>& callback, const char* name, const char* label)
{
if (ar.IsEdit())
{
return ar(static_cast<ICallback&>(callback), name, label);
}
else
{
if (!ar(*callback.value, name, label))
{
return false;
}
return true;
}
}
}
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_CALLBACK_H
Code/CryEngine/CryCommon/Serialization/ClassFactory.h
-376
View File
@@ -1,376 +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_SERIALIZATION_CLASSFACTORY_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_CLASSFACTORY_H
#pragma once
#include <map>
#include <vector>
#include "Serialization/Assert.h"
#include "Serialization/IClassFactory.h"
#include "Serialization/TypeID.h"
namespace Serialization {
class IArchive;
class ClassFactoryManager
{
public:
static ClassFactoryManager& the()
{
static ClassFactoryManager factoryManager;
return factoryManager;
}
const IClassFactory* find(TypeID baseType) const
{
lazyRegisterFactories();
Factories::const_iterator it = factories_.find(baseType);
if (it == factories_.end())
{
return 0;
}
else
{
return it->second;
}
}
void registerFactory([[maybe_unused]] TypeID type, IClassFactory* factory)
{
factory->m_next = m_head;
m_head = factory;
}
protected:
void lazyRegisterFactories() const
{
if (m_head)
{
IClassFactory* factory = m_head;
while (factory)
{
const_cast<ClassFactoryManager*>(this)->factories_[factory->baseType_] = factory;
factory = factory->m_next;
}
const_cast<ClassFactoryManager*>(this)->m_head = nullptr;
}
}
typedef AZStd::unordered_map<TypeID, const IClassFactory*, AZStd::hash<TypeID>, AZStd::equal_to<TypeID>, AZ::StdLegacyAllocator> Factories;
Factories factories_;
IClassFactory* m_head = nullptr;
};
template<class BaseType>
class ClassFactory
: public IClassFactory
{
public:
static ClassFactory& the()
{
static AZStd::aligned_storage_for_t<ClassFactory> storage;
if (s_instance != (decltype(s_instance))&storage)
{
s_instance = new(&storage) ClassFactory();
}
return *s_instance;
}
static void destroy()
{
if (s_instance)
{
s_instance->~ClassFactory();
s_instance = nullptr;
}
}
class CreatorBase
{
public:
virtual ~CreatorBase() {}
virtual BaseType* create() const = 0;
virtual const TypeDescription& description() const{ return *description_; }
virtual void* vptr() const { return vptr_; }
virtual TypeID typeID() const = 0;
protected:
const TypeDescription* description_ = nullptr;
void* vptr_ = nullptr;
public:
CreatorBase* next;
};
static void* extractVPtr(BaseType* ptr)
{
return *((void**)ptr);
}
template<class Derived>
struct Annotation
{
Annotation(IClassFactory* factory, const char* name, const char* value) { static_cast<ClassFactory<BaseType>*>(factory)->addAnnotation<Derived>(name, value); }
};
template<class Derived>
class Creator
: public CreatorBase
{
public:
Creator(const TypeDescription* description, ClassFactory* factory = nullptr)
{
this->description_ = description;
if (!factory)
{
factory = &ClassFactory::the();
}
factory->registerCreator(this);
}
void* vptr() const override
{
if (!this->vptr_)
{
Derived vptrProbe;
const_cast<Creator*>(this)->vptr_ = extractVPtr(&vptrProbe);
}
return this->vptr_;
}
BaseType* create() const override { return new Derived(); }
TypeID typeID() const override { return Serialization::TypeID::get<Derived>(); }
};
ClassFactory()
: IClassFactory(TypeID::get<BaseType>())
{
ClassFactoryManager::the().registerFactory(baseType_, this);
}
~ClassFactory()
{
m_data->~Data();
m_data = nullptr;
}
typedef AZStd::unordered_map<string, const CreatorBase*, AZStd::hash<string>, AZStd::equal_to<string>, AZ::StdLegacyAllocator> TypeToCreatorMap;
typedef AZStd::unordered_map<void*, CreatorBase*, AZStd::hash<void*>, AZStd::equal_to<void*>, AZ::StdLegacyAllocator> VPtrToCreatorMap;
typedef AZStd::unordered_map<string, TypeID, AZStd::hash<string>, AZStd::equal_to<string>, AZ::StdLegacyAllocator> RegisteredNameToTypeID;
typedef AZStd::unordered_map<TypeID, std::vector<std::pair<const char*, const char*> >, AZStd::hash<TypeID>, AZStd::equal_to<TypeID>, AZ::StdLegacyAllocator> AnnotationMap;
virtual BaseType* create(const char* registeredName) const
{
lazyRegisterCreators();
if (!registeredName)
{
return 0;
}
if (registeredName[0] == '\0')
{
return 0;
}
typename TypeToCreatorMap::const_iterator it = m_data->typeToCreatorMap_.find(registeredName);
if (it != m_data->typeToCreatorMap_.end())
{
return it->second->create();
}
else
{
return 0;
}
}
virtual const char* getRegisteredTypeName(BaseType* ptr) const
{
lazyRegisterCreators();
if (ptr == 0)
{
return "";
}
void* vptr = extractVPtr(ptr);
typename VPtrToCreatorMap::const_iterator it = m_data->vptrToCreatorMap_.find(vptr);
if (it == m_data->vptrToCreatorMap_.end())
{
return "";
}
return it->second->description().name();
}
BaseType* createByIndex(int index) const
{
lazyRegisterCreators();
YASLI_ASSERT(size_t(index) < m_data->creators_.size());
return m_data->creators_[index]->create();
}
void serializeNewByIndex(IArchive& ar, int index, const char* name, const char* label)
{
lazyRegisterCreators();
YASLI_ESCAPE(size_t(index) < m_data->creators_.size(), return );
BaseType* ptr = m_data->creators_[index]->create();
ar(*ptr, name, label);
delete ptr;
}
// from ClassFactoryInterface:
size_t size() const{ return m_data->creators_.size(); }
const TypeDescription* descriptionByIndex(int index) const override
{
lazyRegisterCreators();
if (size_t(index) >= int(m_data->creators_.size()))
{
return 0;
}
return &m_data->creators_[index]->description();
}
const TypeDescription* descriptionByRegisteredName(const char* name) const override
{
lazyRegisterCreators();
const size_t numCreators = m_data->creators_.size();
for (size_t i = 0; i < numCreators; ++i)
{
if (strcmp(m_data->creators_[i]->description().name(), name) == 0)
{
return &m_data->creators_[i]->description();
}
}
return 0;
}
// ^^^
TypeID typeIDByRegisteredName(const char* registeredTypeName) const
{
lazyRegisterCreators();
RegisteredNameToTypeID::const_iterator it = m_data->registeredNameToTypeID_.find(registeredTypeName);
if (it == m_data->registeredNameToTypeID_.end())
{
return TypeID();
}
return it->second;
}
const char* findAnnotation(const char* registeredTypeName, const char* name) const
{
lazyRegisterCreators();
TypeID typeID = typeIDByRegisteredName(registeredTypeName);
AnnotationMap::const_iterator it = m_data->annotations_.find(typeID);
if (it == m_data->annotations_.end())
{
return "";
}
for (size_t i = 0; i < it->second.size(); ++i)
{
if (strcmp(it->second[i].first, name) == 0)
{
return it->second[i].second;
}
}
return "";
}
void unregisterCreator(const TypeDescription& typeDescription)
{
auto creator = m_data->typeToCreatorMap_.find(typeDescription.name());
if (creator != m_data->typeToCreatorMap_.end())
{
m_data->creators_.erase(std::find(m_data->creators_.begin(), m_data->creators_.end(), m_data->creator->second));
m_data->vptrToCreatorMap_.erase(m_data->vptrToCreatorMap_.find(creator->second->vptr()));
m_data->typeToCreatorMap_.erase(creator);
}
}
protected:
virtual void registerCreator(CreatorBase* creator)
{
creator->next = creatorsList;
creatorsList = creator;
}
void lazyRegisterCreators() const
{
if (!m_data)
{
const_cast<ClassFactory*>(this)->m_data = ::new((void*)&m_dataStorage) Data();
for (CreatorBase* creator = creatorsList; creator; creator = creator->next)
{
if (!const_cast<ClassFactory*>(this)->m_data->typeToCreatorMap_.insert(AZStd::make_pair(creator->description().name(), creator)).second)
{
YASLI_ASSERT(0 && "Type registered twice in the same factory. Was SERIALIZATION_CLASS_NAME put into header file by mistake?");
}
const_cast<ClassFactory*>(this)->m_data->creators_.push_back(creator);
const_cast<ClassFactory*>(this)->m_data->registeredNameToTypeID_[creator->description().name()] = creator->typeID();
const_cast<ClassFactory*>(this)->m_data->vptrToCreatorMap_[creator->vptr()] = creator;
}
}
}
template<class T>
void addAnnotation(const char* name, const char* value)
{
addAnnotation(Serialization::TypeID::get<T>(), name, value);
}
virtual void addAnnotation(const Serialization::TypeID& id, const char* name, const char* value)
{
lazyRegisterCreators();
m_data->annotations_[id].push_back(std::make_pair(name, value));
}
CreatorBase* creatorsList = nullptr;
static ClassFactory* s_instance;
struct Data
{
TypeToCreatorMap typeToCreatorMap_;
AZStd::vector<CreatorBase*, AZ::StdLegacyAllocator> creators_;
VPtrToCreatorMap vptrToCreatorMap_;
RegisteredNameToTypeID registeredNameToTypeID_;
AnnotationMap annotations_;
};
Data* m_data = nullptr;
AZStd::aligned_storage_for_t<Data> m_dataStorage;
};
template <class T>
ClassFactory<T>* ClassFactory<T>::s_instance = nullptr;
}
#define SERIALIZATION_CLASS_NULL(BaseType, name) \
namespace { \
bool BaseType##_NullRegistered = Serialization::ClassFactory<BaseType>::the().setNullLabel(name); \
}
#define SERIALIZATION_CLASS_NAME(BaseType, Type, name, label) \
static const Serialization::TypeDescription Type##BaseType##_DerivedDescription(name, label); \
static Serialization::ClassFactory<BaseType>::Creator<Type> Type##BaseType##_Creator(&Type##BaseType##_DerivedDescription); \
int dummyForType_##Type##BaseType;
#define SERIALIZATION_CLASS_NAME_FOR_FACTORY(Factory, BaseType, Type, name, label) \
static const Serialization::TypeDescription Type##BaseType##_DerivedDescription(name, label); \
static Serialization::ClassFactory<BaseType>::Creator<Type> Type##BaseType##_Creator(&Type##BaseType##_DerivedDescription, &(Factory));
#define SERIALIZATION_CLASS_ANNOTATION(BaseType, Type, attributeName, attributeValue) \
static Serialization::ClassFactory<BaseType>::Annotation<Type> Type##BaseType##_Annotation(&Serialization::ClassFactory<BaseType>::the(), attributeName, attributeValue);
#define SERIALIZATION_CLASS_ANNOTATION_FOR_FACTORY(factory, BaseType, Type, attributeName, attributeValue) \
static Serialization::ClassFactory<BaseType>::Annotation<Type> Type##BaseType##_Annotation(&factory, attributeName, attributeValue);
#define SERIALIZATION_FORCE_CLASS(BaseType, Type) \
extern int dummyForType_##Type##BaseType; \
int* dummyForTypePtr_##Type##BaseType = &dummyForType_##Type##BaseType + 1;
#include "ClassFactoryImpl.h"
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_CLASSFACTORY_H
Code/CryEngine/CryCommon/Serialization/ClassFactoryImpl.h
-47
View File
@@ -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.
#ifndef CRYINCLUDE_CRYCOMMON_SERIALIZATION_CLASSFACTORYIMPL_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_CLASSFACTORYIMPL_H
#pragma once
#include "IArchive.h"
#include "IClassFactory.h"
#include "STL.h"
#include "ClassFactory.h"
#include "Strings.h"
namespace Serialization {
inline bool Serialize(Serialization::IArchive& ar, Serialization::TypeNameWithFactory& value, const char* name, [[maybe_unused]] const char* label)
{
if (!ar(value.registeredName, name))
{
return false;
}
if (ar.IsInput())
{
const TypeDescription* desc = value.factory->descriptionByRegisteredName(value.registeredName.c_str());
if (!desc)
{
ar.Error(value, "Unable to read TypeID: unregistered type name: \'%s\'", value.registeredName.c_str());
value.registeredName.clear();
return false;
}
}
return true;
}
}
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_CLASSFACTORYIMPL_H
Code/CryEngine/CryCommon/Serialization/Color.h
-55
View File
@@ -1,55 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_SERIALIZATION_COLOR_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_COLOR_H
#pragma once
#include <Serialization/IArchive.h>
#include <Serialization/Decorators/Range.h>
template<typename T>
inline bool Serialize(Serialization::IArchive& ar, Color_tpl<T>& c, const char* name, const char* label);
namespace Serialization
{
struct Vec3AsColor
{
Vec3& v;
Vec3AsColor(Vec3& v)
: v(v) {}
void Serialize(Serialization::IArchive& ar)
{
ar(Range(v.x, 0.0f, 1.0f), "r", "^");
ar(Range(v.y, 0.0f, 1.0f), "g", "^");
ar(Range(v.z, 0.0f, 1.0f), "b", "^");
}
};
inline bool Serialize(Serialization::IArchive& ar, Vec3AsColor& c, const char* name, const char* label)
{
if (ar.IsEdit())
{
return ar(Serialization::SStruct(c), name, label);
}
else
{
typedef float (* Array)[3];
return ar(*((Array) & c.v.x), name, label);
}
}
}
#include "ColorImpl.h"
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_COLOR_H
Code/CryEngine/CryCommon/Serialization/ColorImpl.h
-53
View File
@@ -1,53 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_SERIALIZATION_COLORIMPL_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_COLORIMPL_H
#pragma once
#include "Color.h"
//////////////////////////////////////////////////////////////////////////
template<typename T>
struct SerializableColor_tpl
: Color_tpl<T>
{
static float ColorRangeMin(float) { return 0.0f; }
static float ColorRangeMax(float) { return 1.0f; }
static unsigned char ColorRangeMin(unsigned char) { return 0; }
static unsigned char ColorRangeMax(unsigned char) { return 255; }
void Serialize(Serialization::IArchive& ar)
{
ar(Serialization::Range(Color_tpl<T>::r, ColorRangeMin(Color_tpl<T>::r), ColorRangeMax(Color_tpl<T>::r)), "r", "^");
ar(Serialization::Range(Color_tpl<T>::g, ColorRangeMin(Color_tpl<T>::g), ColorRangeMax(Color_tpl<T>::g)), "g", "^");
ar(Serialization::Range(Color_tpl<T>::b, ColorRangeMin(Color_tpl<T>::b), ColorRangeMax(Color_tpl<T>::b)), "b", "^");
ar(Serialization::Range(Color_tpl<T>::a, ColorRangeMin(Color_tpl<T>::a), ColorRangeMax(Color_tpl<T>::a)), "a", "^");
}
};
template<typename T>
bool Serialize(Serialization::IArchive& ar, Color_tpl<T>& c, const char* name, const char* label)
{
if (ar.IsEdit())
{
return Serialize(ar, static_cast<SerializableColor_tpl<T>&>(c), name, label);
}
else
{
typedef T (& Array)[4];
return ar((Array)c, name, label);
}
}
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_COLORIMPL_H
Code/CryEngine/CryCommon/Serialization/CryExtension.h
-44
View File
@@ -1,44 +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_SERIALIZATION_CRYEXTENSION_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_CRYEXTENSION_H
#pragma once
#ifdef GetClassName
#undef GetClassName
#endif
#include <CryExtension/ICryFactory.h>
namespace Serialization
{
// Allows to have AZStd::shared_ptr<TPointer> but serialize it by
// interface-casting to TSerializable, i.e. implementing Serialization through
// separate interface.
template<class TPointer, class TSerializable = TPointer>
struct CryExtensionPointer
{
AZStd::shared_ptr<TPointer>& ptr;
CryExtensionPointer(AZStd::shared_ptr<TPointer>& _ptr)
: ptr(_ptr) {}
void Serialize(Serialization::IArchive& ar);
};
}
// This function treats T as a type derived from CryUnknown type.
template<class T>
bool Serialize(Serialization::IArchive& ar, AZStd::shared_ptr<T>& ptr, const char* name, const char* label);
#include "CryExtensionImpl.h"
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_CRYEXTENSION_H
Code/CryEngine/CryCommon/Serialization/CryExtensionImpl.h
-281
View File
@@ -1,281 +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_SERIALIZATION_CRYEXTENSIONIMPL_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_CRYEXTENSIONIMPL_H
#pragma once
#include <Serialization/StringList.h>
#include <CryExtension/ICryFactoryRegistry.h>
#include <CryExtension/CryTypeID.h>
#include <ISystem.h>
namespace Serialization {
// Generate user-friendly class name, e.g. convert
// "AnimationPoseModifier_FootStore" -> "Foot Store"
inline string MakePrettyClassName(const char* className)
{
const char* firstSep = strchr(className, '_');
if (!firstSep)
{
// name doesn't follow expected convention, return as is
return className;
}
const char* start = firstSep + 1;
string result;
result.reserve(strlen(start) + 4);
const char* p = start;
while (*p != '\0')
{
if (*p >= 'A' && *p <= 'Z' &&
*(p - 1) >= 'a' && *(p - 1) <= 'z')
{
result += ' ';
}
if (*p == '_')
{
result += ' ';
}
else
{
result += *p;
}
++p;
}
return result;
}
// Provides Serialization::IClassFactory interface for classes
// registered with CryExtension to IArchive.
//
// TSerializable can be used to expose Serialize method through
// a separate interface, rathern than TBase. Safe to missing
// as QueryInterface is used to check its presence.
template<class TBase, class TSerializable = TBase>
class CryExtensionClassFactory
: public Serialization::IClassFactory
{
public:
size_t size() const override
{
return m_types.size();
}
static CryExtensionClassFactory& the()
{
static CryExtensionClassFactory instance;
return instance;
}
CryExtensionClassFactory()
: IClassFactory(Serialization::TypeID::get<TBase>())
{
setNullLabel("[ None ]");
ICryFactoryRegistry* factoryRegistry = gEnv->pSystem->GetCryFactoryRegistry();
size_t factoryCount = 0;
factoryRegistry->IterateFactories(cryiidof<TBase>(), 0, factoryCount);
if (factoryCount)
{
string sharedPrefix;
bool hasSharedPrefix = true;
AZStd::unique_ptr<ICryFactory*[]> factories(new ICryFactory*[factoryCount]);
factoryRegistry->IterateFactories(cryiidof<TBase>(), factories.get(), factoryCount);
for (size_t i = 0; i < factoryCount; ++i)
{
ICryFactory* factory = factories[i];
if (factory->ClassSupports(cryiidof<TSerializable>()))
{
m_factories.push_back(factory);
if (hasSharedPrefix)
{
// make sure that shared prefix is the same for all the names
const char* name = factory->GetName();
const char* lastPrefixCharacter = strchr(name, '_');
if (lastPrefixCharacter == 0)
{
hasSharedPrefix = false;
}
else
{
if (!sharedPrefix.empty())
{
if (strncmp(name, sharedPrefix.c_str(), sharedPrefix.size()) != 0)
{
hasSharedPrefix = false;
}
}
else
{
sharedPrefix.assign(name, lastPrefixCharacter + 1);
}
}
}
}
}
size_t usableFactoriesCount = m_factories.size();
m_types.reserve(usableFactoriesCount);
m_labels.reserve(usableFactoriesCount);
for (size_t i = 0; i < usableFactoriesCount; ++i)
{
ICryFactory* factory = m_factories[i];
m_classIds.push_back(factory->GetClassID());
const char* name = factory->GetName();
m_labels.push_back(MakePrettyClassName(name));
if (hasSharedPrefix)
{
name += sharedPrefix.size();
}
m_types.push_back(Serialization::TypeDescription(name, m_labels.back().c_str()));
}
}
}
const Serialization::TypeDescription* descriptionByIndex(int index) const override
{
if (size_t(index) >= m_types.size())
{
return 0;
}
return &m_types[index];
}
const Serialization::TypeDescription* descriptionByRegisteredName(const char* registeredName) const override
{
size_t count = m_types.size();
for (size_t i = 0; i < m_types.size(); ++i)
{
if (strcmp(m_types[i].name(), registeredName) == 0)
{
return &m_types[i];
}
}
return 0;
}
const char* findAnnotation(const char* typeName, const char* name) const override { return ""; }
void serializeNewByIndex(IArchive& ar, int index, const char* name, const char* label) override
{
if (size_t(index) >= m_types.size())
{
return;
}
AZStd::shared_ptr<TBase> ptr(create(m_types[index].name()));
if (TSerializable* ser = cryinterface_cast<TSerializable>(ptr.get()))
{
ar(*ser, name, label);
}
}
AZStd::shared_ptr<TBase> create(const char* registeredName)
{
size_t count = m_types.size();
for (size_t i = 0; i < count; ++i)
{
if (strcmp(m_types[i].name(), registeredName) == 0)
{
return AZStd::static_pointer_cast<TBase>(m_factories[i]->CreateClassInstance());
}
}
return AZStd::shared_ptr<TBase>();
}
const char* getRegisteredTypeName(const AZStd::shared_ptr<TBase>& ptr) const
{
if (!ptr.get())
{
return "";
}
CryInterfaceID id = AZStd::static_pointer_cast<TBase>(ptr)->GetFactory()->GetClassID();
size_t count = m_classIds.size();
for (size_t i = 0; i < count; ++i)
{
if (m_classIds[i] == id)
{
return m_types[i].name();
}
}
return "";
}
private:
std::vector<Serialization::TypeDescription> m_types;
std::vector<string> m_labels;
std::vector<ICryFactory*> m_factories;
std::vector<CryInterfaceID> m_classIds;
};
// Exposes CryExtension shared_ptr<> as serializeable type for Serialization::IArchive
template<class T, class TSerializable>
class CryExtensionSharedPtr
: public Serialization::IPointer
{
public:
CryExtensionSharedPtr(AZStd::shared_ptr<T>& ptr)
: m_ptr(ptr)
{}
const char* registeredTypeName() const override
{
if (m_ptr)
{
return factory()->getRegisteredTypeName(m_ptr);
}
else
{
return "";
}
}
void create(const char* registeredTypeName) const override
{
if (registeredTypeName[0] != '\0')
{
m_ptr = factory()->create(registeredTypeName);
}
else
{
m_ptr.reset((T*)0);
}
}
Serialization::TypeID baseType() const{ return Serialization::TypeID::get<T>(); }
virtual Serialization::SStruct serializer() const override
{
if (TSerializable* ser = cryinterface_cast<TSerializable>(m_ptr.get()))
{
return Serialization::SStruct(*ser);
}
else
{
return Serialization::SStruct();
}
}
void* get() const override { return reinterpret_cast<void*>(m_ptr.get()); }
const void* handle() const override { return &m_ptr; }
Serialization::TypeID pointerType() const override { return Serialization::TypeID::get<AZStd::shared_ptr<T> >(); }
CryExtensionClassFactory<T, TSerializable>* factory() const override { return &CryExtensionClassFactory<T, TSerializable>::the(); }
protected:
AZStd::shared_ptr<T>& m_ptr;
};
}
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_CRYEXTENSIONIMPL_H
Code/CryEngine/CryCommon/Serialization/CryName.h
-26
View File
@@ -1,26 +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_SERIALIZATION_CRYNAME_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_CRYNAME_H
#pragma once
namespace Serialization {
class IArchive;
}
inline bool Serialize(Serialization::IArchive & ar, class CCryName & cryName, const char* name, const char* label);
#include "CryNameImpl.h"
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_CRYNAME_H
Code/CryEngine/CryCommon/Serialization/CryNameImpl.h
-61
View File
@@ -1,61 +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_SERIALIZATION_CRYNAMEIMPL_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_CRYNAMEIMPL_H
#pragma once
#include "CryName.h"
#include "IArchive.h"
class CryNameSerializer
: public Serialization::IString
{
public:
CryNameSerializer(CCryName& s)
: m_s(s)
{
}
virtual void set(const char* value)
{
m_s = value;
}
virtual const char* get() const
{
return m_s.c_str();
}
virtual const void* handle() const
{
return &m_s;
}
virtual Serialization::TypeID type() const
{
return Serialization::TypeID::get<CCryName>();
}
CCryName& m_s;
};
inline bool Serialize(Serialization::IArchive& ar, CCryName& cryName, const char* name, const char* label)
{
CryNameSerializer serializer(cryName);
return ar(static_cast<Serialization::IString&>(serializer), name, label);
}
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_CRYNAMEIMPL_H
Code/CryEngine/CryCommon/Serialization/CryStrings.h
-36
View File
@@ -1,36 +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 "CryFixedString.h"
#include "Serialization/Serializer.h"
namespace Serialization
{
class IArchive;
}
// Note : if you are looking for the CryStringT serialization, it is handled in Serialization/STL.h
template< size_t N >
bool Serialize(Serialization::IArchive& ar, CryFixedStringT< N >& value, const char* name, const char* label);
template< size_t N >
bool Serialize(Serialization::IArchive& ar, CryStackStringT< char, N >& value, const char* name, const char* label);
template< size_t N >
bool Serialize(Serialization::IArchive& ar, CryStackStringT< wchar_t, N >& value, const char* name, const char* label);
#include "Serialization/CryStringsImpl.h"
Code/CryEngine/CryCommon/Serialization/CryStringsImpl.h
-74
View File
@@ -1,74 +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 "Serialization/IArchive.h"
#include "Serialization/CryStrings.h"
namespace Serialization
{
template< class TFixedStringClass >
class CFixedStringSerializer
: public IString
{
public:
CFixedStringSerializer(TFixedStringClass& str)
: str_(str) { }
void set(const char* value) { str_ = value; }
const char* get() const { return str_.c_str(); }
const void* handle() const { return &str_; }
TypeID type() const { return TypeID::get<TFixedStringClass>(); }
private:
TFixedStringClass& str_;
};
template< class TFixedStringClass >
class CFixedWStringSerializer
: public IWString
{
public:
CFixedWStringSerializer(TFixedStringClass& str)
: str_(str) { }
void set(const wchar_t* value) { str_ = value; }
const wchar_t* get() const { return str_.c_str(); }
const void* handle() const { return &str_; }
TypeID type() const { return TypeID::get<TFixedStringClass>(); }
private:
TFixedStringClass& str_;
};
}
template< size_t N >
inline bool Serialize(Serialization::IArchive& ar, CryFixedStringT< N >& value, const char* name, const char* label)
{
Serialization::CFixedStringSerializer< CryFixedStringT< N > > str(value);
return ar(static_cast<Serialization::IString&>(str), name, label);
}
template< size_t N >
inline bool Serialize(Serialization::IArchive& ar, CryStackStringT< char, N >& value, const char* name, const char* label)
{
Serialization::CFixedStringSerializer< CryStackStringT< char, N > > str(value);
return ar(static_cast<Serialization::IString&>(str), name, label);
}
template< size_t N >
inline bool Serialize(Serialization::IArchive& ar, CryStackStringT< wchar_t, N >& value, const char* name, const char* label)
{
Serialization::CFixedWStringSerializer< CryStackStringT< wchar_t, N > > str(value);
return ar(static_cast<Serialization::IWString&>(str), name, label);
}
Code/CryEngine/CryCommon/Serialization/Decorators/ActionButton.h
-89
View File
@@ -1,89 +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 <SmartPointersHelpers.h>
#include <Serialization/IArchive.h>
#include <AzCore/std/functional.h>
namespace Serialization
{
struct IActionButton;
DECLARE_SMART_POINTERS(IActionButton)
struct IActionButton
{
virtual ~IActionButton() {}
virtual void Callback() const = 0;
virtual const char* Icon() const = 0;
virtual IActionButtonPtr Clone() const = 0;
};
typedef AZStd::function<void()> FunctorActionButtonCallback;
struct FunctorActionButton
: public IActionButton
{
FunctorActionButtonCallback callback;
string icon;
explicit FunctorActionButton(const FunctorActionButtonCallback& callback, const char* icon = "")
: callback(callback)
, icon(icon)
{
}
// IActionButton
virtual void Callback() const override
{
if (callback)
{
callback();
}
}
virtual const char* Icon() const override
{
return icon.c_str();
}
virtual IActionButtonPtr Clone() const override
{
return IActionButtonPtr(new FunctorActionButton(callback, icon.c_str()));
}
// ~IActionButton
};
inline bool Serialize(Serialization::IArchive& ar, FunctorActionButton& button, const char* name, const char* label)
{
if (ar.IsEdit())
{
return ar(Serialization::SStruct::ForEdit(static_cast<Serialization::IActionButton&>(button)), name, label);
}
else
{
return false;
}
}
inline FunctorActionButton ActionButton(const FunctorActionButtonCallback& callback, const char* icon = "")
{
return FunctorActionButton(callback, icon);
}
}
Code/CryEngine/CryCommon/Serialization/Decorators/BitFlags.h
-64
View File
@@ -1,64 +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_SERIALIZATION_DECORATORS_BITFLAGS_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_BITFLAGS_H
#pragma once
#include <Serialization/Enum.h>
namespace Serialization {
class IArchive;
struct BitFlagsWrapper
{
int* variable;
unsigned int visibleMask;
const CEnumDescription* description;
void Serialize(IArchive& ar);
};
template<class Enum>
BitFlagsWrapper BitFlags(Enum& value)
{
BitFlagsWrapper wrapper;
wrapper.variable = (int*)&value;
wrapper.visibleMask = ~0U;
wrapper.description = &getEnumDescription<Enum>();
return wrapper;
}
template<class Enum>
BitFlagsWrapper BitFlags(int& value, int visibleMask = ~0)
{
BitFlagsWrapper wrapper;
wrapper.variable = &value;
wrapper.visibleMask = visibleMask;
wrapper.description = &getEnumDescription<Enum>();
return wrapper;
}
template<class Enum>
BitFlagsWrapper BitFlags(unsigned int& value, unsigned int visibleMask = ~0)
{
BitFlagsWrapper wrapper;
wrapper.variable = (int*)&value;
wrapper.visibleMask = visibleMask;
wrapper.description = &getEnumDescription<Enum>();
return wrapper;
}
}
#include "BitFlagsImpl.h"
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_BITFLAGS_H
Code/CryEngine/CryCommon/Serialization/Decorators/BitFlagsImpl.h
-67
View File
@@ -1,67 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_BITFLAGSIMPL_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_BITFLAGSIMPL_H
#pragma once
#include "Serialization/IArchive.h"
namespace Serialization {
inline void BitFlagsWrapper::Serialize(IArchive& ar)
{
const Serialization::CEnumDescription& desc = *description;
int count = desc.count();
if (ar.IsInput())
{
int previousValue = *variable;
for (int i = 0; i < count; ++i)
{
int flagValue = desc.valueByIndex(i);
if (!(flagValue & visibleMask))
{
continue;
}
bool flag = (previousValue & flagValue) == flagValue;
bool previousFlag = flag;
ar(flag, desc.nameByIndex(i), desc.labelByIndex(i));
if (flag != previousFlag)
{
if (flag)
{
*variable |= flagValue;
}
else
{
*variable &= ~flagValue;
}
}
}
}
else
{
for (int i = 0; i < count; ++i)
{
int flagValue = desc.valueByIndex(i);
if (!(flagValue & visibleMask))
{
continue;
}
bool flag = (*variable & flagValue) == flagValue;
ar(flag, desc.nameByIndex(i), desc.labelByIndex(i));
}
}
}
}
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_BITFLAGSIMPL_H
Code/CryEngine/CryCommon/Serialization/Decorators/ColorPicker.h
-43
View File
@@ -1,43 +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.
*
*/
#ifndef CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_COLORPICKER_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_COLORPICKER_H
#pragma once
#include <Cry_Math.h>
#include <Cry_Color.h>
#include <ISystem.h>
namespace Serialization
{
class IArchive;
struct ColorPicker
{
ColorF* color;
explicit ColorPicker(ColorF& color_)
: color(&color_)
{
}
// the function should stay virtual to ensure cross-dll calls are using right heap
virtual void SetColor(const ColorF* color_){* color = *color_; }
};
bool Serialize(Serialization::IArchive& ar, Serialization::ColorPicker& value, const char* name, const char* label);
} // namespace Serialization
#include "ColorPickerImpl.h"
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_COLORPICKER_H
Code/CryEngine/CryCommon/Serialization/Decorators/ColorPickerImpl.h
-33
View File
@@ -1,33 +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.
*
*/
#ifndef CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_COLORPICKERIMPL_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_COLORPICKERIMPL_H
#pragma once
#include "../Color.h"
namespace Serialization
{
inline bool Serialize(Serialization::IArchive& ar, Serialization::ColorPicker& value, const char* name, const char* label)
{
if (ar.IsEdit())
{
return ar(Serialization::SStruct::ForEdit(value), name, label);
}
else
{
return ar(*value.color, name, label);
}
}
} // namespace Serialization
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_COLORPICKERIMPL_H
Code/CryEngine/CryCommon/Serialization/Decorators/JointName.h
-19
View File
@@ -1,19 +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_SERIALIZATION_DECORATORS_JOINTNAME_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_JOINTNAME_H
#pragma once
#include <Serialization/Decorators/Resources.h>
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_JOINTNAME_H
Code/CryEngine/CryCommon/Serialization/Decorators/JointNameImpl.h
-19
View File
@@ -1,19 +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_SERIALIZATION_DECORATORS_JOINTNAMEIMPL_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_JOINTNAMEIMPL_H
#pragma once
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_JOINTNAMEIMPL_H
Code/CryEngine/CryCommon/Serialization/Decorators/LocalFrame.h
-117
View File
@@ -1,117 +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_SERIALIZATION_DECORATORS_LOCALFRAME_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_LOCALFRAME_H
#pragma once
#include <Cry_Math.h>
#include "Serialization/Math.h"
namespace Serialization
{
class IArchive;
struct LocalPosition
{
Vec3* value;
int space;
const char* parentName;
const void* handle;
LocalPosition(Vec3& _vec, int _space, const char* _parentName, const void* _handle)
: value(&_vec)
, space(_space)
, parentName(_parentName)
, handle(_handle)
{
}
void Serialize(IArchive& ar);
};
struct LocalOrientation
{
Quat* value;
int space;
const char* parentName;
const void* handle;
LocalOrientation(Quat& _vec, int _space, const char* _parentName, const void* _handle)
: value(&_vec)
, space(_space)
, parentName(_parentName)
, handle(_handle)
{
}
void Serialize(IArchive& ar);
};
struct LocalFrame
{
Quat* rotation;
Vec3* position;
const char* parentName;
int rotationSpace;
int positionSpace;
const void* handle;
LocalFrame(Quat* _rotation, int _rotationSpace, Vec3* _position, int _positionSpace, const char* _parentName, const void* _handle)
: rotation(_rotation)
, position(_position)
, parentName(_parentName)
, rotationSpace(_rotationSpace)
, positionSpace(_positionSpace)
, handle(_handle)
{
}
void Serialize(IArchive& ar);
};
enum
{
SPACE_JOINT,
SPACE_ENTITY,
SPACE_JOINT_WITH_PARENT_ROTATION,
SPACE_JOINT_WITH_CHARACTER_ROTATION,
SPACE_SOCKET_RELATIVE_TO_JOINT,
SPACE_SOCKET_RELATIVE_TO_BINDPOSE
};
//position
inline LocalPosition LocalToEntity(Vec3& position, const void* handle = 0)
{
return LocalPosition(position, SPACE_ENTITY, "", handle ? handle : &position);
}
inline LocalPosition LocalToJoint(Vec3& position, const string& jointName, const void* handle = 0)
{
return LocalPosition(position, SPACE_JOINT, jointName.c_str(), handle ? handle : &position);
}
inline LocalPosition LocalToJointCharacterRotation(Vec3& position, const string& jointName, const void* handle = 0)
{
return LocalPosition(position, SPACE_JOINT_WITH_CHARACTER_ROTATION, jointName.c_str(), handle ? handle : &position);
}
bool Serialize(Serialization::IArchive& ar, Serialization::LocalPosition& value, const char* name, const char* label);
bool Serialize(Serialization::IArchive& ar, Serialization::LocalOrientation& value, const char* name, const char* label);
bool Serialize(Serialization::IArchive& ar, Serialization::LocalFrame& value, const char* name, const char* label);
}
#include "LocalFrameImpl.h"
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_LOCALFRAME_H
Code/CryEngine/CryCommon/Serialization/Decorators/LocalFrameImpl.h
-89
View File
@@ -1,89 +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_SERIALIZATION_DECORATORS_LOCALFRAMEIMPL_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_LOCALFRAMEIMPL_H
#pragma once
#include "LocalFrame.h"
#include "Serialization/IArchive.h"
#include "Serialization/MathImpl.h"
namespace Serialization
{
inline void LocalPosition::Serialize(Serialization::IArchive& ar)
{
ar(value->x, "x", "^");
ar(value->y, "y", "^");
ar(value->z, "z", "^");
}
inline void LocalOrientation::Serialize(Serialization::IArchive& ar)
{
ar(Serialization::AsAng3(*value), "q", "^");
}
inline void LocalFrame::Serialize(Serialization::IArchive& ar)
{
ar(*position, "t", "<T");
ar(AsAng3(*rotation), "q", "<R");
}
inline bool Serialize(Serialization::IArchive& ar, Serialization::LocalPosition& value, const char* name, const char* label)
{
if (ar.IsEdit())
{
return ar(Serialization::SStruct(value), name, label);
}
else
{
return ar(*value.value, name, label);
}
}
inline bool Serialize(Serialization::IArchive& ar, Serialization::LocalOrientation& value, const char* name, const char* label)
{
if (ar.IsEdit())
{
return ar(Serialization::SStruct(value), name, label);
}
else
{
return ar(*value.value, name, label);
}
}
inline bool Serialize(Serialization::IArchive& ar, Serialization::LocalFrame& value, const char* name, const char* label)
{
if (ar.IsEdit())
{
return ar(Serialization::SStruct(value), name, label);
}
else
{
QuatT t(*value.rotation, *value.position);
if (!ar(t, name, label))
{
return false;
}
if (ar.IsInput())
{
*value.position = t.t;
*value.rotation = t.q;
}
return true;
}
}
}
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_LOCALFRAMEIMPL_H
Code/CryEngine/CryCommon/Serialization/Decorators/OutputFilePath.h
-49
View File
@@ -1,49 +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_SERIALIZATION_DECORATORS_OUTPUTFILEPATH_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_OUTPUTFILEPATH_H
#pragma once
#include "Serialization/Strings.h"
namespace Serialization
{
class IArchive;
struct OutputFilePath
{
string* m_path;
// if we don't use dynamic filters we could replace following two with const char*
string filter;
string startFolder;
// filters are defined in the following format:
// "All Images (bmp, jpg, tga)|*.bmp;*.jpg;*.tga|Targa (tga)|*.tga"
explicit OutputFilePath(string& path, const char* filter = "All files|*.*", const char* startFolder = "")
: m_path(&path)
, filter(filter)
, startFolder(startFolder)
{
}
// the function should stay virtual to ensure cross-dll calls are using right heap
virtual void SetPath(const char* path) { *this->m_path = path; }
};
bool Serialize(Serialization::IArchive& ar, Serialization::OutputFilePath& value, const char* name, const char* label);
}
#include "OutputFilePathImpl.h"
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_OUTPUTFILEPATH_H
Code/CryEngine/CryCommon/Serialization/Decorators/OutputFilePathImpl.h
-32
View File
@@ -1,32 +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_SERIALIZATION_DECORATORS_OUTPUTFILEPATHIMPL_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_OUTPUTFILEPATHIMPL_H
#pragma once
namespace Serialization
{
inline bool Serialize(Serialization::IArchive& ar, Serialization::OutputFilePath& value, const char* name, const char* label)
{
if (ar.IsEdit())
{
return ar(Serialization::SStruct::ForEdit(value), name, label);
}
else
{
return ar(*value.m_path, name, label);
}
}
}
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_OUTPUTFILEPATHIMPL_H
Code/CryEngine/CryCommon/Serialization/Decorators/Range.h
-63
View File
@@ -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 CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_RANGE_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_RANGE_H
#pragma once
namespace Serialization
{
template<class T>
struct RangeDecorator
{
T* value;
T softMin;
T softMax;
T hardMin;
T hardMax;
};
template<class T>
RangeDecorator<T> Range(T& value, T hardMin, T hardMax)
{
RangeDecorator<T> r;
r.value = &value;
r.softMin = hardMin;
r.softMax = hardMax;
r.hardMin = hardMin;
r.hardMax = hardMax;
return r;
}
template<class T>
RangeDecorator<T> Range(T& value, T softMin, T softMax, T hardMin, T hardMax)
{
RangeDecorator<T> r;
r.value = &value;
r.softMin = softMin;
r.softMax = softMax;
r.hardMin = hardMin;
r.hardMax = hardMax;
return r;
}
namespace Decorators
{
// Obsolete name, will be removed. Please use Serialization::Range instead.
using Serialization::Range;
}
}
#include "RangeImpl.h"
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_RANGE_H
Code/CryEngine/CryCommon/Serialization/Decorators/RangeImpl.h
-50
View File
@@ -1,50 +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_SERIALIZATION_DECORATORS_RANGEIMPL_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_RANGEIMPL_H
#pragma once
namespace Serialization
{
template<class T>
bool Serialize(IArchive& ar, RangeDecorator<T>& value, const char* name, const char* label)
{
if (ar.IsEdit())
{
if (!ar(SStruct::ForEdit(value), name, label))
{
return false;
}
}
else if (!ar(*value.value, name, label))
{
return false;
}
if (ar.IsInput())
{
if (*value.value < value.hardMin)
{
*value.value = value.hardMin;
}
if (*value.value > value.hardMax)
{
*value.value = value.hardMax;
}
}
return true;
}
}
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_RANGEIMPL_H
Code/CryEngine/CryCommon/Serialization/Decorators/ResourceFilePath.h
-59
View File
@@ -1,59 +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_SERIALIZATION_DECORATORS_RESOURCEFILEPATH_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_RESOURCEFILEPATH_H
#pragma once
#include "Serialization/Strings.h"
namespace Serialization
{
class IArchive;
struct ResourceFilePath
{
enum
{
STRIP_EXTENSION = 1 << 0
};
string* m_path;
string filter;
bool group;
int flags;
// filters are defined in the following format:
// "All Images (bmp, jpg, tga)|*.bmp;*.jpg;*.tga|Targa (tga)|*.tga"
explicit ResourceFilePath(string& path, const char* filter = "", bool group = false, int flags = 0)
: m_path(&path)
, filter(filter)
, group(group)
, flags(flags)
{
}
// the function should stay virtual to ensure cross-dll calls are using right heap
virtual void SetPath(const char* path) { *this->m_path = path; }
};
inline ResourceFilePath MaterialPath(string& path)
{
return ResourceFilePath(path, "Material", false, ResourceFilePath::STRIP_EXTENSION);
}
bool Serialize(Serialization::IArchive& ar, Serialization::ResourceFilePath& value, const char* name, const char* label);
}
#include "ResourceFilePathImpl.h"
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_RESOURCEFILEPATH_H
Code/CryEngine/CryCommon/Serialization/Decorators/ResourceFilePathImpl.h
-32
View File
@@ -1,32 +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_SERIALIZATION_DECORATORS_RESOURCEFILEPATHIMPL_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_RESOURCEFILEPATHIMPL_H
#pragma once
namespace Serialization
{
inline bool Serialize(Serialization::IArchive& ar, Serialization::ResourceFilePath& value, const char* name, const char* label)
{
if (ar.IsEdit())
{
return ar(Serialization::SStruct::ForEdit(value), name, label);
}
else
{
return ar(*value.m_path, name, label);
}
}
}
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_RESOURCEFILEPATHIMPL_H
Code/CryEngine/CryCommon/Serialization/Decorators/ResourceFolderPath.h
-43
View File
@@ -1,43 +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_SERIALIZATION_DECORATORS_RESOURCEFOLDERPATH_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_RESOURCEFOLDERPATH_H
#pragma once
#include "Serialization/Strings.h"
namespace Serialization
{
class IArchive;
struct ResourceFolderPath
{
string* m_path;
string startFolder;
explicit ResourceFolderPath(string& path, const char* startFolder = "")
: m_path(&path)
, startFolder(startFolder)
{
}
// the function should stay virtual to ensure cross-dll calls are using right heap
virtual void SetPath(const char* path) { *this->m_path = path; }
};
bool Serialize(Serialization::IArchive& ar, Serialization::ResourceFolderPath& value, const char* name, const char* label);
}
#include "ResourceFolderPathImpl.h"
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_RESOURCEFOLDERPATH_H
Code/CryEngine/CryCommon/Serialization/Decorators/ResourceFolderPathImpl.h
-34
View File
@@ -1,34 +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_SERIALIZATION_DECORATORS_RESOURCEFOLDERPATHIMPL_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_RESOURCEFOLDERPATHIMPL_H
#pragma once
#include "Serialization/IArchive.h"
namespace Serialization
{
inline bool Serialize(Serialization::IArchive& ar, Serialization::ResourceFolderPath& value, const char* name, const char* label)
{
if (ar.IsEdit())
{
return ar(Serialization::SStruct::ForEdit(value), name, label);
}
else
{
return ar(*value.m_path, name, label);
}
}
}
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_RESOURCEFOLDERPATHIMPL_H
Code/CryEngine/CryCommon/Serialization/Decorators/ResourceSelector.h
-100
View File
@@ -1,100 +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
namespace Serialization
{
struct IResourceSelector
{
const char* resourceType;
virtual ~IResourceSelector() {}
virtual const char* GetValue() const = 0;
virtual void SetValue(const char* s) = 0;
virtual int GetId() const{ return -1; }
virtual const void* GetHandle() const = 0;
virtual Serialization::TypeID GetType() const = 0;
};
// Provides a way to annotate resource reference so different UI can be used
// for them. See IResourceSelector.h to see how selectors for specific types
// are registered.
//
// TString could be SCRCRef or CCryName as well.
//
// Do not use this class directly, instead use function that wraps it for
// specific type, see Resources.h for example.
template<class TString>
struct ResourceSelector
: IResourceSelector
{
TString& value;
const char* GetValue() const { return value.c_str(); }
void SetValue(const char* s) { value = s; }
const void* GetHandle() const { return &value; }
Serialization::TypeID GetType() const { return Serialization::TypeID::get<TString>(); }
ResourceSelector(TString& _value, const char* _resourceType)
: value(_value)
{
this->resourceType = _resourceType;
}
};
struct ResourceSelectorWithId
: IResourceSelector
{
string& value;
int id;
const char* GetValue() const { return value.c_str(); }
void SetValue(const char* s) { value = s; }
int GetId() const { return id; }
const void* GetHandle() const { return &value; }
Serialization::TypeID GetType() const { return Serialization::TypeID::get<string>(); }
ResourceSelectorWithId(string& _value, const char* _resourceType, int _id)
: value(_value)
, id(_id)
{
this->resourceType = _resourceType;
}
};
template<class T>
bool Serialize(IArchive& ar, ResourceSelector<T>& value, const char* name, const char* label)
{
if (ar.IsEdit())
{
return ar(Serialization::SStruct::ForEdit(static_cast<IResourceSelector&>(value)), name, label);
}
else
{
return ar(value.value, name, label);
}
}
inline bool Serialize(IArchive& ar, ResourceSelectorWithId& value, const char* name, const char* label)
{
if (ar.IsEdit())
{
return ar(Serialization::SStruct::ForEdit(static_cast<IResourceSelector&>(value)), name, label);
}
else
{
return ar(value.value, name, label);
}
}
}
Code/CryEngine/CryCommon/Serialization/Decorators/Resources.h
-67
View File
@@ -1,67 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_RESOURCES_H
#define CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_RESOURCES_H
#pragma once
#include "ResourceSelector.h"
namespace Serialization
{
// animation resources
template<class T>
ResourceSelector<T> AnimationAlias(T& s) { return ResourceSelector<T>(s, "AnimationAlias"); } // "name" from animation set
template<class T>
ResourceSelector<T> AnimationPath(T& s) { return ResourceSelector<T>(s, "Animation"); }
inline ResourceSelectorWithId AnimationPathWithId(string& s, int id) { return ResourceSelectorWithId(s, "Animation", id); }
template<class T>
ResourceSelector<T> CharacterPath(T& s) { return ResourceSelector<T>(s, "Character"); }
template<class T>
ResourceSelector<T> CharacterPhysicsPath(T& s) { return ResourceSelector<T>(s, "CharacterPhysics"); }
template<class T>
ResourceSelector<T> CharacterRigPath(T& s) { return ResourceSelector<T>(s, "CharacterRig"); }
template<class T>
ResourceSelector<T> SkeletonPath(T& s) { return ResourceSelector<T>(s, "Skeleton"); }
template<class T>
ResourceSelector<T> SkeletonParamsPath(T& s) { return ResourceSelector<T>(s, "SkeletonParams"); } // CHRParams
template<class T>
ResourceSelector<T> JointName(T& s) { return ResourceSelector<T>(s, "Joint"); }
template<class T>
ResourceSelector<T> AttachmentName(T& s) { return ResourceSelector<T>(s, "Attachment"); }
// miscelaneous resources
template<class T>
ResourceSelector<T> SoundName(T& s) { return ResourceSelector<T>(s, "Sound"); }
template<class T>
ResourceSelector<T> DialogName(T& s) { return ResourceSelector<T>(s, "Dialog"); }
template<class T>
ResourceSelector<T> ForceFeedbackIdName(T& s) { return ResourceSelector<T>(s, "ForceFeedbackId"); }
template<class T>
ResourceSelector<T> ModelFilename(T& s) { return ResourceSelector<T>(s, "Model"); }
template<class T>
ResourceSelector<T> ParticleName(T& s) { return ResourceSelector<T>(s, "Particle"); }
namespace Decorators
{
// Decorators namespace is obsolete now, SHOULD NOT BE USED.
template<class T>
ResourceSelector<T> AnimationName(T& s) { return ResourceSelector<T>(s, "Animation"); }
using Serialization::SoundName;
using Serialization::AttachmentName;
template<class T>
ResourceSelector<T> ObjectFilename(T& s) { return ResourceSelector<T>(s, "Model"); }
using Serialization::JointName;
using Serialization::ForceFeedbackIdName;
}
}
#endif // CRYINCLUDE_CRYCOMMON_SERIALIZATION_DECORATORS_RESOURCES_H

Some files were not shown because too many files have changed in this diff Show More