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

Merge branch 'aws-lumberyard:main' into cherry-pick_fix_ATOM14976_to_main

Browse Source
main
Jonny Galloway 5 years ago
parent 7d230dc80e 749ffcfff2
commit 275fbc714d
475 changed files with 5047 additions and 43187 deletions
Show Stats Download Patch File Download Diff File

3
AutomatedTesting/Assets/BadAssets/three_same_named_nodes.fbx
Unescape Escape View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:45b58009dc2f9340e08cafd5e68f142d15d77e19e7cef142933f2dff3cfb9293
size 38352

525
Code/CryEngine/CryCommon/AABBSV.h
Unescape Escape View File

@ -1,525 +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 : shadow volume AABB functionality for overlap testings
#ifndef CRYINCLUDE_CRYCOMMON_AABBSV_H
#define CRYINCLUDE_CRYCOMMON_AABBSV_H
#pragma once
#include "Cry_Geo.h"
struct Shadowvolume
{
uint32 sideamount;
uint32 nplanes;
Plane oplanes[10];
};
namespace NAABB_SV
{
//***************************************************************************************
//***************************************************************************************
//*** Calculate a ShadowVolume using an AABB and a point-light ***
//***************************************************************************************
//*** The planes of the AABB facing away from the point-light are the far-planes ***
//*** of the ShadowVolume. There can be 3-6 far-planes. ***
//***************************************************************************************
void AABB_ReceiverShadowVolume(const Vec3& PointLight, const AABB& Occluder, Shadowvolume& sv);
//***************************************************************************************
//***************************************************************************************
//*** Calculate a ShadowVolume using an AABB and a point-light ***
//***************************************************************************************
//*** The planes of the AABB facing the point-light are the near-planes of the ***
//*** the ShadowVolume. There can be 1-3 near-planes. ***
//*** The far-plane is defined by lightrange. ***
//***************************************************************************************
void AABB_ShadowVolume(const Vec3& PointLight, const AABB& Occluder, Shadowvolume& sv, f32 lightrange);
//***************************************************************************************
//*** this is the "fast" version to check if an AABB is overlapping a shadowvolume ***
//***************************************************************************************
bool Is_AABB_In_ShadowVolume(const Shadowvolume& sv, const AABB& Receiver);
//***************************************************************************************
//*** this is the "hierarchical" check ***
//***************************************************************************************
char Is_AABB_In_ShadowVolume_hierarchical(const Shadowvolume& sv, const AABB& Receiver);
}
inline void NAABB_SV::AABB_ReceiverShadowVolume(const Vec3& PointLight, const AABB& Occluder, Shadowvolume& sv)
{
sv.sideamount = 0;
sv.nplanes = 0;
//------------------------------------------------------------------------------
//-- check if PointLight is in front of any occluder plane or inside occluder --
//------------------------------------------------------------------------------
uint32 front = 0;
if (PointLight.x < Occluder.min.x)
{
front |= 0x01;
}
if (PointLight.x > Occluder.max.x)
{
front |= 0x02;
}
if (PointLight.y < Occluder.min.y)
{
front |= 0x04;
}
if (PointLight.y > Occluder.max.y)
{
front |= 0x08;
}
if (PointLight.z < Occluder.min.z)
{
front |= 0x10;
}
if (PointLight.z > Occluder.max.z)
{
front |= 0x20;
}
sv.sideamount = BoxSides[(front << 3) + 7];
uint32 back = front ^ 0x3f;
if (back & 0x01)
{
sv.oplanes[sv.nplanes].SetPlane(Vec3(-1, +0, +0), Occluder.min);
sv.nplanes++;
}
if (back & 0x02)
{
sv.oplanes[sv.nplanes].SetPlane(Vec3(+1, +0, +0), Occluder.max);
sv.nplanes++;
}
if (back & 0x04)
{
sv.oplanes[sv.nplanes].SetPlane(Vec3(+0, -1, +0), Occluder.min);
sv.nplanes++;
}
if (back & 0x08)
{
sv.oplanes[sv.nplanes].SetPlane(Vec3(+0, +1, +0), Occluder.max);
sv.nplanes++;
}
if (back & 0x10)
{
sv.oplanes[sv.nplanes].SetPlane(Vec3(+0, +0, -1), Occluder.min);
sv.nplanes++;
}
if (back & 0x20)
{
sv.oplanes[sv.nplanes].SetPlane(Vec3(+0, +0, +1), Occluder.max);
sv.nplanes++;
}
if (front == 0)
{
return; //light is inside occluder
}
//all 8 vertices of a AABB
Vec3 o[8] =
{
Vec3(Occluder.min.x, Occluder.min.y, Occluder.min.z),
Vec3(Occluder.max.x, Occluder.min.y, Occluder.min.z),
Vec3(Occluder.min.x, Occluder.max.y, Occluder.min.z),
Vec3(Occluder.max.x, Occluder.max.y, Occluder.min.z),
Vec3(Occluder.min.x, Occluder.min.y, Occluder.max.z),
Vec3(Occluder.max.x, Occluder.min.y, Occluder.max.z),
Vec3(Occluder.min.x, Occluder.max.y, Occluder.max.z),
Vec3(Occluder.max.x, Occluder.max.y, Occluder.max.z)
};
//---------------------------------------------------------------------
//--- find the silhouette-vertices of the occluder-AABB ---
//---------------------------------------------------------------------
uint32 p0 = BoxSides[(front << 3) + 0];
uint32 p1 = BoxSides[(front << 3) + 1];
uint32 p2 = BoxSides[(front << 3) + 2];
uint32 p3 = BoxSides[(front << 3) + 3];
uint32 p4 = BoxSides[(front << 3) + 4];
uint32 p5 = BoxSides[(front << 3) + 5];
float a;
if (sv.sideamount == 4)
{
//sv.oplanes[sv.nplanes+0] = Plane::CreatePlane( o[p0],o[p1], PointLight );
//sv.oplanes[sv.nplanes+1] = Plane::CreatePlane( o[p1],o[p2], PointLight );
//sv.oplanes[sv.nplanes+2] = Plane::CreatePlane( o[p2],o[p3], PointLight );
//sv.oplanes[sv.nplanes+3] = Plane::CreatePlane( o[p3],o[p0], PointLight );
sv.sideamount = 0;
a = (o[p1] - o[p0]) | (o[p0] - PointLight);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p0], o[p1], PointLight);
sv.sideamount++;
}
a = (o[p2] - o[p1]) | (o[p1] - PointLight);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p1], o[p2], PointLight);
sv.sideamount++;
}
a = (o[p3] - o[p2]) | (o[p2] - PointLight);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p2], o[p3], PointLight);
sv.sideamount++;
}
a = (o[p0] - o[p3]) | (o[p3] - PointLight);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p3], o[p0], PointLight);
sv.sideamount++;
}
}
if (sv.sideamount == 6)
{
//sv.oplanes[sv.nplanes+0] = Plane::CreatePlane( o[p0],o[p1], PointLight );
//sv.oplanes[sv.nplanes+1] = Plane::CreatePlane( o[p1],o[p2], PointLight );
//sv.oplanes[sv.nplanes+2] = Plane::CreatePlane( o[p2],o[p3], PointLight );
//sv.oplanes[sv.nplanes+3] = Plane::CreatePlane( o[p3],o[p4], PointLight );
//sv.oplanes[sv.nplanes+4] = Plane::CreatePlane( o[p4],o[p5], PointLight );
//sv.oplanes[sv.nplanes+5] = Plane::CreatePlane( o[p5],o[p0], PointLight );
sv.sideamount = 0;
a = (o[p1] - o[p0]) | (o[p0] - PointLight);
assert(sv.nplanes + sv.sideamount < 10);
PREFAST_ASSUME(sv.nplanes + sv.sideamount < 10);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p0], o[p1], PointLight);
sv.sideamount++;
}
a = (o[p2] - o[p1]) | (o[p1] - PointLight);
assert(sv.nplanes + sv.sideamount < 10);
PREFAST_ASSUME(sv.nplanes + sv.sideamount < 10);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p1], o[p2], PointLight);
sv.sideamount++;
}
a = (o[p3] - o[p2]) | (o[p2] - PointLight);
assert(sv.nplanes + sv.sideamount < 10);
PREFAST_ASSUME(sv.nplanes + sv.sideamount < 10);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p2], o[p3], PointLight);
sv.sideamount++;
}
a = (o[p4] - o[p3]) | (o[p3] - PointLight);
assert(sv.nplanes + sv.sideamount < 10);
PREFAST_ASSUME(sv.nplanes + sv.sideamount < 10);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p3], o[p4], PointLight);
sv.sideamount++;
}
a = (o[p5] - o[p4]) | (o[p4] - PointLight);
assert(sv.nplanes + sv.sideamount < 10);
PREFAST_ASSUME(sv.nplanes + sv.sideamount < 10);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p4], o[p5], PointLight);
sv.sideamount++;
}
a = (o[p0] - o[p5]) | (o[p5] - PointLight);
assert(sv.nplanes + sv.sideamount < 10);
PREFAST_ASSUME(sv.nplanes + sv.sideamount < 10);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p5], o[p0], PointLight);
sv.sideamount++;
}
}
}
inline void NAABB_SV::AABB_ShadowVolume(const Vec3& PointLight, const AABB& Occluder, Shadowvolume& sv, f32 lightrange)
{
sv.sideamount = 0;
sv.nplanes = 0;
//------------------------------------------------------------------------------
//-- check if PointLight is in front of any occluder plane or inside occluder --
//------------------------------------------------------------------------------
uint32 front = 0;
if (PointLight.x < Occluder.min.x)
{
front |= 0x01;
}
if (PointLight.x > Occluder.max.x)
{
front |= 0x02;
}
if (PointLight.y < Occluder.min.y)
{
front |= 0x04;
}
if (PointLight.y > Occluder.max.y)
{
front |= 0x08;
}
if (PointLight.z < Occluder.min.z)
{
front |= 0x10;
}
if (PointLight.z > Occluder.max.z)
{
front |= 0x20;
}
if (front == 0)
{
return; //light is inside occluder
}
sv.sideamount = BoxSides[(front << 3) + 7];
if (front & 0x01)
{
sv.oplanes[sv.nplanes].SetPlane(Vec3(-1, +0, +0), Occluder.min);
sv.nplanes++;
}
if (front & 0x02)
{
sv.oplanes[sv.nplanes].SetPlane(Vec3(+1, +0, +0), Occluder.max);
sv.nplanes++;
}
if (front & 0x04)
{
sv.oplanes[sv.nplanes].SetPlane(Vec3(+0, -1, +0), Occluder.min);
sv.nplanes++;
}
if (front & 0x08)
{
sv.oplanes[sv.nplanes].SetPlane(Vec3(+0, +1, +0), Occluder.max);
sv.nplanes++;
}
if (front & 0x10)
{
sv.oplanes[sv.nplanes].SetPlane(Vec3(+0, +0, -1), Occluder.min);
sv.nplanes++;
}
if (front & 0x20)
{
sv.oplanes[sv.nplanes].SetPlane(Vec3(+0, +0, +1), Occluder.max);
sv.nplanes++;
}
//all 8 vertices of a AABB
Vec3 o[8] =
{
Vec3(Occluder.min.x, Occluder.min.y, Occluder.min.z),
Vec3(Occluder.max.x, Occluder.min.y, Occluder.min.z),
Vec3(Occluder.min.x, Occluder.max.y, Occluder.min.z),
Vec3(Occluder.max.x, Occluder.max.y, Occluder.min.z),
Vec3(Occluder.min.x, Occluder.min.y, Occluder.max.z),
Vec3(Occluder.max.x, Occluder.min.y, Occluder.max.z),
Vec3(Occluder.min.x, Occluder.max.y, Occluder.max.z),
Vec3(Occluder.max.x, Occluder.max.y, Occluder.max.z)
};
//---------------------------------------------------------------------
//--- find the silhouette-vertices of the occluder-AABB ---
//---------------------------------------------------------------------
uint32 p0 = BoxSides[(front << 3) + 0];
uint32 p1 = BoxSides[(front << 3) + 1];
uint32 p2 = BoxSides[(front << 3) + 2];
uint32 p3 = BoxSides[(front << 3) + 3];
uint32 p4 = BoxSides[(front << 3) + 4];
uint32 p5 = BoxSides[(front << 3) + 5];
//the new center-position in world-space
Vec3 MiddleOfOccluder = (Occluder.max + Occluder.min) * 0.5f;
sv.oplanes[sv.nplanes] = Plane::CreatePlane((MiddleOfOccluder - PointLight).GetNormalized(), (MiddleOfOccluder - PointLight).GetNormalized() * lightrange + PointLight);
sv.nplanes++;
float a;
if (sv.sideamount == 4)
{
sv.sideamount = 0;
a = (o[p1] - o[p0]) | (o[p0] - PointLight);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p0], o[p1], PointLight);
sv.sideamount++;
}
a = (o[p2] - o[p1]) | (o[p1] - PointLight);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p1], o[p2], PointLight);
sv.sideamount++;
}
a = (o[p3] - o[p2]) | (o[p2] - PointLight);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p2], o[p3], PointLight);
sv.sideamount++;
}
a = (o[p0] - o[p3]) | (o[p3] - PointLight);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p3], o[p0], PointLight);
sv.sideamount++;
}
}
if (sv.sideamount == 6)
{
sv.sideamount = 0;
a = (o[p1] - o[p0]) | (o[p0] - PointLight);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p0], o[p1], PointLight);
sv.sideamount++;
}
a = (o[p2] - o[p1]) | (o[p1] - PointLight);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p1], o[p2], PointLight);
sv.sideamount++;
}
a = (o[p3] - o[p2]) | (o[p2] - PointLight);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p2], o[p3], PointLight);
sv.sideamount++;
}
a = (o[p4] - o[p3]) | (o[p3] - PointLight);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p3], o[p4], PointLight);
sv.sideamount++;
}
a = (o[p5] - o[p4]) | (o[p4] - PointLight);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p4], o[p5], PointLight);
sv.sideamount++;
}
a = (o[p0] - o[p5]) | (o[p5] - PointLight);
if (a)
{
sv.oplanes[sv.nplanes + sv.sideamount] = Plane::CreatePlane(o[p5], o[p0], PointLight);
sv.sideamount++;
}
}
}
inline bool NAABB_SV::Is_AABB_In_ShadowVolume(const Shadowvolume& sv, const AABB& Receiver)
{
uint32 pa = sv.sideamount + sv.nplanes;
f32 d;
const Vec3* pAABB = &Receiver.min;
union f32_u
{
float floatVal;
uint32 uintVal;
};
//------------------------------------------------------------------------------
//---- check if receiver-AABB is in front of any of these planes ------
//------------------------------------------------------------------------------
for (uint32 x = 0; x < pa; x++)
{
d = sv.oplanes[x].d;
//avoid breaking strict aliasing rules
f32_u ux;
ux.floatVal = sv.oplanes[x].n.x;
f32_u uy;
uy.floatVal = sv.oplanes[x].n.y;
f32_u uz;
uz.floatVal = sv.oplanes[x].n.z;
const uint32 bitX = ux.uintVal >> 31;
const uint32 bitY = uy.uintVal >> 31;
const uint32 bitZ = uz.uintVal >> 31;
d += sv.oplanes[x].n.x * pAABB[bitX].x;
d += sv.oplanes[x].n.y * pAABB[bitY].y;
d += sv.oplanes[x].n.z * pAABB[bitZ].z;
if (d > 0)
{
return CULL_EXCLUSION;
}
}
return CULL_OVERLAP;
}
inline char NAABB_SV::Is_AABB_In_ShadowVolume_hierarchical(const Shadowvolume& sv, const AABB& Receiver)
{
uint32 pa = sv.sideamount + sv.nplanes;
const Vec3* pAABB = &Receiver.min;
f32 dot1, dot2;
uint32 notOverlap = 0x80000000; // will be reset to 0 if there's at least one overlapping
union f32_u
{
float floatVal;
uint32 uintVal;
};
//------------------------------------------------------------------------------
//---- check if receiver-AABB is in front of any of these planes ------
//------------------------------------------------------------------------------
for (uint32 x = 0; x < pa; x++)
{
dot1 = dot2 = sv.oplanes[x].d;
//avoid breaking strict aliasing rules
f32_u ux;
ux.floatVal = sv.oplanes[x].n.x;
f32_u uy;
uy.floatVal = sv.oplanes[x].n.y;
f32_u uz;
uz.floatVal = sv.oplanes[x].n.z;
const uint32 bitX = ux.uintVal >> 31;
const uint32 bitY = uy.uintVal >> 31;
const uint32 bitZ = uz.uintVal >> 31;
dot1 += sv.oplanes[x].n.x * pAABB[0 + bitX].x;
dot2 += sv.oplanes[x].n.x * pAABB[1 - bitX].x;
dot1 += sv.oplanes[x].n.y * pAABB[0 + bitY].y;
dot2 += sv.oplanes[x].n.y * pAABB[1 - bitY].y;
dot1 += sv.oplanes[x].n.z * pAABB[0 + bitZ].z;
dot2 += sv.oplanes[x].n.z * pAABB[1 - bitZ].z;
PREFAST_SUPPRESS_WARNING(6001) f32_u d;
d.floatVal = dot1;
if (!(d.uintVal & 0x80000000))
{
return CULL_EXCLUSION;
}
PREFAST_SUPPRESS_WARNING(6001) f32_u d2;
d2.floatVal = dot2;
notOverlap &= d2.uintVal;
}
if (notOverlap)
{
return CULL_INCLUSION;
}
return CULL_OVERLAP;
}
#endif // CRYINCLUDE_CRYCOMMON_AABBSV_H

74
Code/CryEngine/CryCommon/Algorithm.h
Unescape Escape 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.
*
*/
#ifndef CRYINCLUDE_CRYCOMMON_ALGORITHM_H
#define CRYINCLUDE_CRYCOMMON_ALGORITHM_H
#pragma once
//short hand for using stl algorithms. same syntax (from users perspective) of c++17 range library. Only the shorthand algorithms from range library(N4128) though.
//Not all algorithms are covered. Add any as you need them. It would be a fair amount of work to add them all, so I'm just adding them as needed.
//Note Android doesn't have non member cbegin and cend yet.
#include <algorithm>
#include <numeric>
#include <iterator>
namespace std17
{
template<typename Container, typename Callable>
void for_each(const Container& con, Callable callable)
{
std::for_each(begin(con), end(con), callable);
}
template<typename Container, typename UnaryPredicate>
bool any_of(const Container& con, UnaryPredicate pred)
{
return std::any_of(begin(con), end(con), pred);
}
template<typename Container, typename UnaryPredicate>
bool all_of(const Container& con, UnaryPredicate pred)
{
return std::all_of(begin(con), end(con), pred);
}
template<typename Container, typename UnaryPredicate>
bool none_of(const Container& con, UnaryPredicate pred)
{
return std::none_of(begin(con), end(con), pred);
}
template<typename Container, typename UnaryPredicate>
typename Container::iterator find_if(Container& con, UnaryPredicate pred)
{
return std::find_if(begin(con), end(con), pred);
}
template <typename Container, typename T>
T accumulate(const Container& con, T init)
{
return std::accumulate(begin(con), end(con), init);
}
template <typename Container, typename T, class BinaryOperation>
T accumulate(const Container& con, T init, BinaryOperation binary_op)
{
return std::accumulate(begin(con), end(con), init, binary_op);
}
template <typename Container, typename UnaryPredicate>
auto count_if(const Container&con, UnaryPredicate pred)->decltype(std::count_if(begin(con), end(con), pred))
{
return std::count_if(begin(con), end(con), pred);
}
}
#endif // CRYINCLUDE_CRYCOMMON_ALGORITHM_H

75
Code/CryEngine/CryCommon/Allocator.h
Unescape Escape View File

@ -1,75 +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_ALLOCATOR_H
#define CRYINCLUDE_CRYCOMMON_ALLOCATOR_H
#pragma once
#include "CryMemoryAllocator.h"
////////////////////////////////////////////////////////////////////////
// Allocator default implementation
struct StdAllocator
{
// Class-specific alloc/free/size functions. Use aligned versions only when necessary.
template<class T>
static void* Allocate(T*& p)
{
return p = NeedAlign<T>() ?
(T*)CryModuleMemalign(sizeof(T), alignof(T)) :
(T*)CryModuleMalloc(sizeof(T));
}
template<class T>
static void Deallocate(T* p)
{
if (NeedAlign<T>())
{
CryModuleMemalignFree(p);
}
else
{
CryModuleFree(p);
}
}
template<class T>
static size_t GetMemSize(const T* p)
{
return NeedAlign<T>() ?
sizeof(T) + alignof(T) :
sizeof(T);
}
template<typename T>
void GetMemoryUsage(ICrySizer* pSizer) const { /*nothing*/}
protected:
template<class T>
static bool NeedAlign()
{ PREFAST_SUPPRESS_WARNING(6326); return alignof(T) > _ALIGNMENT; }
};
// Handy delete template function, for any allocator.
template<class TAlloc, class T>
void Delete(TAlloc& alloc, T* ptr)
{
if (ptr)
{
ptr->~T();
alloc.Deallocate(ptr);
}
}
#endif // CRYINCLUDE_CRYCOMMON_ALLOCATOR_H

903
Code/CryEngine/CryCommon/CGFContent.h
Unescape Escape View File

@ -1,903 +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 : Describe contents on CGF file.
#ifndef CRYINCLUDE_CRYCOMMON_CGFCONTENT_H
#define CRYINCLUDE_CRYCOMMON_CGFCONTENT_H
#pragma once
#include <IIndexedMesh.h> // <> required for Interfuscator
#include <IChunkFile.h> // <> required for Interfuscator
#include <CryHeaders.h>
#include <Cry_Color.h>
#include <CryArray.h>
#include <StringUtils.h>
#include <AzCore/Casting/numeric_cast.h>
#include <AzCore/std/containers/unordered_map.h> //Required for LOD support for touch bending vegetation
#include <AzCore/std/string/string.h> //Required for LOD support for touch bending vegetation
const int CGF_NODE_NAME_LENGTH = 64;
//END: Add LOD support for touch bending vegetation
struct CMaterialCGF;
struct IConvertContext;
#define CGF_NODE_NAME_LOD_PREFIX "$lod"
//////////////////////////////////////////////////////////////////////////
// This structure represents CGF node.
//////////////////////////////////////////////////////////////////////////
struct CNodeCGF
: public _cfg_reference_target<CNodeCGF>
{
enum ENodeType
{
NODE_MESH,
NODE_LIGHT,
NODE_HELPER,
};
enum EPhysicalizeFlags
{
ePhysicsalizeFlag_MeshNotNeeded = BIT(2), // When set physics data doesn't need additional Mesh indices or vertices.
ePhysicsalizeFlag_NoBreaking = BIT(3), // node is unsuitable for procedural 3d breaking
};
ENodeType type;
//START: Add LOD support for touch bending vegetation
char name[CGF_NODE_NAME_LENGTH];
//END: Add LOD support for touch bending vegetation
string properties;
Matrix34 localTM; // Local space transformation matrix.
Matrix34 worldTM; // World space transformation matrix.
CNodeCGF* pParent; // Pointer to parent node.
CNodeCGF* pSharedMesh; // Not NULL if this node is sharing mesh and physics from referenced Node.
CMesh* pMesh; // Pointer to mesh loaded for this node. (Only when type == NODE_MESH)
HelperTypes helperType; // Only relevant if type==NODE_HELPER
Vec3 helperSize; // Only relevant if type==NODE_HELPER
CMaterialCGF* pMaterial; // Material node.
// Physical data of the node with mesh.
int nPhysicalizeFlags; // Saved into the nFlags2 chunk member.
AZStd::vector<char> physicalGeomData[4];
int nPhysTriCount; // Not saved! only used for statistics in RC
//////////////////////////////////////////////////////////////////////////
// Used internally.
int nChunkId; // Chunk id as loaded from CGF.
int nParentChunkId; // Chunk id of parent Node.
int nObjectChunkId; // Chunk id of the corresponding mesh.
int pos_cont_id; // position controller chunk id
int rot_cont_id; // rotation controller chunk id
int scl_cont_id; // scale controller chunk id
//////////////////////////////////////////////////////////////////////////
// True if worldTM is identity.
bool bIdentityMatrix;
// True when this node is invisible physics proxy.
bool bPhysicsProxy;
// These values are not saved, but are only used for loading empty mesh chunks.
struct MeshInfo
{
int nVerts;
int nIndices;
int nSubsets;
Vec3 bboxMin;
Vec3 bboxMax;
float fGeometricMean;
};
MeshInfo meshInfo;
CrySkinVtx* pSkinInfo; // for skinning with skeleton meshes (deformable objects)
//////////////////////////////////////////////////////////////////////////
// Constructor.
//////////////////////////////////////////////////////////////////////////
void Init()
{
type = NODE_MESH;
localTM.SetIdentity();
worldTM.SetIdentity();
pParent = 0;
pSharedMesh = 0;
pMesh = 0;
pMaterial = 0;
helperType = HP_POINT;
helperSize.Set(0, 0, 0);
nPhysicalizeFlags = 0;
nChunkId = 0;
nParentChunkId = 0;
nObjectChunkId = 0;
pos_cont_id = rot_cont_id = scl_cont_id = 0;
bIdentityMatrix = true;
bPhysicsProxy = false;
pSkinInfo = 0;
nPhysTriCount = 0;
ZeroStruct(meshInfo);
}
CNodeCGF()
{
Init();
}
explicit CNodeCGF(_cfg_reference_target<CNodeCGF>::DeleteFncPtr pDeleteFnc)
: _cfg_reference_target<CNodeCGF>(pDeleteFnc)
{
Init();
}
~CNodeCGF()
{
if (!pSharedMesh)
{
delete pMesh;
}
if (pSkinInfo)
{
delete[] pSkinInfo;
}
}
};
//////////////////////////////////////////////////////////////////////////
// structures for skinning
//////////////////////////////////////////////////////////////////////////
struct TFace
{
uint16 i0, i1, i2;
TFace() {}
TFace(uint16 v0, uint16 v1, uint16 v2) { i0 = v0; i1 = v1; i2 = v2; }
TFace(const CryFace& face) { i0 = aznumeric_caster(face[0]); i1 = aznumeric_caster(face[1]); i2 = aznumeric_caster(face[2]); }
void operator = (const TFace& f) { i0 = f.i0; i1 = f.i1; i2 = f.i2; }
void GetMemoryUsage([[maybe_unused]] ICrySizer* pSizer) const{}
AUTO_STRUCT_INFO
};
struct PhysicalProxy
{
uint32 ChunkID;
DynArray<Vec3> m_arrPoints;
DynArray<uint16> m_arrIndices;
DynArray<char> m_arrMaterials;
};
struct MorphTargets
{
uint32 MeshID;
string m_strName;
DynArray<SMeshMorphTargetVertex> m_arrIntMorph;
DynArray<SMeshMorphTargetVertex> m_arrExtMorph;
};
typedef MorphTargets* MorphTargetsPtr;
struct IntSkinVertex
{
Vec3 __obsolete0; // thin/fat vertex position. must be removed in the next RC refactoring
Vec3 pos; // vertex-position of model.2
Vec3 __obsolete2; // thin/fat vertex position. must be removed in the next RC refactoring
uint16 boneIDs[4];
f32 weights[4];
ColorB color; //index for blend-array
void GetMemoryUsage([[maybe_unused]] ICrySizer* pSizer) const{}
AUTO_STRUCT_INFO
};
//////////////////////////////////////////////////////////////////////////
// TCB Controller implementation.
//////////////////////////////////////////////////////////////////////////
// retrieves the position and orientation (in the logarithmic space, i.e. instead of quaternion, its logarithm is returned)
// may be optimal for motion interpolation
struct PQLog
{
Vec3 vPos;
Vec3 vRotLog; // logarithm of the rotation
void blendPQ (const PQLog& pqFrom, const PQLog& pqTo, f32 fBlend);
void GetMemoryUsage([[maybe_unused]] ICrySizer* pSizer) const{}
};
struct CControllerType
{
uint16 m_controllertype;
uint16 m_index;
CControllerType()
{
m_controllertype = 0xffff;
m_index = 0xffff;
}
};
struct TCBFlags
{
uint8 f0, f1;
TCBFlags() { f0 = f1 = 0; }
};
struct CStoredSkinningInfo
{
int32 m_nTicksPerFrame;
f32 m_secsPerTick;
int32 m_nStart;
int32 m_nEnd;
f32 m_Speed;
f32 m_Distance;
f32 m_Slope;
int m_nAssetFlags;
f32 m_LHeelStart, m_LHeelEnd;
f32 m_LToe0Start, m_LToe0End;
f32 m_RHeelStart, m_RHeelEnd;
f32 m_RToe0Start, m_RToe0End;
Vec3 m_MoveDirection; // raw storage
CStoredSkinningInfo()
: m_Speed(-1.0f)
, m_Distance(-1.0f)
, m_nAssetFlags(0)
, m_LHeelStart(-10000.0f)
, m_LHeelEnd(-10000.0f)
, m_LToe0Start(-10000.0f)
, m_LToe0End(-10000.0f)
, m_RHeelStart(-10000.0f)
, m_RHeelEnd(-10000.0f)
, m_RToe0Start(-10000.0f)
, m_RToe0End(-10000.0f)
, m_Slope(-1.0f)
{
}
AUTO_STRUCT_INFO
};
// structure for recreating controllers
struct CControllerInfo
{
uint32 m_nControllerID;
uint32 m_nPosKeyTimeTrack;
uint32 m_nPosTrack;
uint32 m_nRotKeyTimeTrack;
uint32 m_nRotTrack;
CControllerInfo()
: m_nControllerID(~0)
, m_nPosKeyTimeTrack(~0)
, m_nPosTrack(~0)
, m_nRotKeyTimeTrack(~0)
, m_nRotTrack(~0) {}
AUTO_STRUCT_INFO
};
struct MeshCollisionInfo
{
AABB m_aABB;
OBB m_OBB;
Vec3 m_Pos;
DynArray<int16> m_arrIndexes;
int32 m_iBoneId;
MeshCollisionInfo()
{
// This didn't help much.
// The BBs are reset to opposite infinites,
// but never clamped/grown by any member points.
m_aABB.min.zero();
m_aABB.max.zero();
m_OBB.m33.SetIdentity();
m_OBB.h.zero();
m_OBB.c.zero();
m_Pos.zero();
}
void GetMemoryUsage(ICrySizer* pSizer) const
{
pSizer->AddObject(m_arrIndexes);
}
};
struct SJointsAimIK_Rot
{
const char* m_strJointName;
int16 m_nJointIdx;
int16 m_nPosIndex;
uint8 m_nPreEvaluate;
uint8 m_nAdditive;
int16 m_nRotJointParentIdx;
SJointsAimIK_Rot()
{
m_strJointName = 0;
m_nJointIdx = -1;
m_nPosIndex = -1;
m_nPreEvaluate = 0;
m_nAdditive = 0;
m_nRotJointParentIdx = -1;
};
void GetMemoryUsage([[maybe_unused]] ICrySizer* pSizer) const{}
};
struct SJointsAimIK_Pos
{
const char* m_strJointName;
int16 m_nJointIdx;
uint8 m_nAdditive;
uint8 m_nEmpty;
SJointsAimIK_Pos()
{
m_strJointName = 0;
m_nJointIdx = -1;
m_nAdditive = 0;
m_nEmpty = 0;
};
void GetMemoryUsage([[maybe_unused]] ICrySizer* pSizer) const{}
};
struct DirectionalBlends
{
string m_AnimToken;
uint32 m_AnimTokenCRC32;
const char* m_strParaJointName;
int16 m_nParaJointIdx;
int16 m_nRotParaJointIdx;
const char* m_strStartJointName;
int16 m_nStartJointIdx;
int16 m_nRotStartJointIdx;
const char* m_strReferenceJointName;
int32 m_nReferenceJointIdx;
DirectionalBlends()
{
m_AnimTokenCRC32 = 0;
m_strParaJointName = 0;
m_nParaJointIdx = -1;
m_nRotParaJointIdx = -1;
m_strStartJointName = 0;
m_nStartJointIdx = -1;
m_nRotStartJointIdx = -1;
m_strReferenceJointName = 0;
m_nReferenceJointIdx = 1; //by default we use the Pelvis
};
void GetMemoryUsage([[maybe_unused]] ICrySizer* pSizer) const {}
};
struct CSkinningInfo
: public _reference_target_t
{
DynArray<CryBoneDescData> m_arrBonesDesc; //animation-bones
DynArray<SJointsAimIK_Rot> m_LookIK_Rot; //rotational joints used for Look-IK
DynArray<SJointsAimIK_Pos> m_LookIK_Pos; //positional joints used for Look-IK
DynArray<DirectionalBlends> m_LookDirBlends; //positional joints used for Look-IK
DynArray<SJointsAimIK_Rot> m_AimIK_Rot; //rotational joints used for Aim-IK
DynArray<SJointsAimIK_Pos> m_AimIK_Pos; //positional joints used for Aim-IK
DynArray<DirectionalBlends> m_AimDirBlends; //positional joints used for Aim-IK
DynArray<PhysicalProxy> m_arrPhyBoneMeshes; //collision proxi
DynArray<MorphTargetsPtr> m_arrMorphTargets;
DynArray<TFace> m_arrIntFaces;
DynArray<IntSkinVertex> m_arrIntVertices;
DynArray<uint16> m_arrExt2IntMap;
DynArray<BONE_ENTITY> m_arrBoneEntities; //physical-bones
DynArray<MeshCollisionInfo> m_arrCollisions;
uint32 m_numChunks{ 0 };
bool m_bRotatedMorphTargets;
bool m_bProperBBoxes;
CSkinningInfo()
: m_bRotatedMorphTargets(false)
, m_bProperBBoxes(false) {}
~CSkinningInfo()
{
for (DynArray<MorphTargetsPtr>::iterator it = m_arrMorphTargets.begin(), end = m_arrMorphTargets.end(); it != end; ++it)
{
delete *it;
}
}
int32 GetJointIDByName(const char* strJointName) const
{
uint32 numJoints = m_arrBonesDesc.size();
for (uint32 i = 0; i < numJoints; i++)
{
if (_stricmp(m_arrBonesDesc[i].m_arrBoneName, strJointName) == 0)
{
return i;
}
}
return -1;
}
// Return name of bone from bone table, return zero id nId is out of range
const char* GetJointNameByID(int32 nJointID) const
{
int32 numJoints = m_arrBonesDesc.size();
if (nJointID >= 0 && nJointID < numJoints)
{
return m_arrBonesDesc[nJointID].m_arrBoneName;
}
return ""; // invalid bone id
}
};
//////////////////////////////////////////////////////////////////////////
// This structure represents Material inside CGF.
//////////////////////////////////////////////////////////////////////////
struct CMaterialCGF
: public _cfg_reference_target<CMaterialCGF>
{
char name[128]; // Material name;
int nFlags; // Material flags.
int nPhysicalizeType;
bool bOldMaterial;
float shOpacity;
// Array of sub materials.
DynArray<CMaterialCGF*> subMaterials;
//////////////////////////////////////////////////////////////////////////
// Used internally.
int nChunkId;
//////////////////////////////////////////////////////////////////////////
void Init()
{
nFlags = 0;
nChunkId = 0;
bOldMaterial = false;
nPhysicalizeType = PHYS_GEOM_TYPE_DEFAULT;
shOpacity = 1.f;
}
CMaterialCGF() { Init(); }
explicit CMaterialCGF(_cfg_reference_target<CMaterialCGF>::DeleteFncPtr pDeleteFnc)
: _cfg_reference_target<CMaterialCGF>(pDeleteFnc)
{ Init(); }
};
//////////////////////////////////////////////////////////////////////////
// Info about physicalization of the CGF.
//////////////////////////////////////////////////////////////////////////
struct CPhysicalizeInfoCGF
{
bool bWeldVertices;
float fWeldTolerance; // Min Distance between vertices when they collapse to single vertex if bWeldVertices enabled.
// breakable physics
int nGranularity;
int nMode;
Vec3* pRetVtx;
int nRetVtx;
int* pRetTets;
int nRetTets;
CPhysicalizeInfoCGF()
: bWeldVertices(true)
, fWeldTolerance(0.01f)
, nMode(-1)
, nGranularity(-1)
, pRetVtx(0)
, nRetVtx(0)
, pRetTets(0)
, nRetTets(0){}
~CPhysicalizeInfoCGF()
{
if (pRetVtx)
{
delete []pRetVtx;
pRetVtx = 0;
}
if (pRetTets)
{
delete []pRetTets;
pRetTets = 0;
}
}
};
//////////////////////////////////////////////////////////////////////////
// Serialized skinnable foliage data
//////////////////////////////////////////////////////////////////////////
#define NODE_PROPERTY_STIFFNESS "stiffness"
#define NODE_PROPERTY_DAMPING "damping"
#define NODE_PROPERTY_THICKNESS "thickness"
struct SSpineRC
{
SSpineRC()
: pVtx(nullptr)
, pSegDim(nullptr)
, nVtx(0)
, len(0)
, pBoneIDs(nullptr)
, parentBoneID(-1)
, pStiffness(nullptr)
, pDamping(nullptr)
, pThickness(nullptr) {}
~SSpineRC()
{
if (pVtx)
{
delete[] pVtx;
}
if (pSegDim)
{
delete[] pSegDim;
}
if (pBoneIDs)
{
delete[] pBoneIDs;
}
if (pStiffness)
{
delete[] pStiffness;
}
if (pDamping)
{
delete[] pDamping;
}
if (pThickness)
{
delete[] pThickness;
}
}
/// Add Skinned Geometry (.CGF) export type (for touch bending vegetation)
static float GetDefaultStiffness() { return 0.5f; }
static float GetDefaultDamping() { return 0.5f; }
static float GetDefaultThickness() { return 0.03f; }
Vec3* pVtx;
Vec4* pSegDim;
int nVtx;
float len;
Vec3 navg;
int parentBoneID;
int* pBoneIDs;
//Per Bone parameters.
float* pStiffness;
float* pDamping;
float* pThickness;
int iAttachSpine;
int iAttachSeg;
};
struct SFoliageInfoCGF
{
SFoliageInfoCGF() { nSpines = 0; pSpines = 0; pBoneMapping = 0; }
~SFoliageInfoCGF()
{
if (pSpines)
{
for (int i = 1; i < nSpines; i++) // spines 1..n-1 use the same buffer, so make sure they don't delete it
{
pSpines[i].pVtx = nullptr;
pSpines[i].pSegDim = nullptr;
pSpines[i].pBoneIDs = nullptr;
pSpines[i].pStiffness = nullptr;
pSpines[i].pDamping = nullptr;
pSpines[i].pThickness = nullptr;
}
delete[] pSpines;
}
SAFE_DELETE_ARRAY(pBoneMapping);
AZStd::unordered_map<AZStd::string, SMeshBoneMappingInfo_uint8*>::iterator iter = boneMappings.begin();
while (iter != boneMappings.end())
{
if (iter->second != nullptr)
{
SAFE_DELETE_ARRAY(iter->second->pBoneMapping);
}
iter++;
}
}
SSpineRC* pSpines;
int nSpines;
///Bone mappings for each LOD level
AZStd::unordered_map<AZStd::string, SMeshBoneMappingInfo_uint8*> boneMappings;
///Bone mapping for legacy format
struct SMeshBoneMapping_uint8* pBoneMapping;
int nSkinnedVtx;
DynArray<uint16> chunkBoneIds;
};
//////////////////////////////////////////////////////////////////////////
struct CExportInfoCGF
{
bool bMergeAllNodes;
bool bUseCustomNormals;
bool bCompiledCGF;
bool bHavePhysicsProxy;
bool bHaveAutoLods;
bool bNoMesh;
bool bWantF32Vertices;
bool b8WeightsPerVertex;
/// Prevent reprocessing skinning data for skinned CGF
bool bSkinnedCGF;
bool bFromColladaXSI;
bool bFromColladaMAX;
bool bFromColladaMAYA;
unsigned int rc_version[4]; // Resource compiler version.
char rc_version_string[16]; // Version as a string.
unsigned int authorToolVersion;
};
//////////////////////////////////////////////////////////////////////////
// This class contain all info loaded from the CGF file.
//////////////////////////////////////////////////////////////////////////
class CContentCGF
{
public:
//////////////////////////////////////////////////////////////////////////
CContentCGF(const char* filename)
{
azstrcpy(m_filename, AZ_ARRAY_SIZE(m_filename), filename);
memset(&m_exportInfo, 0, sizeof(m_exportInfo));
m_exportInfo.bMergeAllNodes = true;
m_exportInfo.bUseCustomNormals = false;
m_exportInfo.bWantF32Vertices = false;
m_exportInfo.b8WeightsPerVertex = false;
m_exportInfo.bSkinnedCGF = false;
m_pCommonMaterial = 0;
m_bConsoleFormat = false;
m_pOwnChunkFile = 0;
}
//////////////////////////////////////////////////////////////////////////
virtual ~CContentCGF()
{
// Free nodes.
m_nodes.clear();
if (m_pOwnChunkFile)
{
m_pOwnChunkFile->Release();
}
}
//////////////////////////////////////////////////////////////////////////
const char* GetFilename() const
{
return m_filename;
}
void SetFilename(const char* filename)
{
azstrcpy(m_filename, AZ_ARRAY_SIZE(m_filename), filename);
}
//////////////////////////////////////////////////////////////////////////
// Access to CGF nodes.
void AddNode(CNodeCGF* pNode)
{
m_nodes.push_back(pNode);
}
int GetNodeCount() const
{
return m_nodes.size();
}
CNodeCGF* GetNode(int i)
{
return m_nodes[i];
}
const CNodeCGF* GetNode(int i) const
{
return m_nodes[i];
}
void ClearNodes()
{
m_nodes.clear();
}
void RemoveNode(CNodeCGF* pNode)
{
assert(pNode);
for (int i = 0; i < m_nodes.size(); ++i)
{
if (m_nodes[i] == pNode)
{
pNode->pParent = 0;
m_nodes.erase(i);
break;
}
}
}
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// Access to CGF materials.
void AddMaterial(CMaterialCGF* pNode)
{
m_materials.push_back(pNode);
}
int GetMaterialCount() const
{
return m_materials.size();
}
CMaterialCGF* GetMaterial(int i)
{
return m_materials[i];
}
void ClearMaterials()
{
m_materials.clear();
}
CMaterialCGF* GetCommonMaterial() const
{
return m_pCommonMaterial;
}
void SetCommonMaterial(CMaterialCGF* pMtl)
{
m_pCommonMaterial = pMtl;
}
DynArray<int>& GetUsedMaterialIDs()
{
return m_usedMaterialIds;
}
const DynArray<int>& GetUsedMaterialIDs() const
{
return m_usedMaterialIds;
}
//////////////////////////////////////////////////////////////////////////
CPhysicalizeInfoCGF* GetPhysicalizeInfo()
{
return &m_physicsInfo;
}
const CPhysicalizeInfoCGF* GetPhysicalizeInfo() const
{
return &m_physicsInfo;
}
CExportInfoCGF* GetExportInfo()
{
return &m_exportInfo;
}
const CExportInfoCGF* GetExportInfo() const
{
return &m_exportInfo;
}
CSkinningInfo* GetSkinningInfo()
{
return &m_SkinningInfo;
}
const CSkinningInfo* GetSkinningInfo() const
{
return &m_SkinningInfo;
}
SFoliageInfoCGF* GetFoliageInfo()
{
return &m_foliageInfo;
}
bool GetConsoleFormat()
{
return m_bConsoleFormat;
}
bool ValidateMeshes(const char** const ppErrorDescription) const
{
for (int i = 0; i < m_nodes.size(); ++i)
{
const CNodeCGF* const pNode = m_nodes[i];
if (pNode && pNode->pMesh && (!pNode->pMesh->Validate(ppErrorDescription)))
{
return false;
}
}
return true;
}
// Set chunk file that this CGF owns.
void SetChunkFile(IChunkFile* pChunkFile)
{
m_pOwnChunkFile = pChunkFile;
}
public:
bool m_bConsoleFormat;
private:
char m_filename[260];
CSkinningInfo m_SkinningInfo;
DynArray<_smart_ptr<CNodeCGF> > m_nodes;
DynArray<_smart_ptr<CMaterialCGF> > m_materials;
DynArray<int> m_usedMaterialIds;
_smart_ptr<CMaterialCGF> m_pCommonMaterial;
CPhysicalizeInfoCGF m_physicsInfo;
CExportInfoCGF m_exportInfo;
SFoliageInfoCGF m_foliageInfo;
IChunkFile* m_pOwnChunkFile;
};
namespace AZ
{
namespace SceneAPI
{
namespace DataTypes
{
class IAnimationGroup;
}
}
}
// Asset Writer interface for writing CContentCGF content to asset file
struct IAssetWriter
{
virtual ~IAssetWriter()
{
}
virtual bool WriteCGF(CContentCGF* content) = 0;
virtual bool WriteCHR(CContentCGF* content, IConvertContext* convertContext) = 0;
virtual bool WriteSKIN(CContentCGF* content, IConvertContext* convertContext, bool exportMorphTargets) = 0;
};
#endif // CRYINCLUDE_CRYCOMMON_CGFCONTENT_H

68
Code/CryEngine/CryCommon/CGFContent_info.cpp
Unescape Escape View File

@ -1,68 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#include "TypeInfo_impl.h"
#include "CGFContent.h"
STRUCT_INFO_BEGIN(TFace)
STRUCT_VAR_INFO(i0, TYPE_INFO(uint16))
STRUCT_VAR_INFO(i1, TYPE_INFO(uint16))
STRUCT_VAR_INFO(i2, TYPE_INFO(uint16))
STRUCT_INFO_END(TFace)
STRUCT_INFO_BEGIN(IntSkinVertex)
STRUCT_VAR_INFO(__obsolete0, TYPE_INFO(Vec3))
STRUCT_VAR_INFO(pos, TYPE_INFO(Vec3))
STRUCT_VAR_INFO(__obsolete2, TYPE_INFO(Vec3))
STRUCT_VAR_INFO(boneIDs, TYPE_ARRAY(4, TYPE_INFO(uint16)))
STRUCT_VAR_INFO(weights, TYPE_ARRAY(4, TYPE_INFO(f32)))
STRUCT_VAR_INFO(color, TYPE_INFO(ColorB))
STRUCT_INFO_END(IntSkinVertex)
STRUCT_INFO_BEGIN(CStoredSkinningInfo)
STRUCT_VAR_INFO(m_nTicksPerFrame, TYPE_INFO(int32))
STRUCT_VAR_INFO(m_secsPerTick, TYPE_INFO(f32))
STRUCT_VAR_INFO(m_nStart, TYPE_INFO(int32))
STRUCT_VAR_INFO(m_nEnd, TYPE_INFO(int32))
STRUCT_VAR_INFO(m_Speed, TYPE_INFO(f32))
STRUCT_VAR_INFO(m_Distance, TYPE_INFO(f32))
STRUCT_VAR_INFO(m_Slope, TYPE_INFO(f32))
STRUCT_VAR_INFO(m_nAssetFlags, TYPE_INFO(int))
STRUCT_VAR_INFO(m_LHeelStart, TYPE_INFO(f32))
STRUCT_VAR_INFO(m_LHeelEnd, TYPE_INFO(f32))
STRUCT_VAR_INFO(m_LToe0Start, TYPE_INFO(f32))
STRUCT_VAR_INFO(m_LToe0End, TYPE_INFO(f32))
STRUCT_VAR_INFO(m_RHeelStart, TYPE_INFO(f32))
STRUCT_VAR_INFO(m_RHeelEnd, TYPE_INFO(f32))
STRUCT_VAR_INFO(m_RToe0Start, TYPE_INFO(f32))
STRUCT_VAR_INFO(m_RToe0End, TYPE_INFO(f32))
STRUCT_VAR_INFO(m_MoveDirection, TYPE_INFO(Vec3))
STRUCT_INFO_END(CStoredSkinningInfo)
STRUCT_INFO_BEGIN(CControllerInfo)
STRUCT_VAR_INFO(m_nControllerID, TYPE_INFO(uint32))
STRUCT_VAR_INFO(m_nPosKeyTimeTrack, TYPE_INFO(uint32))
STRUCT_VAR_INFO(m_nPosTrack, TYPE_INFO(uint32))
STRUCT_VAR_INFO(m_nRotKeyTimeTrack, TYPE_INFO(uint32))
STRUCT_VAR_INFO(m_nRotTrack, TYPE_INFO(uint32))
STRUCT_INFO_END(CControllerInfo)
STRUCT_INFO_BEGIN(UCol)
STRUCT_VAR_INFO(dcolor, TYPE_INFO(uint32))
STRUCT_INFO_END(UCol)
STRUCT_INFO_BEGIN(SVF_P3S_C4B_T2S)
STRUCT_VAR_INFO(xyz, TYPE_INFO(Vec3f16))
STRUCT_VAR_INFO(color, TYPE_INFO(UCol))
STRUCT_VAR_INFO(st, TYPE_INFO(Vec2f16))
STRUCT_INFO_END(SVF_P3S_C4B_T2S)

77
Code/CryEngine/CryCommon/CountedValue.h
Unescape Escape View File

@ -1,77 +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 : A wrapper that counts the number of times the wrapped object
// has been set This is useful for netserializing an object
// that might be given a new value that s the same as the old value
#ifndef CRYINCLUDE_CRYCOMMON_COUNTEDVALUE_H
#define CRYINCLUDE_CRYCOMMON_COUNTEDVALUE_H
#pragma once
template <typename T>
struct CountedValue
{
public:
CountedValue()
: m_lastProducedId(0)
, m_lastConsumedId(0) {}
typedef uint32 TCountedID;
void SetAndDirty(const T& value)
{
m_value = value;
++m_lastProducedId;
CRY_ASSERT(m_lastProducedId > 0);
}
const T* GetLatestValue()
{
bool bHasNewValue = IsDirty(); // check for dirtiness before updating ids
m_lastConsumedId = m_lastProducedId;
return bHasNewValue ? &m_value : NULL;
}
inline bool IsDirty() const
{
return m_lastProducedId != m_lastConsumedId;
}
const T& Peek() const
{
return m_value;
}
TCountedID GetLatestID() const
{
return m_lastProducedId;
}
// This method should only be used to update the object during serialization!
void UpdateDuringSerializationOnly(const T& value, TCountedID lastProducedId)
{
m_value = value;
m_lastProducedId = lastProducedId;
}
private:
TCountedID m_lastProducedId;
TCountedID m_lastConsumedId;
T m_value;
};
#endif // CRYINCLUDE_CRYCOMMON_COUNTEDVALUE_H

160
Code/CryEngine/CryCommon/CrtDebugStats.h
Unescape Escape View File

@ -1,160 +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.
// support for leak dumping and statistics gathering using vs Crt Debug
// should be included in every DLL below DllMain()
#ifndef CRYINCLUDE_CRYCOMMON_CRTDEBUGSTATS_H
#define CRYINCLUDE_CRYCOMMON_CRTDEBUGSTATS_H
#pragma once
#ifdef WIN32
#ifdef _DEBUG
#include <ILog.h>
#include <ISystem.h> // CryLogAlways
#include <crtdbg.h>
// copied from DBGINT.H (not a public header!)
#define nNoMansLandSize 4
typedef struct _CrtMemBlockHeader
{
struct _CrtMemBlockHeader* pBlockHeaderNext;
struct _CrtMemBlockHeader* pBlockHeaderPrev;
char* szFileName;
int nLine;
size_t nDataSize;
int nBlockUse;
long lRequest;
unsigned char gap[nNoMansLandSize];
/* followed by:
* unsigned char data[nDataSize];
* unsigned char anotherGap[nNoMansLandSize];
*/
} _CrtMemBlockHeader;
struct SFileInfo
{
int blocks;
INT_PTR bytes; //AMD Port
SFileInfo(INT_PTR b) { blocks = 1; bytes = b; }; //AMD Port
};
_CrtMemState lastcheckpoint;
bool checkpointset = false;
extern "C" void __declspec(dllexport) CheckPoint()
{
_CrtMemCheckpoint(&lastcheckpoint);
checkpointset = true;
};
bool pairgreater(const std::pair<string, SFileInfo>& elem1, const std::pair<string, SFileInfo>& elem2)
{
return elem1.second.bytes > elem2.second.bytes;
}
extern "C" void __declspec(dllexport) UsageSummary([[maybe_unused]] ILog * log, char* modulename, int* extras)
{
_CrtMemState state;
if (checkpointset)
{
_CrtMemState recent;
_CrtMemCheckpoint(&recent);
_CrtMemDifference(&state, &lastcheckpoint, &recent);
}
else
{
_CrtMemCheckpoint(&state);
};
INT_PTR numblocks = state.lCounts[_NORMAL_BLOCK]; //AMD Port
INT_PTR totalalloc = state.lSizes[_NORMAL_BLOCK]; //AMD Port
check_convert(extras[0]) = totalalloc;
check_convert(extras[1]) = numblocks;
CryLogAlways("$5---------------------------------------------------------------------------------------------------");
if (!numblocks)
{
CryLogAlways("$3Module %s has no memory in use", modulename);
return;
}
;
CryLogAlways("$5Usage summary for module %s", modulename);
CryLogAlways("%d kbytes (peak %d) in %d objects of %d average bytes\n",
totalalloc / 1024, state.lHighWaterCount / 1024, numblocks, numblocks ? totalalloc / numblocks : 0);
CryLogAlways("%d kbytes allocated over time\n", state.lTotalCount / 1024);
typedef std::map<string, SFileInfo> FileMap;
FileMap fm;
for (_CrtMemBlockHeader* h = state.pBlockHeader; h; h = h->pBlockHeaderNext)
{
if (_BLOCK_TYPE(h->nBlockUse) != _NORMAL_BLOCK)
{
continue;
}
string s = h->szFileName ? h->szFileName : "NO_SOURCE";
if (h->nLine > 0)
{
char buf[16];
sprintf_s(buf, "_%d", h->nLine);
s += buf;
}
FileMap::iterator it = fm.find(s);
if (it != fm.end())
{
(*it).second.blocks++;
(*it).second.bytes += h->nDataSize;
}
else
{
fm.insert(FileMap::value_type(s, SFileInfo(h->nDataSize)));
};
}
;
typedef std::vector< std::pair<string, SFileInfo> > FileVector;
FileVector fv;
for (FileMap::iterator it = fm.begin(); it != fm.end(); ++it)
{
fv.push_back((*it));
}
std::sort(fv.begin(), fv.end(), pairgreater);
for (FileVector::iterator it = fv.begin(); it != fv.end(); ++it)
{
CryLogAlways("%6d kbytes / %6d blocks allocated from %s\n",
(*it).second.bytes / 1024, (*it).second.blocks, (*it).first.c_str());
}
;
};
#endif // _DEBUG
#if !defined(_RELEASE) && !defined(_DLL) && defined(HANDLE)
extern "C" HANDLE _crtheap;
extern "C" HANDLE __declspec(dllexport) GetDLLHeap() {
return _crtheap;
};
#endif
#endif // WIN32
#endif // CRYINCLUDE_CRYCOMMON_CRTDEBUGSTATS_H

153
Code/CryEngine/CryCommon/CryArray.h
Unescape Escape View File

@ -15,7 +15,7 @@
#define CRYINCLUDE_CRYCOMMON_CRYARRAY_H
#pragma once
#include <IGeneralMemoryHeap.h> // <> required for Interfuscator
#include "CryLegacyAllocator.h"
//---------------------------------------------------------------------------
// Convenient iteration macros
@ -91,8 +91,6 @@ Public classes:
Array<T, [I, STORAGE]>
StaticArray<T, nSIZE, [I]>
DynArray<T, [I, STORAGE, ALLOC]>
FastDynArray<T, [I]>
FixedDynArray<T, [I]>
StaticDynArray<T, nSIZE, [I]>
Support classes are placed in namespaces NArray and NAlloc to reduce global name usage.
@ -612,13 +610,6 @@ namespace NAlloc
//---------------------------------------------------------------------------
// Allocators for DynArray.
// No reallocation, for use in FixedDynArray
struct NullAlloc
{
static void* alloc(void* pMem, [[maybe_unused]] size_t& nSize, [[maybe_unused]] size_t nAlign, [[maybe_unused]] bool bSlack = false)
{ return pMem; }
};
// Standard CryModule memory allocation, using aligned versions
struct ModuleAlloc
{
@ -655,128 +646,15 @@ namespace NAlloc
// Standard allocator for DynArray stores a compatibility pointer in the memory
typedef AllocCompatible<ModuleAlloc> StandardAlloc;
// Allocator using specific heaps
struct GeneralHeapAlloc
: ModuleAlloc
{
IGeneralMemoryHeap* m_pHeap;
GeneralHeapAlloc()
: m_pHeap(0) {}
explicit GeneralHeapAlloc(IGeneralMemoryHeap* pHeap)
: m_pHeap(pHeap) {}
void* alloc(void* pMem, size_t& nSize, size_t nAlign, bool bSlack = false) const
{
if (m_pHeap)
{
if (pMem)
{
if (!nSize)
{
// Dealloc
m_pHeap->Free(pMem);
return 0;
}
}
else if (nSize)
{
// Alloc
if (bSlack)
{
nSize = realloc_size(nSize);
}
return m_pHeap->Memalign(nAlign, nSize, "");
}
}
return ModuleAlloc::alloc(pMem, nSize, nAlign, bSlack);
}
};
};
//---------------------------------------------------------------------------
// Storage schemes for dynamic arrays
namespace NArray
{
/*---------------------------------------------------------------------------
// STORAGE prototype for DynArray<T,I,STORAGE>
// Extends ArrayStorage with resizing functionality.
struct DynStorage
{
struct Store<T,I>: ArrayStorage<T,I>::Store
{
I capacity() const;
size_t get_alloc_size() const;
void resize_raw( I new_size, bool allow_slack );
};
};
---------------------------------------------------------------------------*/
//---------------------------------------------------------------------------
// FastDynStorage: STORAGE scheme for DynArray<T,I,STORAGE>.
// Simple extension to ArrayStorage: size & capacity fields are inline, 3 words storage, fast access.
template<class A = NAlloc::StandardAlloc>
struct FastDynStorage
{
template<class T, class I>
struct Store
: private A
, public ArrayStorage::Store<T, I>
{
typedef ArrayStorage::Store<T, I> super_type;
using super_type::m_aElems;
using super_type::m_nCount;
// Construction.
Store()
: m_nCapacity(0)
{
}
Store(const A& a)
: A(a)
, m_nCapacity(0)
{
}
I capacity() const
{ return m_nCapacity; }
size_t get_alloc_size() const
{ return NAlloc::get_alloc_size(*this, m_aElems, capacity() * sizeof(T), alignof(T)); }
void resize_raw(I new_size, bool allow_slack = false)
{
if (allow_slack ? new_size > capacity() : new_size != capacity())
{
m_nCapacity = new_size;
m_aElems = NAlloc::reallocate(static_cast<A&>(*this), m_aElems, m_nCount, m_nCapacity, alignof(T), allow_slack);
}
set_size(new_size);
}
protected:
I m_nCapacity;
void set_size(I new_size)
{
assert(new_size >= 0 && new_size <= capacity());
m_nCount = new_size;
}
};
};
//---------------------------------------------------------------------------
// SmallDynStorage: STORAGE scheme for DynArray<T,I,STORAGE,ALLOC>.
// Array is just a single pointer, size and capacity information stored before the array data.
// Slightly slower than FastDynStorage, optimal for saving space, especially when array likely to be empty.
template<class A = NAlloc::StandardAlloc>
struct SmallDynStorage
@ -1459,35 +1337,6 @@ struct LegacyDynArray
}
};
//---------------------------------------------------------------------------
template<class T, class I = int, class A = NAlloc::StandardAlloc>
struct FastDynArray
: DynArray< T, I, NArray::FastDynStorage<A> >
{
};
template<class T, class I = int>
struct FixedDynArray
: LegacyDynArray< T, I, NArray::FastDynStorage<NAlloc::NullAlloc> >
{
typedef NArray::ArrayStorage::Store<T, I> S;
void set(void* elems, I mem_size)
{
this->m_aElems = (T*)elems;
this->m_nCapacity = mem_size / sizeof(T);
this->m_nCount = 0;
}
void set(Array<T, I> array)
{
this->m_aElems = array.begin();
this->m_nCapacity = array.size();
this->m_nCount = 0;
}
};
template<class T, int nSIZE, class I = int>
struct StaticDynArray
: LegacyDynArray< T, I, NArray::StaticDynStorage<nSIZE> >

19
Code/CryEngine/CryCommon/CryCustomTypes.h
Unescape Escape View File

@ -1207,23 +1207,4 @@ protected:
uint nPrefixLength;
};
// Define an irregular enum with TypeInfo
#define DEFINE_ENUM_VALS(EType, TInt, ...) \
struct EType \
{ \
enum E { __VA_ARGS__ }; \
DEFINE_ENUM_VALUE(EType, E, TInt) \
ILINE static uint Count() { return TypeInfo().Count(); } \
static const CEnumInfo<TInt>& TypeInfo() { \
static char enum_str[] = #__VA_ARGS__; \
static LegacyDynArray<CEnumDef::SElem> Elems; \
CEnumDef::SInit::Init(Elems); \
CEnumDef::SInit __VA_ARGS__; \
static CEnumInfo<TInt> info( #EType, Elems, enum_str); \
return info; \
} \
};
#endif // CRYINCLUDE_CRYCOMMON_CRYCUSTOMTYPES_H

309
Code/CryEngine/CryCommon/CryFixedArray.h
Unescape Escape View File

@ -1,309 +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.
/*
CryFixedArray.h
- no longer support being created on the stack (since the alignment code was changed to support adding CryFixedArrays into stl::vectors)
- performs construction or destruction only on elements as they become live/dead or are moved around during the RemoveAt() reshuffle
- just a range checked equivelant of a standard array
- for now only allows push_back() population of array
- if using as a class member variable ensure to put the CryFixedArrays after all other member variables at the bottom of your class
to ensure all members stay on the same cacheline
*/
#ifndef CRYINCLUDE_CRYCOMMON_CRYFIXEDARRAY_H
#define CRYINCLUDE_CRYCOMMON_CRYFIXEDARRAY_H
#pragma once
#define DEBUG_CRYFIXED_ARRAY _DEBUG
template<
unsigned int align >
struct CryFixedArrayDatum
{
};
template<>
struct CryFixedArrayDatum< 4 >
{
typedef uint32 TDatum;
};
template<>
struct CryFixedArrayDatum< 8 >
{
typedef uint64 TDatum;
};
template <class T, unsigned int N>
class CryFixedArray
{
protected:
enum
{
ALIGN = MAX(alignof(T), sizeof(unsigned int))
}; // ALIGN at least sizeof(unsigned int)
typedef typename CryFixedArrayDatum< ALIGN >::TDatum TDatum;
uint32 m_curSize[ sizeof (TDatum) / sizeof (uint32) ]; // Padded for alignment
TDatum m_data[(N * sizeof(T) + (sizeof(TDatum) - 1)) / sizeof(TDatum)]; // simple debugging - in VS: just add to a watch as "(T*)m_data, <N>" to see the array. ie. "(int*)m_data, 5" - the size of the array has to be a literal int
public:
typedef T* iterator;
typedef const T* const_iterator;
CryFixedArray()
{
#if DEBUG_CRYFIXED_ARRAY
if (((uintptr_t)m_data & (ALIGN - 1)) != 0)
{
CryLogAlways("CryFixedArray() error - data is not aligned. This may happen if you are creating a CryFixedArray on the stack, which isn't supported.");
}
#endif
CRY_ASSERT_MESSAGE(((uintptr_t)m_data & (ALIGN - 1)) == 0, "CryFixedArray() error - data is not aligned. This may happen if you are creating a CryFixedArray on the stack, which isn't supported.");
m_curSize[0] = 0;
}
CryFixedArray(const CryFixedArray& other)
{
// doesn't require clear() this is newly constructed
m_curSize[0] = other.m_curSize[0];
int size = m_curSize[0];
for (int i = 0; i < size; i++)
{
T& ele = operator[](i);
const T& otherEle = other.operator[](i);
new (&ele)T(otherEle); // placement new
}
}
CryFixedArray& operator=(const CryFixedArray& other)
{
if (this != &other)
{
clear(); // necessary to avoid potentially leaking within existing elements
m_curSize[0] = other.m_curSize[0];
int size = m_curSize[0];
for (int i = 0; i < size; i++)
{
T& ele = operator[](i);
const T& otherEle = other.operator[](i);
//ele = otherEle; // assignment instead of placement new to keep type of operation consistent - this cannot be done until this is rewritten to assign over existing elements and deconstruct any left overs, and placement new any new elements
new (&ele)T(otherEle); // placement new
}
}
return *this;
}
virtual ~CryFixedArray()
{
clear();
}
ILINE T& at(unsigned int i)
{
#if DEBUG_CRYFIXED_ARRAY
if (i < size())
{
return alias_cast<T*>(m_data)[i];
}
else
{
// Log is required now as its possible to turn off assert output logging, yet you really want to know if this is happening!!!!
CryLogAlways("CryFixedArray::at(i=%d) failed as i is out of range of curSize=%d (maxSize=%d) - forcing a crash", i, m_curSize[0], N);
CRY_ASSERT_MESSAGE(0, string().Format("CryFixedArray::at(i=%d) failed as i is out of range of curSize=%d (maxSize=%d)", i, m_curSize[0], N));
abort(); // better option than dereferncing a nullptr?
}
#else
return alias_cast<T*>(m_data)[i];
#endif
}
ILINE const T& at(unsigned int i) const
{
#if DEBUG_CRYFIXED_ARRAY
if (i < size())
{
return alias_cast<const T*>(m_data)[i];
}
else
{
// Log is required now as its possible to turn off assert output logging, yet you really want to know if this is happening!!!!
CryLogAlways("CryFixedArray::at(i=%d) failed as i is out of range of curSize=%d (maxSize=%d) - forcing a crash", i, m_curSize[0], N);
CRY_ASSERT_MESSAGE(0, string().Format("CryFixedArray::at(i=%d) failed as i is out of range of curSize=%d (maxSize=%d)", i, m_curSize[0], N));
abort(); // better option than dereferncing a nullptr?
}
#else
return alias_cast<const T*>(m_data)[i];
#endif
}
ILINE const T& operator[](unsigned int i) const
{
return at(i);
}
ILINE T& operator[](unsigned int i)
{
return at(i);
}
ILINE void clear()
{
for (uint32 i = 0; i < m_curSize[0]; i++)
{
T& ele = operator[](i);
ele.~T();
}
m_curSize[0] = 0;
#if DEBUG_CRYFIXED_ARRAY
memset(m_data, 0, N * sizeof(T));
#endif
}
ILINE iterator begin()
{
return alias_cast<T*>(m_data);
}
ILINE const_iterator begin() const
{
return alias_cast<T*>(m_data);
}
ILINE iterator end()
{
return &(alias_cast<T*>(m_data))[m_curSize[0]];
}
ILINE const_iterator end() const
{
return &(alias_cast<T*>(m_data))[m_curSize[0]];
}
ILINE unsigned int max_size() const { return N; }
ILINE unsigned int size() const { return m_curSize[0]; }
ILINE bool empty() const { return size() == 0; }
ILINE unsigned int isfull() const { return (size() == max_size()); }
// allows you to push back default constructed elements
ILINE void push_back ()
{
unsigned int curSize = size();
if (curSize < N)
{
T* newT = &(alias_cast<T*>(m_data))[curSize];
new (newT) T();
m_curSize[0]++;
}
else
{
CryLogAlways("CryFixedArray::push_back() failing as array of size %u is full - NOT adding element", N);
CRY_ASSERT_TRACE(0, ("CryFixedArray::push_back() failing as array of size %u is full - NOT adding element", N));
}
}
ILINE void push_back (const T& ele)
{
unsigned int curSize = size();
if (curSize < N)
{
T* newT = &(alias_cast<T*>(m_data))[curSize];
new (newT) T(ele); // placement new copy constructor - setup vtable etc
m_curSize[0]++;
}
else
{
CryLogAlways("CryFixedArray::push_back() failing as array of size %u is full - NOT adding element", N);
CRY_ASSERT_TRACE(0, ("CryFixedArray::push_back() failing as array of size %u is full - NOT adding element", N));
}
}
ILINE void pop_back()
{
if (size() > 0)
{
back().~T(); // destruct back
m_curSize[0]--;
}
else
{
CryLogAlways("CryFixedArray::pop_back() failed as array is empty");
CRY_ASSERT_MESSAGE(0, "CryFixedArray::pop_back() failed as array is empty");
}
}
protected:
ILINE const T& backEx() const
{
#if DEBUG_CRYFIXED_ARRAY
if (m_curSize[0] > 0)
{
return (alias_cast<T*>(m_data))[m_curSize[0] - 1];
}
else
{
CryLogAlways("CryFixedArray::back() failed as array is empty");
CRY_ASSERT_MESSAGE(0, "CryFixedArray::back() failed as array is empty");
abort(); // better option than dereferncing a nullptr?
}
#else
return (alias_cast<T*>(m_data))[m_curSize[0] - 1];
#endif
}
public:
ILINE const T& back() const
{
return backEx();
}
ILINE T& back()
{
return (T&)(backEx());
}
// if returns true then an element has been swapped into the new element[i] and as such may need updating to reflect its new location in memory
ILINE bool removeAt(uint32 i)
{
bool swappedElement = false;
if (i < m_curSize[0])
{
if (i != m_curSize[0] - 1)
{
operator[](i).~T(); // destruct element being removed
// copy back() into element i
T* newT = &(alias_cast<T*>(m_data))[i];
new (newT) T(back()); // placement new copy constructor - setup vtable etc
swappedElement = true;
}
pop_back(); // will destruct back()
}
else
{
CryLog("CryFixedArray::removeAt() failed as i=%d is out of range of curSize=%d", i, m_curSize[0]);
CRY_ASSERT_MESSAGE(0, string().Format("CryFixedArray::removeAt() failed as i=%d is out of range of curSize=%d", i, m_curSize[0]));
}
return swappedElement;
}
};
#endif // CRYINCLUDE_CRYCOMMON_CRYFIXEDARRAY_H

15
Code/CryEngine/CryCommon/CryFixedString.h
Unescape Escape View File

@ -2019,21 +2019,6 @@ inline CryStackStringT<T, S> CryStackStringT<T, S>::Tokenize(const_str charSet,
return CryStackStringT<T, S>();
}
//////////////////////////////////////////////////////////////////////////
// Specialization providing efficient move semantics for array classes.
template <class T, size_t S>
bool raw_movable(const CryStackStringT<T, S>& str)
{
return false;
}
template <class T, size_t S>
void move_init(CryStackStringT<T, S>& dest, CryStackStringT<T, S>& source)
{
dest.move(source);
}
#if defined(_RELEASE)
#define ASSERT_LEN (void)(0)
#define ASSERT_WLEN (void)(0)

274
Code/CryEngine/CryCommon/CryMemoryAllocator.h
Unescape Escape View File

@ -1,274 +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.
/*
* Part of this code coming from STLPort alloc
*
* Copyright (c) 1996,1997
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1997
* Moscow Center for SPARC Technology
*
* Copyright (c) 1999
* Boris Fomitchev
*
*
*/
#ifndef CRYINCLUDE_CRYCOMMON_CRYMEMORYALLOCATOR_H
#define CRYINCLUDE_CRYCOMMON_CRYMEMORYALLOCATOR_H
#pragma once
#include <algorithm>
#define CRY_STL_ALLOC
#if defined(LINUX64) || defined(APPLE)
#include <sys/mman.h>
#endif
#include <string.h> // memset
// DON't USE _MAX_BYTES as identifier for Max Bytes, STLPORT defines the same enum
// this leads to situation where the wrong enum is choosen in different compilation units
// which in case leads to errors(The stlport one is defined as 128)
#if defined (__OS400__) || defined (_WIN64) || defined(MAC) || defined(LINUX64)
enum {_ALIGNMENT = 16, _ALIGN_SHIFT = 4, __MAX_BYTES = 512, NFREELISTS=32, ADDRESSSPACE = 2 * 1024 * 1024, ADDRESS_SHIFT = 40};
#else
enum {_ALIGNMENT = 8, _ALIGN_SHIFT = 3, __MAX_BYTES = 512, NFREELISTS = 64, ADDRESSSPACE = 2 * 1024 * 1024, ADDRESS_SHIFT = 20};
#endif /* __OS400__ */
#define CRY_MEMORY_ALLOCATOR
#define S_FREELIST_INDEX(__bytes) ((__bytes - size_t(1)) >> (int)_ALIGN_SHIFT)
class _Node_alloc_obj {
public:
_Node_alloc_obj * _M_next;
};
#if defined (_WIN64) || defined(APPLE) || defined(LINUX64)
#define MASK_COUNT 0x000000FFFFFFFFFF
#define MASK_VALUE 0xFFFFFF
#define MASK_NEXT 0xFFFFFFFFFF000000
#define MASK_SHIFT 24
#else
#define MASK_COUNT 0x000FFFFF
#define MASK_VALUE 0xFFF
#define MASK_NEXT 0xFFFFF000
#define MASK_SHIFT 12
#endif
#define NUM_OBJ 64
struct _Obj_Address {
// short int * _M_next;
// short int
size_t GetNext(size_t pBase) {
return pBase +(size_t)(_M_value >> MASK_SHIFT);
}
//size_t GetNext() {
// return (size_t)(_M_value >> 20);
//}
size_t GetCount() {
return _M_value & MASK_VALUE;
}
void SetNext(/*void **/size_t pNext) {
_M_value &= MASK_COUNT;
_M_value |= (size_t)pNext << MASK_SHIFT;
}
void SetCount(size_t count) {
_M_value &= MASK_NEXT;
_M_value |= count & MASK_VALUE;
}
private:
size_t _M_value;
// short int * _M_end;
};
//struct _Node_Allocations_Tree {
// enum { eListSize = _Size / (sizeof(void *) * _Num_obj); };
// _Obj_Address * _M_allocations_list[eListSize];
// int _M_Count;
// _Node_Allocations_Tree * _M_next;
//};
template<int _Size>
struct _Node_Allocations_Tree {
//Pointer to the end of the memory block
char *_M_end;
enum { eListSize = _Size / (sizeof(void *) * NUM_OBJ) };
// List of allocations
_Obj_Address _M_allocations_list[eListSize];
int _M_allocations_count;
//Pointer to the next memory block
_Node_Allocations_Tree *_M_Block_next;
};
struct _Node_alloc_Mem_block_Huge {
//Pointer to the end of the memory block
char *_M_end;
// number
int _M_count;
_Node_alloc_Mem_block_Huge *_M_next;
};
template<int _Size>
struct _Node_alloc_Mem_block {
//Pointer to the end of the memory block
char *_M_end;
//Pointer to the next memory block
_Node_alloc_Mem_block_Huge *_M_huge_block;
_Node_alloc_Mem_block *_M_next;
};
// Allocators!
enum EAllocFreeType
{
eCryDefaultMalloc,
eCryMallocCryFreeCRTCleanup,
};
template <EAllocFreeType type>
struct Node_Allocator
{
inline void * pool_alloc(size_t size)
{
return CryModuleMalloc(size);
};
inline void * cleanup_alloc(size_t size)
{
return CryCrtMalloc(size);
};
inline size_t pool_free(void * ptr)
{
CryModuleFree(ptr);
return 0;
};
inline void cleanup_free(void * ptr)
{
CryCrtFree(ptr);
};
inline size_t getSize(void * ptr)
{
return CryCrtSize(ptr);
}
};
// partial
template <>
struct Node_Allocator<eCryDefaultMalloc>
{
inline void * pool_alloc(size_t size)
{
return CryCrtMalloc(size);
};
inline void * cleanup_alloc(size_t size)
{
return CryCrtMalloc(size);
};
inline size_t pool_free(void * ptr)
{
size_t n = CryCrtSize(ptr);
CryCrtFree(ptr);
return n;
};
inline void cleanup_free(void * ptr)
{
CryCrtFree(ptr);
};
inline size_t getSize(void * ptr)
{
return CryCrtSize(ptr);
}
};
// partial
template <>
struct Node_Allocator<eCryMallocCryFreeCRTCleanup>
{
inline void * pool_alloc(size_t size)
{
return CryCrtMalloc(size);
};
inline void * cleanup_alloc(size_t size)
{
return CryCrtMalloc(size);
};
inline size_t pool_free(void * ptr)
{
return CryCrtFree(ptr);
};
inline void cleanup_free(void * ptr)
{
CryCrtFree(ptr);
};
inline size_t getSize(void * ptr)
{
return CryCrtSize(ptr);
}
};
#include "MultiThread.h"
struct InternalCriticalSectionDummy {
char padding[128];
} ;
inline void CryInternalCreateCriticalSection(void * pCS)
{
CryCreateCriticalSectionInplace(pCS);
}
// A class that forward node allocator calls directly to CRT
struct cry_crt_node_allocator
{
static const size_t MaxSize = ~0;
static void *alloc(size_t __n)
{
return CryCrtMalloc(__n);
}
static size_t dealloc( void *p )
{
return CryCrtFree(p);
}
static void *allocate(size_t __n)
{
return alloc(__n);
}
static void *allocate(size_t __n, [[maybe_unused]] size_t nAlignment)
{
return alloc(__n);
}
static size_t deallocate(void *__p)
{
return dealloc(__p);
}
void cleanup() {}
};
//#endif // WIN32|DEBUG
#endif // CRYINCLUDE_CRYCOMMON_CRYMEMORYALLOCATOR_H

295
Code/CryEngine/CryCommon/CryMemoryManager.h
Unescape Escape View File

@ -1,295 +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 functions for CryEngine custom memory manager.
#pragma once
// Section dictionary
#if defined(AZ_RESTRICTED_PLATFORM)
#define CRYMEMORYMANAGER_H_SECTION_TRAITS 1
#define CRYMEMORYMANAGER_H_SECTION_ALLOCPOLICY 2
#endif
#include <AzCore/PlatformRestrictedFileDef.h>
// Traits
#if defined(AZ_RESTRICTED_PLATFORM)
#define AZ_RESTRICTED_SECTION CRYMEMORYMANAGER_H_SECTION_TRAITS
#include AZ_RESTRICTED_FILE(CryMemoryManager_h)
#else
#if !defined(APPLE)
#define CRYMEMORYMANAGER_H_TRAIT_INCLUDE_MALLOC_H 1
#endif
#if defined(LINUX) || defined(APPLE)
#define CRYMEMORYMANAGER_H_TRAIT_INCLUDE_NEW_NOT_NEW_H 1
#endif
#if !defined(LINUX) && !defined(APPLE)
#define CRYMEMORYMANAGER_H_TRAIT_INCLUDE_CRTDBG_H 1
#endif
#if !defined(APPLE)
#define CRYMEMORYMANAGER_H_TRAIT_USE_CRTCHECKMEMORY 1
#endif
#endif
#include "platform.h"
#include <stdarg.h>
#include <algorithm>
#if defined(APPLE) || defined(ANDROID)
#include <AzCore/Memory/OSAllocator.h> // memalign
#endif // defined(APPLE)
#ifndef STLALLOCATOR_CLEANUP
#define STLALLOCATOR_CLEANUP
#endif
#define _CRY_DEFAULT_MALLOC_ALIGNMENT 4
#if CRYMEMORYMANAGER_H_TRAIT_INCLUDE_MALLOC_H
#include <malloc.h>
#endif
#if defined(__cplusplus)
#if CRYMEMORYMANAGER_H_TRAIT_INCLUDE_NEW_NOT_NEW_H
#include <new>
#else
#include <new.h>
#endif
#endif
#ifdef CRYSYSTEM_EXPORTS
#define CRYMEMORYMANAGER_API DLL_EXPORT
#else
#define CRYMEMORYMANAGER_API DLL_IMPORT
#endif
#ifdef __cplusplus
#if defined(_DEBUG) && CRYMEMORYMANAGER_H_TRAIT_INCLUDE_CRTDBG_H
#include <crtdbg.h>
#endif //_DEBUG
#include "LegacyAllocator.h"
namespace CryMemory
{
// checks if the heap is valid in debug; in release, this function shouldn't be called
// returns non-0 if it's valid and 0 if not valid
ILINE int IsHeapValid()
{
#if (defined(_DEBUG) && !defined(RELEASE_RUNTIME) && CRYMEMORYMANAGER_H_TRAIT_USE_CRTCHECKMEMORY) || (defined(DEBUG_MEMORY_MANAGER))
return _CrtCheckMemory();
#else
return true;
#endif
}
inline void* AllocPages(size_t size)
{
const size_t alignment = AZ_PAGE_SIZE;
void* ret = AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().Allocate(size, alignment, 0, "AllocPages", __FILE__, __LINE__);
return ret;
}
inline void FreePages(void* p, size_t size)
{
const size_t alignment = AZ_PAGE_SIZE;
AZ::AllocatorInstance<AZ::LegacyAllocator>::Get().DeAllocate(p, size, alignment);
}
}
//////////////////////////////////////////////////////////////////////////
#endif //__cplusplus
struct ICustomMemoryHeap;
class IGeneralMemoryHeap;
class IPageMappingHeap;
class IMemoryAddressRange;
// Description:
// Interfaces that allow access to the CryEngine memory manager.
struct IMemoryManager
{
typedef unsigned char HeapHandle;
enum
{
BAD_HEAP_HANDLE = 0xFF
};
struct SProcessMemInfo
{
uint64 PageFaultCount;
uint64 PeakWorkingSetSize;
uint64 WorkingSetSize;
uint64 QuotaPeakPagedPoolUsage;
uint64 QuotaPagedPoolUsage;
uint64 QuotaPeakNonPagedPoolUsage;
uint64 QuotaNonPagedPoolUsage;
uint64 PagefileUsage;
uint64 PeakPagefileUsage;
uint64 TotalPhysicalMemory;
int64 FreePhysicalMemory;
uint64 TotalVideoMemory;
int64 FreeVideoMemory;
};
enum EAllocPolicy
{
eapDefaultAllocator,
eapPageMapped,
eapCustomAlignment,
#if defined(AZ_RESTRICTED_PLATFORM)
#define AZ_RESTRICTED_SECTION CRYMEMORYMANAGER_H_SECTION_ALLOCPOLICY
#include AZ_RESTRICTED_FILE(CryMemoryManager_h)
#endif
};
virtual ~IMemoryManager(){}
virtual bool GetProcessMemInfo(SProcessMemInfo& minfo) = 0;
//////////////////////////////////////////////////////////////////////////
// Heap Tracing API
virtual HeapHandle TraceDefineHeap(const char* heapName, size_t size, const void* pBase) = 0;
virtual void TraceHeapAlloc(HeapHandle heap, void* mem, size_t size, size_t blockSize, const char* sUsage, const char* sNameHint = 0) = 0;
virtual void TraceHeapFree(HeapHandle heap, void* mem, size_t blockSize) = 0;
virtual void TraceHeapSetColor(uint32 color) = 0;
virtual uint32 TraceHeapGetColor() = 0;
virtual void TraceHeapSetLabel(const char* sLabel) = 0;
//////////////////////////////////////////////////////////////////////////
// Create an instance of ICustomMemoryHeap
virtual ICustomMemoryHeap* const CreateCustomMemoryHeapInstance(EAllocPolicy const eAllocPolicy) = 0;
virtual IGeneralMemoryHeap* CreateGeneralExpandingMemoryHeap(size_t upperLimit, size_t reserveSize, const char* sUsage) = 0;
virtual IGeneralMemoryHeap* CreateGeneralMemoryHeap(void* base, size_t sz, const char* sUsage) = 0;
virtual IMemoryAddressRange* ReserveAddressRange(size_t capacity, const char* sName) = 0;
virtual IPageMappingHeap* CreatePageMappingHeap(size_t addressSpace, const char* sName) = 0;
};
// Global function implemented in CryMemoryManager_impl.h
IMemoryManager* CryGetIMemoryManager();
// Summary:
// Structure filled by call to CryModuleGetMemoryInfo().
struct CryModuleMemoryInfo
{
uint64 requested;
// Total Ammount of memory allocated.
uint64 allocated;
// Total Ammount of memory freed.
uint64 freed;
// Total number of memory allocations.
int num_allocations;
// Allocated in CryString.
uint64 CryString_allocated;
// Allocated in STL.
uint64 STL_allocated;
// Amount of memory wasted in pools in stl (not usefull allocations).
uint64 STL_wasted;
};
struct CryReplayInfo
{
uint64 uncompressedLength;
uint64 writtenLength;
uint32 trackingSize;
const char* filename;
};
//////////////////////////////////////////////////////////////////////////
// Extern declarations of globals inside CrySystem.
//////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
extern "C" {
#endif //__cplusplus
void* CryMalloc(size_t size, size_t& allocated, size_t alignment);
void* CryRealloc(void* memblock, size_t size, size_t& allocated, size_t& oldsize, size_t alignment);
size_t CryFree(void* p, size_t alignment);
size_t CryGetMemSize(void* p, size_t size);
int CryStats(char* buf);
void CryFlushAll();
void CryCleanup();
int CryGetUsedHeapSize();
int CryGetWastedHeapSize();
size_t CrySystemCrtGetUsedSpace();
CRYMEMORYMANAGER_API void CryGetIMemoryManagerInterface(void** pIMemoryManager);
#ifdef __cplusplus
}
#endif //__cplusplus
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// Cry Memory Manager accessible in all build modes.
//////////////////////////////////////////////////////////////////////////
#if !defined(USING_CRY_MEMORY_MANAGER)
#define USING_CRY_MEMORY_MANAGER
#endif
#include "CryLegacyAllocator.h"
template<typename T, typename ... Args>
inline T* CryAlignedNew(Args&& ... args)
{
void* pAlignedMemory = CryModuleMemalign(sizeof(T), std::alignment_of<T>::value);
return new(pAlignedMemory) T(std::forward<Args>(args) ...);
}
// This utility function should be used for allocating arrays of objects with specific alignment requirements on the heap.
// Note: The caller must remember the number of items in the array, since CryAlignedDeleteArray needs this information.
template<typename T>
inline T* CryAlignedNewArray(size_t count)
{
T* const pAlignedMemory = reinterpret_cast<T*>(CryModuleMemalign(sizeof(T) * count, std::alignment_of<T>::value));
T* pCurrentItem = pAlignedMemory;
for (size_t i = 0; i < count; ++i, ++pCurrentItem)
{
new(static_cast<void*>(pCurrentItem))T();
}
return pAlignedMemory;
}
// Utility function that frees an object previously allocated with CryAlignedNew.
template<typename T>
inline void CryAlignedDelete(T* pObject)
{
if (pObject)
{
pObject->~T();
CryModuleMemalignFree(pObject);
}
}
// Utility function that frees an array of objects previously allocated with CryAlignedNewArray.
// The same count used to allocate the array must be passed to this function.
template<typename T>
inline void CryAlignedDeleteArray(T* pObject, size_t count)
{
if (pObject)
{
for (size_t i = 0; i < count; ++i)
{
(pObject + i)->~T();
}
CryModuleMemalignFree(pObject);
}
}

41
Code/CryEngine/CryCommon/CryMemoryManager_impl.h
Unescape Escape 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 : Provides implementation for CryMemoryManager globally defined functions.
// This file included only by platform_impl.cpp, do not include it directly in code!
#pragma once
#ifdef AZ_MONOLITHIC_BUILD
#include <ISystem.h> // <> required for Interfuscator
#endif // AZ_MONOLITHIC_BUILD
#include "CryLibrary.h"
#include <AzCore/Module/Environment.h>
#define DLL_ENTRY_GETMEMMANAGER "CryGetIMemoryManagerInterface"
// Resolve IMemoryManager by looking in this DLL, then loading and rummaging through
// CrySystem. Cache the result per DLL, because this is not quick.
IMemoryManager* CryGetIMemoryManager()
{
static AZ::EnvironmentVariable<IMemoryManager*> memMan = nullptr;
if (!memMan)
{
memMan = AZ::Environment::FindVariable<IMemoryManager*>("CryIMemoryManagerInterface");
AZ_Assert(memMan, "Unable to find CryIMemoryManagerInterface via AZ::Environment");
}
return *memMan;
}

1
Code/CryEngine/CryCommon/CryName.h
Unescape Escape View File

@ -19,7 +19,6 @@
#include <StlUtils.h>
#include <CrySizer.h>
#include <CryCrc32.h>
#include <STLGlobalAllocator.h>
#include <AzCore/std/containers/unordered_map.h>
class CNameTable;

21
Code/CryEngine/CryCommon/CrySizer.h
Unescape Escape View File

@ -48,8 +48,6 @@ struct SPipTangents;
#include <string.h> // workaround for Amd64 compiler
#endif
#include <IResourceCollector.h> // <> required for Interfuscator. IResourceCollector
namespace AZ
{
class Vector3;
@ -335,20 +333,6 @@ public:
}
}
template<typename T>
void AddObject(const TArray<T>& rVector)
{
if (!this->AddObject(rVector.begin(), rVector.capacity() * sizeof(T)))
{
return;
}
for (int i = 0, end = rVector.size(); i < end; ++i)
{
this->AddObject(rVector[i]);
}
}
template<typename T>
void AddObject(const PodArray<T>& rVector)
{
@ -427,11 +411,6 @@ public:
return AddObject (&rObject, sizeof(T));
}
// used to collect the assets needed for streaming and to gather statistics
// always returns a valid reference
virtual IResourceCollector* GetResourceCollector() = 0;
virtual void SetResourceCollector(IResourceCollector* pColl) = 0;
bool Add (const char* szText)
{
return AddObject(szText, strlen(szText) + 1);

634
Code/CryEngine/CryCommon/CryThreadSafeRendererContainer.h
Unescape Escape View File

@ -1,634 +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 : Specialized Container for Renderer data with the following proberties:
// - Created during the 3DEngine Update, comsumed in the renderer in the following frame
// - This Container is very restricted and likely not optimal for other situations
#ifndef CRYINCLUDE_CRYCOMMON_CRYTHREADSAFERENDERERCONTAINER_H
#define CRYINCLUDE_CRYCOMMON_CRYTHREADSAFERENDERERCONTAINER_H
#pragma once
// This container is specialized for data which is generated in the 3DEngine and consumed by the renderer
// in the following frame due to multithreaded rendering. To be useable by Jobs as well as other Threads
// some very specific desing choices were taken:
// First of the underlying continous memory block is only resized during a call to 'CoalesceMemory'
// to prevent freeing a memory block which could be used by another thread.
// If new memory is requiered, a page of 4 KB is allocated and used as a temp storage till the next
// call to 'CoalesceMemory' which then copies all page memory into one continous block.
// Also all threading relevant functions are implemented LockLess to prevent lock contention and make
// this container useable from Jobs
//
// Right now, the main usage pattern of this container is by the RenderThread, who calls at the beginning
// of its frame 'CoalesceMemory', since then we can be sure that the 3DEngine has finished creating it's elements.
//
// Since the main purpose of this container is multi-threading adding of elements, a slight change was done to the
// push_back interface compared to std::vector:
// All implemented push_back variants can return a pointer into the storage (safe since no memory is freed during adding)
// and a index for this elements. This is done since calling operator[] could be expensive when called before 'CoalesceMemory'
//
// For ease of implementation (and a little bit of speed), this container only supports POD types (which can be copied with memcpy)
// also note that this container only supports push_back (and resize back to 0) and no pop back due cost (performance and code complexity) of supporting lock-free in parallel pop_back
#define TSRC_ALIGN _MS_ALIGN(128)
template<typename T>
class TSRC_ALIGN CThreadSafeRendererContainer
{
public:
CThreadSafeRendererContainer();
~CThreadSafeRendererContainer();
//NOTE: be aware that these valus can potentially change if some objects are added in parallel
size_t size() const;
size_t empty() const;
size_t capacity() const;
//NOTE: be aware that this operator can be more expensive if the memory was not coalesced before
T& operator[](size_t n);
const T& operator[](size_t n) const;
T* push_back_new();
T* push_back_new(size_t& nIndex);
void push_back(const T&);
void push_back(const T&, size_t& nIndex);
// NOTE: These functions are changing the size of the continous memory block and thus are *not* thread-safe
void clear();
void resize(size_t n);
void reserve(size_t n);
void CoalesceMemory();
void GetMemoryUsage(ICrySizer*) const;
// disable copy/assignment
CThreadSafeRendererContainer(const CThreadSafeRendererContainer& rOther) = delete;
CThreadSafeRendererContainer& operator=(const CThreadSafeRendererContainer& rOther) = delete;
private:
/////////////////////////////////////
// Struct to represent a memory chunk
// used in fallback allocations during 'Fill' phase
class CMemoryPage
{
public:
// size of a page to allocate, the CMemoryPage is just the header,
// the actual object data is stored in the 4KB chunk right
// after the header (while keeping the requiered alignment and so on)
enum
{
nMemoryPageSize = 4096
};
CMemoryPage();
// allocation functions
static CMemoryPage* AllocateNewPage();
bool TryAllocateElement(size_t& nIndex, T*& pObj);
// access to the elements
T& GetElement(size_t n);
T* GetData() const;
// information about the page (NOTE: not thread-safe in all combinations)
size_t Size() const;
size_t Capacity() const;
size_t GetDataSize() const;
CMemoryPage* m_pNext; // Pointer to next entry in single-linked list of CMemoryPages
private:
LONG m_nSize; // Number of elements currently in the page
LONG m_nCapacity; // Number of elements which could fit into the page
T* m_arrData; // Element memory, from the same memory chunk right after the CMemoryPage class
};
/////////////////////////////////////
// Private functions which do the lock-less updating
T* push_back_impl(size_t& nIndex);
bool try_append_to_continous_memory(size_t& nIndex, T*& pObj);
T& GetMemoryPageElement(size_t n);
/////////////////////////////////////
// Private Member Variables
T* m_arrData; // Storage for the continous memory part, during coalescing resized to hold all page memory
LONG m_nCapacity; // Avaible Memory in continous memory part, if exhausted during 'Fill' phase, pages as temp memory chunks are allocated
CMemoryPage* m_pMemoryPages; // Single linked list of memory chunks, used for fallback allocations during 'Fill' phase (to prevent changing the continous memory block during 'Fill'
LONG m_nSize; // Number of elements currently in the container, can be larger than m_nCapacity due the nonContinousPages
bool m_bElementAccessSafe; // bool to indicate if we are currently doing a 'CoalasceMemory' step, during which some operations are now allowed
} _ALIGN(128);
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline CThreadSafeRendererContainer<T>::CThreadSafeRendererContainer()
: m_arrData(NULL)
, m_nCapacity(0)
, m_pMemoryPages(NULL)
, m_nSize(0)
, m_bElementAccessSafe(true)
{
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline CThreadSafeRendererContainer<T>::~CThreadSafeRendererContainer()
{
clear();
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline size_t CThreadSafeRendererContainer<T>::size() const
{
return *const_cast<volatile LONG*>(&m_nSize);
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline size_t CThreadSafeRendererContainer<T>::empty() const
{
return *const_cast<volatile LONG*>(&m_nSize) == 0;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline size_t CThreadSafeRendererContainer<T>::capacity() const
{
// capacity of continous memory block
LONG nCapacity = m_nCapacity;
// add capacity of all memory pages
CMemoryPage* pCurrentMemoryPage = m_pMemoryPages;
while (pCurrentMemoryPage)
{
nCapacity += pCurrentMemoryPage->Capacity();
pCurrentMemoryPage = pCurrentMemoryPage->m_pNext;
}
return nCapacity;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline T& CThreadSafeRendererContainer<T>::operator[](size_t n)
{
assert(m_bElementAccessSafe);
T* pRet = NULL;
#if !defined(NULL_RENDERER)
assert((LONG)n < m_nSize);
#endif
if ((LONG)n < m_nCapacity)
{
pRet = &m_arrData[n];
}
else
{
pRet = &GetMemoryPageElement(n);
}
return *pRet;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline const T& CThreadSafeRendererContainer<T>::operator[](size_t n) const
{
return const_cast<const T&>(const_cast<CThreadSafeRendererContainer<T>*>(this)->operator[](n));
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline T* CThreadSafeRendererContainer<T>::push_back_new()
{
assert(m_bElementAccessSafe);
size_t nUnused = ~0;
return push_back_impl(nUnused);
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline T* CThreadSafeRendererContainer<T>::push_back_new(size_t& nIndex)
{
assert(m_bElementAccessSafe);
return push_back_impl(nIndex);
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline void CThreadSafeRendererContainer<T>::push_back(const T& rObj)
{
assert(m_bElementAccessSafe);
size_t nUnused = ~0;
T* pObj = push_back_impl(nUnused);
*pObj = rObj;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline void CThreadSafeRendererContainer<T>::push_back(const T& rObj, size_t& nIndex)
{
assert(m_bElementAccessSafe);
T* pObj = push_back_impl(nIndex);
*pObj = rObj;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline void CThreadSafeRendererContainer<T>::clear()
{
assert(m_bElementAccessSafe);
// free continous part
CryModuleMemalignFree(m_arrData);
m_arrData = NULL;
// free non-continous pages if we have some
CMemoryPage* pCurrentMemoryPage = m_pMemoryPages;
while (pCurrentMemoryPage)
{
CMemoryPage* pOldPage = pCurrentMemoryPage;
pCurrentMemoryPage = pCurrentMemoryPage->m_pNext;
CryModuleFree(pOldPage);
}
m_pMemoryPages = NULL;
m_nSize = 0;
m_nCapacity = 0;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline void CThreadSafeRendererContainer<T>::resize(size_t n)
{
assert(m_bElementAccessSafe);
CoalesceMemory();
size_t nOldSize = m_nSize;
m_nSize = n;
if ((LONG)n <= m_nCapacity)
{
return;
}
T* arrOldData = m_arrData;
m_arrData = reinterpret_cast<T*>(CryModuleMemalign(n * sizeof(T), alignof(T)));
memcpy(m_arrData, arrOldData, nOldSize * sizeof(T));
memset(&m_arrData[m_nCapacity], 0, (n - m_nCapacity) * sizeof(T));
CryModuleMemalignFree(arrOldData);
m_nCapacity = n;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline void CThreadSafeRendererContainer<T>::reserve(size_t n)
{
assert(m_bElementAccessSafe);
CoalesceMemory();
if ((LONG)n <= m_nCapacity)
{
return;
}
T* arrOldData = m_arrData;
m_arrData = reinterpret_cast<T*>(CryModuleMemalign(n * sizeof(T), alignof(T)));
memcpy(m_arrData, arrOldData, m_nSize * sizeof(T));
memset(&m_arrData[m_nCapacity], 0, (n - m_nCapacity) * sizeof(T));
CryModuleMemalignFree(arrOldData);
m_nCapacity = n;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline bool CThreadSafeRendererContainer<T>::try_append_to_continous_memory(size_t& nIndex, T*& pObj)
{
assert(m_bElementAccessSafe);
LONG nSize = ~0;
LONG nCapacity = ~0;
do
{
// read volatile the new size
nSize = *const_cast<volatile LONG*>(&m_nSize);
nCapacity = *const_cast<volatile LONG*>(&m_nCapacity);
if (nSize >= nCapacity)
{
return false;
}
} while (CryInterlockedCompareExchange(alias_cast<volatile LONG*>(&m_nSize), nSize + 1, nSize) != nSize);
nIndex = nSize;
pObj = &m_arrData[nSize];
return true;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline T* CThreadSafeRendererContainer<T>::push_back_impl(size_t& nIndex)
{
assert(m_bElementAccessSafe);
T* pObj = NULL;
// non atomic check to see if there is space in the continous array
if (try_append_to_continous_memory(nIndex, pObj))
{
return pObj;
}
// exhausted continous memory, falling back to page allocation
for (;; )
{
assert(m_bElementAccessSafe);
size_t nPageBaseIndex = 0;
// traverse the page list till the first page with free memory
CMemoryPage* pCurrentMemoryPage = m_pMemoryPages;
while (pCurrentMemoryPage)
{
size_t nAvaibleElements = pCurrentMemoryPage->Capacity() - pCurrentMemoryPage->Size();
if (nAvaibleElements)
{
break;
}
// no memory in this page, go to the next one
nPageBaseIndex += pCurrentMemoryPage->Capacity();
pCurrentMemoryPage = pCurrentMemoryPage->m_pNext;
}
// try to allocate a element on this page
if (pCurrentMemoryPage && pCurrentMemoryPage->TryAllocateElement(nIndex, pObj))
{
// update global elements counter
CryInterlockedIncrement(alias_cast<volatile int*>(&m_nSize));
// adjust in-page-index to global index
nIndex += nPageBaseIndex + m_nCapacity;
return pObj;
}
else
{
// all pages are empty, allocate and link a new one
CMemoryPage* pNewPage = CMemoryPage::AllocateNewPage();
void* volatile* ppLastMemoryPageAddress = NULL;
do
{
// find place to link in page
CMemoryPage* pLastMemoryPage = m_pMemoryPages;
ppLastMemoryPageAddress = alias_cast<void* volatile*>(&m_pMemoryPages);
while (pLastMemoryPage)
{
ppLastMemoryPageAddress = alias_cast<void* volatile*>(&(pLastMemoryPage->m_pNext));
pLastMemoryPage = pLastMemoryPage->m_pNext;
}
} while (CryInterlockedCompareExchangePointer(ppLastMemoryPageAddress, pNewPage, NULL) != NULL);
}
}
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline T& CThreadSafeRendererContainer<T>::GetMemoryPageElement(size_t n)
{
assert(m_bElementAccessSafe);
size_t nFirstListIndex = m_nCapacity;
CMemoryPage* pCurrentMemoryPage = m_pMemoryPages;
size_t nPageCapacity = pCurrentMemoryPage->Capacity();
while (n >= (nFirstListIndex + nPageCapacity))
{
// this is threadsafe because we assume that if we want to get element 'n'
// the clientcode did already fill the container up to element 'n'
// thus up to 'n', m_pNonContinousList will have valid pages
// NOTE: This is not safe when trying to read a element behind the valid
// range (same as std::vector)
nFirstListIndex += nPageCapacity;
pCurrentMemoryPage = pCurrentMemoryPage->m_pNext;
// update page capacity, since it can differe due alignment
nPageCapacity = pCurrentMemoryPage->Capacity();
}
return pCurrentMemoryPage->GetElement(n - nFirstListIndex);
}
///////////////////////////////////////////////////////////////////////////////
// When not not in the 'Fill' phase, it is safe to colace all page entries into one continous memory block
template<typename T>
inline void CThreadSafeRendererContainer<T>::CoalesceMemory()
{
assert(m_bElementAccessSafe);
if (m_pMemoryPages == NULL)
{
return; // nothing to do
}
// mark state as not accessable
m_bElementAccessSafe = false;
#if !defined(NDEBUG)
size_t nOldSize = m_nSize;
#endif
// compute required memory
size_t nRequieredElements = 0;
{
CMemoryPage* pCurrentMemoryPage = m_pMemoryPages;
while (pCurrentMemoryPage)
{
nRequieredElements += pCurrentMemoryPage->Size();
pCurrentMemoryPage = pCurrentMemoryPage->m_pNext;
}
}
T* arrOldData = m_arrData;
m_arrData = reinterpret_cast<T*>(CryModuleMemalign((m_nCapacity + nRequieredElements) * sizeof(T), alignof(T)));
memcpy(m_arrData, arrOldData, m_nCapacity * sizeof(T));
CryModuleMemalignFree(arrOldData);
// copy page data into continous memory block
{
size_t nBeginToFillIndex = m_nCapacity;
CMemoryPage* pCurrentMemoryPage = m_pMemoryPages;
while (pCurrentMemoryPage)
{
// copy data
memcpy(&m_arrData[nBeginToFillIndex], pCurrentMemoryPage->GetData(), pCurrentMemoryPage->GetDataSize());
nBeginToFillIndex += pCurrentMemoryPage->Size();
// free page
CMemoryPage* pOldPage = pCurrentMemoryPage;
pCurrentMemoryPage = pCurrentMemoryPage->m_pNext;
CryModuleFree(pOldPage);
}
m_pMemoryPages = NULL;
}
assert(nOldSize == m_nSize);
m_nCapacity += nRequieredElements;
// the container can be used again
m_bElementAccessSafe = true;
}
///////////////////////////////////////////////////////////////////////////////
// Collect information about used memory
template<typename T>
void CThreadSafeRendererContainer<T>::GetMemoryUsage(ICrySizer* pSizer) const
{
pSizer->AddObject(m_arrData, m_nCapacity * sizeof(T));
CMemoryPage* pCurrentMemoryPage = m_pMemoryPages;
while (pCurrentMemoryPage)
{
pSizer->AddObject(pCurrentMemoryPage, CMemoryPage::nMemoryPageSize);
pCurrentMemoryPage = pCurrentMemoryPage->m_pNext;
}
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline CThreadSafeRendererContainer<T>::CMemoryPage::CMemoryPage()
: m_pNext(NULL)
, m_nSize(0)
{
// compute offset for actual data
size_t nObjectAlignment = alignof(T);
UINT_PTR nMemoryBlockBegin = alias_cast<UINT_PTR>(this);
UINT_PTR nMemoryBlockEnd = alias_cast<UINT_PTR>(this) + nMemoryPageSize;
nMemoryBlockBegin += sizeof(CMemoryPage);
nMemoryBlockBegin = (nMemoryBlockBegin + nObjectAlignment - 1) & ~(nObjectAlignment - 1);
// compute number of avaible elements
assert(nMemoryBlockEnd > nMemoryBlockBegin);
m_nCapacity = (LONG)((nMemoryBlockEnd - nMemoryBlockBegin) / sizeof(T));
// store pointer to store data to
m_arrData = alias_cast<T*>(nMemoryBlockBegin);
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline typename CThreadSafeRendererContainer<T>::CMemoryPage * CThreadSafeRendererContainer<T>::CMemoryPage::AllocateNewPage()
{
void* pNewPageMemoryChunk = CryModuleMalloc(nMemoryPageSize);
assert(pNewPageMemoryChunk != NULL);
memset(pNewPageMemoryChunk, 0, nMemoryPageSize);
CMemoryPage* pNewPage = new(pNewPageMemoryChunk) CMemoryPage();
return pNewPage;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline bool CThreadSafeRendererContainer<T>::CMemoryPage::TryAllocateElement(size_t & nIndex, T * &pObj)
{
LONG nSize = ~0;
LONG nCapacity = ~0;
do
{
// read volatile the new size
nSize = *const_cast<volatile LONG*>(&m_nSize);
nCapacity = *const_cast<volatile LONG*>(&m_nCapacity);
// stop trying if this page is full
if (nSize >= nCapacity)
{
return false;
}
} while (CryInterlockedCompareExchange(alias_cast<volatile LONG*>(&m_nSize), nSize + 1, nSize) != nSize);
//Note: this is the index in the page and it is adjusted in the calling context
nIndex = nSize;
pObj = &m_arrData[nSize];
return true;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline T&CThreadSafeRendererContainer<T>::CMemoryPage::GetElement(size_t n)
{
assert((LONG)n < m_nSize);
assert(m_nSize <= m_nCapacity);
return m_arrData[n];
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline T * CThreadSafeRendererContainer<T>::CMemoryPage::GetData() const
{
return m_arrData;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline size_t CThreadSafeRendererContainer<T>::CMemoryPage::Size() const
{
return m_nSize;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline size_t CThreadSafeRendererContainer<T>::CMemoryPage::GetDataSize() const
{
return m_nSize * sizeof(T);
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline size_t CThreadSafeRendererContainer<T>::CMemoryPage::Capacity() const
{
return m_nCapacity;
}
#endif // CRYINCLUDE_CRYCOMMON_CRYTHREADSAFERENDERERCONTAINER_H

602
Code/CryEngine/CryCommon/CryThreadSafeWorkerContainer.h
Unescape Escape View File

@ -1,602 +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 : Specialized Container for Renderer data with the following properties:
// Created during the 3DEngine Update, consumed in the renderer in the following frame
// This Container is very restricted and likely not optimal for other situations
#ifndef CRYINCLUDE_CRYCOMMON_CRYTHREADSAFEWORKERCONTAINER_H
#define CRYINCLUDE_CRYCOMMON_CRYTHREADSAFEWORKERCONTAINER_H
#pragma once
#include "platform.h"
#include <vector>
#include <AzCore/Jobs/JobContext.h>
#include <AzCore/Jobs/JobManager.h>
#include <AzCore/std/typetraits/typetraits.h>
//
// !!! BE CAREFULL WHEN USING THIS CONTAINER !!!
//
// --- Properties: ---
// - Stores data local to worker thread to avoid thread-safety semantics
// - Allows for a single non-worker thread to be tracked which is stored in m_workers[0]
// Hence: As m_workers[0] is shared between all non-worker threads, ensure that only one additional non-worker thread may access this container e.g. MainThread
// - Coalesce memory to obtain a continues memory block
// - Coalesce memory to for faster element access to a continues memory block
//
// --- Restrictions:---
// - The workers own the memory structure
// - The coalesced memory stores a copy of the workers used memory
// Hence: Be careful when altering data within the coalesced memory.
// If the templated element is a pointer type than altering the memory pointed to, is not be an issue
// If the templated element is of type class or struct than ensure that data changes are done on the worker local data and not on the coalesced memory. Use worker encoded indices to do so.
//
template <class T>
class CThreadSafeWorkerContainer
{
public:
struct SDefaultNoOpFunctor
{
ILINE void operator()(T* pData) const{}
};
struct SDefaultDestructorFunctor
{
ILINE void operator()(T* pData) const
{
pData->~T();
}
};
public:
CThreadSafeWorkerContainer();
~CThreadSafeWorkerContainer();
void Init();
void SetNonWorkerThreadID(threadID nThreadId) { m_foreignThreadId = nThreadId; }
// Safe access of elements for calling thread via operator[]
uint32 ConvertToEncodedWorkerId_threadlocal(uint32 nIndex) const;
// Returns the number of threads that can use this container, including the one non-worker-thread.
uint32 GetNumWorkers() const;
// Returns the Worker ID for the current thread. Ranges from 0 to GetNumWorkers()-1.
// Note, WorkerId is not the same thing as JobManager's WorkerThreadId.
uint32 GetWorkerId_threadlocal() const;
//NOTE: be aware that these values can potentially change if some objects are added in parallel
size_t size() const;
size_t empty() const;
size_t capacity() const;
size_t size_threadlocal() const;
size_t empty_threadlocal() const;
size_t capacity_threadlocal() const;
//NOTE: be aware that this operator is more expensive if the memory was not coalesced before
T& operator[](size_t n);
const T& operator[](size_t n) const;
T* push_back_new();
T* push_back_new(size_t& nIndex);
void push_back(const T& rObj);
void push_back(const T& rObj, size_t& nIndex);
// NOTE: These functions are changing the size of the continous memory block and thus are *not* thread-safe
void clear();
template< class OnElementDeleteFunctor>
void clear(const OnElementDeleteFunctor& rFunctor = CThreadSafeWorkerContainer<T>::SDefaultNoOpFunctor());
void erase(const T& rObj);
void resize(size_t n);
void reserve(size_t n);
// *not* thread-safe functions
void PrefillContainer(T* pElement, size_t numElements);
void CoalesceMemory();
void GetMemoryUsage(ICrySizer* pSizer) const;
private:
void clear(AZStd::true_type);
void clear(AZStd::false_type);
class SWorker
{
public:
AZ_CLASS_ALLOCATOR(SWorker, AZ::LegacyAllocator, 0);
SWorker()
: m_dataSize(0) {}
uint32 m_dataSize;
AZStd::vector<T> m_data;
} _ALIGN(128);
T* push_back_impl(size_t& nIndex);
void ReserverCoalescedMemory(size_t n);
threadID m_foreignThreadId; // OS thread ID of the non-job-manager-worker-thread allowed to use this container, too.
AZStd::vector<SWorker> m_workers; // Holds data for each thread that can use this container. A non-worker-thread (Main) has data stored at 0. Actual worker threads range from 1 to m_nNumWorkers-1
uint32 m_nNumWorkers = 0; // The number of threads that can use this container, including one non-worker-thread.
uint32 m_coalescedArrCapacity;
T* m_coalescedArr;
bool m_isCoalesced;
};
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline CThreadSafeWorkerContainer<T>::CThreadSafeWorkerContainer()
: m_nNumWorkers(0)
, m_coalescedArrCapacity(0)
, m_coalescedArr(0)
, m_isCoalesced(false)
{
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline CThreadSafeWorkerContainer<T>::~CThreadSafeWorkerContainer()
{
clear();
m_workers.clear();
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline void CThreadSafeWorkerContainer<T>::Init()
{
m_nNumWorkers = AZ::JobContext::GetGlobalContext()->GetJobManager().GetNumWorkerThreads() + 1;
m_workers.resize(m_nNumWorkers);
m_foreignThreadId = THREADID_NULL;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline size_t CThreadSafeWorkerContainer<T>::size() const
{
uint32 totalSize = 0;
for (int i = 0; i < m_nNumWorkers; ++i)
{
totalSize += m_workers[i].m_dataSize;
}
return totalSize;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline size_t CThreadSafeWorkerContainer<T>::empty() const
{
return size() == 0;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline size_t CThreadSafeWorkerContainer<T>::capacity() const
{
uint32 totalCapacity = 0;
for (int i = 0; i < m_nNumWorkers; ++i)
{
totalCapacity += m_workers[i].m_data.capacity();
}
return totalCapacity;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline size_t CThreadSafeWorkerContainer<T>::size_threadlocal() const
{
const uint32 nWorkerThreadId = GetWorkerId_threadlocal();
return m_workers[nWorkerThreadId].m_dataSize;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline size_t CThreadSafeWorkerContainer<T>::empty_threadlocal() const
{
const uint32 nWorkerThreadId = GetWorkerId_threadlocal();
return m_workers[nWorkerThreadId].m_data.empty();
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline size_t CThreadSafeWorkerContainer<T>::capacity_threadlocal() const
{
const uint32 nWorkerThreadId = GetWorkerId_threadlocal();
return m_workers[nWorkerThreadId].m_data.capacity();
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline T& CThreadSafeWorkerContainer<T>::operator[](size_t n)
{
const uint32 nHasWorkerEncodedIndex = (n & 0x80000000) >> 31;
IF ((m_isCoalesced && !nHasWorkerEncodedIndex), 1)
{
AZ_Assert(m_coalescedArr, "null array");
AZ_Assert(n < m_coalescedArrCapacity, "Index out of bounds");
return m_coalescedArr[n];
}
else
{
const uint32 nWorkerThreadId = (n & 0x7F00007F) >> 24; // Mask bit 24-30 (0 is starting bit)
const uint32 nOffset = (n & ~0xFF000000); // Mask out top 8 bits
// Encoded offset into worker local array
if (nHasWorkerEncodedIndex)
{
return m_workers[nWorkerThreadId].m_data[nOffset];
}
else // None-coalesced and none worker encoded offset
{
uint32 nTotalOffset = nOffset;
for (int i = 0; i < m_nNumWorkers; ++i)
{
SWorker& worker = m_workers[i];
if (nTotalOffset < worker.m_dataSize)
{
return worker.m_data[nTotalOffset];
}
else
{
nTotalOffset -= worker.m_dataSize;
}
}
// Out of bound access detected!
CRY_ASSERT_MESSAGE(false, "CThreadSafeWorkerContainer::operator[] - Out of bounds access");
__debugbreak();
AZ_Assert(m_coalescedArr, "null array");
AZ_Assert(m_coalescedArrCapacity > 0, "Index out of bounds");
return m_coalescedArr[0];
}
}
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline const T& CThreadSafeWorkerContainer<T>::operator[](size_t n) const
{
return const_cast<const T&>(const_cast<CThreadSafeWorkerContainer<T>*>(this)->operator[](n));
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline T* CThreadSafeWorkerContainer<T>::push_back_new()
{
size_t unused = ~0;
return push_back_impl(unused);
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline T* CThreadSafeWorkerContainer<T>::push_back_new(size_t& nIndex)
{
return push_back_impl(nIndex);
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline void CThreadSafeWorkerContainer<T>::push_back(const T& rObj)
{
size_t nUnused = ~0;
T* pObj = push_back_impl(nUnused);
*pObj = rObj;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline void CThreadSafeWorkerContainer<T>::push_back(const T& rObj, size_t& nIndex)
{
T* pObj = push_back_impl(nIndex);
*pObj = rObj;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline void CThreadSafeWorkerContainer<T>::clear()
{
clear(typename std::is_destructible<T>::type());
}
template<typename T>
void CThreadSafeWorkerContainer<T>::clear(AZStd::true_type)
{
clear(SDefaultDestructorFunctor());
}
template<typename T>
void CThreadSafeWorkerContainer<T>::clear(AZStd::false_type)
{
clear(SDefaultNoOpFunctor());
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
template<class OnElementDeleteFunctor>
inline void CThreadSafeWorkerContainer<T>::clear(const OnElementDeleteFunctor& rFunctor)
{
// Reset worker data
for (int i = 0; i < m_nNumWorkers; ++i)
{
// Delete elements
uint32 nSize = m_workers[i].m_data.size();
for (int j = 0; j < nSize; ++j)
{
// Call on element delete functor
// Note: Default functor will do nothing with the element
rFunctor(&m_workers[i].m_data[j]);
}
m_workers[i].m_data.clear();
m_workers[i].m_dataSize = 0;
}
// Reset container data
if (m_coalescedArr)
{
CryModuleMemalignFree(m_coalescedArr);
}
m_coalescedArr = 0;
m_coalescedArrCapacity = 0;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline void CThreadSafeWorkerContainer<T>::erase(const T& rObj)
{
for (int i = 0; i < m_nNumWorkers; ++i)
{
typename std::vector<T>::iterator iter = m_workers[i].m_data.begin();
typename std::vector<T>::iterator iterEnd = m_workers[i].m_data.end();
for (; iter != iterEnd; ++iter)
{
if (rObj == *iter)
{
m_workers[i].m_data.erase(iter);
--m_workers[i].m_dataSize;
m_isCoalesced = false;
return;
}
}
}
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline void CThreadSafeWorkerContainer<T>::resize(size_t n)
{
CoalesceMemory();
uint32 nSizePerWorker = n / m_nNumWorkers;
uint32 nExcessSize = n % m_nNumWorkers;
// Resize workers evenly
for (int i = 0; i < m_nNumWorkers; ++i)
{
uint32 nWorkerSize = nSizePerWorker + nExcessSize;
if (nWorkerSize > m_workers[i].m_data.size())
{
m_workers[i].m_data.resize(nWorkerSize);
}
m_workers[i].m_dataSize = nWorkerSize;
nExcessSize = 0; // First worker creates excess items
}
ReserverCoalescedMemory(n);
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline void CThreadSafeWorkerContainer<T>::reserve(size_t n)
{
CoalesceMemory();
uint32 nSizePerWorker = n / m_nNumWorkers;
uint32 nExcessSize = n % m_nNumWorkers;
// Resize workers evenly
for (int i = 0; i < m_nNumWorkers; ++i)
{
uint32 nWorkerSize = nSizePerWorker + nExcessSize;
if (nWorkerSize > m_workers[i].m_data.size())
{
m_workers[i].m_data.resize(nWorkerSize);
}
nExcessSize = 0; // First worker creates excess items
}
ReserverCoalescedMemory(n);
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline void CThreadSafeWorkerContainer<T>::PrefillContainer(T* pElement, size_t numElements)
{
reserve(numElements);
uint32 nOffset = 0;
uint32 nNumItemPerWorker = numElements / m_nNumWorkers;
uint32 nNumExcessItems = numElements % m_nNumWorkers;
// Store items evenly in workers
for (int i = 0; i < m_nNumWorkers; ++i)
{
uint32 nNumItems = nNumItemPerWorker + nNumExcessItems;
for (int j = 0; j < nNumItems; ++j)
{
m_workers[i].m_data[j] = pElement[nOffset + j];
}
m_workers[i].m_dataSize = nNumItems;
nOffset += nNumItems;
nNumExcessItems = 0; // First worker stores excess items
}
m_isCoalesced = false;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline void CThreadSafeWorkerContainer<T>::CoalesceMemory()
{
if (m_isCoalesced)
{
return;
}
// Ensure enough memory exists
uint32 minSizeNeeded = 0;
for (int i = 0; i < m_nNumWorkers; ++i)
{
minSizeNeeded += m_workers[i].m_dataSize;
}
IF (minSizeNeeded >= m_coalescedArrCapacity, 0)
{
ReserverCoalescedMemory(minSizeNeeded + (minSizeNeeded / 4));
}
// Copy data to coalesced array
uint32 nOffest = 0;
for (int i = 0; i < m_nNumWorkers; ++i)
{
SWorker& rWorker = m_workers[i];
if (rWorker.m_dataSize == 0)
{
continue;
}
AZ_Assert((nOffest + rWorker.m_dataSize) <= m_coalescedArrCapacity, "Index out of bounds");
memcpy(m_coalescedArr + nOffest, &rWorker.m_data[0], sizeof(T) * rWorker.m_dataSize);
nOffest += rWorker.m_dataSize;
}
m_isCoalesced = true;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
uint32 CThreadSafeWorkerContainer<T>::ConvertToEncodedWorkerId_threadlocal(uint32 nIndex) const
{
const uint32 workerId = GetWorkerId_threadlocal();
assert(nIndex < m_workers[workerId].m_dataSize);
return (uint32)((1 << 31) | (workerId << 24) | nIndex);
}
//////////////////////////////////////////////////////////////////////////
template<typename T>
uint32 CThreadSafeWorkerContainer<T>::GetNumWorkers() const
{
return m_nNumWorkers;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline void CThreadSafeWorkerContainer<T>::GetMemoryUsage(ICrySizer* pSizer) const
{
pSizer->AddObject(m_coalescedArr, m_coalescedArrCapacity * sizeof(T));
for (int i = 0; i < m_nNumWorkers; ++i)
{
pSizer->AddContainer(m_workers[i].m_data);
}
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline void CThreadSafeWorkerContainer<T>::ReserverCoalescedMemory(size_t n)
{
if (n <= m_coalescedArrCapacity)
{
return;
}
T* arrOldData = m_coalescedArr;
m_coalescedArr = reinterpret_cast<T*>(CryModuleMemalign(n * sizeof(T), alignof(T)));
memcpy(m_coalescedArr, arrOldData, m_coalescedArrCapacity * sizeof(T));
if (arrOldData)
{
CryModuleMemalignFree(arrOldData);
}
m_coalescedArrCapacity = n;
}
///////////////////////////////////////////////////////////////////////////////
template<typename T>
inline T* CThreadSafeWorkerContainer<T>::push_back_impl(size_t& nIndex)
{
// Avoid writing to thread share resource and take hit of 'if statement to avoid false-sharing between threads
IF (m_isCoalesced, 0)
{
m_isCoalesced = false;
}
// Get worker id
const uint32 nWorkerThreadId = GetWorkerId_threadlocal();
SWorker& activeWorker = m_workers[nWorkerThreadId];
// Ensure enough space
if (activeWorker.m_dataSize >= activeWorker.m_data.size())
{
activeWorker.m_data.resize(activeWorker.m_data.size() + (activeWorker.m_data.size() / 2) + 1);
}
// Encode worker local offset into index and return
T* retItem = &activeWorker.m_data[activeWorker.m_dataSize];
nIndex = (size_t)((1 << 31) | (nWorkerThreadId << 24) | activeWorker.m_dataSize);
++activeWorker.m_dataSize;
return retItem;
}
template<typename T>
uint32 CThreadSafeWorkerContainer<T>::GetWorkerId_threadlocal() const
{
const uint32 workerThreadId = AZ::JobContext::GetGlobalContext()->GetJobManager().GetWorkerThreadId();
if (workerThreadId == AZ::JobManager::InvalidWorkerThreadId)
{
// Only one non-worker thread is allowed, so check to see if this is that thread.
const threadID currentThreadId = CryGetCurrentThreadId();
if (m_foreignThreadId != currentThreadId)
{
CryFatalError("Trying to access CThreadSafeWorkerContainer from an unspecified non-worker thread. The only non-worker threadId with access rights: %" PRI_THREADID ". Current threadId: %" PRI_THREADID, m_foreignThreadId, currentThreadId);
}
}
// Non-worker has id of ~0 ... add +1 to shift to 0. Worker0 will use slot 1 etc.
static_assert(AZ::JobManager::InvalidWorkerThreadId == ~0u, "Assumptions about InvalidWorkerId no longer hold true");
return workerThreadId + 1;
}
#endif // CRYINCLUDE_CRYCOMMON_CRYTHREADSAFEWORKERCONTAINER_H

79
Code/CryEngine/CryCommon/CustomMemoryHeap.h
Unescape Escape View File

@ -1,79 +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 __CustomMemoryHeap_h__
#define __CustomMemoryHeap_h__
#pragma once
#include "IMemory.h"
class CCustomMemoryHeap;
//////////////////////////////////////////////////////////////////////////
class CCustomMemoryHeapBlock
: public ICustomMemoryBlock
{
public:
CCustomMemoryHeapBlock(CCustomMemoryHeap* pHeap);
virtual ~CCustomMemoryHeapBlock();
//////////////////////////////////////////////////////////////////////////
// IMemoryBlock
//////////////////////////////////////////////////////////////////////////
virtual void* GetData();
virtual int GetSize() { return m_nSize; }
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// ICustomMemoryBlock
//////////////////////////////////////////////////////////////////////////
virtual void CopyMemoryRegion(void* pOutputBuffer, size_t nOffset, size_t nSize);
//////////////////////////////////////////////////////////////////////////
private:
friend class CCustomMemoryHeap;
CCustomMemoryHeap* m_pHeap;
string m_sUsage;
void* m_pData;
uint32 m_nGPUHandle;
size_t m_nSize;
};
//////////////////////////////////////////////////////////////////////////
class CCustomMemoryHeap
: public ICustomMemoryHeap
{
public:
explicit CCustomMemoryHeap(IMemoryManager::EAllocPolicy const eAllocPolicy);
~CCustomMemoryHeap();
//////////////////////////////////////////////////////////////////////////
// ICustomMemoryHeap
//////////////////////////////////////////////////////////////////////////
virtual ICustomMemoryBlock* AllocateBlock(size_t const nAllocateSize, char const* const sUsage, size_t const nAlignment = 16);
virtual void GetMemoryUsage(ICrySizer* pSizer);
virtual size_t GetAllocated();
//////////////////////////////////////////////////////////////////////////
void DeallocateBlock(CCustomMemoryHeapBlock* pBlock);
private:
friend class CCustomMemoryHeapBlock;
int m_nAllocatedSize;
IMemoryManager::EAllocPolicy m_eAllocPolicy;
IMemoryManager::HeapHandle m_nTraceHeapHandle;
};
#endif // __CustomMemoryHeap_h__

1
Code/CryEngine/CryCommon/HeapAllocator.h
Unescape Escape View File

@ -420,7 +420,6 @@ namespace stl
{
nInterval++;
nCount = 0;
assert(CryMemory::IsHeapValid());
}
#endif
}

1
Code/CryEngine/CryCommon/IEntityRenderState.h
Unescape Escape View File

@ -572,7 +572,6 @@ struct IVoxelObject
: public IRenderNode
{
// <interfuscator:shuffle>
virtual struct IMemoryBlock* GetCompiledData(EEndian eEndian) = 0;
virtual void SetCompiledData(void* pData, int nSize, uint8 ucChildId, EEndian eEndian) = 0;
virtual void SetObjectName(const char* pName) = 0;
virtual void SetMatrix(const Matrix34& mat) = 0;

4
Code/CryEngine/CryCommon/IFont.h
Unescape Escape View File

@ -145,6 +145,7 @@ struct STextDrawContext
Vec2 m_size;
Vec2i m_requestSize;
float m_widthScale;
float m_lineSpacing;
float m_clipX;
float m_clipY;
@ -175,6 +176,7 @@ struct STextDrawContext
, m_size(16.0f, 16.0f)
, m_requestSize(static_cast<int32>(m_size.x), static_cast<int32>(m_size.y))
, m_widthScale(1.0f)
, m_lineSpacing(0.f)
, m_clipX(0)
, m_clipY(0)
, m_clipWidth(0)
@ -209,11 +211,13 @@ struct STextDrawContext
void SetTransform(const Matrix34& transform) { m_transform = transform; }
void SetBaseState(int baseState) { m_baseState = baseState; }
void SetOverrideViewProjMatrices(bool overrideViewProjMatrices) { m_overrideViewProjMatrices = overrideViewProjMatrices; }
void SetLineSpacing(float lineSpacing) { m_lineSpacing = lineSpacing; }
float GetCharWidth() const { return m_size.x; }
float GetCharHeight() const { return m_size.y; }
float GetCharWidthScale() const { return m_widthScale; }
int GetFlags() const { return m_drawTextFlags; }
float GetLineSpacing() const { return m_lineSpacing; }
bool IsColorOverridden() const { return m_colorOverride.a != 0; }
};

52
Code/CryEngine/CryCommon/IGeneralMemoryHeap.h
Unescape Escape 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.
#ifndef CRYINCLUDE_CRYCOMMON_IGENERALMEMORYHEAP_H
#define CRYINCLUDE_CRYCOMMON_IGENERALMEMORYHEAP_H
#pragma once
namespace AZ
{
class IAllocator;
}
class IGeneralMemoryHeap
{
public:
// <interfuscator:shuffle>
virtual bool Cleanup() = 0;
virtual int AddRef() = 0;
virtual int Release() = 0;
virtual bool IsInAddressRange(void* ptr) const = 0;
virtual void* Calloc(size_t nmemb, size_t size, const char* sUsage) = 0;
virtual void* Malloc(size_t sz, const char* sUsage) = 0;
// Attempts to free the allocation. Returns the size of the allocation if successful, 0 if the heap doesn't own the address.
virtual size_t Free(void* ptr) = 0;
virtual void* Realloc(void* ptr, size_t sz, const char* sUsage) = 0;
virtual void* ReallocAlign(void* ptr, size_t size, size_t alignment, const char* sUsage) = 0;
virtual void* Memalign(size_t boundary, size_t size, const char* sUsage) = 0;
virtual AZ::IAllocator* GetAllocator() const = 0;
// Get the size of the allocation. Returns 0 if the ptr doesn't belong to the heap.
virtual size_t UsableSize(void* ptr) const = 0;
// </interfuscator:shuffle>
protected:
virtual ~IGeneralMemoryHeap() {}
};
#endif // CRYINCLUDE_CRYCOMMON_IGENERALMEMORYHEAP_H

41
Code/CryEngine/CryCommon/IImageHandler.h
Unescape Escape 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.
*
*/
#ifndef CRYINCLUDE_CRYCOMMON_IIMAGEHANDLER_H
#define CRYINCLUDE_CRYCOMMON_IIMAGEHANDLER_H
#pragma once
#include <memory>
/**
Utility for loading and saving images. only works with RGB data(no alpha), and lossless compressed tiff files for now.
*/
struct IImageHandler
{
struct IImage
{
virtual ~IImage() {}
virtual const std::vector<unsigned char>& GetData() const = 0;
virtual int GetWidth() const = 0;
virtual int GetHeight() const = 0;
};
virtual ~IImageHandler() {}
///data must be RGB, 3 bytes per pixel.
virtual std::unique_ptr<IImage> CreateImage(std::vector<unsigned char>&& data, int width, int height) const = 0;
virtual std::unique_ptr<IImage> LoadImage(const char* filename) const = 0;
virtual bool SaveImage(IImage* image, const char* filename) const = 0;
virtual std::unique_ptr<IImage> CreateDiffImage(IImage* image1, IImage* image2) const = 0;
virtual float CalculatePSNR(IImage* diffIimage) const = 0;
};
#endif // CRYINCLUDE_CRYCOMMON_IIMAGEHANDLER_H

32
Code/CryEngine/CryCommon/ILZ4Decompressor.h
Unescape Escape 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.
// Description : Provides the interface for the lz4 hc decompress wrapper
#ifndef CRYINCLUDE_CRYCOMMON_ILZ4DECOMPRESSOR_H
#define CRYINCLUDE_CRYCOMMON_ILZ4DECOMPRESSOR_H
#pragma once
struct ILZ4Decompressor
{
protected:
virtual ~ILZ4Decompressor() {}; // use Release()
public:
virtual bool DecompressData(const char* pIn, char* pOut, const uint outputSize) const = 0;
virtual void Release() = 0;
};
#endif // CRYINCLUDE_CRYCOMMON_ILZ4DECOMPRESSOR_H

86
Code/CryEngine/CryCommon/IMemory.h
Unescape Escape View File

@ -1,86 +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_IMEMORY_H
#define CRYINCLUDE_CRYCOMMON_IMEMORY_H
#pragma once
#include <smartptr.h>
#include <IGeneralMemoryHeap.h> // <> required for Interfuscator
#include <smartptr.h>
struct IMemoryBlock
: public CMultiThreadRefCount
{
// <interfuscator:shuffle>
virtual void* GetData() = 0;
virtual int GetSize() = 0;
// </interfuscator:shuffle>
};
TYPEDEF_AUTOPTR(IMemoryBlock);
//////////////////////////////////////////////////////////////////////////
struct ICustomMemoryBlock
: public IMemoryBlock
{
// Copy region from from source memory to the specified output buffer
virtual void CopyMemoryRegion(void* pOutputBuffer, size_t nOffset, size_t nSize) = 0;
};
//////////////////////////////////////////////////////////////////////////
struct ICustomMemoryHeap
: public CMultiThreadRefCount
{
// <interfuscator:shuffle>
virtual ICustomMemoryBlock* AllocateBlock(size_t const nAllocateSize, char const* const sUsage, size_t const nAlignment = 16) = 0;
virtual void GetMemoryUsage(ICrySizer* pSizer) = 0;
virtual size_t GetAllocated() = 0;
// </interfuscator:shuffle>
};
class IMemoryAddressRange
{
public:
// <interfuscator:shuffle>
virtual void Release() = 0;
virtual char* GetBaseAddress() const = 0;
virtual size_t GetPageCount() const = 0;
virtual size_t GetPageSize() const = 0;
virtual void* MapPage(size_t pageIdx) = 0;
virtual void UnmapPage(size_t pageIdx) = 0;
// </interfuscator:shuffle>
protected:
virtual ~IMemoryAddressRange() {}
};
class IPageMappingHeap
{
public:
// <interfuscator:shuffle>
virtual void Release() = 0;
virtual size_t GetGranularity() const = 0;
virtual bool IsInAddressRange(void* ptr) const = 0;
virtual size_t FindLargestFreeBlockSize() const = 0;
virtual void* Map(size_t sz) = 0;
virtual void Unmap(void* ptr, size_t sz) = 0;
// </interfuscator:shuffle>
protected:
virtual ~IPageMappingHeap() {}
};
#endif // CRYINCLUDE_CRYCOMMON_IMEMORY_H

2
Code/CryEngine/CryCommon/IRenderer.h
Unescape Escape View File

@ -1510,7 +1510,6 @@ struct IRenderer
// Summary:
// Loads lightmap for name.
virtual int EF_LoadLightmap (const char* name) = 0;
virtual bool EF_RenderEnvironmentCubeHDR (int size, Vec3& Pos, TArray<unsigned short>& vecData) = 0;
// Summary:
// Starts using of the shaders (return first index for allow recursions).
@ -1547,7 +1546,6 @@ struct IRenderer
virtual int EF_AddDeferredLight(const CDLight& pLight, float fMult, const SRenderingPassInfo& passInfo, const SRendItemSorter& rendItemSorter) = 0;
virtual uint32 EF_GetDeferredLightsNum(eDeferredLightType eLightType = eDLT_DeferredLight) = 0;
virtual void EF_ClearDeferredLightsList() = 0;
virtual TArray<SRenderLight>* EF_GetDeferredLights(const SRenderingPassInfo& passInfo, eDeferredLightType eLightType = eDLT_DeferredLight) = 0;
virtual uint8 EF_AddDeferredClipVolume(const IClipVolume* pClipVolume) = 0;
virtual bool EF_SetDeferredClipVolumeBlendData(const IClipVolume* pClipVolume, const SClipVolumeBlendInfo& blendInfo) = 0;

64
Code/CryEngine/CryCommon/IResourceCollector.h
Unescape Escape 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_IRESOURCECOLLECTOR_H
#define CRYINCLUDE_CRYCOMMON_IRESOURCECOLLECTOR_H
#pragma once
// used to collect the assets needed for streaming and to gather statistics
struct IResourceCollector
{
// <interfuscator:shuffle>
// Arguments:
// dwMemSize 0xffffffff if size is unknown
// Returns:
// true=new resource was added, false=resource was already registered
virtual bool AddResource(const char* szFileName, const uint32 dwMemSize) = 0;
// Arguments:
// szFileName - needs to be registered before with AddResource()
// pInstance - must not be 0
virtual void AddInstance(const char* szFileName, void* pInstance) = 0;
//
// Arguments:
// szFileName - needs to be registered before with AddResource()
virtual void OpenDependencies(const char* szFileName) = 0;
//
virtual void CloseDependencies() = 0;
// Resets the internal data structure for the resource collector.
virtual void Reset() = 0;
// </interfuscator:shuffle>
protected:
virtual ~IResourceCollector() {}
};
class NullResCollector
: public IResourceCollector
{
public:
virtual bool AddResource([[maybe_unused]] const char* szFileName, [[maybe_unused]] const uint32 dwMemSize) { return true; }
virtual void AddInstance([[maybe_unused]] const char* szFileName, [[maybe_unused]] void* pInstance) {}
virtual void OpenDependencies([[maybe_unused]] const char* szFileName) {}
virtual void CloseDependencies() {}
virtual void Reset() {}
virtual ~NullResCollector() {}
};
#endif // CRYINCLUDE_CRYCOMMON_IRESOURCECOLLECTOR_H

84
Code/CryEngine/CryCommon/IResourceManager.h
Unescape Escape View File

@ -1,84 +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 Resource Manager
#ifndef CRYINCLUDE_CRYCOMMON_IRESOURCEMANAGER_H
#define CRYINCLUDE_CRYCOMMON_IRESOURCEMANAGER_H
#pragma once
namespace AZ::IO
{
struct IResourceList;
}
struct SLayerPakStats
{
struct SEntry
{
string name;
size_t nSize;
string status;
bool bStreaming;
};
typedef std::vector<SEntry> TEntries;
TEntries m_entries;
size_t m_MaxSize;
size_t m_UsedSize;
};
//////////////////////////////////////////////////////////////////////////
// IResource manager interface
//////////////////////////////////////////////////////////////////////////
struct IResourceManager
{
// <interfuscator:shuffle>
virtual ~IResourceManager(){}
// Called by level system to set the level folder
virtual void PrepareLevel(const char* sLevelFolder, const char* sLevelName) = 0;
// Called by level system after the level has been unloaded.
virtual void UnloadLevel() = 0;
// Call to get current level resource list.
virtual AZ::IO::IResourceList* GetLevelResourceList() = 0;
// Load pak file from level cache to memory.
// sBindRoot is a path in virtual file system, where new pak will be mapper to (ex. LevelCache/mtl)
virtual bool LoadLevelCachePak(const char* sPakName, const char* sBindRoot, bool bOnlyDuringLevelLoading = true) = 0;
// Unloads level cache pak file from memory.
virtual void UnloadLevelCachePak(const char* sPakName) = 0;
//Loads the pak file for mode switching into memory e.g. Single player mode to Multiplayer mode
virtual bool LoadModeSwitchPak(const char* sPakName, const bool multiplayer) = 0;
//Unloads the mode switching pak file
virtual void UnloadModeSwitchPak(const char* sPakName, const char* sResourceListName, const bool multiplayer) = 0;
// Load general pak file to memory.
virtual bool LoadPakToMemAsync(const char* pPath, bool bLevelLoadOnly) = 0;
// Unload all aync paks
virtual void UnloadAllAsyncPaks() = 0;
// Load pak file from active layer to memory.
virtual bool LoadLayerPak(const char* sLayerName) = 0;
// Unloads layer pak file from memory if no more references.
virtual void UnloadLayerPak(const char* sLayerName) = 0;
// Retrieve stats on the layer pak
virtual void GetLayerPakStats(SLayerPakStats& stats, bool bCollectAllStats) const = 0;
// Return time it took to load and precache the level.
virtual CTimeValue GetLastLevelLoadTime() const = 0;
virtual void GetMemoryStatistics(ICrySizer* pSizer) = 0;
// </interfuscator:shuffle>
};
#endif // CRYINCLUDE_CRYCOMMON_IRESOURCEMANAGER_H

53
Code/CryEngine/CryCommon/ISerialize.h
Unescape Escape View File

@ -20,7 +20,6 @@
#include <Cry_Math.h>
#include <IXml.h>
#include "CountedValue.h"
#include "MiniQueue.h"
#include <VectorSet.h>
#include <VectorMap.h>
@ -471,58 +470,6 @@ public:
}
}
template <class T>
void Value(const char* name, CountedValue<T>& countedValue)
{
if (!BeginOptionalGroup(name, true))
{
return;
}
if (IsWriting())
{
T rawValue = countedValue.Peek();
Value("Value", rawValue);
typename CountedValue<T>::TCountedID rawId = countedValue.GetLatestID();
Value("Id", rawId, 'ui32');
}
if (IsReading())
{
T rawValue;
Value("Value", rawValue);
typename CountedValue<T>::TCountedID rawId;
Value("Id", rawId, 'ui32');
countedValue.UpdateDuringSerializationOnly(rawValue, rawId);
}
EndGroup();
}
template <class T>
void Value(const char* name, CountedValue<T>& countedValue, int policy)
{
if (!BeginOptionalGroup(name, true))
{
return;
}
if (IsWriting())
{
T rawValue = countedValue.Peek();
Value("Value", rawValue, policy);
typename CountedValue<T>::TCountedID rawId = countedValue.GetLatestID();
Value("Id", rawId, 'ui32');
}
if (IsReading())
{
T rawValue;
Value("Value", rawValue, policy);
typename CountedValue<T>::TCountedID rawId;
Value("Id", rawId, 'ui32');
countedValue.UpdateDuringSerializationOnly(rawValue, rawId);
}
EndGroup();
}
bool ValueChar(const char* name, char* buffer, int len)
{
string temp;

72
Code/CryEngine/CryCommon/IShader.h
Unescape Escape View File

@ -36,8 +36,6 @@
#include <CrySizer.h>
#include <IMaterial.h>
#include <CryThreadSafeRendererContainer.h>
struct IMaterial;
class CRendElementBase;
class CRenderObject;
@ -2238,74 +2236,6 @@ struct SShaderTexSlots
}
};
struct SShaderGenBit
{
SShaderGenBit()
{
m_Mask = 0;
m_Flags = 0;
m_nDependencySet = 0;
m_nDependencyReset = 0;
m_NameLength = 0;
m_dwToken = 0;
}
string m_ParamName;
string m_ParamProp;
string m_ParamDesc;
int m_NameLength;
uint64 m_Mask;
uint32 m_Flags;
uint32 m_dwToken;
std::vector<uint32> m_PrecacheNames;
std::vector<string> m_DependSets;
std::vector<string> m_DependResets;
uint32 m_nDependencySet;
uint32 m_nDependencyReset;
void GetMemoryUsage(ICrySizer* pSizer) const
{
pSizer->AddObject(m_ParamName);
pSizer->AddObject(m_ParamProp);
pSizer->AddObject(m_ParamDesc);
pSizer->AddObject(m_PrecacheNames);
pSizer->AddObject(m_DependSets);
pSizer->AddObject(m_DependResets);
}
};
struct SShaderGen
{
uint32 m_nRefCount;
TArray<SShaderGenBit*> m_BitMask;
SShaderGen()
{
m_nRefCount = 1;
}
~SShaderGen()
{
uint32 i;
for (i = 0; i < m_BitMask.Num(); i++)
{
SShaderGenBit* pBit = m_BitMask[i];
SAFE_DELETE(pBit);
}
m_BitMask.Free();
}
void Release()
{
m_nRefCount--;
if (!m_nRefCount)
{
delete this;
}
}
void GetMemoryUsage(ICrySizer* pSizer) const
{
pSizer->AddObject(m_BitMask);
}
};
//===================================================================================
enum EShaderType
@ -2570,7 +2500,6 @@ public:
virtual void SetFlags2(int Flags) = 0;
virtual void ClearFlags2(int Flags) = 0;
virtual bool Reload(int nFlags, const char* szShaderName) = 0;
virtual TArray<CRendElementBase*>* GetREs (int nTech) = 0;
virtual AZStd::vector<SShaderParam>& GetPublicParams() = 0;
virtual int GetTexId () = 0;
virtual ITexture* GetBaseTexture(int* nPass, int* nTU) = 0;
@ -2579,7 +2508,6 @@ public:
virtual ECull GetCull(void) = 0;
virtual int Size(int Flags) = 0;
virtual uint64 GetGenerationMask() = 0;
virtual SShaderGen* GetGenerationParams() = 0;
virtual size_t GetNumberOfUVSets() = 0;
virtual int GetTechniqueID(int nTechnique, int nRegisteredTechnique) = 0;
virtual AZ::Vertex::Format GetVertexFormat(void) = 0;

493
Code/CryEngine/CryCommon/IStreamEngine.h
Unescape Escape View File

@ -1,493 +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.
// This is the prototypes of interfaces that will be used for asynchronous
// I/O (streaming).
// THIS IS NOT FINAL AND IS SUBJECT TO CHANGE WITHOUT NOTICE
// Some excerpts explaining basic ideas behind streaming design here:
/*
* The idea is that the data loaded is ready for usage and ideally doesn't need further transformation,
* therefore the client allocates the buffer (to avoid extra copy). All the data transformations should take place in the Resource Compiler. If you have to allocate a lot of small memory objects, you should revise this strategy in favor of one big allocation (again, that will be read directly from the compiled file).
* Anyway, we can negotiate that the streaming engine allocates this memory.
* In the end, it could make use of a memory pool, and copying data is not the bottleneck in our engine
*
* The client should take care of all fast operations. Looking up file size should be fast on the virtual
* file system in a pak file, because the directory should be preloaded in memory
*/
#ifndef CRYINCLUDE_CRYCOMMON_ISTREAMENGINE_H
#define CRYINCLUDE_CRYCOMMON_ISTREAMENGINE_H
#pragma once
#include <list>
#include "smartptr.h"
#include "CryThread.h"
#include "IStreamEngineDefs.h"
class IStreamCallback;
class ICrySizer;
#define STREAM_TASK_TYPE_AUDIO_ALL ((1 << eStreamTaskTypeMusic) | (1 << eStreamTaskTypeSound) | (1 << eStreamTaskTypeFSBCache))
// Description:
// This is used as parameter to the asynchronous read function
// all the unnecessary parameters go here, because there are many of them.
struct StreamReadParams
{
public:
StreamReadParams()
{
memset(this, 0, sizeof(*this));
ePriority = estpNormal;
}
StreamReadParams (
DWORD_PTR _dwUserData,
EStreamTaskPriority _ePriority = estpNormal,
unsigned _nLoadTime = 0,
unsigned _nMaxLoadTime = 0,
unsigned _nOffset = 0,
unsigned _nSize = 0,
void* _pBuffer = NULL,
unsigned _nFlags = 0
)
: dwUserData (_dwUserData)
, ePriority(_ePriority)
, nPerceptualImportance(0)
, nLoadTime(_nLoadTime)
, nMaxLoadTime(_nMaxLoadTime)
, pBuffer (_pBuffer)
, nOffset (_nOffset)
, nSize (_nSize)
, eMediaType(eStreamSourceTypeUnknown)
, nFlags (_nFlags)
{
}
// Summary:
// File name.
//const char* szFile;
// Summary:
// The callback.
//IStreamCallback* pAsyncCallback;
// Summary:
// The user data that'll be used to call the callback.
DWORD_PTR dwUserData;
// The priority of this read
EStreamTaskPriority ePriority;
// Value from 0-255 of the perceptual importance of the task (used for debugging task sheduling)
uint8 nPerceptualImportance;
// Description:
// The desirable loading time, in milliseconds, from the time of call
// 0 means as fast as possible (desirably in this frame).
unsigned nLoadTime;
// Description:
// The maximum load time, in milliseconds. 0 means forever. If the read lasts longer, it can be discarded.
// WARNING: avoid too small max times, like 1-10 ms, because many loads will be discarded in this case.
unsigned nMaxLoadTime;
// Description:
// The buffer into which to read the file or the file piece
// if this is NULL, the streaming engine will supply the buffer.
// Notes:
// DO NOT USE THIS BUFFER during read operation! DO NOT READ from it, it can lead to memory corruption!
void* pBuffer;
// Description:
// Offset in the file to read; if this is not 0, then the file read
// occurs beginning with the specified offset in bytes.
// The callback interface receives the size of already read data as nSize
// and generally behaves as if the piece of file would be a file of its own.
unsigned nOffset;
// Description:
// Number of bytes to read; if this is 0, then the whole file is read,
// if nSize == 0 && nOffset != 0, then the file from the offset to the end is read.
// If nSize != 0, then the file piece from nOffset is read, at most nSize bytes
// (if less, an error is reported). So, from nOffset byte to nOffset + nSize - 1 byte in the file.
unsigned nSize;
// Description:
// Media type to use when starting file request - if wrong, the request may take longer to complete
EStreamSourceMediaType eMediaType;
// Description:
// The combination of one or several flags from the stream engine general purpose flags.
// See also:
// IStreamEngine::EFlags
unsigned nFlags;
};
struct StreamReadBatchParams
{
StreamReadBatchParams()
: tSource((EStreamTaskType)0)
, szFile(NULL)
, pCallback(NULL)
{
}
EStreamTaskType tSource;
const char* szFile;
IStreamCallback* pCallback;
StreamReadParams params;
};
struct IStreamEngineListener
{
// <interfuscator:shuffle>
virtual ~IStreamEngineListener() {}
virtual void OnStreamEnqueue(const void* pReq, const char* filename, EStreamTaskType source, const StreamReadParams& readParams) = 0;
virtual void OnStreamComputedSortKey(const void* pReq, uint64 key) = 0;
virtual void OnStreamBeginIO(const void* pReq, uint32 compressSize, uint32 readSize, EStreamSourceMediaType mediaType) = 0;
virtual void OnStreamEndIO(const void* pReq) = 0;
virtual void OnStreamBeginInflate(const void* pReq) = 0;
virtual void OnStreamEndInflate(const void* pReq) = 0;
virtual void OnStreamBeginAsyncCallback(const void* pReq) = 0;
virtual void OnStreamEndAsyncCallback(const void* pReq) = 0;
virtual void OnStreamDone(const void* pReq) = 0;
virtual void OnStreamPreempted(const void* pReq) = 0;
virtual void OnStreamResumed(const void* pReq) = 0;
// </interfuscator:shuffle>
};
// Description:
// The highest level. There is only one StreamingEngine in the application
// and it controls all I/O streams.
struct IStreamEngine
{
public:
enum EJobType
{
ejtStarted = 1 << 0,
ejtPending = 1 << 1,
ejtFinished = 1 << 2,
};
// Summary:
// General purpose flags.
enum EFlags
{
// Description:
// If this is set only asynchronous callback will be called.
FLAGS_NO_SYNC_CALLBACK = BIT(0),
// Description:
// If this is set the file will be read from disc directly, instead of from the pak system.
FLAGS_FILE_ON_DISK = BIT(1),
// Description:
// Ignore the tmp out of streaming memory for this request
FLAGS_IGNORE_TMP_OUT_OF_MEM = BIT(2),
// Description:
// External buffer is write only
FLAGS_WRITE_ONLY_EXTERNAL_BUFFER = BIT(3),
};
// <interfuscator:shuffle>
// Description:
// Starts asynchronous read from the specified file (the file may be on a
// virtual file system, in pak or zip file or wherever).
// Reads the file contents into the given buffer, up to the given size.
// Upon success, calls success callback. If the file is truncated or for other
// reason can not be read, calls error callback. The callback can be NULL (in this case, the client should poll
// the returned IReadStream object; the returned object must be locked for that)
// NOTE: the error/success/ progress callbacks can also be called from INSIDE this function.
// Arguments:
// tSource -
// szFile -
// pCallback -
// pParams - PLACEHOLDER for the future additional parameters (like priority), or really
// a pointer to a structure that will hold the parameters if there are too many of them.
// Return Value:
// IReadStream is reference-counted and will be automatically deleted if you don't refer to it;
// if you don't store it immediately in an auto-pointer, it may be deleted as soon as on the next line of code,
// because the read operation may complete immediately inside StartRead() and the object is self-disposed
// as soon as the callback is called.
// Remarks:
// In some implementations disposal of the old pointers happen synchronously
// (in the main thread) outside StartRead() (it happens in the entity update),
// so you're guaranteed that it won't trash inside the calling function. However, this may change in the future
// and you'll be required to assign it to IReadStream immediately (StartRead will return IReadStream_AutoPtr then).
// See also:
// IReadStream,IReadStream_AutoPtr
virtual IReadStreamPtr StartRead (const EStreamTaskType tSource, const char* szFile, IStreamCallback* pCallback = NULL, const StreamReadParams* pParams = NULL) = 0;
// Pass a callback to preRequestCallback if you need to execute code right before the requests get enqueued; the callback is called only once per execution
virtual size_t StartBatchRead(IReadStreamPtr* pStreamsOut, const StreamReadBatchParams* pReqs, size_t numReqs, AZStd::function<void ()>* preRequestCallback = nullptr) = 0;
// Call this methods before/after submitting large number of new requests.
virtual void BeginReadGroup() = 0;
virtual void EndReadGroup() = 0;
// Pause/resumes streaming of specific data types.
// nPauseTypesBitmask is a bit mask of data types (ex, 1<<eStreamTaskTypeGeometry)
virtual void PauseStreaming(bool bPause, uint32 nPauseTypesBitmask) = 0;
// Get pause bit mask
virtual uint32 GetPauseMask() const = 0;
// Pause/resumes any IO active from the streaming engine
virtual void PauseIO(bool bPause) = 0;
// Description:
// Is the streaming data available on harddisc for fast streaming
virtual bool IsStreamDataOnHDD() const = 0;
// Description:
// Inform streaming engine that the streaming data is available on HDD
virtual void SetStreamDataOnHDD(bool bFlag) = 0;
// Description:
// Per frame update ofthe streaming engine, synchronous events are dispatched from this function.
virtual void Update() = 0;
// Description:
// Per frame update of the streaming engine, synchronous events are dispatched from this function, by particular TypesBitmask.
virtual void Update(uint32 nUpdateTypesBitmask) = 0;
// Description:
// Waits until all submitted requests are complete. (can abort all reads which are currently in flight)
virtual void UpdateAndWait(bool bAbortAll = false) = 0;
// Description:
// Puts the memory statistics into the given sizer object.
// According to the specifications in interface ICrySizer.
// See also:
// ICrySizer
virtual void GetMemoryStatistics(ICrySizer* pSizer) = 0;
#if defined(STREAMENGINE_ENABLE_STATS)
// Description:
// Returns the streaming statistics collected from the previous call.
virtual SStreamEngineStatistics& GetStreamingStatistics() = 0;
virtual void ClearStatistics() = 0;
// Description:
// returns the bandwidth used for the given type of streaming task
virtual void GetBandwidthStats(EStreamTaskType type, float* bandwidth) = 0;
#endif
// Description:
// Returns the counts of open streaming requests.
virtual void GetStreamingOpenStatistics(SStreamEngineOpenStats& openStatsOut) = 0;
virtual const char* GetStreamTaskTypeName(EStreamTaskType type) = 0;
#if defined(STREAMENGINE_ENABLE_LISTENER)
// Description:
// Sets up a listener for stream events (used for statoscope)
virtual void SetListener(IStreamEngineListener* pListener) = 0;
virtual IStreamEngineListener* GetListener() = 0;
#endif
virtual ~IStreamEngine() {}
// </interfuscator:shuffle>
};
// Description:
// This is the file "handle" that can be used to query the status
// of the asynchronous operation on the file. The same object may be returned
// for the same file to multiple clients.
// Notes:
// It will actually represent the asynchronous object in memory, and will be
// thread-safe reference-counted (both AddRef() and Release() will be virtual
// and thread-safe, just like the others)
// Example:
// USE:
// IReadStream_AutoPtr pReadStream = pStreamEngine->StartRead ("bla.xxx", this);
// OR:
// pStreamEngine->StartRead ("MusicSystem","bla.xxx", this);
class IReadStream
{
public:
// <interfuscator:shuffle>
// Summary:
// Increment ref count, returns new count
virtual int AddRef() = 0;
// Summary:
// Decrement ref count, returns new count
virtual int Release() = 0;
// Summary:
// Returns true if the file read was not successful.
virtual bool IsError() = 0;
// Return Value:
// True if the file read was completed successfully.
// Summary:
// Checks IsError to check if the whole requested file (piece) was read.
virtual bool IsFinished() = 0;
// Description:
// Returns the number of bytes read so far (the whole buffer size if IsFinished())
// Arguments:
// bWait - if == true, then waits until the pending I/O operation completes.
// Return Value:
// The total number of bytes read (if it completes successfully, returns the size of block being read)
virtual unsigned int GetBytesRead(bool bWait = false) = 0;
// Description:
// Returns the buffer into which the data has been or will be read
// at least GetBytesRead() bytes in this buffer are guaranteed to be already read.
// Notes:
// DO NOT USE THIS BUFFER during read operation! DO NOT READ from it, it can lead to memory corruption!
virtual const void* GetBuffer () = 0;
// Description:
// Returns the transparent DWORD that was passed in the StreamReadParams::dwUserData field
// of the structure passed in the call to IStreamEngine::StartRead.
// See also:
// StreamReadParams::dwUserData,IStreamEngine::StartRead
virtual DWORD_PTR GetUserData() = 0;
// Summary:
// Set user defined data into stream's params.
virtual void SetUserData(DWORD_PTR dwUserData) = 0;
// Description:
// Tries to stop reading the stream; this is advisory and may have no effect
// but the callback will not be called after this. If you just destructing object,
// dereference this object and it will automatically abort and release all associated resources.
virtual void Abort() = 0;
// Description:
// Tries to stop reading the stream, as long as IO or the async callback is not currently
// in progress.
virtual bool TryAbort() = 0;
// Summary:
// Unconditionally waits until the callback is called.
// if nMaxWaitMillis is not negative wait for the specified ammount of milliseconds then exit.
// Example:
// If the stream hasn't yet finish, it's guaranteed that the user-supplied callback
// is called before return from this function (unless no callback was specified).
virtual void Wait(int nMaxWaitMillis = -1) = 0;
// Summary:
// Returns stream params.
virtual const StreamReadParams& GetParams() const = 0;
// Summary:
// Returns caller type.
virtual const EStreamTaskType GetCallerType() const = 0;
// Summary:
// Returns media type used to satisfy request - only valid once stream has begun read.
virtual EStreamSourceMediaType GetMediaType() const = 0;
// Summary:
// Returns pointer to callback routine(can be NULL).
virtual IStreamCallback* GetCallback() const = 0;
// Summary:
// Returns IO error #.
virtual unsigned GetError() const = 0;
// Summary:
// Returns IO error name
virtual const char* GetErrorName() const = 0;
// Summary:
// Returns stream name.
virtual const char* GetName() const = 0;
// Summary:
// Free temporary memory allocated for this stream, when not needed anymore.
// Can be called from Async callback, to free memory earlier, not waiting for synchrounus callback.
virtual void FreeTemporaryMemory() = 0;
// </interfuscator:shuffle>
protected:
// Summary:
// The clients are not allowed to destroy this object directly; only via Release().
virtual ~IReadStream() {}
};
TYPEDEF_AUTOPTR(IReadStream);
// Description:
// CryPak supports asynchronous reading through this interface. The callback
// is called from the main thread in the frame update loop.
//
// The callback receives packets through StreamOnComplete() and
// StreamOnProgress(). The second one can be used to update the asset based
// on the partial data that arrived. the callback that will be called by the
// streaming engine must be implemented by all clients that want to use
// StreamingEngine services
// Remarks:
// the pStream interface is guaranteed to be locked (have reference count > 0)
// while inside the function, but can vanish any time outside the function.
// If you need it, keep it from the beginning (after call to StartRead())
// some or all callbacks MAY be called from inside IStreamEngine::StartRead()
//
// Example:
// <code>
// IStreamEngine *pStreamEngine = g_pISystem->GetStreamEngine(); // get streaming engine
// IStreamCallback *pAsyncCallback = &MyClass; // user
//
// StreamReadParams params;
//
// params.dwUserData = 0;
// params.nSize = 0;
// params.pBuffer = NULL;
// params.nLoadTime = 10000;
// params.nMaxLoadTime = 10000;
//
// pStreamEngine->StartRead( .. pAsyncCallback .. params .. ); // registers callback
// </code>
class IStreamCallback
{
public:
// <interfuscator:shuffle>
virtual ~IStreamCallback(){}
// Description:
// Signals that the file length for the request has been found, and that storage is needed
// Either a pointer to a block of nSize bytes can be returned, into which the file will be
// streamed, or NULL can be returned, in which case temporary memory will be allocated
// internally by the stream engine (which will be freed upon job completion).
virtual void* StreamOnNeedStorage ([[maybe_unused]] IReadStream* pStream, [[maybe_unused]] unsigned nSize, [[maybe_unused]] bool& bAbortOnFailToAlloc) {return NULL; }
// Description:
// Signals that reading the requested data has completed (with or without error).
// This callback is always called, whether an error occurs or not.
// pStream will signal either IsFinished() or IsError() and will hold the (perhaps partially) read data until this interface is released.
// GetBytesRead() will return the size of the file (the completely read buffer) in case of successful operation end
// or the size of partially read data in case of error (0 if nothing was read).
// Pending status is true during this callback, because the callback itself is the part of IO operation.
// nError == 0 : Success
// nError != 0 : Error code
virtual void StreamAsyncOnComplete ([[maybe_unused]] IReadStream* pStream, [[maybe_unused]] unsigned nError) {}
// Description:
// Signals that reading the requested data has completed (with or without error).
// This callback is always called, whether an error occurs or not.
// pStream will signal either IsFinished() or IsError() and will hold the (perhaps partially) read data until this interface is released.
// GetBytesRead() will return the size of the file (the completely read buffer) in case of successful operation end
// or the size of partially read data in case of error (0 if nothing was read).
// Pending status is true during this callback, because the callback itself is the part of IO operation.
// nError == 0 : Success
// nError != 0 : Error code
virtual void StreamOnComplete ([[maybe_unused]] IReadStream* pStream, [[maybe_unused]] unsigned nError) {}
// </interfuscator:shuffle>
};
#endif // CRYINCLUDE_CRYCOMMON_ISTREAMENGINE_H

236
Code/CryEngine/CryCommon/IStreamEngineDefs.h
Unescape Escape 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.
#ifndef CRYINCLUDE_CRYCOMMON_ISTREAMENGINEDEFS_H
#define CRYINCLUDE_CRYCOMMON_ISTREAMENGINEDEFS_H
#pragma once
#if defined(ENABLE_PROFILING_CODE)
#define STREAMENGINE_ENABLE_LISTENER
#define STREAMENGINE_ENABLE_STATS
#endif
enum : unsigned int
{
ERROR_UNKNOWN_ERROR = 0xF0000000,
ERROR_UNEXPECTED_DESTRUCTION = 0xF0000001,
ERROR_INVALID_CALL = 0xF0000002,
ERROR_CANT_OPEN_FILE = 0xF0000003,
ERROR_REFSTREAM_ERROR = 0xF0000004,
ERROR_OFFSET_OUT_OF_RANGE = 0xF0000005,
ERROR_REGION_OUT_OF_RANGE = 0xF0000006,
ERROR_SIZE_OUT_OF_RANGE = 0xF0000007,
ERROR_CANT_START_READING = 0xF0000008,
ERROR_OUT_OF_MEMORY = 0xF0000009,
ERROR_ABORTED_ON_SHUTDOWN = 0xF000000A,
ERROR_OUT_OF_MEMORY_QUOTA = 0xF000000B,
ERROR_ZIP_CACHE_FAILURE = 0xF000000C,
ERROR_USER_ABORT = 0xF000000D,
ERROR_MISSCHEDULED = 0xF000000F,
ERROR_VERIFICATION_FAIL = 0xF0000010,
ERROR_PREEMPTED = 0xF0000011,
ERROR_DECOMPRESSION_FAIL = 0xF0000012
};
// Summary:
// Types of streaming tasks
// Affects priority directly
enum EStreamTaskType
{
eStreamTaskTypeCount = 14,
eStreamTaskTypeGeomCache = 13,
eStreamTaskTypePak = 12,
eStreamTaskTypeFlash = 11,
eStreamTaskTypeVideo = 10,
eStreamTaskTypeMergedMesh = 9,
eStreamTaskTypeShader = 8,
eStreamTaskTypeSound = 7,
eStreamTaskTypeMusic = 6,
eStreamTaskTypeFSBCache = 5,
eStreamTaskTypeAnimation = 4,
eStreamTaskTypeTerrain = 3,
eStreamTaskTypeGeometry = 2,
eStreamTaskTypeTexture = 1,
};
// Summary:
// Priority types of streaming tasks
// Affects priority directly
// Limiting number of priority values allows streaming system to minimize seek time
enum EStreamTaskPriority
{
estpUrgent = 0,
estpPreempted = 1, //For internal use only
estpAboveNormal = 2,
estpNormal = 3,
estpBelowNormal = 4,
estpIdle = 5,
};
enum EStreamSourceMediaType : int32_t
{
eStreamSourceTypeUnknown = 0,
eStreamSourceTypeHDD,
eStreamSourceTypeDisc,
eStreamSourceTypeMemory,
};
#if defined(STREAMENGINE_ENABLE_STATS)
struct SStreamEngineStatistics
{
struct SMediaTypeInfo
{
SMediaTypeInfo()
{
ResetStats();
}
void ResetStats()
{
memset(this, 0, sizeof(SMediaTypeInfo));
}
float fActiveDuringLastSecond; // Amount of time media device was active during last second
float fAverageActiveTime; // Average time since last reset that the media device was active
uint32 nBytesRead; // Bytes read during last second.
uint32 nRequestCount; // Amount of requests during last second.
uint64 nTotalBytesRead; // Read bytes total from reset.
uint32 nTotalRequestCount; // Number of request from reset.
uint64 nSeekOffsetLastSecond; // Average seek offset during the last second
uint64 nAverageSeekOffset; // Average seek offset since last reset
uint32 nCurrentReadBandwidth; // Bytes/second for last second
uint32 nSessionReadBandwidth; // Bytes/second for last second
uint32 nActualReadBandwidth; // Bytes/second for last second - only taking actual reading into account
uint32 nAverageActualReadBandwidth; // Average read bandwidth in total from reset - only taking actual read time into account
};
SMediaTypeInfo hddInfo;
SMediaTypeInfo memoryInfo;
SMediaTypeInfo discInfo;
uint32 nTotalSessionReadBandwidth;// Average read bandwidth in total from reset - taking full time into account from reset
uint32 nTotalCurrentReadBandwidth;// Total bytes/sec over all types and systems.
int nPendingReadBytes; // How many bytes still need to be read
float fAverageCompletionTime; // Time in seconds on average takes to complete file request.
float fAverageRequestCount; // Average requests per second being done to streaming engine
uint64 nMainStreamingThreadWait;
uint64 nTotalBytesRead; // Read bytes total from reset.
uint32 nTotalRequestCount; // Number of request from reset to the streaming engine.
uint32 nTotalStreamingRequestCount; // Number of request from reset which actually resulted in streaming data.
int nCurrentDecompressCount; // Number of requests currently waiting to be decompresses
int nCurrentAsyncCount; // Number of requests currently waiting to be async callback
int nCurrentFinishedCount; // Number of requests currently waiting to be finished by mainthread
uint32 nDecompressBandwidth; // Bytes/second for last second
uint32 nVerifyBandwidth; // Bytes/second for last second
uint32 nDecompressBandwidthAverage; // Bytes/second in total.
uint32 nVerifyBandwidthAverage; // Bytes/second in total.
bool bTempMemOutOfBudget; // Was the temporary streaming memory out of budget during the last second
int nMaxTempMemory; // Maximum temporary memory used by the streaming system
int nTempMemory;
struct SRequestTypeInfo
{
SRequestTypeInfo()
: nPendingReadBytes(0)
{
ResetStats();
}
void ResetStats()
{
nTmpReadBytes = 0;
nTotalStreamingRequestCount = 0;
nTotalReadBytes = 0;
nTotalRequestDataSize = 0;
nTotalRequestCount = 0;
nCurrentReadBandwidth = 0;
nSessionReadBandwidth = 0;
fTotalCompletionTime = .0f;
fAverageCompletionTime = .0f;
}
void Merge(const SRequestTypeInfo& _other)
{
nPendingReadBytes += _other.nPendingReadBytes;
nTmpReadBytes += _other.nTmpReadBytes;
nTotalStreamingRequestCount += _other.nTotalStreamingRequestCount;
nTotalReadBytes += _other.nTotalReadBytes;
nTotalRequestDataSize += _other.nTotalRequestDataSize;
nTotalRequestCount += _other.nTotalRequestCount;
fTotalCompletionTime += _other.fTotalCompletionTime;
}
int nPendingReadBytes; // How many bytes still need to be read from media
uint64 nTmpReadBytes; // Read bytes since last update to compute current bandwidth
uint32 nTotalStreamingRequestCount; // Total actual streaming requests of this type
uint64 nTotalReadBytes; // Total actual read bytes (compressed data)
uint64 nTotalRequestDataSize; // Total requested bytes from client (uncompressed data)
uint32 nTotalRequestCount; // Total number of finished requests
uint32 nCurrentReadBandwidth; // Bytes/second for this type during last second
uint32 nSessionReadBandwidth; // Average read bandwidth in total from reset - taking full time into account from reset
float fTotalCompletionTime; // Time it took to finish all current requests
float fAverageCompletionTime; // Average time it takes to fully complete a request of this type
float fAverageRequestCount; // Average amount of requests made per second
};
SRequestTypeInfo typeInfo[eStreamTaskTypeCount];
struct SAsset
{
CryStringLocal m_sName;
int m_nSize;
const bool operator<(const SAsset& a) const { return m_nSize > a.m_nSize; }
SAsset() {}
SAsset(const CryStringLocal& sName, const int nSize)
: m_sName(sName)
, m_nSize(nSize) { }
friend void swap(SAsset& a, SAsset& b)
{
using std::swap;
a.m_sName.swap(b.m_sName);
swap(a.m_nSize, b.m_nSize);
}
};
DynArray<SAsset> vecHeavyAssets;
};
#endif
struct SStreamEngineOpenStats
{
int nOpenRequestCount;
int nOpenRequestCountByType[eStreamTaskTypeCount];
};
class IReadStream;
TYPEDEF_AUTOPTR(IReadStream);
// typedef IReadStream_AutoPtr auto ptr wrapper
typedef IReadStream_AutoPtr IReadStreamPtr;
#endif // CRYINCLUDE_CRYCOMMON_ISTREAMENGINEDEFS_H

123
Code/CryEngine/CryCommon/ISystem.h
Unescape Escape View File

@ -65,12 +65,10 @@ struct IProcess;
struct ITimer;
struct ICryFont;
struct IMovieSystem;
struct IMemoryManager;
namespace Audio
{
struct IAudioSystem;
} // namespace Audio
struct IStreamEngine;
struct SFileVersion;
struct INameTable;
struct ILevelSystem;
@ -78,18 +76,11 @@ struct IViewSystem;
class ICrySizer;
class IXMLBinarySerializer;
struct IReadWriteXMLSink;
struct IResourceManager;
struct ITextModeConsole;
struct IAVI_Reader;
class CPNoise3;
struct ILocalizationManager;
struct IZLibCompressor;
struct IZLibDecompressor;
struct ILZ4Decompressor;
class IZStdDecompressor;
struct IOutputPrintSink;
struct IWindowMessageHandler;
struct IImageHandler;
namespace AZ
{
@ -528,7 +519,6 @@ struct SSystemInitParams
ISystemUserCallback* pUserCallback;
const char* sLogFileName; // File name to use for log.
bool autoBackupLogs; // if true, logs will be automatically backed up each startup
IValidator* pValidator; // You can specify different validator object to use by System.
IOutputPrintSink* pPrintSync; // Print Sync which can be used to catch all output from engine
char szSystemCmdLine[2048]; // Command line.
@ -558,7 +548,6 @@ struct SSystemInitParams
pUserCallback = NULL;
sLogFileName = NULL;
autoBackupLogs = true;
pValidator = NULL;
pPrintSync = NULL;
memset(szSystemCmdLine, 0, sizeof(szSystemCmdLine));
@ -828,22 +817,10 @@ struct ISystem
virtual void DoWorkDuringOcclusionChecks() = 0;
virtual bool NeedDoWorkDuringOcclusionChecks() = 0;
// Summary:
// Returns the current used memory.
virtual uint32 GetUsedMemory() = 0;
// Summary:
// Retrieve the name of the user currently logged in to the computer.
virtual const char* GetUserName() = 0;
// Summary:
// Gets current supported CPU features flags. (CPUF_SSE, CPUF_SSE2, CPUF_3DNOW, CPUF_MMX)
virtual int GetCPUFlags() = 0;
// Summary:
// Gets number of CPUs
virtual int GetLogicalCPUCount() = 0;
// Summary:
// Quits the application.
virtual void Quit() = 0;
@ -860,13 +837,6 @@ struct ISystem
virtual bool IsRelaunch() const = 0;
// Summary:
// Displays an error message to display info for certain time
// Arguments:
// acMessage - Message to show
// fTime - Amount of seconds to show onscreen
virtual void DisplayErrorMessage(const char* acMessage, float fTime, const float* pfColor = 0, bool bHardError = true) = 0;
// Description:
// Displays error message.
// Logs it to console and file and error message box then terminates execution.
@ -897,35 +867,21 @@ struct ISystem
// return the related subsystem interface
//
virtual IZLibCompressor* GetIZLibCompressor() = 0;
virtual IZLibDecompressor* GetIZLibDecompressor() = 0;
virtual ILZ4Decompressor* GetLZ4Decompressor() = 0;
virtual IZStdDecompressor* GetZStdDecompressor() = 0;
virtual IViewSystem* GetIViewSystem() = 0;
virtual ILevelSystem* GetILevelSystem() = 0;
virtual INameTable* GetINameTable() = 0;
virtual IValidator* GetIValidator() = 0;
virtual IStreamEngine* GetStreamEngine() = 0;
virtual ICmdLine* GetICmdLine() = 0;
virtual ILog* GetILog() = 0;
virtual AZ::IO::IArchive* GetIPak() = 0;
virtual ICryFont* GetICryFont() = 0;
virtual IMemoryManager* GetIMemoryManager() = 0;
virtual IMovieSystem* GetIMovieSystem() = 0;
virtual ::IConsole* GetIConsole() = 0;
virtual IRemoteConsole* GetIRemoteConsole() = 0;
// Returns:
// Can be NULL, because it only exists when running through the editor, not in pure game mode.
virtual IResourceManager* GetIResourceManager() = 0;
virtual IProfilingSystem* GetIProfilingSystem() = 0;
virtual ISystemEventDispatcher* GetISystemEventDispatcher() = 0;
virtual ITimer* GetITimer() = 0;
virtual void DebugStats(bool checkpoint, bool leaks) = 0;
virtual void DumpWinHeaps() = 0;
virtual int DumpMMStats(bool log) = 0;
// Arguments:
// bValue - Set to true when running on a cheat protected server or a client that is connected to it (not used in singleplayer).
virtual void SetForceNonDevMode(bool bValue) = 0;
@ -934,7 +890,6 @@ struct ISystem
virtual bool GetForceNonDevMode() const = 0;
virtual bool WasInDevMode() const = 0;
virtual bool IsDevMode() const = 0;
virtual bool IsMODValid(const char* szMODName) const = 0;
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
@ -991,13 +946,6 @@ struct ISystem
// Gets build version.
virtual const SFileVersion& GetBuildVersion() = 0;
// Summary:
// Data compression
//##@{
virtual bool CompressDataBlock(const void* input, size_t inputSize, void* output, size_t& outputSize, int level = 3) = 0;
virtual bool DecompressDataBlock(const void* input, size_t inputSize, void* output, size_t& outputSize) = 0;
//##@}
//////////////////////////////////////////////////////////////////////////
// Configuration.
//////////////////////////////////////////////////////////////////////////
@ -1019,21 +967,8 @@ struct ISystem
// pCallback - 0 means normal LoadConfigVar behaviour is used
virtual void LoadConfiguration(const char* sFilename, ILoadConfigurationEntrySink* pSink = 0, bool warnIfMissing = true) = 0;
// Summary:
// Retrieves current configuration specification for client or server.
// Arguments:
// bClient - If true returns local client config spec, if false returns server config spec.
virtual ESystemConfigSpec GetConfigSpec(bool bClient = true) = 0;
virtual ESystemConfigSpec GetMaxConfigSpec() const = 0;
// Summary:
// Changes current configuration specification for client or server.
// Arguments:
// bClient - If true changes client config spec (sys_spec variable changed),
// if false changes only server config spec (as known on the client).
virtual void SetConfigSpec(ESystemConfigSpec spec, ESystemConfigPlatform platform, bool bClient) = 0;
//////////////////////////////////////////////////////////////////////////
// Summary:
@ -1045,10 +980,6 @@ struct ISystem
virtual void SetConfigPlatform(ESystemConfigPlatform platform) = 0;
//////////////////////////////////////////////////////////////////////////
// Summary:
// Detects and set optimal spec.
virtual void AutoDetectSpec(bool detectResolution) = 0;
// Summary:
// Query if system is now paused.
// Pause flag is set when calling system update with pause mode.
@ -1058,8 +989,6 @@ struct ISystem
// Retrieves localized strings manager interface.
virtual ILocalizationManager* GetLocalizationManager() = 0;
virtual ITextModeConsole* GetITextModeConsole() = 0;
// Summary:
// Retrieves the perlin noise singleton instance.
virtual CPNoise3* GetNoiseGen() = 0;
@ -1150,24 +1079,10 @@ struct ISystem
virtual ESystemGlobalState GetSystemGlobalState(void) = 0;
virtual void SetSystemGlobalState(ESystemGlobalState systemGlobalState) = 0;
// Summary:
// Asynchronous memcpy
// Note sync variable will be incremented (in calling thread) before job starts
// and decremented when job finishes. Multiple async copies can therefore be
// tied to the same sync variable, therefore it's advised to wait for completion with
// while(*sync) (yield());
virtual void AsyncMemcpy(void* dst, const void* src, size_t size, int nFlags, volatile int* sync) = 0;
// </interfuscator:shuffle>
#if !defined(_RELEASE)
virtual bool IsSavingResourceList() const = 0;
#endif
// Initializes Steam if needed and returns if it was successful
virtual bool SteamInit() = 0;
virtual const IImageHandler* GetImageHandler() const = 0;
// Summary:
// Gets the root window message handler function
// The returned pointer is platform-specific:
@ -1771,44 +1686,6 @@ inline void CryLogAlways(const char* format, ...)
#endif // EXCLUDE_NORMAL_LOG
/*****************************************************
ASYNC MEMCPY FUNCTIONS
*****************************************************/
// Complex delegation required because it is not really easy to
// export a external standalone symbol like a memcpy function when
// building with modules. Dll pay an extra indirection cost for calling this
// function.
#if !defined(AZ_MONOLITHIC_BUILD)
# define CRY_ASYNC_MEMCPY_DELEGATE_TO_CRYSYSTEM
#endif
#define CRY_ASYNC_MEMCPY_API extern "C"
// Note sync variable will be incremented (in calling thread) before job starts
// and decremented when job finishes. Multiple async copies can therefore be
// tied to the same sync variable, therefore wait for completion with
// while(*sync) (yield());
#if defined(CRY_ASYNC_MEMCPY_DELEGATE_TO_CRYSYSTEM)
inline void cryAsyncMemcpy(
void* dst
, const void* src
, size_t size
, int nFlags
, volatile int* sync)
{
GetISystem()->AsyncMemcpy(dst, src, size, nFlags, sync);
}
# else
CRY_ASYNC_MEMCPY_API void cryAsyncMemcpy(
void* dst
, const void* src
, size_t size
, int nFlags
, volatile int* sync);
#endif
//////////////////////////////////////////////////////////////////////////
// Additional headers.
//////////////////////////////////////////////////////////////////////////

35
Code/CryEngine/CryCommon/ITextModeConsole.h
Unescape Escape View File

@ -1,35 +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 : Allows creation of text mode displays the for dedicated server
#ifndef CRYINCLUDE_CRYCOMMON_ITEXTMODECONSOLE_H
#define CRYINCLUDE_CRYCOMMON_ITEXTMODECONSOLE_H
#pragma once
struct ITextModeConsole
{
// <interfuscator:shuffle>
virtual ~ITextModeConsole() {}
virtual Vec2_tpl<int> BeginDraw() = 0;
virtual void PutText(int x, int y, const char* msg) = 0;
virtual void EndDraw() = 0;
virtual void OnShutdown() = 0;
virtual void SetTitle([[maybe_unused]] const char* title) {}
// </interfuscator:shuffle>
};
#endif // CRYINCLUDE_CRYCOMMON_ITEXTMODECONSOLE_H

219
Code/CryEngine/CryCommon/IZLibCompressor.h
Unescape Escape View File

@ -1,219 +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_IZLIBCOMPRESSOR_H
#define CRYINCLUDE_CRYCOMMON_IZLIBCOMPRESSOR_H
#pragma once
/*
wrapper interface for the zlib compression / deflate interface
supports multiple compression streams with an async compatible wrapper
Gotchas:
the ptr to the input data must remain valid whilst the stream is deflating
the ptr to the output buffer must remain valid whilst the stream is deflating
****************************************************************************************
usage example:
IZLibCompressor *pComp=GetISystem()->GetIZLibCompressor();
// see deflateInit2() documentation zlib manual for more info on the parameters here
// this initializes the stream to produce a gzip format block with fairly low memory requirements
IZLibDeflateStream *pStream=pComp->CreateDeflateStream(2,eZMeth_Deflated,24,3,eZStrat_Default,eZFlush_NoFlush);
char *pOutput=new char[512]; // arbitrary size
const char *pInputData="This is an example piece of data that is to be compressed. It can be any arbitrary block of binary data - not just text";
const int inputBlockSize=16; // to simulate streaming of input, this example provides the input in 16 byte blocks
int totalInput=sizeof(pInputData);
int bytesInput=0;
bool done=false;
FILE *outputFile=fopen("myfile.gz","rb");
do
{
EZDeflateState state=pStream->GetState();
switch (state)
{
case eZDefState_AwaitingInput:
// 'stream' input data, there is no restriction on the block size you can input, if all the data is available immediately, input all of it at once
{
int inputSize=min(inputBlockSize,totalInput-bytesInput);
if (inputSize<=0)
{
pStream->EndInput();
}
else
{
pStream->Input(pInputData+bytesInput,inputSize);
bytesInput+=inputSize;
}
}
break;
case eZDefState_Deflating:
// do something more interesting... like getting out of this loop and running the rest of your game...
break;
case eZDefState_ConsumeOutput:
// stream output to a file
{
int bytesToOutput=pStream->GetBytesOutput();
if (bytesToOutput>0)
{
fwrite(pOutput,1,bytesToOutput,outputFile);
}
pStream->SetOutputBuffer(pOutput,sizeof(pOutput));
}
break;
case eZDefState_Finished:
case ezDefState_Error:
done=true;
break;
}
} while (!done);
fclose(outputFile);
pStream->Release();
delete [] pOutput;
****************************************************************************************/
// don't change the order of these zlib wrapping enum values without updating the mapping
// implementation in CZLibCompressorStream
enum EZLibStrategy
{
eZStrat_Default, // Z_DEFAULT_STRATEGY
eZStrat_Filtered, // Z_FILTERED
eZStrat_HuffmanOnly, // Z_HUFFMAN_ONLY
eZStrat_RLE // Z_RLE
};
enum EZLibMethod
{
eZMeth_Deflated // Z_DEFLATED
};
enum EZLibFlush
{
eZFlush_NoFlush, // Z_NO_FLUSH
eZFlush_PartialFlush, // Z_PARTIAL_FLUSH
eZFlush_SyncFlush, // Z_SYNC_FLUSH
eZFlush_FullFlush, // Z_FULL_FLUSH
};
enum EZDeflateState
{
eZDefState_AwaitingInput, // caller must call Input() or Finish() to continue
eZDefState_Deflating, // caller must wait
eZDefState_ConsumeOutput, // caller must consume output and then call SetOutputBuffer() to continue
eZDefState_Finished, // stream finished, caller must call Release() to destroy stream
eZDefState_Error // error has occurred and the stream has been closed and will no longer compress
};
struct IZLibDeflateStream
{
protected:
virtual ~IZLibDeflateStream() {}; // use Release()
public:
struct SStats
{
int bytesInput;
int bytesOutput;
int curMemoryUsed;
int peakMemoryUsed;
};
// <interfuscator:shuffle>
// Description:
// Specifies the output buffer for the deflate operation
// Should be set before providing input
// The specified buffer must remain valid (ie do not free) whilst compression is in progress (state == eZDefState_Deflating)
virtual void SetOutputBuffer(char* pInBuffer, int inSize) = 0;
// Description:
// Returns the number of bytes from the output buffer that are ready to be consumed. After consuming any output, you should call SetOutputBuffer() again to mark the buffer as available
virtual int GetBytesOutput() = 0;
// Description:
// Begins compressing the source data pInSource of length inSourceSize to a previously specified output buffer
// Only valid to be called if the stream is in state eZDefState_AwaitingInput
// The specified buffer must remain valid (ie do not free) whilst compression is in progress (state == eZDefState_Deflating)
virtual void Input(const char* pInSource, int inSourceSize) = 0;
// Description:
// Finishes the compression, causing all data to be flushed to the output buffer
// Once called no more data can be input
// After calling the caller must wait until GetState() reutrns eZDefState_Finished
virtual void EndInput() = 0;
// Description:
// Returns the state of the stream,
virtual EZDeflateState GetState() = 0;
// Description:
// Gets stats on deflate stream, valid to call at anytime
virtual void GetStats(SStats* pOutStats) = 0;
// Description:
// Deletes the deflate stream. Will assert if stream is in an invalid state to be released (in state eZDefState_Deflating)
virtual void Release() = 0;
// </interfuscator:shuffle>
};
// md5 support structure
struct SMD5Context
{
uint32 buf[4];
uint32 bits[2];
unsigned char in[64];
};
struct IZLibCompressor
{
protected:
virtual ~IZLibCompressor() {}; // use Release()
public:
// <interfuscator:shuffle>
// Description:
// Creates a deflate stream to compress data using zlib
// See documentation for zlib deflateInit2() for usage details
// inFlushMethod is passed to calls to zlib deflate(), see zlib docs on deflate() for more details
virtual IZLibDeflateStream* CreateDeflateStream(int inLevel, EZLibMethod inMethod, int inWindowBits, int inMemLevel, EZLibStrategy inStrategy, EZLibFlush inFlushMethod) = 0;
virtual void Release() = 0;
// Description:
// Initializes an MD5 context
virtual void MD5Init(SMD5Context* pIOCtx) = 0;
// Description:
// Digests some data into an existing MD5 context
virtual void MD5Update(SMD5Context* pIOCtx, const char* pInBuff, unsigned int len) = 0;
// Description:
// Closes the MD5 context and extract the final 16 byte MD5 digest value
virtual void MD5Final(SMD5Context * pIOCtx, char outDigest[16]) = 0;
// </interfuscator:shuffle>
};
#endif // CRYINCLUDE_CRYCOMMON_IZLIBCOMPRESSOR_H

94
Code/CryEngine/CryCommon/IZlibDecompressor.h
Unescape Escape View File

@ -1,94 +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 : Provides the interface for the zlib inflate wrapper
#ifndef CRYINCLUDE_CRYCOMMON_IZLIBDECOMPRESSOR_H
#define CRYINCLUDE_CRYCOMMON_IZLIBDECOMPRESSOR_H
#pragma once
enum EZInflateState
{
eZInfState_AwaitingInput, // caller must call Input() to continue
eZInfState_Inflating, // caller must wait
eZInfState_ConsumeOutput, // caller must consume output and then call SetOutputBuffer() to continue
eZInfState_Finished, // caller must call Release()
eZInfState_Error // error has occurred and the stream has been closed and will no longer compress
};
struct IZLibInflateStream
{
protected:
virtual ~IZLibInflateStream() {}; // use Release()
public:
struct SStats
{
int bytesInput;
int bytesOutput;
int curMemoryUsed;
int peakMemoryUsed;
};
// Description:
// Specifies the output buffer for the inflate operation
// Should be set before providing input
// The specified buffer must remain valid (ie do not free) whilst compression is in progress (state == eZInfState_Inflating)
virtual void SetOutputBuffer(char* pInBuffer, unsigned int inSize) = 0;
// Description:
// Returns the number of bytes from the output buffer that are ready to be consumed. After consuming any output, you should call SetOutputBuffer() again to mark the buffer as available
virtual unsigned int GetBytesOutput() = 0;
// Description:
// Begins decompressing the source data pInSource of length inSourceSize to a previously specified output buffer
// Only valid to be called if the stream is in state eZInfState_AwaitingInput
// The specified buffer must remain valid (ie do not free) whilst compression is in progress (state == eZInfState_Inflating)
virtual void Input(const char* pInSource, unsigned int inSourceSize) = 0;
// Description:
// Finishes the compression, causing all data to be flushed to the output buffer
// Once called no more data can be input
// After calling the caller must wait until GetState() reuturns eZInfState_Finished
virtual void EndInput() = 0;
// Description:
// Returns the state of the stream,
virtual EZInflateState GetState() = 0;
// Description:
// Gets stats on inflate stream, valid to call at anytime
virtual void GetStats(SStats* pOutStats) = 0;
// Description:
// Deletes the inflate stream. Will assert if stream is in an invalid state to be released (in state eZInfState_Inflating)
virtual void Release() = 0;
};
struct IZLibDecompressor
{
protected:
virtual ~IZLibDecompressor() {}; // use Release()
public:
// Description:
// Creates a inflate stream to decompress data using zlib
virtual IZLibInflateStream* CreateInflateStream() = 0;
virtual void Release() = 0;
};
#endif // CRYINCLUDE_CRYCOMMON_IZLIBDECOMPRESSOR_H

86
Code/CryEngine/CryCommon/ImageExtensionHelper.cpp
Unescape Escape View File

@ -1,86 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#include <CryCommon/ImageExtensionHelper.h>
namespace CImageExtensionHelper
{
ColorF GetAverageColor(uint8 const* pMem)
{
pMem = _findChunkStart(pMem, FOURCC_AvgC);
if (pMem)
{
ColorF ret = ColorF(SwapEndianValue(*(uint32*)pMem));
//flip red and blue
const float cRed = ret.r;
ret.r = ret.b;
ret.b = cRed;
return ret;
}
return Col_White; // chunk does not exist
}
bool IsRangeless(ETEX_Format eTF)
{
return (eTF == eTF_BC6UH ||
eTF == eTF_BC6SH ||
eTF == eTF_R9G9B9E5 ||
eTF == eTF_R16G16B16A16F ||
eTF == eTF_R32G32B32A32F ||
eTF == eTF_R16F ||
eTF == eTF_R32F ||
eTF == eTF_R16G16F ||
eTF == eTF_R11G11B10F);
}
bool IsQuantized(ETEX_Format eTF)
{
return (eTF == eTF_B4G4R4A4 ||
eTF == eTF_B5G6R5 ||
eTF == eTF_B5G5R5 ||
eTF == eTF_BC1 ||
eTF == eTF_BC2 ||
eTF == eTF_BC3 ||
eTF == eTF_BC4U ||
eTF == eTF_BC4S ||
eTF == eTF_BC5U ||
eTF == eTF_BC5S ||
eTF == eTF_BC6UH ||
eTF == eTF_BC6SH ||
eTF == eTF_BC7 ||
eTF == eTF_R9G9B9E5 ||
eTF == eTF_ETC2 ||
eTF == eTF_EAC_R11 ||
eTF == eTF_ETC2A ||
eTF == eTF_EAC_RG11 ||
eTF == eTF_PVRTC2 ||
eTF == eTF_PVRTC4 ||
eTF == eTF_ASTC_4x4 ||
eTF == eTF_ASTC_5x4 ||
eTF == eTF_ASTC_5x5 ||
eTF == eTF_ASTC_6x5 ||
eTF == eTF_ASTC_6x6 ||
eTF == eTF_ASTC_8x5 ||
eTF == eTF_ASTC_8x6 ||
eTF == eTF_ASTC_8x8 ||
eTF == eTF_ASTC_10x5 ||
eTF == eTF_ASTC_10x6 ||
eTF == eTF_ASTC_10x8 ||
eTF == eTF_ASTC_10x10 ||
eTF == eTF_ASTC_12x10 ||
eTF == eTF_ASTC_12x12
);
}
}

2155
Code/CryEngine/CryCommon/ImageExtensionHelper.h
View File

File diff suppressed because it is too large Load Diff

69
Code/CryEngine/CryCommon/ImageExtensionHelper_info.h
Unescape Escape View File

@ -1,69 +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_IMAGEEXTENSIONHELPER_INFO_H
#define CRYINCLUDE_CRYCOMMON_IMAGEEXTENSIONHELPER_INFO_H
#pragma once
#include "CryString.h"
#include "TypeInfo_decl.h"
#include "ImageExtensionHelper.h"
// Crytek specific image extensions
//
// usually added to the end of DDS files
STRUCT_INFO_BEGIN(CImageExtensionHelper::DDS_PIXELFORMAT)
STRUCT_VAR_INFO(dwSize, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(dwFlags, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(dwFourCC, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(dwRGBBitCount, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(dwRBitMask, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(dwGBitMask, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(dwBBitMask, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(dwABitMask, TYPE_INFO(DWORD))
STRUCT_INFO_END(CImageExtensionHelper::DDS_PIXELFORMAT)
STRUCT_INFO_BEGIN(CImageExtensionHelper::DDS_HEADER_DXT10)
STRUCT_VAR_INFO(dxgiFormat, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(resourceDimension, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(miscFlag, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(arraySize, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(reserved, TYPE_INFO(DWORD))
STRUCT_INFO_END(CImageExtensionHelper::DDS_HEADER_DXT10)
STRUCT_INFO_BEGIN(CImageExtensionHelper::DDS_HEADER)
STRUCT_VAR_INFO(dwSize, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(dwHeaderFlags, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(dwHeight, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(dwWidth, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(dwPitchOrLinearSize, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(dwDepth, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(dwMipMapCount, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(dwAlphaBitDepth, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(dwReserved1, TYPE_ARRAY(10, TYPE_INFO(DWORD)))
STRUCT_VAR_INFO(ddspf, TYPE_INFO(CImageExtensionHelper::DDS_PIXELFORMAT))
STRUCT_VAR_INFO(dwSurfaceFlags, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(dwCubemapFlags, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(bNumPersistentMips, TYPE_INFO(BYTE))
STRUCT_VAR_INFO(bReserved2, TYPE_ARRAY(7, TYPE_INFO(BYTE)))
STRUCT_VAR_INFO(dwTextureStage, TYPE_INFO(DWORD))
STRUCT_INFO_END(CImageExtensionHelper::DDS_HEADER)
STRUCT_INFO_BEGIN(CImageExtensionHelper::DDS_FILE_DESC)
STRUCT_VAR_INFO(dwMagic, TYPE_INFO(DWORD))
STRUCT_VAR_INFO(header, TYPE_INFO(CImageExtensionHelper::DDS_HEADER))
STRUCT_INFO_END(CImageExtensionHelper::DDS_FILE_DESC)
#endif // CRYINCLUDE_CRYCOMMON_IMAGEEXTENSIONHELPER_INFO_H

4
Code/CryEngine/CryCommon/Mocks/IRendererMock.h
Unescape Escape View File

@ -330,8 +330,6 @@ public:
ITexture * (const char* nameTex));
MOCK_METHOD1(EF_LoadLightmap,
int(const char* name));
MOCK_METHOD3(EF_RenderEnvironmentCubeHDR,
bool(int size, Vec3 & Pos, TArray<unsigned short>&vecData));
MOCK_METHOD1(EF_StartEf,
void(const SRenderingPassInfo& passInfo));
MOCK_METHOD3(EF_GetObjData,
@ -360,8 +358,6 @@ public:
uint32(eDeferredLightType));
MOCK_METHOD0(EF_ClearDeferredLightsList,
void());
MOCK_METHOD2(EF_GetDeferredLights,
TArray<SRenderLight>*(const SRenderingPassInfo&, const eDeferredLightType));
MOCK_METHOD1(EF_AddDeferredClipVolume,
uint8(const IClipVolume * pClipVolume));
MOCK_METHOD2(EF_SetDeferredClipVolumeBlendData,

51
Code/CryEngine/CryCommon/Mocks/ISystemMock.h
Unescape Escape View File

@ -37,14 +37,8 @@ public:
bool());
MOCK_METHOD0(RenderStatistics,
void());
MOCK_METHOD0(GetUsedMemory,
uint32());
MOCK_METHOD0(GetUserName,
const char*());
MOCK_METHOD0(GetCPUFlags,
int());
MOCK_METHOD0(GetLogicalCPUCount,
int());
MOCK_METHOD0(Quit,
void());
MOCK_METHOD1(Relaunch,
@ -57,8 +51,6 @@ public:
int());
MOCK_CONST_METHOD0(IsRelaunch,
bool());
MOCK_METHOD4(DisplayErrorMessage,
void(const char*, float, const float*, bool));
void FatalError([[maybe_unused]] const char* sFormat, ...) override {}
void ReportBug([[maybe_unused]] const char* sFormat, ...) override {}
@ -72,24 +64,12 @@ public:
int(const char* text, const char* caption, unsigned int uType));
MOCK_METHOD1(CheckLogVerbosity,
bool(int verbosity));
MOCK_METHOD0(GetIZLibCompressor,
IZLibCompressor * ());
MOCK_METHOD0(GetIZLibDecompressor,
IZLibDecompressor * ());
MOCK_METHOD0(GetLZ4Decompressor,
ILZ4Decompressor * ());
MOCK_METHOD0(GetZStdDecompressor,
IZStdDecompressor * ());
MOCK_METHOD0(GetIViewSystem,
IViewSystem * ());
MOCK_METHOD0(GetILevelSystem,
ILevelSystem * ());
MOCK_METHOD0(GetINameTable,
INameTable * ());
MOCK_METHOD0(GetIValidator,
IValidator * ());
MOCK_METHOD0(GetStreamEngine,
IStreamEngine * ());
MOCK_METHOD0(GetICmdLine,
ICmdLine * ());
MOCK_METHOD0(GetILog,
@ -98,8 +78,6 @@ public:
AZ::IO::IArchive * ());
MOCK_METHOD0(GetICryFont,
ICryFont * ());
MOCK_METHOD0(GetIMemoryManager,
IMemoryManager * ());
MOCK_METHOD0(GetIMovieSystem,
IMovieSystem * ());
MOCK_METHOD0(GetIAudioSystem,
@ -108,20 +86,12 @@ public:
::IConsole * ());
MOCK_METHOD0(GetIRemoteConsole,
IRemoteConsole * ());
MOCK_METHOD0(GetIResourceManager,
IResourceManager * ());
MOCK_METHOD0(GetIProfilingSystem,
IProfilingSystem * ());
MOCK_METHOD0(GetISystemEventDispatcher,
ISystemEventDispatcher * ());
MOCK_METHOD0(GetITimer,
ITimer * ());
MOCK_METHOD2(DebugStats,
void(bool checkpoint, bool leaks));
MOCK_METHOD0(DumpWinHeaps,
void());
MOCK_METHOD1(DumpMMStats,
int(bool log));
MOCK_METHOD1(SetForceNonDevMode,
void(bool bValue));
MOCK_CONST_METHOD0(GetForceNonDevMode,
@ -130,8 +100,6 @@ public:
bool());
MOCK_CONST_METHOD0(IsDevMode,
bool());
MOCK_CONST_METHOD1(IsMODValid,
bool(const char* szMODName));
MOCK_METHOD3(CreateXmlNode,
XmlNodeRef(const char*, bool, bool));
MOCK_METHOD4(LoadXmlFromBuffer,
@ -161,11 +129,6 @@ public:
MOCK_METHOD0(GetBuildVersion,
const SFileVersion&());
MOCK_METHOD5(CompressDataBlock,
bool(const void*, size_t, void*, size_t &, int));
MOCK_METHOD4(DecompressDataBlock,
bool(const void* input, size_t inputSize, void* output, size_t & outputSize));
MOCK_METHOD1(AddCVarGroupDirectory,
void(const string&));
MOCK_METHOD0(SaveConfiguration,
@ -173,24 +136,16 @@ public:
MOCK_METHOD3(LoadConfiguration,
void(const char*, ILoadConfigurationEntrySink*, bool));
MOCK_METHOD1(GetConfigSpec,
ESystemConfigSpec(bool));
MOCK_CONST_METHOD0(GetMaxConfigSpec,
ESystemConfigSpec());
MOCK_METHOD3(SetConfigSpec,
void(ESystemConfigSpec spec, ESystemConfigPlatform platform, bool bClient));
MOCK_CONST_METHOD0(GetConfigPlatform,
ESystemConfigPlatform());
MOCK_METHOD1(SetConfigPlatform,
void(ESystemConfigPlatform platform));
MOCK_METHOD1(AutoDetectSpec,
void(bool detectResolution));
MOCK_CONST_METHOD0(IsPaused,
bool());
MOCK_METHOD0(GetLocalizationManager,
ILocalizationManager * ());
MOCK_METHOD0(GetITextModeConsole,
ITextModeConsole * ());
MOCK_METHOD0(GetNoiseGen,
CPNoise3 * ());
MOCK_METHOD0(GetUpdateCounter,
@ -227,18 +182,12 @@ public:
ESystemGlobalState(void));
MOCK_METHOD1(SetSystemGlobalState,
void(ESystemGlobalState systemGlobalState));
MOCK_METHOD5(AsyncMemcpy,
void(void* dst, const void* src, size_t size, int nFlags, volatile int* sync));
#if !defined(_RELEASE)
MOCK_CONST_METHOD0(IsSavingResourceList,
bool());
#endif
MOCK_METHOD0(SteamInit,
bool());
MOCK_CONST_METHOD0(GetImageHandler,
const IImageHandler * ());
MOCK_METHOD0(GetRootWindowMessageHandler,
void*());
MOCK_METHOD1(RegisterWindowMessageHandler,

3
Code/CryEngine/CryCommon/PoolAllocator.h
Unescape Escape View File

@ -36,9 +36,6 @@
// require a pointer to the bucket be stored, whereas now no memory is used
// while the block is allocated.
//
// This allocator is suitable for use with STL lists - see STLPoolAllocator
// for an STL-compatible interface.
//
// The class can optionally support multi-threading, using the second
// template parameter. By default it is multithread-safe.
// See Synchronization.h.

2
Code/CryEngine/CryCommon/ProjectDefines.h
Unescape Escape View File

@ -40,8 +40,6 @@
#endif
#endif
#define USE_STEAM 0 // Enable this to start using Steam
// The following definitions are used by Sandbox and RC to determine which platform support is needed
#define TOOLS_SUPPORT_POWERVR
#define TOOLS_SUPPORT_ETC2COMP

8
Code/CryEngine/CryCommon/RenderBus.h
Unescape Escape View File

@ -33,14 +33,6 @@ namespace AZ
static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
//////////////////////////////////////////////////////////////////////////
/**
* This event gets posted at the end of CD3D9Renderer's EF_Scene3D method.
* CSystem (in SystemRenderer.cpp) uses this to render the console, aux geom and UI
* in a manner that will make sure the render calls end up as part of the scene's render.
* This is important or else those render calls won't show up properly in VR.
*/
virtual void OnScene3DEnd() {};
/**
* This event gets posted at the beginning of CD3D9Renderer's FreeResources method, before the resources have been freed.
*/

185
Code/CryEngine/CryCommon/STLGlobalAllocator.h
Unescape Escape View File

@ -1,185 +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_STLGLOBALALLOCATOR_H
#define CRYINCLUDE_CRYCOMMON_STLGLOBALALLOCATOR_H
#pragma once
//---------------------------------------------------------------------------
// STL-compatible interface for an std::allocator using the global heap.
//---------------------------------------------------------------------------
#include <stddef.h>
#include <climits>
#include "CryMemoryManager.h"
#include <AzCore/Memory/AllocatorBase.h>
#include <AzCore/Memory/HphaSchema.h>
#include <AzCore/Memory/AllocatorManager.h>
struct CryLegacySTLAllocatorDescriptor
: public AZ::HphaSchema::Descriptor
{
CryLegacySTLAllocatorDescriptor()
{
m_systemChunkSize = 4 * 1024 * 1024; // Ask the OS for 4MB at a time
}
};
class CryLegacySTLAllocator
: public AZ::SimpleSchemaAllocator<AZ::HphaSchema, CryLegacySTLAllocatorDescriptor>
{
public:
AZ_TYPE_INFO(CryLegacySTLAllocator, "{87EE21F1-8215-4979-B493-AF13D8D91DAD}");
using Descriptor = CryLegacySTLAllocatorDescriptor;
using Base = AZ::SimpleSchemaAllocator<AZ::HphaSchema, CryLegacySTLAllocatorDescriptor>;
CryLegacySTLAllocator()
: Base("CryLegacySTLAllocator", "Allocator used to dodge limits on static init time allocations")
{
}
};
// Specialize for the CryLegacySTLAllocator to provide one per module that does not use the
// environment for its storage, since this thing is designed to get around the lack
// of static allocators
namespace AZ
{
template <>
class AllocatorInstance<CryLegacySTLAllocator> : public Internal::AllocatorInstanceBase<CryLegacySTLAllocator, AllocatorStorage::ModuleStoragePolicy<CryLegacySTLAllocator>>
{
};
}
class ICrySizer;
namespace stl
{
template <class T>
class STLGlobalAllocator
{
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;
template <class U>
struct rebind
{
typedef STLGlobalAllocator<U> other;
};
STLGlobalAllocator() throw()
{
}
STLGlobalAllocator(const STLGlobalAllocator&) throw()
{
}
template <class U>
STLGlobalAllocator(const STLGlobalAllocator<U>&) throw()
{
}
~STLGlobalAllocator() throw()
{
}
pointer address(reference x) const
{
return &x;
}
const_pointer address(const_reference x) const
{
return &x;
}
pointer allocate(size_type n = 1, const void* hint = 0)
{
(void)hint;
pointer ret = static_cast<pointer>(AZ::AllocatorInstance<CryLegacySTLAllocator>::Get().Allocate(n * sizeof(T), 0));
return ret;
}
void deallocate(pointer p, [[maybe_unused]] size_type n = 1)
{
AZ::AllocatorInstance<CryLegacySTLAllocator>::Get().DeAllocate(p);
}
size_type max_size() const throw()
{
return INT_MAX;
}
#if !defined(_LIBCPP_VERSION)
void construct(pointer p, const T& val)
{
new(static_cast<void*>(p))T(val);
}
void construct(pointer p)
{
new(static_cast<void*>(p))T();
}
#endif // !_LIBCPP_VERSION
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 STLGlobalAllocator&) const { return true; }
bool operator!=(const STLGlobalAllocator&) const { return false; }
static void GetMemoryUsage(ICrySizer* pSizer)
{
}
};
template <>
class STLGlobalAllocator<void>
{
public:
typedef void* pointer;
typedef const void* const_pointer;
typedef void value_type;
template <class U>
struct rebind
{
typedef STLGlobalAllocator<U> other;
};
};
}
#endif // CRYINCLUDE_CRYCOMMON_STLGLOBALALLOCATOR_H

208
Code/CryEngine/CryCommon/STLPoolAllocator.h
Unescape Escape View File

@ -1,208 +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_STLPOOLALLOCATOR_H
#define CRYINCLUDE_CRYCOMMON_STLPOOLALLOCATOR_H
#pragma once
//---------------------------------------------------------------------------
// STL-compatible interface for the pool allocator (see PoolAllocator.h).
//
// This class is suitable for use as an allocator for STL lists. Note it will
// not work with vectors, since it allocates fixed-size blocks, while vectors
// allocate elements in variable-sized contiguous chunks.
//
// To create a list of type UserDataType using this allocator, use the
// following syntax:
//
// std::list<UserDataType, STLPoolAllocator<UserDataType> > myList;
//---------------------------------------------------------------------------
#include "PoolAllocator.h"
#include "MetaUtils.h"
#include <stddef.h>
#include <climits>
namespace stl
{
namespace STLPoolAllocatorHelper
{
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, bool FreeWhenEmpty, typename T>
struct STLPoolAllocatorStatic
{
// Non-freeing stl pool allocators should just go on the global heap - only if they've been explicitly
// set to cleanup should they go on the default heap.
typedef SizePoolAllocator<
HeapAllocator<
L,
typename metautils::select<FreeWhenEmpty, HeapSysAllocator, GlobalHeapSysAllocator>::type>
> AllocatorType;
static AllocatorType* GetOrCreateAllocator()
{
if (allocator)
{
return allocator;
}
allocator = new AllocatorType(S, A, FHeap().FreeWhenEmpty(FreeWhenEmpty));
return allocator;
}
static AllocatorType* allocator;
};
template <class T, class L, size_t A, bool FreeWhenEmpty>
struct STLPoolAllocatorKungFu
: public STLPoolAllocatorStatic<sizeof(T), L, A, FreeWhenEmpty, T>
{
};
template <class T, class L = PSyncMultiThread, size_t A = 0, bool FreeWhenEmpty = false>
class STLPoolAllocator
{
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;
template <class U>
struct rebind
{
typedef STLPoolAllocator<U, L, A, FreeWhenEmpty> other;
};
STLPoolAllocator() throw()
{
}
STLPoolAllocator(const STLPoolAllocator&) throw()
{
}
template <class U, class M, size_t B, bool FreeWhenEmptyA>
STLPoolAllocator(const STLPoolAllocator<U, M, B, FreeWhenEmptyA>&) throw()
{
}
~STLPoolAllocator() throw()
{
}
pointer address(reference x) const
{
return &x;
}
const_pointer address(const_reference x) const
{
return &x;
}
pointer allocate([[maybe_unused]] size_type n = 1, [[maybe_unused]] const void* hint = 0)
{
assert(n == 1);
typename STLPoolAllocatorKungFu<T, L, A, FreeWhenEmpty>::AllocatorType * allocator = STLPoolAllocatorKungFu<T, L, A, FreeWhenEmpty>::GetOrCreateAllocator();
return static_cast<T*>(allocator->Allocate());
}
void deallocate(pointer p, [[maybe_unused]] size_type n = 1)
{
assert(n == 1);
typename STLPoolAllocatorKungFu<T, L, A, FreeWhenEmpty>::AllocatorType * allocator = STLPoolAllocatorKungFu<T, L, A, FreeWhenEmpty>::allocator;
allocator->Deallocate(p);
}
size_type max_size() const throw()
{
return INT_MAX;
}
#ifndef _LIBCPP_VERSION
void construct(pointer p, const T& val)
{
new(static_cast<void*>(p))T(val);
}
void construct(pointer p)
{
new(static_cast<void*>(p))T();
}
#endif // !(_LIBCPP_VERSION)
void destroy(pointer p)
{
STLPoolAllocatorHelper::destruct(p);
}
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 STLPoolAllocator&) {return true; }
bool operator!=(const STLPoolAllocator&) {return false; }
static void GetMemoryUsage(ICrySizer* pSizer)
{
pSizer->AddObject(STLPoolAllocatorKungFu<T, L, A, FreeWhenEmpty>::allocator);
}
};
template <class T, size_t A = 0, bool FreeWhenEmpty = false>
class STLPoolAllocatorNoMT
: public STLPoolAllocator<T, PSyncNone, A, FreeWhenEmpty>
{
};
template <>
class STLPoolAllocator<void>
{
public:
typedef void* pointer;
typedef const void* const_pointer;
typedef void value_type;
template <class U, class L>
struct rebind
{
typedef STLPoolAllocator<U> other;
};
};
template <size_t S, typename L, size_t A, bool FreeWhenEmpty, typename T>
typename STLPoolAllocatorStatic<S, L, A, FreeWhenEmpty, T>::AllocatorType * STLPoolAllocatorStatic<S, L, A, FreeWhenEmpty, T>::allocator;
}
#endif // CRYINCLUDE_CRYCOMMON_STLPOOLALLOCATOR_H

107
Code/CryEngine/CryCommon/STLPoolAllocator_ManyElems.h
Unescape Escape View File

@ -1,107 +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_STLPOOLALLOCATOR_MANYELEMS_H
#define CRYINCLUDE_CRYCOMMON_STLPOOLALLOCATOR_MANYELEMS_H
#pragma once
//---------------------------------------------------------------------------
// STL-compatible interface for the pool allocator (see PoolAllocator.h).
//
// this class acts like STLPoolAllocator, but it is also usable for vectors
// which means that it can be used as a more efficient allocator for many
// implementations of hash_map (typically this uses internally a vector and
// a list with the same allocator)
//---------------------------------------------------------------------------
#include "STLPoolAllocator.h"
namespace stl
{
template <size_t S, typename L, size_t A>
struct STLPoolAllocator_ManyElemsStatic
{
static PoolAllocator<S, L, A>* allocator;
};
template <typename T, typename L = PSyncMultiThread, size_t LargeAllocationSizeThreshold = 54* sizeof(void*), size_t A = 0>
class STLPoolAllocator_ManyElems
: public STLPoolAllocator<T, L, A>
{
typedef STLPoolAllocator<T, L, A> Super;
typedef PoolAllocator<LargeAllocationSizeThreshold, L, A> LargeAllocator;
public:
typedef typename Super::pointer pointer;
typedef typename Super::pointer pointer_type;
typedef typename Super::size_type size_type;
typedef AZStd::false_type allow_memory_leaks;
template <typename U>
struct rebind
{
typedef STLPoolAllocator_ManyElems<U, L, LargeAllocationSizeThreshold, A> other;
};
STLPoolAllocator_ManyElems() throw()
{
}
template <typename U, typename M, size_t C, size_t B>
STLPoolAllocator_ManyElems(const STLPoolAllocator_ManyElems<U, M, C, B>&) throw()
{
}
pointer allocate(size_type n = 1, const void* hint = 0)
{
if (n == 1)
{
return Super::allocate(n, hint);
}
else if (n * sizeof(T) <= LargeAllocationSizeThreshold)
{
if (!STLPoolAllocator_ManyElemsStatic<LargeAllocationSizeThreshold, L, A>::allocator)
{
STLPoolAllocator_ManyElemsStatic<LargeAllocationSizeThreshold, L, A>::allocator = new LargeAllocator();
}
return static_cast<T*>(STLPoolAllocator_ManyElemsStatic<LargeAllocationSizeThreshold, L, A>::allocator->Allocate());
}
else
{
return static_cast<pointer>(CryModuleMalloc(n * sizeof(T)));
}
}
void deallocate(pointer p, size_type n = 1)
{
if (n == 1)
{
Super::deallocate(p);
}
else if (n * sizeof(T) <= LargeAllocationSizeThreshold)
{
STLPoolAllocator_ManyElemsStatic<LargeAllocationSizeThreshold, L, A>::allocator->Deallocate(p);
}
else
{
CryModuleFree(p);
}
}
};
template <size_t S, typename L, size_t A>
PoolAllocator<S, L, A>* STLPoolAllocator_ManyElemsStatic<S, L, A>::allocator;
}
#endif // CRYINCLUDE_CRYCOMMON_STLPOOLALLOCATOR_MANYELEMS_H

1
Code/CryEngine/CryCommon/StlUtils.h
Unescape Escape View File

@ -27,7 +27,6 @@
#endif
#define STATIC_ASSERT(condition, errMessage) static_assert(condition, errMessage)
#include "STLGlobalAllocator.h"
#include <map>
#include <set>

397
Code/CryEngine/CryCommon/Tarray.h
Unescape Escape View File

@ -19,7 +19,6 @@
#include <ILog.h>
#include <Cry_Math.h>
#include <AzCore/IO/FileIO.h>
#include <STLGlobalAllocator.h>
#ifndef CLAMP
#define CLAMP(X, mn, mx) ((X) < (mn) ? (mn) : ((X) < (mx) ? (X) : (mx)))
@ -58,400 +57,4 @@
}
#endif
// General array class.
// Can refer to a general (unowned) region of memory (m_nAllocatedCount = 0).
// Can allocate, grow, and shrink an array.
// Does not deep copy.
template<class T>
class TArray
{
protected:
T* m_pElements;
unsigned int m_nCount;
unsigned int m_nAllocatedCount;
public:
typedef T value_type;
// Empty array.
TArray()
{
ClearArr();
}
// Create a new array, delete it on destruction.
TArray(int Count)
{
m_nCount = Count;
m_nAllocatedCount = Count;
m_pElements = NULL;
Realloc(0);
}
TArray(int Use, int Max)
{
m_nCount = Use;
m_nAllocatedCount = Max;
m_pElements = NULL;
Realloc(0);
}
// Reference pre-existing memory. Does not delete it.
TArray(T* Elems, int Count)
{
m_pElements = Elems;
m_nCount = Count;
m_nAllocatedCount = 0;
}
~TArray()
{
Free();
}
void Free()
{
m_nCount = 0;
if (m_nAllocatedCount && AZ::AllocatorInstance<CryLegacySTLAllocator>::IsReady())
{
AZ::AllocatorInstance<CryLegacySTLAllocator>::Get().DeAllocate(m_pElements);
}
m_nAllocatedCount = 0;
m_pElements = NULL;
}
void Create (int Count)
{
m_pElements = NULL;
m_nCount = Count;
m_nAllocatedCount = Count;
Realloc(0);
Clear();
}
void Copy (const TArray<T>& src)
{
m_pElements = NULL;
m_nCount = m_nAllocatedCount = src.Num();
Realloc(0);
PREFAST_ASSUME(m_pElements); // realloc asserts if it fails - so this is safe
memcpy(m_pElements, src.m_pElements, src.Num() * sizeof(T));
}
void Copy (const T* src, unsigned int numElems)
{
int nOffs = m_nCount;
Grow(numElems);
memcpy(&m_pElements[nOffs], src, numElems * sizeof(T));
}
void Align4Copy (const T* src, unsigned int& numElems)
{
int nOffs = m_nCount;
Grow((numElems + 3) & ~3);
memcpy(&m_pElements[nOffs], src, numElems * sizeof(T));
if (numElems & 3)
{
int nSet = 4 - (numElems & 3);
memset(&m_pElements[nOffs + numElems], 0, nSet);
numElems += nSet;
}
}
void Realloc([[maybe_unused]] int nOldAllocatedCount)
{
if (!m_nAllocatedCount)
{
m_pElements = NULL;
}
else
{
m_pElements = static_cast<decltype(m_pElements)>(AZ::AllocatorInstance<CryLegacySTLAllocator>::Get().ReAllocate(m_pElements, m_nAllocatedCount * sizeof(T), alignof(T)));
assert (m_pElements);
}
}
void Remove(unsigned int Index, unsigned int Count = 1)
{
if (Count)
{
memmove(m_pElements + Index, m_pElements + (Index + Count), sizeof(T) * (m_nCount - Index - Count));
m_nCount -= Count;
}
}
void Shrink()
{
if (m_nCount == 0 || m_nAllocatedCount == 0)
{
return;
}
assert(m_nAllocatedCount >= m_nCount);
if (m_nAllocatedCount != m_nCount)
{
int nOldAllocatedCount = m_nAllocatedCount;
m_nAllocatedCount = m_nCount;
Realloc(nOldAllocatedCount);
}
}
void _Remove(unsigned int Index, unsigned int Count)
{
assert (Index >= 0);
assert (Index <= m_nCount);
assert ((Index + Count) <= m_nCount);
Remove(Index, Count);
}
unsigned int Num(void) const { return m_nCount; }
unsigned int Capacity(void) const { return m_nAllocatedCount; }
unsigned int MemSize(void) const { return m_nCount * sizeof(T); }
void SetNum(unsigned int n) { m_nCount = m_nAllocatedCount = n; }
void SetUse(unsigned int n) { m_nCount = n; }
void Alloc(unsigned int n) { int nOldAllocatedCount = m_nAllocatedCount; m_nAllocatedCount = n; Realloc(nOldAllocatedCount); }
void Reserve(unsigned int n) { int nOldAllocatedCount = m_nAllocatedCount; SetNum(n); Realloc(nOldAllocatedCount); Clear(); }
void ReserveNoClear(unsigned int n) { int nOldAllocatedCount = m_nAllocatedCount; SetNum(n); Realloc(nOldAllocatedCount); }
void Expand(unsigned int n)
{
if (n > m_nAllocatedCount)
{
ReserveNew(n);
}
}
void ReserveNew(unsigned int n)
{
int num = m_nCount;
if (n > m_nAllocatedCount)
{
int nOldAllocatedCount = m_nAllocatedCount;
m_nAllocatedCount = n * 2;
Realloc(nOldAllocatedCount);
}
m_nCount = n;
memset(&m_pElements[num], 0, sizeof(T) * (m_nCount - num));
}
T* Grow(unsigned int n)
{
int nStart = m_nCount;
m_nCount += n;
if (m_nCount > m_nAllocatedCount)
{
int nOldAllocatedCount = m_nAllocatedCount;
m_nAllocatedCount = m_nCount * 2;
Realloc(nOldAllocatedCount);
}
return &m_pElements[nStart];
}
T* GrowReset(unsigned int n)
{
int num = m_nAllocatedCount;
T* Obj = AddIndex(n);
if (num != m_nAllocatedCount)
{
memset(&m_pElements[num], 0, sizeof(T) * (m_nAllocatedCount - num));
}
return Obj;
}
unsigned int* GetNumAddr(void) { return &m_nCount; }
T** GetDataAddr(void) { return &m_pElements; }
T* Data(void) const { return m_pElements; }
T& Get(unsigned int id) const { return m_pElements[id]; }
void Assign(TArray& fa)
{
m_pElements = fa.m_pElements;
m_nCount = fa.m_nCount;
m_nAllocatedCount = fa.m_nAllocatedCount;
}
/*const TArray operator=(TArray fa) const
{
TArray<T> t = TArray(fa.m_nCount,fa.m_nAllocatedCount);
for ( int i=0; i<fa.Num(); i++ )
{
t.AddElem(fa[i]);
}
return t;
}*/
const T& operator[](unsigned int i) const { assert(i < m_nCount); return m_pElements[i]; }
T& operator[](unsigned int i) { assert(i < m_nCount); return m_pElements[i]; }
T& operator * () { assert(m_nCount > 0); return *m_pElements; }
TArray<T> operator()(unsigned int Start)
{
assert(Start < m_nCount);
return TArray<T>(m_pElements + Start, m_nCount - Start);
}
TArray<T> operator()(unsigned int Start, unsigned int Count)
{
assert(Start < m_nCount);
assert(Start + Count <= m_nCount);
return TArray<T>(m_pElements + Start, Count);
}
// For simple types only
TArray(const TArray<T>& cTA)
{
m_pElements = NULL;
m_nCount = m_nAllocatedCount = cTA.Num();
Realloc(0);
if (m_pElements)
{
memcpy(m_pElements, &cTA[0], m_nCount * sizeof(T));
}
/*for (unsigned int i=0; i<cTA.Num(); i++ )
{
AddElem(cTA[i]);
}*/
}
inline TArray& operator = (const TArray& cTA)
{
Free();
new(this)TArray(cTA);
return *this;
}
void ClearArr(void)
{
m_nCount = 0;
m_nAllocatedCount = 0;
m_pElements = NULL;
}
void Clear(void)
{
memset(m_pElements, 0, m_nCount * sizeof(T));
}
void AddString(const char* szStr)
{
assert(szStr);
int nLen = strlen(szStr) + 1;
T* pDst = Grow(nLen);
memcpy(pDst, szStr, nLen);
}
void Set(unsigned int m)
{
memset(m_pElements, m, m_nCount * sizeof(T));
}
ILINE T* AddIndex(unsigned int inc)
{
unsigned int nIndex = m_nCount;
unsigned int nNewCount = m_nCount + inc;
if (nNewCount > m_nAllocatedCount)
{
int nOldAllocatedCount = m_nAllocatedCount;
m_nAllocatedCount = nNewCount + (nNewCount >> 1) + 10;
Realloc(nOldAllocatedCount);
}
m_nCount = nNewCount;
return &m_pElements[nIndex];
}
T& Insert(unsigned int nIndex, unsigned int inc = 1)
{
m_nCount += inc;
if (m_nCount > m_nAllocatedCount)
{
int nOldAllocatedCount = m_nAllocatedCount;
m_nAllocatedCount = m_nCount + (m_nCount >> 1) + 32;
Realloc(nOldAllocatedCount);
}
memmove(&m_pElements[nIndex + inc], &m_pElements[nIndex], (m_nCount - inc - nIndex) * sizeof(T));
return m_pElements[nIndex];
}
void AddIndexNoCache(unsigned int inc)
{
m_nCount += inc;
if (m_nCount > m_nAllocatedCount)
{
int nOldAllocatedCount = m_nAllocatedCount;
m_nAllocatedCount = m_nCount;
Realloc(nOldAllocatedCount);
}
}
void Add(const T& elem){AddElem(elem); }
void AddElem(const T& elem)
{
unsigned int m = m_nCount;
AddIndex(1);
m_pElements[m] = elem;
}
void AddElemNoCache(const T& elem)
{
unsigned int m = m_nCount;
AddIndexNoCache(1);
m_pElements[m] = elem;
}
int Find(const T& p)
{
for (unsigned int i = 0; i < m_nCount; i++)
{
if (p == (*this)[i])
{
return i;
}
}
return -1;
}
void Delete(unsigned int n){DelElem(n); }
void DelElem(unsigned int n)
{
// memset(&m_pElements[n],0,sizeof(T));
_Remove(n, 1);
}
// Standard compliance interface
//
// This is for those who don't want to learn the non standard and
// thus not very convenient interface of TArray, but are unlucky
// enough not to be able to avoid using it.
void clear(){Free(); }
void resize(unsigned int nSize) { reserve(nSize); m_nCount = nSize; }
void reserve(unsigned int nSize)
{
if (nSize > m_nAllocatedCount)
{
Alloc(nSize);
}
}
unsigned size() const {return m_nCount; }
unsigned capacity() const {return m_nAllocatedCount; }
bool empty() const {return size() == 0; }
void push_back (const T& rSample) {Add(rSample); }
void pop_back () {m_nCount--; }
void erase (T* pElem)
{
int n = int(pElem - m_pElements);
assert(n >= 0 && n < m_nCount);
_Remove(n, 1);
}
T* begin() {return m_pElements; }
T* end() {return m_pElements + m_nCount; }
T last() {return m_pElements[m_nCount - 1]; }
const T* begin() const {return m_pElements; }
const T* end() const {return m_pElements + m_nCount; }
int GetMemoryUsage() const { return (int)(m_nAllocatedCount * sizeof(T)); }
};
template <class T>
inline void Exchange(T& X, T& Y)
{
const T Tmp = X;
X = Y;
Y = Tmp;
}
#endif // CRYINCLUDE_CRYCOMMON_TARRAY_H

33
Code/CryEngine/CryCommon/crycommon_files.cmake
Unescape Escape View File

@ -12,7 +12,6 @@
set(FILES
QTangent.h
CryCommon.cpp
Allocator.h
FinalizingSpline.h
IAudioInterfacesCommonData.h
IAudioSystem.h
@ -26,10 +25,8 @@ set(FILES
IFunctorBase.h
IFuncVariable.h
IGem.h
IGeneralMemoryHeap.h
IGeomCache.h
IImage.h
IImageHandler.h
IIndexedMesh.h
IIndexedMesh_info.cpp
ILevelSystem.h
@ -37,9 +34,7 @@ set(FILES
LocalizationManagerBus.h
LocalizationManagerBus.inl
ILog.h
ILZ4Decompressor.h
IMaterial.h
IMemory.h
IMeshBaking.h
IMiniLog.h
IMovieSystem.h
@ -51,8 +46,6 @@ set(FILES
IRenderAuxGeom.h
IRenderer.h
IRenderMesh.h
IResourceCollector.h
IResourceManager.h
ISerialize.h
IShader.h
IShader_info.h
@ -60,11 +53,8 @@ set(FILES
IStatObj.h
StatObjBus.h
IStereoRenderer.h
IStreamEngine.h
IStreamEngineDefs.h
ISurfaceType.h
ISystem.h
ITextModeConsole.h
ITexture.h
ITimer.h
IValidator.h
@ -72,9 +62,6 @@ set(FILES
IViewSystem.h
IWindowMessageHandler.h
IXml.h
IZLibCompressor.h
IZlibDecompressor.h
IZStdDecompressor.h
IProximityTriggerSystem.h
MicrophoneBus.h
physinterface.h
@ -85,10 +72,8 @@ set(FILES
IObjManager.h
INavigationSystem.h
IMNM.h
AzDXGIFormat.h
SFunctor.h
FunctorBaseFunction.h
CustomMemoryHeap.h
FunctorBaseMember.h
stridedptr.h
Options.h
@ -102,31 +87,21 @@ set(FILES
CryTypeInfo.cpp
BaseTypes.h
CompileTimeAssert.h
CryThreadSafeWorkerContainer.h
CryThreadSafeRendererContainer.h
intrusive_list.hpp
MemoryAccess.h
Algorithm.h
AnimKey.h
BitFiddling.h
CGFContent.h
CGFContent_info.cpp
Common_TypeInfo.cpp
CountedValue.h
CrtDebugStats.h
CryArray.h
CryArray2d.h
CryAssert.h
CryCrc32.h
CryCustomTypes.h
CryFile.h
CryFixedArray.h
CryFixedString.h
CryHeaders.h
CryHeaders_info.cpp
CryListenerSet.h
CryMemoryAllocator.h
CryMemoryManager.h
CryLegacyAllocator.h
CryName.h
CryPath.h
@ -145,9 +120,6 @@ set(FILES
HashGrid.h
HeapAllocator.h
HeapContainer.h
ImageExtensionHelper.cpp
ImageExtensionHelper.h
ImageExtensionHelper_info.h
InplaceFactory.h
LegacyAllocator.h
MetaUtils.h
@ -172,8 +144,6 @@ set(FILES
SmartPointersHelpers.h
smartptr.h
StackContainer.h
STLGlobalAllocator.h
STLPoolAllocator.h
StlUtils.h
StringUtils.h
Synchronization.h
@ -203,7 +173,6 @@ set(FILES
Cry_Matrix44.h
Cry_MatrixDiag.h
Cry_Vector4.h
AABBSV.h
Cry_Camera.h
Cry_Color.h
Cry_Geo.h
@ -224,7 +193,6 @@ set(FILES
Cry_HWVector3.h
AndroidSpecific.h
AppleSpecific.h
Console_std.h
CryAssert_Android.h
CryAssert_impl.h
CryAssert_iOS.h
@ -232,7 +200,6 @@ set(FILES
CryAssert_Mac.h
CryLibrary.cpp
CryLibrary.h
CryMemoryManager_impl.h
CryThread_dummy.h
CryThread_pthreads.h
CryThread_windows.h

10
Code/CryEngine/CryCommon/platform.h
Unescape Escape View File

@ -479,15 +479,7 @@ ILINE DestinationType alias_cast(SourceType pPtr)
return conv_union.pDst;
}
//////////////////////////////////////////////////////////////////////////
#include "CryMemoryManager.h"
// Memory manager breaks strdup
// Use something higher level, like CryString
#undef strdup
#define strdup dont_use_strdup
#include "CryLegacyAllocator.h"
//////////////////////////////////////////////////////////////////////////
#ifndef DEPRECATED

6
Code/CryEngine/CryCommon/platform_impl.cpp
Unescape Escape View File

@ -20,6 +20,7 @@
#include <AzCore/Debug/Profiler.h>
#include <AzCore/Debug/ProfileModuleInit.h>
#include <AzCore/Memory/AllocatorManager.h>
#include <AzCore/Module/Environment.h>
// Section dictionary
@ -194,11 +195,6 @@ void __stl_debug_message(const char* format_str, ...)
#include <intrin.h>
#endif
// If we use cry memory manager this should be also included in every module.
#if defined(USING_CRY_MEMORY_MANAGER)
#include <CryMemoryManager_impl.h>
#endif
#if defined(APPLE) || defined(LINUX)
#include "CryAssert_impl.h"
#endif

94
Code/CryEngine/CrySystem/AndroidConsole.cpp
Unescape Escape View File

@ -1,94 +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 : Console implementation for Android, reports back to the main interface.
#include "CrySystem_precompiled.h"
#if defined(ANDROID)
#include "AndroidConsole.h"
#include "android/log.h"
CAndroidConsole::CAndroidConsole()
: m_isInitialized(false)
{
}
CAndroidConsole::~CAndroidConsole()
{
}
// Interface IOutputPrintSink /////////////////////////////////////////////
void CAndroidConsole::Print(const char* line)
{
__android_log_print(ANDROID_LOG_VERBOSE, "CryEngine", "MSG: %s\n", line);
}
// Interface ISystemUserCallback //////////////////////////////////////////
bool CAndroidConsole::OnError(const char* errorString)
{
__android_log_print(ANDROID_LOG_ERROR, "CryEngine", "ERR: %s\n", errorString);
return true;
}
void CAndroidConsole::OnInitProgress(const char* sProgressMsg)
{
(void) sProgressMsg;
// Do Nothing
}
void CAndroidConsole::OnInit(ISystem* pSystem)
{
if (!m_isInitialized)
{
IConsole* pConsole = pSystem->GetIConsole();
if (pConsole != 0)
{
pConsole->AddOutputPrintSink(this);
}
m_isInitialized = true;
}
}
void CAndroidConsole::OnShutdown()
{
if (m_isInitialized)
{
// remove outputprintsink
m_isInitialized = false;
}
}
void CAndroidConsole::OnUpdate()
{
// Do Nothing
}
void CAndroidConsole::GetMemoryUsage(ICrySizer* pSizer)
{
size_t size = sizeof(*this);
pSizer->AddObject(this, size);
}
// Interface ITextModeConsole /////////////////////////////////////////////
Vec2_tpl<int> CAndroidConsole::BeginDraw()
{
return Vec2_tpl<int>(0, 0);
}
void CAndroidConsole::PutText(int x, int y, const char* msg)
{
__android_log_print(ANDROID_LOG_VERBOSE, "CryEngine", "PUT: %s\n", msg);
}
void CAndroidConsole::EndDraw()
{
// Do Nothing
}
#endif // ANDROID

62
Code/CryEngine/CrySystem/AndroidConsole.h
Unescape Escape View File

@ -1,62 +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 : Console implementation for Android, reports back to the main interface.
#ifndef CRYINCLUDE_CRYSYSTEM_ANDROIDCONSOLE_H
#define CRYINCLUDE_CRYSYSTEM_ANDROIDCONSOLE_H
#pragma once
#include <IConsole.h>
#include <ITextModeConsole.h>
class CAndroidConsole
: public ISystemUserCallback
, public IOutputPrintSink
, public ITextModeConsole
{
CAndroidConsole(const CAndroidConsole&);
CAndroidConsole& operator = (const CAndroidConsole&);
bool m_isInitialized;
public:
static CryCriticalSectionNonRecursive s_lock;
public:
CAndroidConsole();
~CAndroidConsole();
// Interface IOutputPrintSink /////////////////////////////////////////////
DLL_EXPORT virtual void Print(const char* line);
// Interface ISystemUserCallback //////////////////////////////////////////
virtual bool OnError(const char* errorString);
virtual bool OnSaveDocument() { return false; }
virtual void OnProcessSwitch() { }
virtual void OnInitProgress(const char* sProgressMsg);
virtual void OnInit(ISystem*);
virtual void OnShutdown();
virtual void OnUpdate();
virtual void GetMemoryUsage(ICrySizer* pSizer);
void SetRequireDedicatedServer(bool) {}
void SetHeader(const char*) {}
// Interface ITextModeConsole /////////////////////////////////////////////
virtual Vec2_tpl<int> BeginDraw();
virtual void PutText(int x, int y, const char* msg);
virtual void EndDraw();
};
#endif // CRYINCLUDE_CRYSYSTEM_ANDROIDCONSOLE_H

516
Code/CryEngine/CrySystem/AsyncPakManager.cpp
Unescape Escape View File

@ -1,516 +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 : Manage async pak files
#include "CrySystem_precompiled.h"
#include "AsyncPakManager.h"
#include "System.h"
#include "IStreamEngine.h"
#include <AzFramework/Archive/Archive.h>
#include <AzFramework/API/ApplicationAPI.h>
#include "ResourceManager.h"
#define MEGA_BYTE 1024* 1024
//////////////////////////////////////////////////////////////////////////
string& CAsyncPakManager::SAsyncPak::GetStatus(string& status) const
{
switch (eState)
{
case STATE_UNLOADED:
status = "Unloaded";
break;
case STATE_REQUESTED:
status = "Requested";
break;
case STATE_REQUESTUNLOAD:
status = "RequestUnload";
break;
case STATE_LOADED:
status = "Loaded";
break;
default:
status = "Unknown";
break;
}
return status;
}
//////////////////////////////////////////////////////////////////////////
CAsyncPakManager::CAsyncPakManager()
{
m_nTotalOpenLayerPakSize = 0;
m_bRequestLayerUpdate = false;
}
CAsyncPakManager::~CAsyncPakManager()
{
Clear();
}
//////////////////////////////////////////////////////////////////////////
void CAsyncPakManager::Clear()
{
//float startTime = gEnv->pTimer->GetAsyncCurTime();
for (TPakMap::iterator it = m_paks.begin();
it != m_paks.end(); ++it)
{
SAsyncPak& layerPak = it->second;
if (layerPak.bStreaming)
{
// wait until finished
layerPak.pReadStream->Abort();
}
ReleaseData(&layerPak);
}
m_paks.clear();
m_bRequestLayerUpdate = false;
assert(m_nTotalOpenLayerPakSize == 0);
m_nTotalOpenLayerPakSize = 0;
//printf("CAsyncPakManager::Clear() %0.4f secs\n", gEnv->pTimer->GetAsyncCurTime() - startTime);
}
void CAsyncPakManager::UnloadLevelLoadPaks()
{
for (TPakMap::iterator it = m_paks.begin();
it != m_paks.end(); ++it)
{
SAsyncPak& layerPak = it->second;
if (layerPak.eLifeTime == SAsyncPak::LIFETIME_LOAD_ONLY)
{
if (layerPak.bStreaming)
{
// wait until finished
layerPak.pReadStream->Abort();
}
ReleaseData(&layerPak);
}
}
}
//////////////////////////////////////////////////////////////////////////
void CAsyncPakManager::ParseLayerPaks(const string& levelCachePath)
{
string layerPath = levelCachePath + "/"; // "/layers/";
string search = layerPath + "*";
auto pPak = gEnv->pCryPak;
// allow this find first to actually touch the file system
AZ::IO::ArchiveFileIterator fileIterator= pPak->FindFirst(search.c_str(), 0, true);
if (fileIterator)
{
do
{
if ((fileIterator.m_fileDesc.nAttrib & AZ::IO::FileDesc::Attribute::Subdirectory) == AZ::IO::FileDesc::Attribute::Subdirectory || fileIterator.m_filename == "." || fileIterator.m_filename == "..")
{
continue;
}
string pakName(fileIterator.m_filename.data(), fileIterator.m_filename.size());
size_t findPos = pakName.find_last_of('.');
if (findPos == string::npos)
{
continue;
}
string extension = pakName.substr(findPos + 1, pakName.size());
if (extension != "pak")
{
continue;
}
SAsyncPak layerPak;
layerPak.layername = pakName.substr(0, findPos);
layerPak.filename = layerPath + pakName;
layerPak.nSize = pPak->FGetSize(layerPak.filename.c_str(), true); // allow to go to disc for this access
layerPak.bClosePakOnRelease = true;
m_paks[layerPak.layername] = layerPak;
} while (fileIterator = pPak->FindNext(fileIterator));
pPak->FindClose(fileIterator);
}
}
//////////////////////////////////////////////////////////////////////////
void CAsyncPakManager::StartStreaming(SAsyncPak* pLayerPak)
{
StreamReadParams params;
params.dwUserData = (DWORD_PTR) pLayerPak;
params.nSize = 0;
params.pBuffer = NULL;
params.nFlags = IStreamEngine::FLAGS_FILE_ON_DISK;
params.ePriority = estpIdle;
pLayerPak->pReadStream = gEnv->pSystem->GetStreamEngine()->StartRead(eStreamTaskTypePak, pLayerPak->filename.c_str(), this, &params);
if (pLayerPak->pReadStream)
{
pLayerPak->bStreaming = true;
}
else
{
pLayerPak->eState = SAsyncPak::STATE_UNLOADED;
pLayerPak->pData.reset();
}
}
void CAsyncPakManager::ReleaseData(SAsyncPak* pLayerPak)
{
if (pLayerPak->eState == SAsyncPak::STATE_LOADED)
{
if (pLayerPak->bClosePakOnRelease)
{
gEnv->pCryPak->ClosePack(pLayerPak->filename.c_str(), 0);
//printf("Unload pak from mem: %s\n", pLayerPak->filename.c_str());
}
else
{
gEnv->pCryPak->LoadPakToMemory(pLayerPak->filename.c_str(), AZ::IO::IArchive::eInMemoryPakLocale_Unload);
//printf("Close pak: %s\n", pLayerPak->filename.c_str());
}
m_nTotalOpenLayerPakSize -= pLayerPak->nSize;
}
if (pLayerPak->pData)
{
assert(pLayerPak->pData->use_count() == 1);
}
assert((!pLayerPak->pData) || (pLayerPak->pData && pLayerPak->pData->use_count() == 1));
pLayerPak->pData.reset();
pLayerPak->eState = SAsyncPak::STATE_UNLOADED;
m_bRequestLayerUpdate = true;
}
//////////////////////////////////////////////////////////////////////////
bool CAsyncPakManager::LoadLayerPak(const char* sLayerName)
{
// only load layer paks from valid files
TPakMap::iterator findResult = m_paks.find(sLayerName);
if (findResult != m_paks.end())
{
return LoadPak(findResult->second);
}
return false;
}
bool CAsyncPakManager::LoadPakToMemAsync(const char* pPath, bool bLevelLoadOnly)
{
//check if pak reference exists
TPakMap::iterator findResult = m_paks.find(pPath);
if (findResult != m_paks.end())
{
return LoadPak(findResult->second);
}
else
{
char szFullPathBuf[AZ::IO::IArchive::MaxPath];
const char* szFullPath = gEnv->pCryPak->AdjustFileName(pPath, szFullPathBuf, AZ_ARRAY_SIZE(szFullPathBuf), AZ::IO::IArchive::FOPEN_HINT_QUIET | AZ::IO::IArchive::FLAGS_PATH_REAL);
// Check if the pak file actually exists before trying to load
if (!gEnv->pCryPak->IsFileExist(szFullPath, AZ::IO::IArchive::eFileLocation_Any))
{
// Cached file does not exist
CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "Level cache pak file %s does not exist", szFullPath);
return false;
}
SAsyncPak layerPak;
layerPak.layername = pPath;
layerPak.filename = szFullPathBuf;
layerPak.nSize = 0;
layerPak.eLifeTime = bLevelLoadOnly ? SAsyncPak::LIFETIME_LOAD_ONLY : SAsyncPak::LIFETIME_LEVEL_COMPLETE;
m_paks[layerPak.layername] = layerPak;
return LoadPak(m_paks[layerPak.layername]);
}
return false;
}
bool CAsyncPakManager::LoadPak(SAsyncPak& layerPak)
{
layerPak.nRequestCount++;
if (layerPak.eState == SAsyncPak::STATE_LOADED || layerPak.bStreaming ||
layerPak.eState == SAsyncPak::STATE_REQUESTED)
{
return true;
}
layerPak.eState = SAsyncPak::STATE_REQUESTED;
//printf("Streaming level pak: %s\n", layerPak.layername.c_str());
StartStreaming(&layerPak);
return false;
}
//////////////////////////////////////////////////////////////////////////
void CAsyncPakManager::UnloadLayerPak(const char* sLayerName)
{
TPakMap::iterator findResult = m_paks.find(sLayerName);
if (findResult == m_paks.end())
{
return;
}
SAsyncPak& layerPak = findResult->second;
layerPak.nRequestCount--;
assert(layerPak.nRequestCount >= 0);
if (layerPak.nRequestCount > 0)
{
return;
}
if (layerPak.bStreaming)
{
if (layerPak.pReadStream)
{
layerPak.pReadStream->Abort();
}
layerPak.eState = SAsyncPak::STATE_REQUESTUNLOAD;
return;
}
if (layerPak.eState == SAsyncPak::STATE_LOADED)
{
ReleaseData(&layerPak);
m_bRequestLayerUpdate = true;
}
if (layerPak.eState == SAsyncPak::STATE_REQUESTED)
{
layerPak.eState = SAsyncPak::STATE_UNLOADED;
}
}
//////////////////////////////////////////////////////////////////////////
void CAsyncPakManager::GetLayerPakStats(
SLayerPakStats& stats, bool bCollectAllStats) const
{
stats.m_MaxSize = (g_cvars.archiveVars.nTotalInMemoryPakSizeLimit * MEGA_BYTE);
stats.m_UsedSize = m_nTotalOpenLayerPakSize;
for (TPakMap::const_iterator it = m_paks.begin(); it != m_paks.end(); ++it)
{
const SAsyncPak& layerPak = it->second;
if (bCollectAllStats || layerPak.eState != SAsyncPak::STATE_UNLOADED)
{
SLayerPakStats::SEntry entry;
entry.name = it->first;
entry.nSize = layerPak.nSize;
entry.bStreaming = layerPak.bStreaming;
layerPak.GetStatus(entry.status);
stats.m_entries.push_back(entry);
}
}
}
//////////////////////////////////////////////////////////////////////////
void CAsyncPakManager::StreamAsyncOnComplete(
IReadStream* pStream, unsigned nError)
{
if (nError != 0)
{
return;
}
SAsyncPak* pLayerPak = (SAsyncPak*) pStream->GetUserData();
//Check is pak is already open, if so, just assign mem
if (gEnv->pCryPak->LoadPakToMemory(pLayerPak->filename.c_str(), AZ::IO::IArchive::eInMemoryPakLocale_GPU, pLayerPak->pData))
{
pLayerPak->bPakAlreadyOpen = true;
}
else
{
bool usePrefabSystemForLevels = false;
AzFramework::ApplicationRequests::Bus::BroadcastResult(
usePrefabSystemForLevels,
&AzFramework::ApplicationRequests::IsPrefabSystemForLevelsEnabled);
if (usePrefabSystemForLevels)
{
gEnv->pCryPak->OpenPack(
"@assets@", {pLayerPak->filename.c_str(), pLayerPak->filename.size()}, AZ::IO::IArchive::FLAGS_FILENAMES_AS_CRC32, NULL);
}
else
{
//
// ugly hack - depending on the pak file pak may need special root info / open flags
//
if (pLayerPak->layername.find("level.pak") != string::npos)
{
gEnv->pCryPak->OpenPack(
{pLayerPak->filename.c_str(), pLayerPak->filename.size()}, AZ::IO::IArchive::FLAGS_FILENAMES_AS_CRC32, NULL);
}
else if (pLayerPak->layername.find("levelshadercache.pak") != string::npos)
{
gEnv->pCryPak->OpenPack(
"@assets@", {pLayerPak->filename.c_str(), pLayerPak->filename.size()}, AZ::IO::IArchive::FLAGS_PATH_REAL, NULL);
}
else
{
gEnv->pCryPak->OpenPack(
"@assets@", {pLayerPak->filename.c_str(), pLayerPak->filename.size()}, AZ::IO::IArchive::FLAGS_FILENAMES_AS_CRC32,
NULL);
}
}
gEnv->pCryPak->LoadPakToMemory(pLayerPak->filename.c_str(), AZ::IO::IArchive::eInMemoryPakLocale_GPU, pLayerPak->pData);
}
pLayerPak->eState = SAsyncPak::STATE_LOADED;
//printf("Finished streaming level pak: %s\n", pLayerPak->layername.c_str());
}
//////////////////////////////////////////////////////////////////////////
void CAsyncPakManager::StreamOnComplete(
IReadStream* pStream, unsigned nError)
{
SAsyncPak* pLayerPak = (SAsyncPak*) pStream->GetUserData();
if (nError != 0)
{
ReleaseData(pLayerPak);
}
pLayerPak->bStreaming = false;
pLayerPak->pReadStream = NULL;
m_bRequestLayerUpdate = true;
}
void* CAsyncPakManager::StreamOnNeedStorage(IReadStream* pStream, unsigned nSize, bool& bAbortOnFailToAlloc)
{
SAsyncPak* pAsyncPak = (SAsyncPak*)pStream->GetUserData();
pAsyncPak->nSize = nSize;
if ((m_nTotalOpenLayerPakSize + nSize) > (size_t)(g_cvars.archiveVars.nTotalInMemoryPakSizeLimit * MEGA_BYTE))
{
CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "Not enough space to load in memory layer pak %s (Current: %" PRISIZE_T " Required: %d)",
pAsyncPak->filename.c_str(), m_nTotalOpenLayerPakSize, nSize);
//printf("Not enough space to load in memory layer pak %s (Current: %d Required: %d)\n", pAsyncPak->filename.c_str(), m_nTotalOpenLayerPakSize, nSize);
pAsyncPak->eState = SAsyncPak::STATE_UNLOADED;
pAsyncPak->bStreaming = false;
pAsyncPak->pReadStream = NULL;
bAbortOnFailToAlloc = true;
return NULL;
}
if (nSize)
{
auto pCryPak = static_cast<AZ::IO::Archive*>(gEnv->pCryPak);
// allocate the data
const char* szUsage = "In Memory Zip File";
pAsyncPak->pData = pCryPak->PoolAllocMemoryBlock(nSize, szUsage, alignof(uint8_t));
m_nTotalOpenLayerPakSize += nSize;
return pAsyncPak->pData->m_address.get();
}
return NULL;
}
//////////////////////////////////////////////////////////////////////////
void CAsyncPakManager::Update()
{
if (!m_bRequestLayerUpdate)
{
return;
}
m_bRequestLayerUpdate = false;
for (TPakMap::iterator it = m_paks.begin();
it != m_paks.end(); ++it)
{
SAsyncPak& layerPak = it->second;
if (!layerPak.bStreaming)
{
if (layerPak.eState == SAsyncPak::STATE_REQUESTUNLOAD)
{
// done streaming and not interested in it anymore, then release it again
ReleaseData(&layerPak);
}
else if (layerPak.eState == SAsyncPak::STATE_REQUESTED &&
(m_nTotalOpenLayerPakSize + layerPak.nSize <= ((size_t)g_cvars.archiveVars.nTotalInMemoryPakSizeLimit * MEGA_BYTE)))
{
// do we have enough memory now to start streaming the pak
StartStreaming(&layerPak);
}
}
}
}
// Abort streaming jobs and prevent any more requests
// Paks which are loaded remain, they will be cleaned up as usual
void CAsyncPakManager::CancelPendingJobs()
{
for (TPakMap::iterator it = m_paks.begin(); it != m_paks.end(); ++it)
{
SAsyncPak& layerPak = it->second;
if (layerPak.bStreaming)
{
layerPak.pReadStream->Abort();
ReleaseData(&layerPak);
//printf("Pak %s Aborted\n", layerPak.filename.c_str());
}
else if (layerPak.eState == SAsyncPak::STATE_REQUESTED)
{
layerPak.eState = SAsyncPak::STATE_UNLOADED;
ReleaseData(&layerPak);
//printf("Pak %s Cancelled\n", layerPak.filename.c_str());
}
}
}
//////////////////////////////////////////////////////////////////////////

116
Code/CryEngine/CrySystem/AsyncPakManager.h
Unescape Escape 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.
// Description : Manage async pak files
#ifndef CRYINCLUDE_CRYSYSTEM_ASYNCPAKMANAGER_H
#define CRYINCLUDE_CRYSYSTEM_ASYNCPAKMANAGER_H
#pragma once
#include <AzCore/std/smart_ptr/intrusive_ptr.h>
#include <IResourceManager.h>
#include <IStreamEngine.h>
namespace AZ::IO
{
struct MemoryBlock;
}
class CAsyncPakManager
: public IStreamCallback
{
protected:
struct SAsyncPak
{
enum EState
{
STATE_UNLOADED,
STATE_REQUESTED,
STATE_REQUESTUNLOAD,
STATE_LOADED,
};
enum ELifeTime
{
LIFETIME_LOAD_ONLY,
LIFETIME_LEVEL_COMPLETE,
LIFETIME_PERMANENT
};
SAsyncPak()
: nRequestCount(0)
, eState(STATE_UNLOADED)
, eLifeTime(LIFETIME_LOAD_ONLY)
, nSize(0)
, pData(0)
, bStreaming(false)
, bPakAlreadyOpen(false)
, bClosePakOnRelease(false)
, pReadStream(0) {}
string& GetStatus(string&) const;
string layername;
string filename;
size_t nSize;
AZStd::intrusive_ptr<AZ::IO::MemoryBlock> pData;
EState eState;
ELifeTime eLifeTime;
bool bStreaming;
bool bPakAlreadyOpen;
bool bClosePakOnRelease;
int nRequestCount;
IReadStreamPtr pReadStream;
};
typedef std::map<string, SAsyncPak> TPakMap;
public:
CAsyncPakManager();
~CAsyncPakManager();
void ParseLayerPaks(const string& levelCachePath);
bool LoadPakToMemAsync(const char* pPath, bool bLevelLoadOnly);
void UnloadLevelLoadPaks();
bool LoadLayerPak(const char* sLayerName);
void UnloadLayerPak(const char* sLayerName);
void CancelPendingJobs();
void GetLayerPakStats(SLayerPakStats& stats, bool bCollectAllStats) const;
void Clear();
void Update();
protected:
bool LoadPak(SAsyncPak& layerPak);
void StartStreaming(SAsyncPak* pLayerPak);
void ReleaseData(SAsyncPak* pLayerPak);
//////////////////////////////////////////////////////////////////////////
// IStreamCallback interface implementation.
//////////////////////////////////////////////////////////////////////////
virtual void StreamAsyncOnComplete (IReadStream* pStream, unsigned nError);
virtual void StreamOnComplete (IReadStream* pStream, unsigned nError);
virtual void* StreamOnNeedStorage(IReadStream* pStream, unsigned nSize, bool& bAbortOnFailToAlloc);
//////////////////////////////////////////////////////////////////////////
TPakMap m_paks;
size_t m_nTotalOpenLayerPakSize;
bool m_bRequestLayerUpdate;
};
#endif // CRYINCLUDE_CRYSYSTEM_ASYNCPAKMANAGER_H

1097
Code/CryEngine/CrySystem/AutoDetectSpec.cpp
View File

File diff suppressed because it is too large Load Diff

54
Code/CryEngine/CrySystem/AutoDetectSpec.h
Unescape Escape View File

@ -1,54 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYSYSTEM_AUTODETECTSPEC_H
#define CRYINCLUDE_CRYSYSTEM_AUTODETECTSPEC_H
#pragma once
#if defined(WIN32) || defined(WIN64)
// exposed AutoDetectSpec() helper functions for reuse in CrySystem
namespace Win32SysInspect
{
enum DXFeatureLevel
{
DXFL_Undefined,
DXFL_9_1,
DXFL_9_2,
DXFL_9_3,
DXFL_10_0,
DXFL_10_1,
DXFL_11_0
};
const char* GetFeatureLevelAsString(DXFeatureLevel featureLevel);
void GetNumCPUCores(unsigned int& totAvailToSystem, unsigned int& totAvailToProcess);
bool IsDX11Supported();
bool GetGPUInfo(char* pName, size_t bufferSize, unsigned int& vendorID, unsigned int& deviceID, unsigned int& totLocalVidMem, DXFeatureLevel& featureLevel);
int GetGPURating(unsigned int vendorId, unsigned int deviceId);
void GetOS(SPlatformInfo::EWinVersion& ver, bool& is64Bit, char* pName, size_t bufferSize);
bool IsVistaKB940105Required();
inline size_t SafeMemoryThreshold(size_t memMB)
{
return (memMB * 8) / 10;
}
}
#endif // #if defined(WIN32) || defined(WIN64)
#endif // CRYINCLUDE_CRYSYSTEM_AUTODETECTSPEC_H

63
Code/CryEngine/CrySystem/CMakeLists.txt
Unescape Escape View File

@ -9,46 +9,17 @@
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
ly_get_list_relative_pal_filename(pal_dir ${CMAKE_CURRENT_LIST_DIR}/Platform/${PAL_PLATFORM_NAME})
ly_get_list_relative_pal_filename(common_dir ${CMAKE_CURRENT_LIST_DIR}/Platform/Common)
add_subdirectory(XML)
# The following target is a 'C' file only library to work around an issue in cmake and VS generators that
# will append 'std=c++17' to both C and C++ compiler flags for clang. Do not add any .cpp files to this
# library.
ly_add_target(
NAME CrySystem.DLMalloc.C STATIC
NAMESPACE Legacy
FILES_CMAKE
crysystem_dlmalloc_files.cmake
INCLUDE_DIRECTORIES
PUBLIC
.
PRIVATE
${pal_dir}
)
ly_get_pal_tool_dirs(pal_tool_dirs ${CMAKE_CURRENT_LIST_DIR}/Platform)
ly_add_target(
NAME CrySystem.Static STATIC
NAMESPACE Legacy
FILES_CMAKE
crysystem_files.cmake
${pal_dir}/platform_${PAL_PLATFORM_NAME_LOWERCASE}_files.cmake
PLATFORM_INCLUDE_FILES
${pal_dir}/platform_${PAL_PLATFORM_NAME_LOWERCASE}.cmake
INCLUDE_DIRECTORIES
PUBLIC
.
${pal_dir}
PRIVATE
${common_dir}
${pal_tool_dirs}
BUILD_DEPENDENCIES
PUBLIC
Legacy::CrySystem.DLMalloc.C
PRIVATE
3rdParty::expat
3rdParty::lz4
@ -68,19 +39,11 @@ ly_add_source_properties(
VALUES ${LY_PAL_TOOLS_DEFINES}
)
ly_add_source_properties(
SOURCES SystemCFG.cpp
PROPERTY COMPILE_DEFINITIONS
VALUES LY_BUILD=${LY_VERSION_BUILD_NUMBER}
)
ly_add_target(
NAME CrySystem ${PAL_TRAIT_MONOLITHIC_DRIVEN_LIBRARY_TYPE}
NAMESPACE Legacy
FILES_CMAKE
crysystem_shared_files.cmake
PLATFORM_INCLUDE_FILES
${pal_dir}/platform_${PAL_PLATFORM_NAME_LOWERCASE}.cmake
INCLUDE_DIRECTORIES
PUBLIC
.
@ -90,29 +53,3 @@ ly_add_target(
AZ::AzCore
Legacy::CryCommon
)
################################################################################
# Tests
################################################################################
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED)
ly_add_target(
NAME CrySystem.Tests ${PAL_TRAIT_TEST_TARGET_TYPE}
NAMESPACE Legacy
FILES_CMAKE
crysystem_test_files.cmake
INCLUDE_DIRECTORIES
PRIVATE
.
BUILD_DEPENDENCIES
PRIVATE
AZ::AzTest
Legacy::CryCommon
Legacy::CrySystem.Static
AZ::AzFramework
)
ly_add_googletest(
NAME Legacy::CrySystem.Tests
)
endif()

1622
Code/CryEngine/CrySystem/CPUDetect.cpp
View File

File diff suppressed because it is too large Load Diff

180
Code/CryEngine/CrySystem/CPUDetect.h
Unescape Escape View File

@ -1,180 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYSYSTEM_CPUDETECT_H
#define CRYINCLUDE_CRYSYSTEM_CPUDETECT_H
#pragma once
//-------------------------------------------------------
/// Cpu class
//-------------------------------------------------------
#if defined(WIN64) || defined(LINUX)
#define MAX_CPU 96
#else
#define MAX_CPU 32
#endif
/// Cpu Features
#define CFI_FPUEMULATION 0x01
#define CFI_MMX 0x02
#define CFI_3DNOW 0x04
#define CFI_SSE 0x08
#define CFI_SSE2 0x10
#define CFI_SSE3 0x20
#define CFI_F16C 0x40
#define CFI_SSE41 0x80
/// Type of Cpu Vendor.
enum ECpuVendor
{
eCVendor_Unknown,
eCVendor_Intel,
eCVendor_Cyrix,
eCVendor_AMD,
eCVendor_Centaur,
eCVendor_NexGen,
eCVendor_UMC,
eCVendor_M68K
};
/// Type of Cpu Model.
enum ECpuModel
{
eCpu_Unknown,
eCpu_8086,
eCpu_80286,
eCpu_80386,
eCpu_80486,
eCpu_Pentium,
eCpu_PentiumPro,
eCpu_Pentium2,
eCpu_Pentium3,
eCpu_Pentium4,
eCpu_Pentium2Xeon,
eCpu_Pentium3Xeon,
eCpu_Celeron,
eCpu_CeleronA,
eCpu_Am5x86,
eCpu_AmK5,
eCpu_AmK6,
eCpu_AmK6_2,
eCpu_AmK6_3,
eCpu_AmK6_3D,
eCpu_AmAthlon,
eCpu_AmDuron,
eCpu_CyrixMediaGX,
eCpu_Cyrix6x86,
eCpu_CyrixGXm,
eCpu_Cyrix6x86MX,
eCpu_CenWinChip,
eCpu_CenWinChip2,
};
struct SCpu
{
ECpuVendor meVendor;
ECpuModel meModel;
unsigned long mFeatures;
bool mbSerialPresent;
char mSerialNumber[30];
int mFamily;
int mModel;
int mStepping;
char mVendor[64];
char mCpuType[64];
char mFpuType[64];
bool mbPhysical; // false for hyperthreaded
DWORD_PTR mAffinityMask;
// constructor
SCpu()
: meVendor(eCVendor_Unknown)
, meModel(eCpu_Unknown)
, mFeatures(0)
, mbSerialPresent(false)
, mFamily(0)
, mModel(0)
, mStepping(0)
, mbPhysical(true)
, mAffinityMask(0)
{
memset(mSerialNumber, 0, sizeof(mSerialNumber));
memset(mVendor, 0, sizeof(mVendor));
memset(mCpuType, 0, sizeof(mCpuType));
memset(mFpuType, 0, sizeof(mFpuType));
}
};
class CCpuFeatures
{
private:
int m_NumLogicalProcessors;
int m_NumSystemProcessors;
int m_NumAvailProcessors;
int m_NumPhysicsProcessors;
bool m_bOS_ISSE;
bool m_bOS_ISSE_EXCEPTIONS;
public:
SCpu m_Cpu[MAX_CPU];
public:
CCpuFeatures()
{
m_NumLogicalProcessors = 0;
m_NumSystemProcessors = 0;
m_NumAvailProcessors = 0;
m_NumPhysicsProcessors = 0;
m_bOS_ISSE = 0;
m_bOS_ISSE_EXCEPTIONS = 0;
ZeroMemory(m_Cpu, sizeof(m_Cpu));
}
void Detect(void);
bool hasSSE() { return (m_Cpu[0].mFeatures & CFI_SSE) != 0; }
bool hasSSE2() { return (m_Cpu[0].mFeatures & CFI_SSE2) != 0; }
bool hasSSE3() { return (m_Cpu[0].mFeatures & CFI_SSE3) != 0; }
bool hasSSE41() { return (m_Cpu[0].mFeatures & CFI_SSE41) != 0; }
bool has3DNow() { return (m_Cpu[0].mFeatures & CFI_3DNOW) != 0; }
bool hasMMX() { return (m_Cpu[0].mFeatures & CFI_MMX) != 0; }
bool hasF16C() { return (m_Cpu[0].mFeatures & CFI_F16C) != 0; }
unsigned int GetLogicalCPUCount() { return m_NumLogicalProcessors; }
unsigned int GetPhysCPUCount() { return m_NumPhysicsProcessors; }
unsigned int GetCPUCount() { return m_NumAvailProcessors; }
DWORD_PTR GetCPUAffinityMask(unsigned int iCPU) { assert(iCPU < MAX_CPU); return iCPU < GetCPUCount() ? m_Cpu[iCPU].mAffinityMask : 0; }
DWORD_PTR GetPhysCPUAffinityMask(unsigned int iCPU)
{
if (iCPU > GetPhysCPUCount())
{
return 0;
}
int i;
for (i = 0; (int)iCPU >= 0; i++)
{
if (m_Cpu[i].mbPhysical)
{
--iCPU;
}
}
PREFAST_ASSUME(i > 0 && i < MAX_CPU);
return m_Cpu[i - 1].mAffinityMask;
}
};
#endif // CRYINCLUDE_CRYSYSTEM_CPUDETECT_H

90
Code/CryEngine/CrySystem/ClientHandler.cpp
Unescape Escape View File

@ -1,90 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#include "CrySystem_precompiled.h"
#include "ProjectDefines.h"
#if defined(MAP_LOADING_SLICING)
#include "ClientHandler.h"
ClientHandler::ClientHandler(const char* bucket, int affinity, int clientTimeout)
: HandlerBase(bucket, affinity)
{
m_clientTimeout = clientTimeout;
Reset();
}
void ClientHandler::Reset()
{
m_srvLock.reset(0);
for (int i = 0; i < MAX_CLIENTS_NUM; i++)
{
std::unique_ptr<SSyncLock> srv(new SSyncLock(m_serverLockName, i, false));
// first get the client lock up!
if (!srv->IsValid())
{
//try to create client lock
m_clientLock.reset(new SSyncLock(m_clientLockName, i, true));
if (m_clientLock->IsValid())
{
break;
}
else
{
m_clientLock.reset(0);
}
}
}
}
bool ClientHandler::ServerIsValid()
{
if (!m_srvLock.get())
{
if (m_clientLock.get() && m_clientLock->IsValid())
{
m_srvLock.reset(new SSyncLock(m_serverLockName, m_clientLock->number, false));
if (m_srvLock->IsValid())
{
SetAffinity();
//got synched
return true;
}
m_srvLock.reset(0);
}
return false;
}
return m_srvLock->IsValid();
}
bool ClientHandler::Sync()
{
if (ServerIsValid())
{
m_clientLock->Signal();//signal that we're done and
if (m_srvLock->Wait(m_clientTimeout))//wait for server
{
//bla bla, track waiting
return true;
}
else
{
Reset();
}
}
return false;
}
#endif // defined(MAP_LOADING_SLICING)

36
Code/CryEngine/CrySystem/ClientHandler.h
Unescape Escape 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.
#ifndef CRYINCLUDE_CRYSYSTEM_CLIENTHANDLER_H
#define CRYINCLUDE_CRYSYSTEM_CLIENTHANDLER_H
#pragma once
#include "HandlerBase.h"
#include "SyncLock.h"
struct ClientHandler
: public HandlerBase
{
ClientHandler(const char* bucket, int affinity, int clientTimeout);
void Reset();
bool ServerIsValid();
bool Sync();
private:
int m_clientTimeout;
std::unique_ptr<SSyncLock> m_clientLock;
std::unique_ptr<SSyncLock> m_srvLock;
};
#endif

167
Code/CryEngine/CrySystem/Components/MathConversionTests.cpp
Unescape Escape View File

@ -1,167 +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 "CrySystem_precompiled.h"
#include <AzTest/AzTest.h>
#include <MathConversion.h>
#include <Cry_Quat.h>
#include <Cry_Matrix34.h>
//namespace MathConversionUnitTests
//{
const float kEpsilon = 0.01f;
bool IsNearlyEqual(const AZ::Vector3& az, const Vec3& ly)
{
return fcmp(az.GetX(), ly.x, kEpsilon)
&& fcmp(az.GetY(), ly.y, kEpsilon)
&& fcmp(az.GetZ(), ly.z, kEpsilon);
}
bool IsNearlyEqual(const AZ::Quaternion& az, const Quat& ly)
{
return fcmp(az.GetX(), ly.v.x, kEpsilon)
&& fcmp(az.GetY(), ly.v.y, kEpsilon)
&& fcmp(az.GetZ(), ly.v.z, kEpsilon)
&& fcmp(az.GetW(), ly.w, kEpsilon);
}
bool IsNearlyEqual(const AZ::Transform& az, const Matrix34& ly)
{
float azFloats[12];
const AZ::Matrix3x4 matrix3x4 = AZ::Matrix3x4::CreateFromTransform(az);
matrix3x4.StoreToRowMajorFloat12(azFloats);
const float* lyFloats = ly.GetData();
for (int i = 0; i < 12; ++i)
{
if (!fcmp(azFloats[i], lyFloats[i], kEpsilon))
{
return false;
}
}
return true;
}
bool IsNearlyEqual(const AZ::Transform& az, const QuatT& ly)
{
return IsNearlyEqual(az.GetTranslation(), ly.t)
&& IsNearlyEqual(az.GetRotation(), ly.q);
}
TEST(MathConversionTests, BasicConversions)
{
{ // check vector3 comparisons
AZ::Vector3 az(1.f, 2.f, 3.f);
Vec3 ly(1.f, 2.f, 3.f);
EXPECT_TRUE(IsNearlyEqual(az, ly));
// reverse XYZ
ly = Vec3(3.f, 2.f, 1.f);
EXPECT_TRUE(!IsNearlyEqual(az, ly));
// off by 0.1
ly = Vec3(1.1f, 2.1f, 3.1f);
EXPECT_TRUE(!IsNearlyEqual(az, ly));
}
{ // check vector3 conversions
Vec3 ly1(1.f, 2.f, 3.f);
AZ::Vector3 az = LYVec3ToAZVec3(ly1);
EXPECT_TRUE(IsNearlyEqual(az, ly1));
Vec3 ly2 = AZVec3ToLYVec3(az);
EXPECT_TRUE(IsNearlyEqual(az, ly1));
EXPECT_TRUE(ly1.IsEquivalent(ly2));
}
{ // check quaternion comparisons
AZ::Quaternion az(AZ::Quaternion::CreateIdentity());
Quat ly(IDENTITY);
EXPECT_TRUE(IsNearlyEqual(az, ly));
az = AZ::Quaternion(1.f, 2.f, 3.f, 4.f);
ly = Quat(4.f, 1.f, 2.f, 3.f);
EXPECT_TRUE(IsNearlyEqual(az, ly));
// w in wrong place
ly = Quat(1.f, 2.f, 3.f, 4.f);
EXPECT_TRUE(!IsNearlyEqual(az, ly));
}
{ // check quaternion conversions
Quat ly1(4.f, 1.f, 2.f, 3.f);
AZ::Quaternion az = LYQuaternionToAZQuaternion(ly1);
EXPECT_TRUE(IsNearlyEqual(az, ly1));
Quat ly2 = AZQuaternionToLYQuaternion(az);
EXPECT_TRUE(IsNearlyEqual(az, ly2));
EXPECT_TRUE(Quat::IsEquivalent(ly1, ly2));
}
{ // check transform comparisons
AZ::Transform az = AZ::Transform::Identity();
Matrix34 ly = Matrix34::CreateIdentity();
EXPECT_TRUE(IsNearlyEqual(az, ly));
// rotating pi/2 will get us a non-symmetric matrix.
// good for testing that we're not confusing rows & columns
float rotation = gf_PI / 2.f;
ly = Matrix34::CreateRotationX(rotation, Vec3(1.f, 2.f, 3.f));
az = AZ::Transform::CreateRotationX(rotation);
az.SetTranslation(1.f, 2.f, 3.f);
EXPECT_TRUE(IsNearlyEqual(az, ly));
// rotate around different axis
ly = Matrix34::CreateRotationY(rotation, Vec3(1.f, 2.f, 3.f));
EXPECT_TRUE(!IsNearlyEqual(az, ly));
}
{ // check transform conversions
Matrix34 ly1 = Matrix34::CreateRotationXYZ(Ang3(0.1f, 0.5f, 0.9f), Vec3(1.f, 2.f, 3.f));
AZ::Transform az = LYTransformToAZTransform(ly1);
EXPECT_TRUE(IsNearlyEqual(az, ly1));
Matrix34 ly2 = AZTransformToLYTransform(az);
EXPECT_TRUE(IsNearlyEqual(az, ly2));
EXPECT_TRUE(Matrix34::IsEquivalent(ly1, ly2));
}
{ // check QuatT comparisons
AZ::Transform az = AZ::Transform::Identity();
QuatT ly(IDENTITY);
EXPECT_TRUE(IsNearlyEqual(az, ly));
az = AZ::Transform::CreateRotationX(AZ::Constants::HalfPi);
az.SetTranslation(1.f, 2.f, 3.f);
ly.q.SetRotationX(AZ::Constants::HalfPi);
ly.t.Set(1.f, 2.f, 3.f);
EXPECT_TRUE(IsNearlyEqual(az, ly));
// off by 0.1
ly.t.z += 0.1f;
EXPECT_TRUE(!IsNearlyEqual(az, ly));
}
{ // check QuatT conversions
QuatT ly1(Quat::CreateRotationX(AZ::Constants::HalfPi), Vec3(5.f, 6.f, 7.f));
AZ::Transform az = LYQuatTToAZTransform(ly1);
EXPECT_TRUE(IsNearlyEqual(az, ly1));
QuatT ly2 = AZTransformToLYQuatT(az);
EXPECT_TRUE(IsNearlyEqual(az, ly2));
EXPECT_TRUE(QuatT::IsEquivalent(ly1, ly2));
}
}
//} // namespace MathConversionUnitTests

38
Code/CryEngine/CrySystem/CompressedFile.cpp
Unescape Escape View File

@ -1,38 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#include "CrySystem_precompiled.h"
#include "System.h"
#include "CryZlib.h"
bool CSystem::CompressDataBlock(const void* input, size_t inputSize, void* output, size_t& outputSize, int level)
{
uLongf destLen = outputSize;
Bytef* dest = static_cast<Bytef*>(output);
uLong sourceLen = inputSize;
const Bytef* source = static_cast<const Bytef*>(input);
bool ok = Z_OK == compress2(dest, &destLen, source, sourceLen, level);
outputSize = destLen;
return ok;
}
bool CSystem::DecompressDataBlock(const void* input, size_t inputSize, void* output, size_t& outputSize)
{
uLongf destLen = outputSize;
Bytef* dest = static_cast<Bytef*>(output);
uLong sourceLen = inputSize;
const Bytef* source = static_cast<const Bytef*>(input);
bool ok = Z_OK == uncompress(dest, &destLen, source, sourceLen);
outputSize = destLen;
return ok;
}

114
Code/CryEngine/CrySystem/CrashHandler.rc
Unescape Escape View File

@ -1,114 +0,0 @@
// Microsoft Visual C++ generated resource script.
//
#include "resource.h"
#define APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 2 resource.
//
#include "winres.h"
/////////////////////////////////////////////////////////////////////////////
#undef APSTUDIO_READONLY_SYMBOLS
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
/////////////////////////////////////////////////////////////////////////////
//
// DESIGNINFO
//
#ifdef APSTUDIO_INVOKED
GUIDELINES DESIGNINFO
BEGIN
IDD_CRITICAL_ERROR, DIALOG
BEGIN
LEFTMARGIN, 5
RIGHTMARGIN, 260
BOTTOMMARGIN, 223
END
IDD_EXCEPTION, DIALOG
BEGIN
END
IDD_CONFIRM_SAVE_LEVEL, DIALOG
BEGIN
LEFTMARGIN, 7
RIGHTMARGIN, 239
TOPMARGIN, 7
BOTTOMMARGIN, 96
END
END
#endif // APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Dialog
//
IDD_CRITICAL_ERROR DIALOGEX 0, 0, 267, 230
STYLE DS_SETFONT | DS_MODALFRAME | DS_SETFOREGROUND | DS_CENTER | WS_POPUP | WS_VISIBLE | WS_CAPTION
CAPTION "Critical Exception"
FONT 8, "MS Sans Serif", 0, 0, 0x0
BEGIN
DEFPUSHBUTTON "&Abort",IDB_EXIT,100,207,58,14
EDITTEXT IDC_CALLSTACK,10,95,245,102,ES_MULTILINE | ES_AUTOVSCROLL | WS_VSCROLL | WS_HSCROLL
EDITTEXT IDC_EXCEPTION_CODE,10,25,50,12,ES_AUTOHSCROLL | ES_READONLY
LTEXT "Call Stack Trace",IDC_STATIC,13,85,54,8
LTEXT "Code",IDC_STATIC,10,15,18,8
LTEXT "Address:",IDC_STATIC,66,15,28,8
EDITTEXT IDC_EXCEPTION_ADDRESS,65,25,75,12,ES_AUTOHSCROLL | ES_READONLY
LTEXT "Description",IDC_STATIC,10,40,36,8
GROUPBOX "Exception Info",IDC_STATIC,5,5,255,200
EDITTEXT IDC_EXCEPTION_MODULE,145,25,110,12,ES_AUTOHSCROLL | ES_READONLY
LTEXT "Module",IDC_STATIC,145,15,24,8
EDITTEXT IDC_EXCEPTION_DESC,10,50,245,30,ES_MULTILINE | ES_AUTOHSCROLL | ES_READONLY
PUSHBUTTON "&Ignore",IDB_IGNORE,160,207,59,14,WS_DISABLED
END
IDD_EXCEPTION DIALOG 0, 0, 138, 52
STYLE DS_SETFONT | DS_MODALFRAME | DS_CENTER | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
CAPTION "Exception"
FONT 8, "MS Sans Serif"
BEGIN
LTEXT "Exception Intercepted\r\nRetrieving Info...",IDC_STATIC,33,18,71,19
END
IDD_CONFIRM_SAVE_LEVEL DIALOGEX 0, 0, 280, 123
STYLE DS_SYSMODAL | DS_SETFONT | DS_MODALFRAME | DS_SETFOREGROUND | DS_FIXEDSYS | DS_CENTER | WS_POPUP | WS_VISIBLE | WS_CAPTION
EXSTYLE WS_EX_TOPMOST
CAPTION "Engine, Game or Editor Crash"
FONT 8, "MS Shell Dlg", 400, 0, 0x1
BEGIN
PUSHBUTTON "Save",IDB_CONFIRM_SAVE,4,96,68,20
PUSHBUTTON "Cancel",IDB_DONT_SAVE,206,96,68,20
LTEXT "Open 3D Engine has encountered an error and needs to close.\n\nA backup has been saved to the '_savebackup' subfolder.\n\nIf you are unable to save your file, you can recover by copying the contents of the _savebackup folder over the broken files.",IDC_STATIC,60,8,210,61
LTEXT "Attempt save?",IDC_STATIC,60,72,180,21
CONTROL 128,IDC_STATIC,"Static",SS_BITMAP | SS_CENTERIMAGE | SS_REALSIZEIMAGE,8,8,48,40
END
/////////////////////////////////////////////////////////////////////////////
//
// Bitmap
//
IDB_CRASH_FACE BITMAP "crash_face.bmp"
#endif // English (United States) resources
/////////////////////////////////////////////////////////////////////////////
#ifndef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 3 resource.
//
/////////////////////////////////////////////////////////////////////////////
#endif // not APSTUDIO_INVOKED

58
Code/CryEngine/CrySystem/CryAsyncMemcpy.cpp
Unescape Escape 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.
#include "CrySystem_precompiled.h"
#include <AzCore/Debug/Profiler.h>
#include <AzCore/Jobs/JobFunction.h>
namespace
{
static void cryAsyncMemcpy_Int(
void* dst
, const void* src
, size_t size
, int nFlags
, volatile int* sync)
{
AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::System);
cryMemcpy(dst, src, size, nFlags);
if (sync)
{
CryInterlockedDecrement(sync);
}
}
}
#if !defined(CRY_ASYNC_MEMCPY_DELEGATE_TO_CRYSYSTEM)
CRY_ASYNC_MEMCPY_API void cryAsyncMemcpy(
#else
CRY_ASYNC_MEMCPY_API void cryAsyncMemcpyDelegate(
#endif
void* dst
, const void* src
, size_t size
, int nFlags
, volatile int* sync)
{
AZ::Job* job = AZ::CreateJobFunction(
[dst, src, size, nFlags, sync]()
{
cryAsyncMemcpy_Int(dst, src, size, nFlags, sync);
},
true); // Auto-delete
job->Start();
}

6645
Code/CryEngine/CrySystem/CryDLMalloc.c
View File

File diff suppressed because it is too large Load Diff

91
Code/CryEngine/CrySystem/CrySystem.rc
Unescape Escape View File

@ -1,91 +0,0 @@
// Microsoft Visual C++ generated resource script.
//
#include "resource.h"
#define APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 2 resource.
//
#include "winres.h"
/////////////////////////////////////////////////////////////////////////////
#undef APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
// German (Germany) resources
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_DEU)
LANGUAGE LANG_GERMAN, SUBLANG_GERMAN
#pragma code_page(1252)
/////////////////////////////////////////////////////////////////////////////
//
// Version
//
VS_VERSION_INFO VERSIONINFO
FILEVERSION 1,0,0,1
PRODUCTVERSION 1,0,0,1
FILEFLAGSMASK 0x17L
#ifdef _DEBUG
FILEFLAGS 0x1L
#else
FILEFLAGS 0x0L
#endif
FILEOS 0x4L
FILETYPE 0x2L
FILESUBTYPE 0x0L
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "000904b0"
BEGIN
VALUE "CompanyName", "Amazon.com, Inc."
VALUE "FileVersion", "1, 0, 0, 1"
VALUE "LegalCopyright", "Portions of this file Copyright (c) Amazon.com, Inc. or its affiliates. All Rights Reserved. Original file Copyright (c) Crytek GMBH. Used under license by Amazon.com, Inc. and its affiliates."
VALUE "ProductName", "Lumberyard"
VALUE "ProductVersion", "1, 0, 0, 1"
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x9, 1200
END
END
#endif // German (Germany) resources
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// English (United States) resources
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
#pragma code_page(1252)
#ifdef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// TEXTINCLUDE
//
1 TEXTINCLUDE
BEGIN
"resource.h\0"
END
2 TEXTINCLUDE
BEGIN
"#include ""winres.h""\r\n"
"\0"
END
3 TEXTINCLUDE
BEGIN
"\r\n"
"\0"
END
#endif // APSTUDIO_INVOKED
#endif // English (United States) resources

34
Code/CryEngine/CrySystem/CryWaterMark.h
Unescape Escape 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.
// Header for adding a watermark to an exe, which can then be set
// by the external CryWaterMark program. To use, simply write:
//
// WATERMARKDATA(__blah);
//
// anywhere in the global scope in the program
#ifndef CRYINCLUDE_CRYSYSTEM_CRYWATERMARK_H
#define CRYINCLUDE_CRYSYSTEM_CRYWATERMARK_H
#pragma once
#define NUMMARKWORDS 10
#define WATERMARKDATA(name) unsigned int name[] = { 0xDEBEFECA, 0xFABECEDA, 0xADABAFBE, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
// (the name is such that you can have multiple watermarks in one exe, don't use
// names like "watermark" just incase you accidentally give out an exe with
// debug information).
#endif // CRYINCLUDE_CRYSYSTEM_CRYWATERMARK_H

155
Code/CryEngine/CrySystem/CustomMemoryHeap.cpp
Unescape Escape 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.
#include "CrySystem_precompiled.h"
#include "CustomMemoryHeap.h"
#if defined(AZ_RESTRICTED_PLATFORM)
#undef AZ_RESTRICTED_SECTION
#define CUSTOMMEMORYHEAP_CPP_SECTION_1 1
#define CUSTOMMEMORYHEAP_CPP_SECTION_2 2
#define CUSTOMMEMORYHEAP_CPP_SECTION_3 3
#endif
#if defined(AZ_RESTRICTED_PLATFORM)
#define AZ_RESTRICTED_SECTION CUSTOMMEMORYHEAP_CPP_SECTION_1
#include AZ_RESTRICTED_FILE(CustomMemoryHeap_cpp)
#endif
//////////////////////////////////////////////////////////////////////////
CCustomMemoryHeapBlock::CCustomMemoryHeapBlock(CCustomMemoryHeap* pHeap)
: m_pHeap(pHeap)
, m_pData(0)
, m_nSize(0)
, m_nGPUHandle(0)
{
}
//////////////////////////////////////////////////////////////////////////
CCustomMemoryHeapBlock::~CCustomMemoryHeapBlock()
{
m_pHeap->DeallocateBlock(this);
}
//////////////////////////////////////////////////////////////////////////
void* CCustomMemoryHeapBlock::GetData()
{
return m_pData;
}
//////////////////////////////////////////////////////////////////////////
void CCustomMemoryHeapBlock::CopyMemoryRegion(void* pOutputBuffer, size_t nOffset, size_t nSize)
{
assert(nOffset + nSize <= m_nSize);
if (nOffset + nSize <= m_nSize)
{
memcpy(pOutputBuffer, (uint8*)m_pData + nOffset, nSize);
}
else
{
CryFatalError("Bad CopyMemoryRegion range");
}
}
//////////////////////////////////////////////////////////////////////////
ICustomMemoryBlock* CCustomMemoryHeap::AllocateBlock(size_t const nAllocateSize, char const* const sUsage, size_t const nAlignment /* = 16 */)
{
CCustomMemoryHeapBlock* pBlock = new CCustomMemoryHeapBlock(this);
pBlock->m_sUsage = sUsage;
pBlock->m_nSize = nAllocateSize;
switch (m_eAllocPolicy)
{
case IMemoryManager::eapDefaultAllocator:
{
size_t allocated = 0;
pBlock->m_pData = CryMalloc(nAllocateSize, allocated, nAlignment);
break;
}
case IMemoryManager::eapPageMapped:
pBlock->m_pData = CryMemory::AllocPages(nAllocateSize);
break;
case IMemoryManager::eapCustomAlignment:
#if defined(DEBUG)
if (nAlignment == 0)
{
CryFatalError("CCustomMemoryHeap: trying to allocate memory via eapCustomAlignment with an alignment of zero!");
}
#endif
pBlock->m_pData = CryModuleMemalign(nAllocateSize, nAlignment);
break;
#if defined(AZ_RESTRICTED_PLATFORM)
#define AZ_RESTRICTED_SECTION CUSTOMMEMORYHEAP_CPP_SECTION_2
#include AZ_RESTRICTED_FILE(CustomMemoryHeap_cpp)
#endif
default:
CryFatalError("CCustomMemoryHeap: unknown allocation policy during AllocateBlock!");
break;
}
CryInterlockedAdd(&m_nAllocatedSize, nAllocateSize);
return pBlock;
}
void CCustomMemoryHeap::DeallocateBlock(CCustomMemoryHeapBlock* pBlock)
{
switch (m_eAllocPolicy)
{
case IMemoryManager::eapDefaultAllocator:
CryFree(pBlock->m_pData, 0);
break;
case IMemoryManager::eapPageMapped:
CryMemory::FreePages(pBlock->m_pData, pBlock->GetSize());
break;
case IMemoryManager::eapCustomAlignment:
CryModuleMemalignFree(pBlock->m_pData);
break;
#if defined(AZ_RESTRICTED_PLATFORM)
#define AZ_RESTRICTED_SECTION CUSTOMMEMORYHEAP_CPP_SECTION_3
#include AZ_RESTRICTED_FILE(CustomMemoryHeap_cpp)
#endif
default:
CryFatalError("CCustomMemoryHeap: unknown allocation policy during DeallocateBlock!");
break;
}
int nAllocateSize = (int)pBlock->m_nSize;
CryInterlockedAdd(&m_nAllocatedSize, -nAllocateSize);
}
//////////////////////////////////////////////////////////////////////////
void CCustomMemoryHeap::GetMemoryUsage(ICrySizer* pSizer)
{
pSizer->AddObject(this, m_nAllocatedSize);
}
//////////////////////////////////////////////////////////////////////////
size_t CCustomMemoryHeap::GetAllocated()
{
return m_nAllocatedSize;
}
//////////////////////////////////////////////////////////////////////////
CCustomMemoryHeap::CCustomMemoryHeap(IMemoryManager::EAllocPolicy const eAllocPolicy)
{
m_nAllocatedSize = 0;
m_eAllocPolicy = eAllocPolicy;
m_nTraceHeapHandle = 0;
}
//////////////////////////////////////////////////////////////////////////
CCustomMemoryHeap::~CCustomMemoryHeap()
{
}

44
Code/CryEngine/CrySystem/DllMain.cpp
Unescape Escape View File

@ -62,46 +62,6 @@ AZ_POP_DISABLE_WARNING
}
#endif
//////////////////////////////////////////////////////////////////////////
struct CSystemEventListner_System
: public ISystemEventListener
{
public:
virtual void OnSystemEvent(ESystemEvent event, [[maybe_unused]] UINT_PTR wparam, [[maybe_unused]] UINT_PTR lparam)
{
switch (event)
{
case ESYSTEM_EVENT_LEVEL_LOAD_START:
case ESYSTEM_EVENT_LEVEL_LOAD_END:
{
CryCleanup();
break;
}
case ESYSTEM_EVENT_LEVEL_POST_UNLOAD:
{
CryCleanup();
STLALLOCATOR_CLEANUP;
break;
}
}
}
};
static CSystemEventListner_System g_system_event_listener_system;
static AZ::EnvironmentVariable<IMemoryManager*> s_cryMemoryManager;
// Force the CryMemoryManager into the AZ::Environment for exposure to other DLLs
void ExportCryMemoryManager()
{
IMemoryManager* cryMemoryManager = nullptr;
CryGetIMemoryManagerInterface((void**)&cryMemoryManager);
AZ_Assert(cryMemoryManager, "Unable to resolve CryMemoryManager");
s_cryMemoryManager = AZ::Environment::CreateVariable<IMemoryManager*>("CryIMemoryManagerInterface", cryMemoryManager);
}
extern "C"
{
CRYSYSTEM_API ISystem* CreateSystemInterface(const SSystemInitParams& startupParams)
@ -113,8 +73,6 @@ CRYSYSTEM_API ISystem* CreateSystemInterface(const SSystemInitParams& startupPar
// Environment should have been attached via InjectEnvironment
AZ_Assert(AZ::Environment::IsReady(), "Environment is not attached, must be attached before CreateSystemInterface can be called");
ExportCryMemoryManager();
pSystem = new CSystem(startupParams.pSharedEnvironment);
ModuleInitISystem(pSystem, "CrySystem");
@ -146,8 +104,6 @@ CRYSYSTEM_API ISystem* CreateSystemInterface(const SSystemInitParams& startupPar
return 0;
}
pSystem->GetISystemEventDispatcher()->RegisterListener(&g_system_event_listener_system);
return pSystem;
}
};

188
Code/CryEngine/CrySystem/GeneralMemoryHeap.cpp
Unescape Escape View File

@ -1,188 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#include "CrySystem_precompiled.h"
#include "GeneralMemoryHeap.h"
#include <AzCore/Memory/AllocatorBase.h>
#include <AzCore/Memory/HphaSchema.h>
class GeneralMemoryHeapAllocator
: public AZ::SimpleSchemaAllocator<AZ::HphaSchema>
{
using Base = AZ::SimpleSchemaAllocator<AZ::HphaSchema>;
public:
static const size_t DEFAULT_ALIGNMENT = sizeof(void*);
GeneralMemoryHeapAllocator(const char* desc)
: Base("GeneralMemoryHeapAllocator", desc)
{
}
void Reserve(size_t size)
{
// Allocate a block, then free it, forcing it into the page tree/cache
void* block = m_schema->Allocate(size, GeneralMemoryHeapAllocator::DEFAULT_ALIGNMENT, 0, "GeneralMemoryHeapAllocator Reserve", __FILE__, __LINE__);
m_schema->DeAllocate(block);
}
};
CGeneralMemoryHeap::CGeneralMemoryHeap([[maybe_unused]] UINT_PTR base, [[maybe_unused]] size_t upperLimit, size_t reserveSize, const char* sUsage)
: m_refCount(0)
, m_block(nullptr)
, m_blockSize(0)
{
AZ::HphaSchema::Descriptor desc;
desc.m_subAllocator = &AZ::AllocatorInstance<AZ::LegacyAllocator>::Get();
m_allocator.reset(new AZ::AllocatorWrapper<GeneralMemoryHeapAllocator>);
m_allocator->Create(desc, sUsage);
if (reserveSize)
{
(*m_allocator)->Reserve(reserveSize);
}
}
CGeneralMemoryHeap::CGeneralMemoryHeap(void* base, size_t size, const char* sUsage)
: m_refCount(0)
, m_block(base)
, m_blockSize(size)
{
AZ::HphaSchema::Descriptor desc;
desc.m_fixedMemoryBlock = base;
desc.m_fixedMemoryBlockByteSize = size;
desc.m_fixedMemoryBlockAlignment = GeneralMemoryHeapAllocator::DEFAULT_ALIGNMENT;
m_allocator.reset(new AZ::AllocatorWrapper<GeneralMemoryHeapAllocator>);
m_allocator->Create(desc, sUsage);
}
CGeneralMemoryHeap::~CGeneralMemoryHeap()
{
}
bool CGeneralMemoryHeap::Cleanup()
{
(*m_allocator)->GarbageCollect();
return true;
}
int CGeneralMemoryHeap::AddRef()
{
return m_refCount.fetch_add(1);
}
int CGeneralMemoryHeap::Release()
{
int nRef = m_refCount.fetch_sub(1);
if (nRef <= 1)
{
delete this;
}
return nRef;
}
void CGeneralMemoryHeap::RecordAlloc(void* ptr, size_t size)
{
if (m_block == nullptr)
{
m_allocs.emplace(ptr, size);
}
}
void CGeneralMemoryHeap::RecordFree(void* ptr, size_t size)
{
if (m_block == nullptr)
{
m_allocs.erase(Alloc(ptr, size));
}
}
bool CGeneralMemoryHeap::IsInAddressRange(void* ptr) const
{
if (m_block)
{
return (static_cast<char*>(ptr) - static_cast<char*>(m_block)) <= m_blockSize;
}
auto it = m_allocs.find(Alloc(ptr));
return it != m_allocs.end();
}
void* CGeneralMemoryHeap::Calloc(size_t numElements, size_t size, const char* sUsage)
{
void* ptr = (*m_allocator)->Allocate(numElements * size, GeneralMemoryHeapAllocator::DEFAULT_ALIGNMENT, 0, sUsage, __FILE__, __LINE__);
memset(ptr, 0, numElements * size);
RecordAlloc(ptr, numElements * size);
return ptr;
}
void* CGeneralMemoryHeap::Malloc(size_t size, const char* sUsage)
{
void* ptr = (*m_allocator)->Allocate(size, GeneralMemoryHeapAllocator::DEFAULT_ALIGNMENT, 0, sUsage, __FILE__, __LINE__);
RecordAlloc(ptr, size);
return ptr;
}
size_t CGeneralMemoryHeap::Free(void* ptr)
{
// The client code using these heaps tend to use a guesswork algorithm to freeing
// which involves handing the pointer to every known heap until it frees, so
// it's necessary to validate that the ptr belongs to this heap before attempting to free
if (IsInAddressRange(ptr))
{
size_t size = (*m_allocator)->AllocationSize(ptr);
RecordFree(ptr, size);
(*m_allocator)->DeAllocate(ptr);
return size;
}
return 0;
}
void* CGeneralMemoryHeap::Realloc(void* ptr, size_t size, const char* /*sUsage*/)
{
RecordFree(ptr, (*m_allocator)->AllocationSize(ptr));
void* newPtr = (*m_allocator)->ReAllocate(ptr, size, GeneralMemoryHeapAllocator::DEFAULT_ALIGNMENT);
RecordAlloc(newPtr, size);
return newPtr;
}
void* CGeneralMemoryHeap::ReallocAlign(void* ptr, size_t size, size_t alignment, const char* /*sUsage*/)
{
RecordFree(ptr, (*m_allocator)->AllocationSize(ptr));
void* newPtr = (*m_allocator)->ReAllocate(ptr, size, alignment);
RecordAlloc(newPtr, size);
return newPtr;
}
void* CGeneralMemoryHeap::Memalign(size_t boundary, size_t size, const char* sUsage)
{
void* ptr = (*m_allocator)->Allocate(size, boundary, 0, sUsage, __FILE__, __LINE__);
RecordAlloc(ptr, size);
return ptr;
}
size_t CGeneralMemoryHeap::UsableSize(void* ptr) const
{
// The client code using these heaps tend to use a guesswork algorithm to determine
// which heap owns the pointer. Calls to UsableSize() are a part of this guesswork.
// The overrun detector doesn't play nicely on AllocationSize() lookups for pointers that
// don't belong to the heap, so validate that we're in the correct address range before trying
// to look up the size.
return IsInAddressRange(ptr) ? (*m_allocator)->AllocationSize(ptr) : 0;
}
AZ::IAllocator* CGeneralMemoryHeap::GetAllocator() const
{
return m_allocator->Get();
}

94
Code/CryEngine/CrySystem/GeneralMemoryHeap.h
Unescape Escape View File

@ -1,94 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYSYSTEM_GENERALMEMORYHEAP_H
#define CRYINCLUDE_CRYSYSTEM_GENERALMEMORYHEAP_H
#pragma once
#include "IMemory.h"
#include <AzCore/std/smart_ptr/unique_ptr.h>
#include <AzCore/std/parallel/atomic.h>
#include <AzCore/std/containers/set.h>
class GeneralMemoryHeapAllocator;
class CGeneralMemoryHeap
: public IGeneralMemoryHeap
{
struct Alloc
{
void* m_base;
size_t m_size;
Alloc(void* base = nullptr, size_t size = 0)
: m_base(base)
, m_size(size)
{}
bool operator==(const Alloc& rhs) const
{
// size doesn't matter
return m_base == rhs.m_base;
}
bool operator<(const Alloc& rhs) const
{
// this will cause allocs to be sorted by address
return m_base < rhs.m_base;
}
};
public:
// Create a heap that will map/unmap pages in the range [baseAddress, baseAddress + upperLimit).
CGeneralMemoryHeap(UINT_PTR baseAddress, size_t upperLimit, size_t reserveSize, const char* sUsage);
// Create a heap that will assumes all memory in the range [base, base + size) is already mapped.
CGeneralMemoryHeap(void* base, size_t size, const char* sUsage);
~CGeneralMemoryHeap();
public: // IGeneralMemoryHeap Members
bool Cleanup();
int AddRef();
int Release();
bool IsInAddressRange(void* ptr) const;
void* Calloc(size_t nmemb, size_t size, const char* sUsage = NULL);
void* Malloc(size_t sz, const char* sUsage = NULL);
size_t Free(void* ptr);
void* Realloc(void* ptr, size_t sz, const char* sUsage = NULL);
void* ReallocAlign(void* ptr, size_t size, size_t alignment, const char* sUsage = NULL);
void* Memalign(size_t boundary, size_t size, const char* sUsage = NULL);
size_t UsableSize(void* ptr) const;
AZ::IAllocator* GetAllocator() const override;
private:
CGeneralMemoryHeap(const CGeneralMemoryHeap&) = delete;
CGeneralMemoryHeap& operator = (const CGeneralMemoryHeap&) = delete;
void RecordAlloc(void* ptr, size_t size);
void RecordFree(void* ptr, size_t size);
private:
AZStd::unique_ptr<AZ::AllocatorWrapper<GeneralMemoryHeapAllocator>> m_allocator;
AZStd::atomic_int m_refCount;
void* m_block;
size_t m_blockSize;
AZStd::set<Alloc, AZStd::less<Alloc>, AZ::AZStdAlloc<AZ::LegacyAllocator>> m_allocs;
};
#endif // CRYINCLUDE_CRYSYSTEM_GENERALMEMORYHEAP_H

131
Code/CryEngine/CrySystem/HandlerBase.cpp
Unescape Escape View File

@ -1,131 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#include "CrySystem_precompiled.h"
#include "ProjectDefines.h"
#if defined(MAP_LOADING_SLICING)
#include "HandlerBase.h"
const char* SERVER_LOCK_NAME = "SynchronizeGameServer";
const char* CLIENT_LOCK_NAME = "SynchronizeGameClient";
HandlerBase::HandlerBase(const char* bucket, int affinity)
{
m_serverLockName.Format("%s_%s", SERVER_LOCK_NAME, bucket);
m_clientLockName.Format("%s_%s", CLIENT_LOCK_NAME, bucket);
if (affinity != 0)
{
m_affinity = uint32(1) << (affinity - 1);
}
else
{
m_affinity = -1;
}
m_prevAffinity = 0;
}
HandlerBase::~HandlerBase()
{
if (m_prevAffinity)
{
if (SyncSetAffinity(m_prevAffinity))
{
CryLogAlways("Restored affinity to %d", m_prevAffinity);
}
else
{
CryLogAlways("Failed to restore affinity to %d", m_prevAffinity);
}
}
}
void HandlerBase::SetAffinity()
{
if (m_prevAffinity) //already set
{
return;
}
if (uint32 p = SyncSetAffinity(m_affinity))
{
CryLogAlways("Changed affinity to %d", m_affinity);
m_prevAffinity = p;
}
else
{
CryLogAlways("Failed to change affinity to %d", m_affinity);
}
}
#if defined(LINUX)
uint32 HandlerBase::SyncSetAffinity(uint32 cpuMask)//put -1
{
if (cpuMask != 0)
{
cpu_set_t cpuSet;
uint32 affinity = 0;
if (!sched_getaffinity(getpid(), sizeof cpuSet, &cpuSet))
{
for (int cpu = 0; cpu < sizeof(cpuMask) * 8; ++cpu)
{
if (CPU_ISSET(cpu, &cpuSet))
{
affinity |= 1 << cpu;
}
}
}
if (affinity)
{
CPU_ZERO(&cpuSet);
for (int cpu = 0; cpu < sizeof(cpuMask) * 8; ++cpu)
{
if (cpuMask & (1 << cpu))
{
CPU_SET(cpu, &cpuSet);
}
}
if (!sched_setaffinity(getpid(), sizeof(cpuSet), &cpuSet))
{
return affinity;
}
}
}
return 0;
}
#elif AZ_LEGACY_CRYSYSTEM_TRAIT_USE_HANDLER_SYNC_AFFINITY
uint32 HandlerBase::SyncSetAffinity(uint32 cpuMask)//put -1
{
uint32 p = (uint32)SetThreadAffinityMask(GetCurrentThread(), cpuMask);
if (p == 0)
{
CryLogAlways("Error updating affinity mask to %d", cpuMask);
}
return p;
}
#else
uint32 HandlerBase::SyncSetAffinity(uint32 cpuMask)//put -1
{
CryLogAlways("Updating thread affinity not supported on this platform");
return 0;
}
#endif
#endif // defined(MAP_LOADING_SLICING)

35
Code/CryEngine/CrySystem/HandlerBase.h
Unescape Escape View File

@ -1,35 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYSYSTEM_HANDLERBASE_H
#define CRYINCLUDE_CRYSYSTEM_HANDLERBASE_H
#pragma once
const int MAX_CLIENTS_NUM = 100;
struct HandlerBase
{
HandlerBase(const char* bucket, int affinity);
~HandlerBase();
void SetAffinity();
uint32 SyncSetAffinity(uint32 cpuMask);
string m_serverLockName;
string m_clientLockName;
uint32 m_affinity;
uint32 m_prevAffinity;
};
#endif // CRYINCLUDE_CRYSYSTEM_HANDLERBASE_H

54
Code/CryEngine/CrySystem/IOSConsole.h
Unescape Escape View File

@ -1,54 +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 : Console implementation for iOS, reports back to the main interface
#pragma once
#include <IConsole.h>
#include <ITextModeConsole.h>
class CIOSConsole
: public ISystemUserCallback
, public IOutputPrintSink
, public ITextModeConsole
{
CIOSConsole(const CIOSConsole&);
CIOSConsole& operator = (const CIOSConsole&);
bool m_isInitialized;
public:
static CryCriticalSectionNonRecursive s_lock;
public:
CIOSConsole();
~CIOSConsole();
// Interface IOutputPrintSink /////////////////////////////////////////////
DLL_EXPORT virtual void Print(const char* line);
// Interface ISystemUserCallback //////////////////////////////////////////
virtual bool OnError(const char* errorString);
virtual bool OnSaveDocument() { return false; }
virtual void OnProcessSwitch() { }
virtual void OnInitProgress(const char* sProgressMsg);
virtual void OnInit(ISystem*);
virtual void OnShutdown();
virtual void OnUpdate();
virtual void GetMemoryUsage(ICrySizer* pSizer);
void SetRequireDedicatedServer(bool) {}
void SetHeader(const char*) {}
// Interface ITextModeConsole /////////////////////////////////////////////
virtual Vec2_tpl<int> BeginDraw();
virtual void PutText(int x, int y, const char* msg);
virtual void EndDraw();
};

94
Code/CryEngine/CrySystem/IOSConsole.mm
Unescape Escape View File

@ -1,94 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#include "CrySystem_precompiled.h"
#if defined(IOS)
#include "IOSConsole.h"
CIOSConsole::CIOSConsole():
m_isInitialized(false)
{
}
CIOSConsole::~CIOSConsole()
{
}
// Interface IOutputPrintSink /////////////////////////////////////////////
void CIOSConsole::Print(const char *line)
{
printf("MSG: %s\n", line);
}
// Interface ISystemUserCallback //////////////////////////////////////////
bool CIOSConsole::OnError(const char *errorString)
{
printf("ERR: %s\n", errorString);
return true;
}
void CIOSConsole::OnInitProgress(const char *sProgressMsg)
{
(void) sProgressMsg;
// Do Nothing
}
void CIOSConsole::OnInit(ISystem *pSystem)
{
if (!m_isInitialized)
{
IConsole* pConsole = pSystem->GetIConsole();
if (pConsole != 0)
{
pConsole->AddOutputPrintSink(this);
}
m_isInitialized = true;
}
}
void CIOSConsole::OnShutdown()
{
if (m_isInitialized)
{
// remove outputprintsink
m_isInitialized = false;
}
}
void CIOSConsole::OnUpdate()
{
// Do Nothing
}
void CIOSConsole::GetMemoryUsage(ICrySizer *pSizer)
{
size_t size = sizeof(*this);
pSizer->AddObject(this, size);
}
// Interface ITextModeConsole /////////////////////////////////////////////
Vec2_tpl<int> CIOSConsole::BeginDraw()
{
return Vec2_tpl<int>(0,0);
}
void CIOSConsole::PutText( int x, int y, const char * msg )
{
printf("PUT: %s\n", msg);
}
void CIOSConsole::EndDraw() {
// Do Nothing
}
#endif // IOS

280
Code/CryEngine/CrySystem/ImageHandler.cpp
Unescape Escape View File

@ -1,280 +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 "CrySystem_precompiled.h"
#include <AzCore/IO/SystemFile.h>
#include "ImageHandler.h"
#include <numeric>
#include "ScopeGuard.h"
#include "Algorithm.h"
#include "System.h"
#if defined(AZ_RESTRICTED_PLATFORM)
#include AZ_RESTRICTED_FILE(ImageHandler_cpp)
#endif
#if !(defined(ANDROID) || defined(IOS) || defined(LINUX)) && AZ_LEGACY_CRYSYSTEM_TRAIT_IMAGEHANDLER_TIFFIO // Rally US1050 - Compile libtiff for Android and IOS
#include <tiffio.h>
static_assert(sizeof(thandle_t) >= sizeof(AZ::IO::HandleType), "Platform defines thandle_t to be smaller than required");
#endif
namespace
{
class Image
: public IImageHandler::IImage
{
public:
Image(std::vector<unsigned char>&& data, int width, int height)
{
CRY_ASSERT(data.size() == width * height * ImageHandler::c_BytesPerPixel);
m_data = std::move(data);
m_width = width;
m_height = height;
}
private:
virtual const std::vector<unsigned char>& GetData() const override { return m_data; }
virtual int GetWidth() const override { return m_width; }
virtual int GetHeight() const override { return m_height; }
unsigned int m_width;
unsigned int m_height;
std::vector<unsigned char> m_data;
};
#if AZ_LEGACY_CRYSYSTEM_TRAIT_IMAGEHANDLER_TIFFIO
struct TiffIO
{
static tsize_t Read(thandle_t handle, tdata_t buffer, tsize_t size)
{
AZ::u64 bytesRead = 0;
AZ::IO::FileIOBase::GetDirectInstance()->Read(static_cast<AZ::IO::HandleType>(reinterpret_cast<AZ::u64>(handle)), buffer, size, false, &bytesRead);
return static_cast<tsize_t>(bytesRead);
};
static tsize_t Write(thandle_t handle, tdata_t buffer, tsize_t size)
{
AZ::u64 sizeWritten;
if (AZ::IO::FileIOBase::GetDirectInstance()->Write(static_cast<AZ::IO::HandleType>(reinterpret_cast<AZ::u64>(handle)), buffer, size, &sizeWritten))
{
return static_cast<tsize_t>(sizeWritten);
}
else
{
return 0;
}
};
static int Close(thandle_t handle)
{
AZ::IO::FileIOBase::GetDirectInstance()->Close(static_cast<AZ::IO::HandleType>(reinterpret_cast<AZ::u64>(handle)));
return 0;
};
static toff_t Seek(thandle_t handle, toff_t pos, int mode)
{
if (AZ::IO::FileIOBase::GetDirectInstance()->Seek(static_cast<AZ::IO::HandleType>(reinterpret_cast<AZ::u64>(handle)), static_cast<uint64_t>(pos), AZ::IO::GetSeekTypeFromFSeekMode(mode)))
{
if (mode == SEEK_SET)
{
return pos;
}
else
{
AZ::u64 offsetFromBegin;
if (AZ::IO::FileIOBase::GetDirectInstance()->Tell(static_cast<AZ::IO::HandleType>(reinterpret_cast<AZ::u64>(handle)), offsetFromBegin))
{
return static_cast<tsize_t>(offsetFromBegin);
}
else
{
return -1;
}
}
}
return -1;
};
static toff_t Size(thandle_t handle)
{
AZ::u64 fileSize = 0;
AZ::IO::FileIOBase::GetDirectInstance()->Size(static_cast<AZ::IO::HandleType>(reinterpret_cast<AZ::u64>(handle)), fileSize);
return static_cast<tsize_t>(fileSize);
};
static int Map(thandle_t, tdata_t*, toff_t*)
{
return 0;
};
static void Unmap(thandle_t, tdata_t, toff_t)
{
return;
};
};
#endif
}
std::unique_ptr<IImageHandler::IImage> ImageHandler::CreateImage(std::vector<unsigned char>&& data, int width, int height) const
{
return std::make_unique<Image>(std::move(data), width, height);
}
std::unique_ptr<IImageHandler::IImage> ImageHandler::LoadImage([[maybe_unused]] const char* filename) const
{
#if AZ_LEGACY_CRYSYSTEM_TRAIT_IMAGEHANDLER_TIFFIO
AZ::IO::HandleType fileHandle;
AZ::IO::FileIOBase::GetDirectInstance()->Open(filename, AZ::IO::GetOpenModeFromStringMode("rb"), fileHandle);
if (fileHandle == AZ::IO::InvalidHandle)
{
CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_ERROR, "Failed to open image file %s", filename);
return nullptr;
}
auto tifHandle = std17::unique_resource_checked(TIFFClientOpen(filename, "rb", reinterpret_cast<thandle_t>(static_cast<AZ::u64>(fileHandle)), TiffIO::Read, TiffIO::Write, TiffIO::Seek, TiffIO::Close, &TiffIO::Size, TiffIO::Map, TiffIO::Unmap), (TIFF*)nullptr, TIFFClose);
if (!tifHandle)
{
CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_ERROR, "Failed to load image %s", filename);
return nullptr;
}
int width = 0;
int height = 0;
TIFFGetField(tifHandle, TIFFTAG_IMAGEWIDTH, &width);
TIFFGetField(tifHandle, TIFFTAG_IMAGELENGTH, &height);
std::vector<unsigned char> data(4 * width * height);
if (!TIFFReadRGBAImageOriented(tifHandle, width, height, reinterpret_cast<uint32*>(data.data()), ORIENTATION_TOPLEFT))
{
CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_ERROR, "Failed to load image %s", filename);
return nullptr;
}
//strip alpha
int every4th = 0;
data.erase(std::remove_if(begin(data), end(data), [&](unsigned char)
{
return (every4th++ & 3) == 3;
}), end(data));
return std::make_unique<Image>(std::move(data), width, height);
#else
CRY_ASSERT(0); // UNIMPLEMENTED
return nullptr;
#endif
}
bool ImageHandler::SaveImage([[maybe_unused]] IImageHandler::IImage* image, [[maybe_unused]] const char* filename) const
{
#if AZ_LEGACY_CRYSYSTEM_TRAIT_IMAGEHANDLER_TIFFIO
AZ::IO::HandleType fileHandle;
AZ::IO::FileIOBase::GetDirectInstance()->Open(filename, AZ::IO::GetOpenModeFromStringMode("wb"), fileHandle);
if (fileHandle == AZ::IO::InvalidHandle)
{
CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_ERROR, "Failed to open image file for write %s", filename);
return false;
}
auto tifHandle = std17::unique_resource_checked(TIFFClientOpen(filename, "wb", reinterpret_cast<thandle_t>(static_cast<AZ::u64>(fileHandle)), TiffIO::Read, TiffIO::Write, TiffIO::Seek, TiffIO::Close, &TiffIO::Size, TiffIO::Map, TiffIO::Unmap), (TIFF*)nullptr, TIFFClose);
if (!tifHandle)
{
CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_ERROR, "Failed to save image %s", filename);
return false;
}
TIFFSetField(tifHandle, TIFFTAG_IMAGEWIDTH, image->GetWidth());
TIFFSetField(tifHandle, TIFFTAG_IMAGELENGTH, image->GetHeight());
TIFFSetField(tifHandle, TIFFTAG_SAMPLESPERPIXEL, c_BytesPerPixel);
TIFFSetField(tifHandle, TIFFTAG_BITSPERSAMPLE, 8);
TIFFSetField(tifHandle, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
TIFFSetField(tifHandle, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
TIFFSetField(tifHandle, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
TIFFSetField(tifHandle, TIFFTAG_COMPRESSION, COMPRESSION_LZW);
tsize_t bytesPerLine = c_BytesPerPixel * image->GetWidth();
std::vector<unsigned char> lineBuffer;
if (TIFFScanlineSize(tifHandle) != bytesPerLine)
{
lineBuffer.resize(bytesPerLine);
}
else
{
lineBuffer.resize(TIFFScanlineSize(tifHandle));
}
TIFFSetField(tifHandle, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(tifHandle, image->GetWidth() * c_BytesPerPixel));
auto srcData = image->GetData().data();
for (uint32 row = 0; row < image->GetHeight(); row++)
{
memcpy(lineBuffer.data(), &srcData[row * bytesPerLine], bytesPerLine);
if (TIFFWriteScanline(tifHandle, lineBuffer.data(), row, 0) < 0)
{
CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "Failed to write part of image %s", filename);
return false;
}
}
return true;
#else
CRY_ASSERT(0); // UNIMPLEMENTED
return false;
#endif
}
std::unique_ptr<IImageHandler::IImage> ImageHandler::CreateDiffImage(IImageHandler::IImage* image1, IImageHandler::IImage* image2) const
{
if (!image1 || !image2)
{
CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "Could not create diff image, null arguments");
return nullptr;
}
if (image1->GetWidth() != image2->GetWidth() || image1->GetHeight() != image2->GetHeight())
{
CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "Could not create diff image, 2 images were not the same size");
return nullptr;
}
CRY_ASSERT(image1->GetData().size() == image1->GetWidth() * image1->GetHeight() * ImageHandler::c_BytesPerPixel);
CRY_ASSERT(image2->GetData().size() == image2->GetWidth() * image2->GetHeight() * ImageHandler::c_BytesPerPixel);
std::vector<unsigned char> resultRGBData;
auto iter1 = image1->GetData().data();
auto iter2 = image2->GetData().data();
for (int i = 0; i < image1->GetWidth() * image1->GetHeight() * c_BytesPerPixel; ++i)
{
resultRGBData.push_back(static_cast<unsigned char>(abs(static_cast<int>(iter1[i]) - static_cast<int>(iter2[i]))));
}
return std::make_unique<Image>(std::move(resultRGBData), image1->GetWidth(), image1->GetHeight());
}
float ImageHandler::CalculatePSNR(IImageHandler::IImage* diffIimage) const
{
if (!diffIimage)
{
CryWarning(VALIDATOR_MODULE_SYSTEM, VALIDATOR_WARNING, "Could not create diff image, null arguments");
return 0;
}
CRY_ASSERT(diffIimage->GetData().size() == diffIimage->GetWidth() * diffIimage->GetHeight() * ImageHandler::c_BytesPerPixel);
auto mse = std17::accumulate(diffIimage->GetData(), 0.0, [](double result, unsigned char value) -> double { return result += (double)value * (double)value; });
mse /= (c_BytesPerPixel * diffIimage->GetWidth() * diffIimage->GetHeight());
if (mse <= 0)
{
return std::numeric_limits<float>::max();
}
// see http://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio for a derivation of this formula and source for magic numbers
return static_cast<float>(20 * log10(255) - 10 * log10(mse));
}

30
Code/CryEngine/CrySystem/ImageHandler.h
Unescape Escape 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.
*
*/
#pragma once
#ifndef CRYINCLUDE_CRYSYSTEM_IMAGEHANDLER_H
#define CRYINCLUDE_CRYSYSTEM_IMAGEHANDLER_H
#include "IImageHandler.h"
class ImageHandler
: public IImageHandler
{
public:
static const int c_BytesPerPixel = 3; //This only deals with RGB data for now, no alpha
private:
virtual std::unique_ptr<IImageHandler::IImage> CreateImage(std::vector<unsigned char>&& rgbData, int width, int height) const override;
virtual std::unique_ptr<IImageHandler::IImage> LoadImage(const char* filename) const override;
virtual bool SaveImage(IImageHandler::IImage* image, const char* filename) const override;
virtual std::unique_ptr<IImageHandler::IImage> CreateDiffImage(IImageHandler::IImage* image1, IImageHandler::IImage* image2) const override;
virtual float CalculatePSNR(IImageHandler::IImage* diffIimage) const override;
};
#endif // CRYINCLUDE_CRYSYSTEM_IMAGEHANDLER_H

29
Code/CryEngine/CrySystem/LZ4Decompressor.cpp
Unescape Escape 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 : lz4 hc decompress wrapper
#include "CrySystem_precompiled.h"
#include <lz4.h>
#include "LZ4Decompressor.h"
bool CLZ4Decompressor::DecompressData(const char* pIn, char* pOut, const uint outputSize) const
{
return LZ4_decompress_fast(pIn, pOut, outputSize) >= 0;
}
void CLZ4Decompressor::Release()
{
delete this;
}

35
Code/CryEngine/CrySystem/LZ4Decompressor.h
Unescape Escape View File

@ -1,35 +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 : lz4 hc decompress wrapper
#ifndef CRYINCLUDE_CRYSYSTEM_LZ4DECOMPRESSOR_H
#define CRYINCLUDE_CRYSYSTEM_LZ4DECOMPRESSOR_H
#pragma once
#include "ILZ4Decompressor.h"
class CLZ4Decompressor
: public ILZ4Decompressor
{
public:
virtual bool DecompressData(const char* pIn, char* pOut, const uint outputSize) const;
virtual void Release();
private:
virtual ~CLZ4Decompressor() {}
};
#endif // CRYINCLUDE_CRYSYSTEM_LZ4DECOMPRESSOR_H

16
Code/CryEngine/CrySystem/LevelSystem/LevelSystem.cpp
Unescape Escape View File

@ -17,7 +17,6 @@
#include "LevelSystem.h"
#include <IAudioSystem.h>
#include "IMovieSystem.h"
#include <IResourceManager.h>
#include <ILocalizationManager.h>
#include "CryPath.h"
#include <Pak/CryPakUtils.h>
@ -261,16 +260,6 @@ void CLevelSystem::Rescan(const char* levelsFolder)
{
if (levelsFolder)
{
if (const ICmdLineArg* pModArg = m_pSystem->GetICmdLine()->FindArg(eCLAT_Pre, "MOD"))
{
if (m_pSystem->IsMODValid(pModArg->GetValue()))
{
m_levelsFolder.format("Mods/%s/%s", pModArg->GetValue(), levelsFolder);
m_levelInfos.clear();
ScanFolder(0, true);
}
}
m_levelsFolder = levelsFolder;
}
@ -778,9 +767,6 @@ void CLevelSystem::PrepareNextLevel(const char* levelName)
// switched to level heap, so now imm start the loading screen (renderer will be reinitialized in the levelheap)
gEnv->pSystem->GetISystemEventDispatcher()->OnSystemEvent(ESYSTEM_EVENT_LEVEL_LOAD_START_LOADINGSCREEN, 0, 0);
gEnv->pSystem->SetSystemGlobalState(ESYSTEM_GLOBAL_STATE_LEVEL_LOAD_START_PREPARE);
// Inform resource manager about loading of the new level.
GetISystem()->GetIResourceManager()->PrepareLevel(pLevelInfo->GetPath(), pLevelInfo->GetName());
}
for (AZStd::vector<ILevelSystemListener*>::const_iterator it = m_listeners.begin(); it != m_listeners.end(); ++it)
@ -987,8 +973,6 @@ void CLevelSystem::UnloadLevel()
m_lastLevelName.clear();
GetISystem()->GetIResourceManager()->UnloadLevel();
SAFE_RELEASE(m_pCurrentLevel);
// Force Lua garbage collection (may no longer be needed now the legacy renderer has been removed).

3
Code/CryEngine/CrySystem/LevelSystem/SpawnableLevelSystem.cpp
Unescape Escape View File

@ -14,7 +14,6 @@
#include "SpawnableLevelSystem.h"
#include <IAudioSystem.h>
#include "IMovieSystem.h"
#include <IResourceManager.h>
#include <LoadScreenBus.h>
@ -566,8 +565,6 @@ namespace LegacyLevelSystem
m_lastLevelName.clear();
GetISystem()->GetIResourceManager()->UnloadLevel();
// Force Lua garbage collection (may no longer be needed now the legacy renderer has been removed).
// Normally the GC step is triggered at the end of this method (by the ESYSTEM_EVENT_LEVEL_POST_UNLOAD event).
EBUS_EVENT(AZ::ScriptSystemRequestBus, GarbageCollect);

41
Code/CryEngine/CrySystem/Log.cpp
Unescape Escape View File

@ -20,7 +20,6 @@
//this should not be included here
#include <IConsole.h>
#include <ISystem.h>
#include <IStreamEngine.h>
#include "System.h"
#include "CryPath.h" // PathUtil::ReplaceExtension()
#include <Pak/CryPakUtils.h>
@ -418,7 +417,7 @@ void CLog::LogV(const ELogType type, const char* szFormat, va_list args)
LogV(type, 0, szFormat, args);
}
void CLog::LogV(const ELogType type, int flags, const char* szFormat, va_list args)
void CLog::LogV(const ELogType type, [[maybe_unused]]int flags, const char* szFormat, va_list args)
{
// this is here in case someone called LogV directly, with an invalid formatter.
if (!CheckLogFormatter(szFormat))
@ -596,28 +595,6 @@ void CLog::LogV(const ELogType type, int flags, const char* szFormat, va_list ar
GetISystem()->GetIRemoteConsole()->AddLogError(szString);
break;
}
//////////////////////////////////////////////////////////////////////////
if (type == eWarningAlways || type == eWarning || type == eError || type == eErrorAlways)
{
IValidator* pValidator = m_pSystem->GetIValidator();
if (pValidator && (flags & VALIDATOR_FLAG_SKIP_VALIDATOR) == 0)
{
CryAutoCriticalSection scope_lock(m_logCriticalSection);
SValidatorRecord record;
record.text = szBuffer;
record.module = VALIDATOR_MODULE_SYSTEM;
record.severity = VALIDATOR_WARNING;
record.assetScope = GetAssetScopeString();
record.flags = flags;
if (type == eError || type == eErrorAlways)
{
record.severity = VALIDATOR_ERROR;
}
pValidator->Report(record);
}
}
}
//will log the text both to the end of file and console
@ -1439,22 +1416,6 @@ void CLog::UpdateLoadingScreen(const char* szFormat, ...)
va_end(args);
}
#endif
if (CryGetCurrentThreadId() == m_nMainThreadId)
{
#ifndef LINUX
// Take this opportunity to update streaming engine.
if (IStreamEngine* pStreamEngine = GetISystem()->GetStreamEngine())
{
const float curTime = m_pSystem->GetITimer()->GetAsyncCurTime();
if (curTime - m_fLastLoadingUpdateTime > .1f) // not frequent than once in 100ms
{
m_fLastLoadingUpdateTime = curTime;
pStreamEngine->Update();
}
}
#endif
}
}
//////////////////////////////////////////////////////////////////////////

163
Code/CryEngine/CrySystem/MTSafeAllocator.cpp
Unescape Escape View File

@ -1,163 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#include "CrySystem_precompiled.h"
#include "MTSafeAllocator.h"
#include <IConsole.h>
extern CMTSafeHeap* g_pPakHeap;
// Uncomment this define to enable time tracing of the MTSAFE heap
#define MTSAFE_PROFILE 1
//#undef MTSAFE_PROFILE
namespace
{
class CSimpleTimer
{
LARGE_INTEGER& m_result;
LARGE_INTEGER m_start;
public:
CSimpleTimer(LARGE_INTEGER& li)
: m_result(li)
{ QueryPerformanceCounter(&m_start); }
~CSimpleTimer()
{
LARGE_INTEGER end;
QueryPerformanceCounter(&end);
m_result.QuadPart = end.QuadPart - m_start.QuadPart;
}
};
};
//////////////////////////////////////////////////////////////////////////
CMTSafeHeap::CMTSafeHeap()
: m_LiveTempAllocations()
, m_TotalAllocations()
, m_TempAllocationsFailed()
, m_TempAllocationsTime()
{
size_t allocated = 0;
m_pGeneralHeapStorage = (char*)CryMalloc(MTSAFE_GENERAL_HEAP_SIZE, allocated, MTSAFE_DEFAULT_ALIGNMENT);
m_pGeneralHeapStorageEnd = m_pGeneralHeapStorage + MTSAFE_GENERAL_HEAP_SIZE;
m_pGeneralHeap = CryGetIMemoryManager()->CreateGeneralMemoryHeap(m_pGeneralHeapStorage, MTSAFE_GENERAL_HEAP_SIZE, "MTSafeHeap");
}
//////////////////////////////////////////////////////////////////////////
CMTSafeHeap::~CMTSafeHeap()
{
SAFE_RELEASE(m_pGeneralHeap);
CryFree(m_pGeneralHeapStorage, MTSAFE_DEFAULT_ALIGNMENT);
}
//////////////////////////////////////////////////////////////////////////
size_t CMTSafeHeap::PersistentAllocSize(size_t nSize)
{
return nSize;
}
//////////////////////////////////////////////////////////////////////////
void* CMTSafeHeap::PersistentAlloc(size_t nSize)
{
size_t allocated = 0;
return CryMalloc(nSize, allocated, MTSAFE_DEFAULT_ALIGNMENT);
}
//////////////////////////////////////////////////////////////////////////
void CMTSafeHeap::FreePersistent(void* p)
{
CryFree(p, MTSAFE_DEFAULT_ALIGNMENT);
}
//////////////////////////////////////////////////////////////////////////
void* CMTSafeHeap::TempAlloc(size_t nSize, const char* szDbgSource, bool& bFallBackToMalloc, uint32 align)
{
# if MTSAFE_PROFILE
CSimpleTimer timer(m_TempAllocationsTime);
# endif
void* ptr = NULL;
if (align)
{
ptr = m_pGeneralHeap->Memalign(align, nSize, szDbgSource);
}
else
{
ptr = m_pGeneralHeap->Malloc(nSize, szDbgSource);
}
//explicit alignment not supported beyond this point, safer to return NULL
if (ptr || !bFallBackToMalloc)
{
bFallBackToMalloc = false;
return ptr;
}
bFallBackToMalloc = true;
# if MTSAFE_PROFILE
CryInterlockedAdd((volatile int*)&m_TempAllocationsFailed, (int)nSize);
# endif
return CryModuleMemalign(nSize, align > 0 ? align : MTSAFE_DEFAULT_ALIGNMENT);
}
//////////////////////////////////////////////////////////////////////////
void CMTSafeHeap::FreeTemporary(void* p)
{
# if MTSAFE_PROFILE
CSimpleTimer timer(m_TempAllocationsTime);
# endif
if (m_pGeneralHeap->IsInAddressRange(p))
{
m_pGeneralHeap->Free(p);
return;
}
// Fallback to free
CryModuleMemalignFree(p);
}
//////////////////////////////////////////////////////////////////////////
void* CMTSafeHeap::StaticAlloc([[maybe_unused]] void* pOpaque, unsigned nItems, unsigned nSize)
{
return g_pPakHeap->TempAlloc(nItems * nSize, "StaticAlloc");
}
//////////////////////////////////////////////////////////////////////////
void CMTSafeHeap::StaticFree ([[maybe_unused]] void* pOpaque, void* pAddress)
{
g_pPakHeap->FreeTemporary(pAddress);
}
//////////////////////////////////////////////////////////////////////////
void CMTSafeHeap::GetMemoryUsage(ICrySizer* pSizer)
{
SIZER_COMPONENT_NAME(pSizer, "FileSystem Pool");
}
void CMTSafeHeap::PrintStats()
{
# if MTSAFE_PROFILE
LARGE_INTEGER freq;
QueryPerformanceFrequency(&freq);
const double rFreq = 1. / static_cast<double>(freq.QuadPart);
CryLogAlways("mtsafe temporary pool failed for %" PRISIZE_T " bytes, time spent in allocations %3.08f seconds",
m_TempAllocationsFailed, static_cast<double>(m_TempAllocationsTime.QuadPart) * rFreq);
# endif
}

108
Code/CryEngine/CrySystem/MTSafeAllocator.h
Unescape Escape View File

@ -1,108 +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(LINUX)
# include "Linux_Win32Wrapper.h"
#endif
#include <ISystem.h>
////////////////////////////////////////////////////////////////////////////////
#if defined(AZ_RESTRICTED_PLATFORM)
#include AZ_RESTRICTED_FILE(MTSafeAllocator_h)
#endif
#if defined(AZ_RESTRICTED_SECTION_IMPLEMENTED)
#undef AZ_RESTRICTED_SECTION_IMPLEMENTED
#elif defined(MOBILE) // IOS/Android
# define MTSAFE_DEFAULT_ALIGNMENT 8
# define MTSAFE_GENERAL_HEAP_SIZE ((1U << 20) + (1U << 19))
#elif defined(WIN32) || defined(WIN64) || defined(LINUX) || defined(MAC)
# define MTSAFE_GENERAL_HEAP_SIZE (12U << 20)
# define MTSAFE_DEFAULT_ALIGNMENT 8
#else
# error Unknown target platform
#endif
class CMTSafeHeap
{
public:
// Constructor
CMTSafeHeap();
// Destructor
~CMTSafeHeap();
// Performs a persisistent (in other words, non-temporary) allocation.
void* PersistentAlloc(size_t nSize);
// Retrieves system memory allocation size for any call to PersistentAlloc.
// Required to not count virtual memory usage inside CrySizer
size_t PersistentAllocSize(size_t nSize);
// Frees memory allocation
void FreePersistent(void* p);
// Perform a allocation that is considered temporary and will be handled by
// the pool itself.
// Note: It is important that these temporary allocations are actually
// temporary and do not persist for a long persiod of time.
void* TempAlloc (size_t nSize, const char* szDbgSource, uint32 align = 0)
{
bool bFallbackToMalloc = true;
return TempAlloc(nSize, szDbgSource, bFallbackToMalloc, align);
}
void* TempAlloc (size_t nSize, const char* szDbgSource, bool& bFallBackToMalloc, uint32 align = 0);
bool IsInGeneralHeap(const void* p)
{
return m_pGeneralHeapStorage <= p && p < m_pGeneralHeapStorageEnd;
}
// Free a temporary allocaton.
void FreeTemporary(void* p);
// The number of live allocations allocation within the temporary pool
size_t NumAllocations() const { return m_LiveTempAllocations; }
// The memory usage of the mtsafe allocator
void GetMemoryUsage(ICrySizer* pSizer);
// zlib-compatible stubs
static void* StaticAlloc (void* pOpaque, unsigned nItems, unsigned nSize);
static void StaticFree (void* pOpaque, void* pAddress);
// Dump some statistics to the cry log
void PrintStats();
private:
friend class CSystem;
IGeneralMemoryHeap* m_pGeneralHeap;
char* m_pGeneralHeapStorage;
char* m_pGeneralHeapStorageEnd;
// The number of temporary allocations currently active within the pool
size_t m_LiveTempAllocations;
// The total number of allocations performed in the pool
size_t m_TotalAllocations;
// The total bytes that weren't temporarily allocated
size_t m_TempAllocationsFailed;
// The total number of temporary allocations that fell back to global system memory
LARGE_INTEGER m_TempAllocationsTime;
};

145
Code/CryEngine/CrySystem/MemoryAddressRange.cpp
Unescape Escape 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.
#include "CrySystem_precompiled.h"
#include "MemoryAddressRange.h"
#include "System.h"
#if defined(APPLE) || defined(LINUX)
#include <sys/mman.h>
#endif
CMemoryAddressRange::CMemoryAddressRange(char* pBaseAddress, size_t nPageSize, size_t nPageCount, [[maybe_unused]] const char* sName)
: m_pBaseAddress(pBaseAddress)
, m_nPageSize(nPageSize)
, m_nPageCount(nPageCount)
{
}
void CMemoryAddressRange::Release()
{
delete this;
}
char* CMemoryAddressRange::GetBaseAddress() const
{
return m_pBaseAddress;
}
size_t CMemoryAddressRange::GetPageCount() const
{
return m_nPageCount;
}
size_t CMemoryAddressRange::GetPageSize() const
{
return m_nPageSize;
}
#if AZ_LEGACY_CRYSYSTEM_TRAIT_MEMADDRESSRANGE_WINDOWS_STYLE
void* CMemoryAddressRange::ReserveSpace(size_t capacity)
{
return VirtualAlloc(NULL, capacity, MEM_RESERVE, PAGE_READWRITE);
}
size_t CMemoryAddressRange::GetSystemPageSize()
{
SYSTEM_INFO si;
GetSystemInfo(&si);
return si.dwPageSize;
}
CMemoryAddressRange::CMemoryAddressRange(size_t capacity, [[maybe_unused]] const char* name)
{
m_nPageSize = GetSystemPageSize();
size_t algnCap = Align(capacity, m_nPageSize);
m_pBaseAddress = (char*)ReserveSpace(algnCap);
m_nPageCount = algnCap / m_nPageSize;
}
CMemoryAddressRange::~CMemoryAddressRange()
{
VirtualFree(m_pBaseAddress, 0, MEM_RELEASE);
}
void* CMemoryAddressRange::MapPage(size_t pageIdx)
{
void* pRet = VirtualAlloc(m_pBaseAddress + pageIdx * m_nPageSize, m_nPageSize, MEM_COMMIT, PAGE_READWRITE);
return pRet;
}
void CMemoryAddressRange::UnmapPage(size_t pageIdx)
{
char* pBase = m_pBaseAddress + pageIdx * m_nPageSize;
// Disable warning about only decommitting pages, and not releasing them
VirtualFree(pBase, m_nPageSize, MEM_DECOMMIT);
}
#elif defined(AZ_RESTRICTED_PLATFORM)
#include AZ_RESTRICTED_FILE(MemoryAddressRange_cpp)
#elif defined(APPLE) || defined(LINUX)
void* CMemoryAddressRange::ReserveSpace(size_t capacity)
{
return mmap(0, capacity, PROT_NONE, MAP_ANON | MAP_NORESERVE | MAP_PRIVATE, -1, 0);
}
size_t CMemoryAddressRange::GetSystemPageSize()
{
return sysconf(_SC_PAGESIZE);
}
CMemoryAddressRange::CMemoryAddressRange(size_t capacity, const char* name)
{
m_nPageSize = GetSystemPageSize();
m_allocatedSpace = Align(capacity, m_nPageSize);
m_pBaseAddress = (char*)ReserveSpace(m_allocatedSpace);
assert(m_pBaseAddress != MAP_FAILED);
m_nPageCount = m_allocatedSpace / m_nPageSize;
}
CMemoryAddressRange::~CMemoryAddressRange()
{
int ret = munmap(m_pBaseAddress, m_allocatedSpace);
(void) ret;
assert(ret == 0);
}
void* CMemoryAddressRange::MapPage(size_t pageIdx)
{
// There is no equivalent to this function with mmap, this
// happens automatically in the OS. We just return the
// correct address.
void* pRet = NULL;
if (0 == mprotect(m_pBaseAddress + (pageIdx * m_nPageSize), m_nPageSize, PROT_READ | PROT_WRITE))
{
pRet = m_pBaseAddress + (pageIdx * m_nPageSize);
}
return pRet;
}
void CMemoryAddressRange::UnmapPage(size_t pageIdx)
{
char* pBase = m_pBaseAddress + pageIdx * m_nPageSize;
int ret = mprotect(pBase, m_nPageSize, PROT_NONE);
(void) ret;
assert(ret == 0);
}
#endif

61
Code/CryEngine/CrySystem/MemoryAddressRange.h
Unescape Escape 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_CRYSYSTEM_MEMORYADDRESSRANGE_H
#define CRYINCLUDE_CRYSYSTEM_MEMORYADDRESSRANGE_H
#pragma once
#include "IMemory.h"
class CMemoryAddressRange
: public IMemoryAddressRange
{
public:
static void* ReserveSpace(size_t sz);
static size_t GetSystemPageSize();
public:
CMemoryAddressRange(char* pBaseAddress, size_t nPageSize, size_t nPageCount, const char* sName);
CMemoryAddressRange(size_t capacity, const char* name);
~CMemoryAddressRange();
ILINE bool IsInRange(void* p) const
{
return m_pBaseAddress <= p && p < (m_pBaseAddress + m_nPageSize * m_nPageCount);
}
public:
void Release();
char* GetBaseAddress() const;
size_t GetPageCount() const;
size_t GetPageSize() const;
void* MapPage(size_t pageIdx);
void UnmapPage(size_t pageIdx);
private:
CMemoryAddressRange(const CMemoryAddressRange&);
CMemoryAddressRange& operator = (const CMemoryAddressRange&);
private:
char* m_pBaseAddress;
size_t m_nPageSize;
size_t m_nPageCount;
#if defined(APPLE) || defined(LINUX)
size_t m_allocatedSpace; // Required to unmap latter on
#endif
};
#endif // CRYINCLUDE_CRYSYSTEM_MEMORYADDRESSRANGE_H

226
Code/CryEngine/CrySystem/MemoryManager.cpp
Unescape Escape View File

@ -1,226 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#include "CrySystem_precompiled.h"
#include "MemoryManager.h"
#include "platform.h"
#include "CustomMemoryHeap.h"
#include "GeneralMemoryHeap.h"
#include "PageMappingHeap.h"
#if defined(AZ_RESTRICTED_PLATFORM)
#undef AZ_RESTRICTED_SECTION
#define MEMORYMANAGER_CPP_SECTION_1 1
#endif
#if defined(WIN32)
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <Psapi.h>
#endif
#if defined(APPLE)
#include <mach/mach.h> // task_info
#endif
#if defined(APPLE) || defined(LINUX)
#include <sys/types.h> // required by mman.h
#include <sys/mman.h> //mmap - virtual memory manager
#endif
#ifdef MEMMAN_STATIC
CCryMemoryManager g_memoryManager;
#endif
//////////////////////////////////////////////////////////////////////////
CCryMemoryManager* CCryMemoryManager::GetInstance()
{
#ifdef MEMMAN_STATIC
return &g_memoryManager;
#else
static CCryMemoryManager memman;
return &memman;
#endif
}
//////////////////////////////////////////////////////////////////////////
bool CCryMemoryManager::GetProcessMemInfo(SProcessMemInfo& minfo)
{
ZeroStruct(minfo);
#if defined(WIN32)
MEMORYSTATUSEX mem;
mem.dwLength = sizeof(mem);
GlobalMemoryStatusEx (&mem);
minfo.TotalPhysicalMemory = mem.ullTotalPhys;
minfo.FreePhysicalMemory = mem.ullAvailPhys;
//////////////////////////////////////////////////////////////////////////
typedef BOOL (WINAPI * GetProcessMemoryInfoProc)(HANDLE, PPROCESS_MEMORY_COUNTERS, DWORD);
PROCESS_MEMORY_COUNTERS pc;
ZeroStruct(pc);
pc.cb = sizeof(pc);
static HMODULE hPSAPI = LoadLibraryA("psapi.dll");
if (hPSAPI)
{
static GetProcessMemoryInfoProc pGetProcessMemoryInfo = (GetProcessMemoryInfoProc)GetProcAddress(hPSAPI, "GetProcessMemoryInfo");
if (pGetProcessMemoryInfo)
{
if (pGetProcessMemoryInfo(GetCurrentProcess(), &pc, sizeof(pc)))
{
minfo.PageFaultCount = pc.PageFaultCount;
minfo.PeakWorkingSetSize = pc.PeakWorkingSetSize;
minfo.WorkingSetSize = pc.WorkingSetSize;
minfo.QuotaPeakPagedPoolUsage = pc.QuotaPeakPagedPoolUsage;
minfo.QuotaPagedPoolUsage = pc.QuotaPagedPoolUsage;
minfo.QuotaPeakNonPagedPoolUsage = pc.QuotaPeakNonPagedPoolUsage;
minfo.QuotaNonPagedPoolUsage = pc.QuotaNonPagedPoolUsage;
minfo.PagefileUsage = pc.PagefileUsage;
minfo.PeakPagefileUsage = pc.PeakPagefileUsage;
return true;
}
}
}
return false;
#else
#define AZ_RESTRICTED_SECTION_IMPLEMENTED
#if defined(AZ_RESTRICTED_PLATFORM)
#define AZ_RESTRICTED_SECTION MEMORYMANAGER_CPP_SECTION_1
#include AZ_RESTRICTED_FILE(MemoryManager_cpp)
#endif
bool retVal = true;
#if defined(AZ_RESTRICTED_SECTION_IMPLEMENTED)
#undef AZ_RESTRICTED_SECTION_IMPLEMENTED
#elif defined(LINUX)
MEMORYSTATUS MemoryStatus;
GlobalMemoryStatus(&MemoryStatus);
minfo.PagefileUsage = minfo.PeakPagefileUsage = MemoryStatus.dwTotalPhys - MemoryStatus.dwAvailPhys;
minfo.FreePhysicalMemory = MemoryStatus.dwAvailPhys;
minfo.TotalPhysicalMemory = MemoryStatus.dwTotalPhys;
#if defined(ANDROID)
// On Android, mallinfo() is an EXTREMELY time consuming operation. Nearly 80% CPU time will be spent
// on this operation once -memreplay is given. Since WorkingSetSize is only used for statistics and
// debugging purpose, it's simply ignored.
minfo.WorkingSetSize = 0;
#else
struct mallinfo meminfo = mallinfo();
minfo.WorkingSetSize = meminfo.usmblks + meminfo.uordblks;
#endif
#elif defined(APPLE)
MEMORYSTATUS MemoryStatus;
GlobalMemoryStatus(&MemoryStatus);
minfo.PagefileUsage = minfo.PeakPagefileUsage = MemoryStatus.dwTotalPhys - MemoryStatus.dwAvailPhys;
minfo.FreePhysicalMemory = MemoryStatus.dwAvailPhys;
minfo.TotalPhysicalMemory = MemoryStatus.dwTotalPhys;
// Retrieve WorkingSetSize from task_info
task_basic_info kTaskInfo;
mach_msg_type_number_t uInfoCount(sizeof(kTaskInfo) / sizeof(natural_t));
if (task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&kTaskInfo, &uInfoCount) != 0)
{
gEnv->pLog->LogError("task_info failed\n");
return false;
}
minfo.WorkingSetSize = kTaskInfo.resident_size;
#else
retVal = false;
#endif
return retVal;
#endif
}
//////////////////////////////////////////////////////////////////////////
CCryMemoryManager::HeapHandle CCryMemoryManager::TraceDefineHeap([[maybe_unused]] const char* heapName, [[maybe_unused]] size_t size, [[maybe_unused]] const void* pBase)
{
return 0;
}
//////////////////////////////////////////////////////////////////////////
void CCryMemoryManager::TraceHeapAlloc([[maybe_unused]] HeapHandle heap, [[maybe_unused]] void* mem, [[maybe_unused]] size_t size, [[maybe_unused]] size_t blockSize, [[maybe_unused]] const char* sUsage, [[maybe_unused]] const char* sNameHint)
{
}
//////////////////////////////////////////////////////////////////////////
void CCryMemoryManager::TraceHeapFree([[maybe_unused]] HeapHandle heap, [[maybe_unused]] void* mem, [[maybe_unused]] size_t blockSize)
{
}
//////////////////////////////////////////////////////////////////////////
void CCryMemoryManager::TraceHeapSetColor([[maybe_unused]] uint32 color)
{
}
//////////////////////////////////////////////////////////////////////////
void CCryMemoryManager::TraceHeapSetLabel([[maybe_unused]] const char* sLabel)
{
}
//////////////////////////////////////////////////////////////////////////
uint32 CCryMemoryManager::TraceHeapGetColor()
{
return 0;
}
//////////////////////////////////////////////////////////////////////////
ICustomMemoryHeap* const CCryMemoryManager::CreateCustomMemoryHeapInstance(IMemoryManager::EAllocPolicy const eAllocPolicy)
{
return new CCustomMemoryHeap(eAllocPolicy);
}
IGeneralMemoryHeap* CCryMemoryManager::CreateGeneralExpandingMemoryHeap(size_t upperLimit, size_t reserveSize, const char* sUsage)
{
return new CGeneralMemoryHeap(static_cast<UINT_PTR>(0), upperLimit, reserveSize, sUsage);
}
IGeneralMemoryHeap* CCryMemoryManager::CreateGeneralMemoryHeap(void* base, size_t sz, const char* sUsage)
{
return new CGeneralMemoryHeap(base, sz, sUsage);
}
IMemoryAddressRange* CCryMemoryManager::ReserveAddressRange(size_t capacity, const char* sName)
{
return new CMemoryAddressRange(capacity, sName);
}
IPageMappingHeap* CCryMemoryManager::CreatePageMappingHeap(size_t addressSpace, const char* sName)
{
return new CPageMappingHeap(addressSpace, sName);
}
extern "C"
{
CRYMEMORYMANAGER_API void CryGetIMemoryManagerInterface(void** pIMemoryManager)
{
// Static instance of the memory manager
*pIMemoryManager = CCryMemoryManager::GetInstance();
}
};

52
Code/CryEngine/CrySystem/MemoryManager.h
Unescape Escape 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.
#ifndef CRYINCLUDE_CRYSYSTEM_MEMORYMANAGER_H
#define CRYINCLUDE_CRYSYSTEM_MEMORYMANAGER_H
#pragma once
#include "ISystem.h"
//////////////////////////////////////////////////////////////////////////
// Class that implements IMemoryManager interface.
//////////////////////////////////////////////////////////////////////////
#ifndef MEMMAN_STATIC
class CCryMemoryManager
: public IMemoryManager
{
public:
// Singleton
static CCryMemoryManager* GetInstance();
//////////////////////////////////////////////////////////////////////////
virtual bool GetProcessMemInfo(SProcessMemInfo& minfo);
virtual HeapHandle TraceDefineHeap(const char* heapName, size_t size, const void* pBase);
virtual void TraceHeapAlloc(HeapHandle heap, void* mem, size_t size, size_t blockSize, const char* sUsage, const char* sNameHint = 0);
virtual void TraceHeapFree(HeapHandle heap, void* mem, size_t blockSize);
virtual void TraceHeapSetColor(uint32 color);
virtual uint32 TraceHeapGetColor();
virtual void TraceHeapSetLabel(const char* sLabel);
virtual ICustomMemoryHeap* const CreateCustomMemoryHeapInstance(IMemoryManager::EAllocPolicy const eAllocPolicy);
virtual IGeneralMemoryHeap* CreateGeneralExpandingMemoryHeap(size_t upperLimit, size_t reserveSize, const char* sUsage);
virtual IGeneralMemoryHeap* CreateGeneralMemoryHeap(void* base, size_t sz, const char* sUsage);
virtual IMemoryAddressRange* ReserveAddressRange(size_t capacity, const char* sName);
virtual IPageMappingHeap* CreatePageMappingHeap(size_t addressSpace, const char* sName);
};
#else
typedef IMemoryManager CCryMemoryManager;
#endif
#endif // CRYINCLUDE_CRYSYSTEM_MEMORYMANAGER_H

151
Code/CryEngine/CrySystem/MobileDetectSpec.cpp
Unescape Escape View File

@ -1,151 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#include "CrySystem_precompiled.h"
#include <AzCore/std/string/regex.h>
#include <AzCore/std/string/string.h>
#include <IXml.h>
#include "MobileDetectSpec.h"
namespace MobileSysInspect
{
struct GpuApiPair
{
AZStd::string gpuDescription;
AZStd::string apiDescription;
};
AZStd::vector<AZStd::pair<AZStd::string, AZStd::string>> deviceSpecMapping;
AZStd::vector<AZStd::pair<GpuApiPair, AZStd::string>> gpuSpecMapping;
const float LOW_SPEC_RAM = 1.0f;
const float MEDIUM_SPEC_RAM = 2.0f;
const float HIGH_SPEC_RAM = 3.0f;
bool GetSpecForGPUAndAPI(const AZStd::string& gpuName, const AZStd::string& apiDescription, AZStd::string& specName)
{
for (const auto& descriptionSpecPair : gpuSpecMapping)
{
const GpuApiPair& currentPair = descriptionSpecPair.first;
AZStd::regex currentRegex(currentPair.gpuDescription.c_str());
if (!AZStd::regex_search(gpuName, currentRegex))
{
continue;
}
currentRegex.assign(currentPair.apiDescription.c_str());
if (!currentRegex.Empty() && !AZStd::regex_search(apiDescription, currentRegex))
{
continue;
}
specName = descriptionSpecPair.second;
return true;
}
return false;
}
namespace Internal
{
void LoadDeviceSpecMapping_impl(const char* filename)
{
XmlNodeRef xmlNode = GetISystem()->LoadXmlFromFile(filename);
if (!xmlNode)
{
return;
}
const int fileCount = xmlNode->getChildCount();
for (int i = 0; i < fileCount; ++i)
{
XmlNodeRef fileNode = xmlNode->getChild(i);
AZStd::string file = fileNode->getAttr("file");
if (!file.empty())
{
const int mappingCount = fileNode->getChildCount();
deviceSpecMapping.reserve(mappingCount);
for (int j = 0; j < mappingCount; ++j)
{
XmlNodeRef modelNode = fileNode->getChild(j);
AZStd::string model = modelNode->getAttr("model");
if (!model.empty())
{
deviceSpecMapping.push_back(AZStd::make_pair(model, file));
}
}
}
}
}
void LoadGpuSpecMapping_impl(const char* filename)
{
XmlNodeRef xmlNode = GetISystem()->LoadXmlFromFile(filename);
if (!xmlNode)
{
return;
}
const int fileCount = xmlNode->getChildCount();
for (int i = 0; i < fileCount; ++i)
{
XmlNodeRef fileNode = xmlNode->getChild(i);
AZStd::string file = fileNode->getAttr("file");
if (!file.empty())
{
const int mappingCount = fileNode->getChildCount();
gpuSpecMapping.reserve(mappingCount);
for (int j = 0; j < mappingCount; ++j)
{
XmlNodeRef modelNode = fileNode->getChild(j);
GpuApiPair gpuApiPair;
gpuApiPair.gpuDescription = modelNode->getAttr("gpuName");
gpuApiPair.apiDescription = modelNode->getAttr("apiVersion");
if (!gpuApiPair.gpuDescription.empty() || !gpuApiPair.apiDescription.empty())
{
gpuSpecMapping.push_back(AZStd::make_pair(gpuApiPair, file));
}
}
}
}
}
bool GetSpecForModelName(const AZStd::string& modelName, AZStd::string& specName)
{
for (const auto& descriptionSpecPair : deviceSpecMapping)
{
AZStd::regex currentRegex(descriptionSpecPair.first.c_str());
if (AZStd::regex_search(modelName, currentRegex))
{
specName = descriptionSpecPair.second;
return true;
}
}
return false;
}
} // namespace Internal
} // namespace MobileSysInspect

35
Code/CryEngine/CrySystem/MobileDetectSpec.h
Unescape Escape View File

@ -1,35 +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 "AzCore/std/containers/unordered_map.h"
namespace MobileSysInspect
{
extern const float LOW_SPEC_RAM;
extern const float MEDIUM_SPEC_RAM;
extern const float HIGH_SPEC_RAM;
void LoadDeviceSpecMapping();
bool GetAutoDetectedSpecName(AZStd::string &buffer);
bool GetSpecForGPUAndAPI(const AZStd::string& gpuName, const AZStd::string& apiDescription, AZStd::string& specName);
const float GetDeviceRamInGB();
namespace Internal
{
void LoadDeviceSpecMapping_impl(const char* fileName);
void LoadGpuSpecMapping_impl(const char* filename);
bool GetSpecForModelName(const AZStd::string& modelName, AZStd::string& specName);
}
}

47
Code/CryEngine/CrySystem/MobileDetectSpec_Android.cpp
Unescape Escape 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.
#include "CrySystem_precompiled.h"
#include <AzCore/Android/JNI/JNI.h>
#include <AzCore/Android/JNI/Object.h>
#include <AzCore/std/string/string.h>
#include "MobileDetectSpec.h"
namespace MobileSysInspect
{
void LoadDeviceSpecMapping()
{
Internal::LoadDeviceSpecMapping_impl("@assets@/config/gpu/android_models.xml");
Internal::LoadGpuSpecMapping_impl("@assets@/config/gpu/android_gpus.xml");
}
// Returns true if device is found in the device spec mapping
bool GetAutoDetectedSpecName(AZStd::string &buffer)
{
static constexpr const char* s_javaFieldName = "MODEL";
AZ::Android::JNI::Object obj("android/os/Build");
obj.RegisterStaticField(s_javaFieldName, "Ljava/lang/String;");
AZStd::string name = obj.GetStaticStringField(s_javaFieldName);
return Internal::GetSpecForModelName(name, buffer);
}
const float GetDeviceRamInGB()
{
static constexpr const char* s_javaFuntionNameGetDeviceRamInGB = "GetDeviceRamInGB";
AZ::Android::JNI::Object obj("com/amazon/lumberyard/AndroidDeviceManager");
obj.RegisterStaticMethod(s_javaFuntionNameGetDeviceRamInGB, "()F");
return obj.InvokeStaticFloatMethod(s_javaFuntionNameGetDeviceRamInGB);
}
}

40
Code/CryEngine/CrySystem/MobileDetectSpec_Ios.cpp
Unescape Escape 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.
#include "CrySystem_precompiled.h"
#include <AzCore/std/string/string.h>
#include "MobileDetectSpec.h"
#include <AzFramework/Utils/SystemUtilsApple.h>
namespace MobileSysInspect
{
void LoadDeviceSpecMapping()
{
Internal::LoadDeviceSpecMapping_impl("@assets@/config/gpu/ios_models.xml");
}
// Returns true if device is found in the device spec mapping
bool GetAutoDetectedSpecName(AZStd::string &buffer)
{
AZStd::string name = SystemUtilsApple::GetMachineName();
return Internal::GetSpecForModelName(name, buffer);
}
const float GetDeviceRamInGB()
{
// not supported on this platform
return 0.0f;
}
}

258
Code/CryEngine/CrySystem/PageMappingHeap.cpp
Unescape Escape View File

@ -1,258 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#include "CrySystem_precompiled.h"
#include "PageMappingHeap.h"
namespace
{
template <typename Func>
inline void FindZeroRanges(const uint32* str, size_t strLen, Func& yield)
{
size_t carry = 0;
size_t bitIdx = 0;
for (size_t wordIdx = 0; wordIdx < strLen; ++wordIdx)
{
size_t wordBitIdx = 0;
int64 word = str[wordIdx];
// Set up sign extension to insert bits that are the last bit, inverted.
if (!(word & 0x80000000))
{
reinterpret_cast<uint64&>(word) |= 0xffffffff00000000ULL;
}
do
{
size_t wordZeroRunLen = countTrailingZeroes(word);
wordBitIdx += wordZeroRunLen;
carry += wordZeroRunLen;
if (wordBitIdx == 32)
{
break;
}
yield(bitIdx, carry);
word >>= wordZeroRunLen;
bitIdx += carry;
carry = 0;
size_t wordOneRunLen = countTrailingZeroes(~word);
bitIdx += wordOneRunLen;
wordBitIdx += wordOneRunLen;
if (wordBitIdx == 32)
{
break;
}
word >>= wordOneRunLen;
}
while (true);
}
if (carry)
{
yield(bitIdx, carry);
}
}
struct DLMMapFindBest
{
DLMMapFindBest(size_t size)
: requiredLength(size)
, bestPosition(-1)
, bestFragmentLength(INT_MAX)
{
}
bool operator () (size_t position, size_t length)
{
if (length == requiredLength)
{
bestPosition = position;
bestFragmentLength = 0;
return false;
}
else if (length > requiredLength)
{
size_t fragment = length - requiredLength;
if (fragment < bestFragmentLength)
{
bestPosition = position;
bestFragmentLength = fragment;
}
}
return true;
}
size_t requiredLength;
ptrdiff_t bestPosition;
size_t bestFragmentLength;
};
struct FindLargest
{
FindLargest()
: largest(0)
{
}
bool operator () (size_t, size_t length)
{
largest = max(largest, length);
return true;
}
size_t largest;
};
}
CPageMappingHeap::CPageMappingHeap(char* pAddressSpace, size_t nNumPages, size_t nPageSize, const char* sName)
: m_addrRange(pAddressSpace, nPageSize, nNumPages, sName)
{
Init();
}
CPageMappingHeap::CPageMappingHeap(size_t addressSpace, const char* sName)
: m_addrRange(addressSpace, sName)
{
Init();
}
CPageMappingHeap::~CPageMappingHeap()
{
}
void CPageMappingHeap::Release()
{
delete this;
}
size_t CPageMappingHeap::GetGranularity() const
{
return m_addrRange.GetPageSize();
}
bool CPageMappingHeap::IsInAddressRange(void* ptr) const
{
return m_addrRange.IsInRange(ptr);
}
size_t CPageMappingHeap::FindLargestFreeBlockSize() const
{
CryAutoLock<CryCriticalSectionNonRecursive> lock(m_lock);
const size_t pageSize = m_addrRange.GetPageSize();
FindLargest findLargest;
FindZeroRanges(&m_pageBitmap[0], m_pageBitmap.size(), findLargest);
return findLargest.largest * pageSize;
}
void* CPageMappingHeap::Map(size_t length)
{
CryAutoLock<CryCriticalSectionNonRecursive> lock(m_lock);
const size_t pageBitmapElemBitSize = (sizeof(uint32) * 8);
const size_t pageSize = m_addrRange.GetPageSize();
const size_t numPages = m_addrRange.GetPageCount();
if (length % pageSize)
{
__debugbreak();
length = (length + (pageSize - 1)) & ~(pageSize - 1);
}
DLMMapFindBest findBest(length / pageSize);
FindZeroRanges(&m_pageBitmap[0], m_pageBitmap.size(), findBest);
if ((findBest.bestPosition == -1) || (findBest.bestPosition >= (int)numPages))
{
return NULL;
}
void* mapAddress = m_addrRange.GetBaseAddress() + pageSize * findBest.bestPosition;
for (size_t pageIdx = findBest.bestPosition, pageIdxEnd = pageIdx + length / pageSize; pageIdx != pageIdxEnd; ++pageIdx)
{
if (!m_addrRange.MapPage(pageIdx))
{
// Unwind the pages we've already mapped.
for (; pageIdx > static_cast<size_t>(findBest.bestPosition); --pageIdx)
{
m_addrRange.UnmapPage(pageIdx - 1);
}
return NULL;
}
}
for (size_t pageIdx = findBest.bestPosition, pageIdxEnd = pageIdx + length / pageSize; pageIdx != pageIdxEnd; ++pageIdx)
{
size_t pageSegment = pageIdx / pageBitmapElemBitSize;
uint32 pageMask = 1U << static_cast<uint32>(pageIdx % pageBitmapElemBitSize);
m_pageBitmap[pageSegment] |= pageMask;
}
return mapAddress;
}
void CPageMappingHeap::Unmap(void* mem, size_t length)
{
CryAutoLock<CryCriticalSectionNonRecursive> lock(m_lock);
const size_t pageSize = m_addrRange.GetPageSize();
if (length % pageSize)
{
__debugbreak();
length = (length + (pageSize - 1)) & ~(pageSize - 1);
}
char* mapAddress = reinterpret_cast<char*>(mem);
for (size_t pageIdx = (mapAddress - m_addrRange.GetBaseAddress()) / pageSize, pageIdxEnd = pageIdx + length / pageSize; pageIdx != pageIdxEnd; ++pageIdx)
{
m_addrRange.UnmapPage(pageIdx);
const size_t pageBitmapElemBitSize = (sizeof(uint32) * 8);
size_t pageSegment = pageIdx / pageBitmapElemBitSize;
uint32 pageMask = ~(1U << static_cast<uint32>(pageIdx % pageBitmapElemBitSize));
m_pageBitmap[pageSegment] &= pageMask;
}
}
void CPageMappingHeap::Init()
{
UINT_PTR start = (UINT_PTR)m_addrRange.GetBaseAddress();
UINT_PTR end = start + m_addrRange.GetPageCount() * m_addrRange.GetPageSize();
size_t addressSpace = end - start;
size_t pageSize = m_addrRange.GetPageSize();
size_t numPages = (addressSpace + pageSize - 1) / pageSize;
m_pageBitmap.resize((numPages + 31) / 32);
size_t pageCapacity = m_pageBitmap.size() * 32;
size_t numUnavailablePages = pageCapacity - numPages;
if (numUnavailablePages > 0)
{
m_pageBitmap.back() = ~((1 << (32 - numUnavailablePages)) - 1);
}
}

55
Code/CryEngine/CrySystem/PageMappingHeap.h
Unescape Escape 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_CRYSYSTEM_PAGEMAPPINGHEAP_H
#define CRYINCLUDE_CRYSYSTEM_PAGEMAPPINGHEAP_H
#pragma once
#include "MemoryAddressRange.h"
#include "IMemory.h"
class CPageMappingHeap
: public IPageMappingHeap
{
public:
CPageMappingHeap(char* pAddressSpace, size_t nNumPages, size_t nPageSize, const char* sName);
CPageMappingHeap(size_t addressSpace, const char* sName);
~CPageMappingHeap();
public: // IPageMappingHeap Members
virtual void Release();
virtual size_t GetGranularity() const;
virtual bool IsInAddressRange(void* ptr) const;
virtual size_t FindLargestFreeBlockSize() const;
virtual void* Map(size_t sz);
virtual void Unmap(void* ptr, size_t sz);
private:
CPageMappingHeap(const CPageMappingHeap&);
CPageMappingHeap& operator = (const CPageMappingHeap&);
private:
void Init();
private:
mutable CryCriticalSectionNonRecursive m_lock;
CMemoryAddressRange m_addrRange;
std::vector<uint32> m_pageBitmap;
};
#endif // CRYINCLUDE_CRYSYSTEM_PAGEMAPPINGHEAP_H

18
Code/CryEngine/CrySystem/PhysRenderer.cpp
Unescape Escape View File

@ -1,18 +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 : impelemnation of a simple dedicated renderer for the physics subsystem
#include "CrySystem_precompiled.h"

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

Write Preview
Loading…
Cancel
Save