RomkaZVO/FC1
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
main
FC1/RenderDll/RenderPCH.h
romkazvo 34d6c5d489 123
2023-08-07 19:29:24 +08:00

872 lines
23 KiB
C++
Raw Permalink Blame History

/*=============================================================================
RenderPC.cpp: Cry Render support precompiled header generator.
Copyright 2001 Crytek Studios. All Rights Reserved.
Revision history:
* Created by Honitch Andrey
=============================================================================*/
#define CRY_API
#ifdef _DEBUG
#define CRTDBG_MAP_ALLOC
#endif //_DEBUG
//////////////////////////////////////////////////////////////////////////
// THIS MUST BE AT THE VERY BEGINING OF STDAFX.H FILE.
// Disable STL threading support, (makes STL faster)
//////////////////////////////////////////////////////////////////////////
#define _NOTHREADS
#define _STLP_NO_THREADS
//////////////////////////////////////////////////////////////////////////
//! Include standart headers.
//#define PS2
//#define OPENGL
#if ((PROC_INTEL) && (!defined __GNUC__) && !defined(WIN64))
#define __HAS_SSE__ 1
#endif
#if __HAS_SSE__
#include <fvec.h>
#define CONST_INT32_PS(N, V3, V2, V1, V0) \
const _MM_ALIGN16 int _##N[] = { V0, V1, V2, V3 }; /*little endian!*/ \
const F32vec4 N = _mm_load_ps((float*)_##N);
#endif
#ifdef _XBOX
//! Include standart headers.
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <memory.h>
#include <io.h>
#include <memory.h>
#include <time.h>
#include <direct.h>
#include <search.h>
#include <stdarg.h>
typedef unsigned long DWORD;
typedef unsigned short WORD;
typedef unsigned char BYTE;
#include <xtl.h>
#else
#include <platform.h>
#ifdef LINUX
#include <asm/msr.h>
#endif
#if defined(_AMD64_) && !defined(LINUX)
#include <io.h>
#endif
#endif
// enable memory pool usage
#define USE_NEWPOOL
#include <CryMemoryManager.h>
#include "CrtOverrides.h"
void CRTFreeData(void *pData);
void CRTDeleteArray(void *pData);
//#if defined _DEBUG && defined OPENGL
//#define DEBUGALLOC
//#endif
/////////////////////////////////////////////////////////////////////////////
// STL //////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
#include <vector>
#include <list>
#include <map>
#ifdef WIN64
#define hash_map map
#else
#if defined(LINUX)
#include <ext/hash_map>
#else
#include <hash_map>
#endif
#endif
#include <set>
#include <string>
#include <algorithm>
#if !defined(LINUX)
#include <assert.h>
#endif
typedef const char* cstr;
#define SIZEOF_ARRAY(arr) (sizeof(arr)/sizeof((arr)[0]))
// Include common headers.
//#include "Common\CryHelpers.h"
//typedef string String;
#ifdef DEBUGALLOC
#include <crtdbg.h>
#define DEBUG_CLIENTBLOCK new( _NORMAL_BLOCK, __FILE__, __LINE__)
#define new DEBUG_CLIENTBLOCK
// memman
#define calloc(s,t) _calloc_dbg(s, t, _NORMAL_BLOCK, __FILE__, __LINE__)
#define malloc(s) _malloc_dbg(s, _NORMAL_BLOCK, __FILE__, __LINE__)
#define realloc(p, s) _realloc_dbg(p, s, _NORMAL_BLOCK, __FILE__, __LINE__)
#endif
#include <list2.h>
#include <Names.h>
#define MAX_TMU 8
//! Include main interfaces.
#include <ICryPak.h>
#include <IProcess.h>
#include <ITimer.h>
#include <ISystem.h>
#include <ILog.h>
#include <IConsole.h>
#include <IRenderer.h>
#include <IStreamEngine.h>
#include <CrySizer.h>
#include "Font.h"
#include <Cry_Math.h>
#include "Cry_Camera.h"
//#include "_Malloc.h"
#include "math.h"
#include <VertexFormats.h>
#include "Common/Shaders/Shader.h"
//#include "Common/XFile/File.h"
//#include "Common/Image.h"
#include "Common/Shaders/CShader.h"
#include "Common/EvalFuncs.h"
#include "Common/RenderPipeline.h"
#include "Common/Renderer.h"
#include "Common/Textures/TexMan.h"
#include "Common/Shaders/Parser.h"
#include "Common/SimpleFrameProfiler.h"
// per-frame profilers: collect the infromation for each frame for
// displaying statistics at the beginning of each frame
//#define PROFILER(ID,NAME) DECLARE_FRAME_PROFILER(ID,NAME)
//#include "Common/FrameProfilers-list.h"
//#undef PROFILER
#include "Common/3DUtils.h"
// All handled render elements (except common ones included in "RendElement.h")
#include "Common/RendElements/CREBeam.h"
#include "Common/RendElements/CREPrefabGeom.h"
#include "Common/RendElements/CREClientPoly.h"
#include "Common/RendElements/CREClientPoly2D.h"
#include "Common/RendElements/CREParticleSpray.h"
#include "Common/RendElements/CREFlares.h"
#include "Common/RendElements/CREPolyBlend.h"
#include "Common/RendElements/CRESkyZone.h"
#include "Common/RendElements/CREOcean.h"
#include "Common/RendElements/CREGlare.h"
#include "Common/RendElements/CRETempMesh.h"
#include "Common/RendElements/CREScreenCommon.h"
#include "Common/RendElements/CREHDRProcess.h"
#if !defined(LINUX)
#define max(a,b) (((a) > (b)) ? (a) : (b))
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif
/*-----------------------------------------------------------------------------
Vector transformations.
-----------------------------------------------------------------------------*/
extern int g_CpuFlags;
extern double g_SecondsPerCycle;
//
// Transformations in optimized assembler format.
// An adaption of Michael Abrash' optimal transformation code.
//
#if DO_ASM
_inline void ASMTransformPoint(const SCoord &Coords, const Vec3d& InVector, Vec3d& OutVector)
{
// SCoords is a structure of 4 vectors: Origin, X, Y, Z
// x y z
// Vector Origin; 0 4 8
// Vector XAxis; 12 16 20
// Vector YAxis; 24 28 32
// Vector ZAxis; 36 40 44
//
// task: VectorSubtract(InVector, Coords.org, Temp);
// Outvector[0] = DotProduct(Temp, Coords.rot[0]);
// Outvector[1] = DotProduct(Temp, Coords.rot[1]);
// Outvector[2] = DotProduct(Temp, Coords.rot[2]);
//
// About 33 cycles on a Pentium.
//
__asm
{
mov esi,[InVector]
mov edx,[Coords]
mov edi,[OutVector]
// get source
fld dword ptr [esi+0]
fld dword ptr [esi+4]
fld dword ptr [esi+8] // z y x
fxch st(2) // xyz
// subtract origin
fsub dword ptr [edx + 0] // xyz
fxch st(1)
fsub dword ptr [edx + 4] // yxz
fxch st(2)
fsub dword ptr [edx + 8] // zxy
fxch st(1) // X Z Y
// triplicate X for transforming
fld st(0) // X X Z Y
fmul dword ptr [edx+12] // Xx X Z Y
fld st(1) // X Xx X Z Y
fmul dword ptr [edx+24] // Xy Xx X Z Y
fxch st(2)
fmul dword ptr [edx+36] // Xz Xx Xy Z Y
fxch st(4) // Y Xx Xy Z Xz
fld st(0) // Y Y Xx Xy Z Xz
fmul dword ptr [edx+16]
fld st(1) // Y Yx Y Xx Xy Z Xz
fmul dword ptr [edx+28]
fxch st(2) // Y Yx Yy Xx Xy Z Xz
fmul dword ptr [edx+40] // Yz Yx Yy Xx Xy Z Xz
fxch st(1) // Yx Yz Yy Xx Xy Z Xz
faddp st(3),st(0) // Yz Yy XxYx Xy Z Xz
faddp st(5),st(0) // Yy XxYx Xy Z XzYz
faddp st(2),st(0) // XxYx XyYy Z XzYz
fxch st(2) // Z XyYy XxYx XzYz
fld st(0) // Z Z XyYy XxYx XzYz
fmul dword ptr [edx+20]
fld st(1) // Z Zx Z XyYy XxYx XzYz
fmul dword ptr [edx+32]
fxch st(2) // Z Zx Zy
fmul dword ptr [edx+44] // Zz Zx Zy XyYy XxYx XzYz
fxch st(1) // Zx Zz Zy XyYy XxYx XzYz
faddp st(4),st(0) // Zz Zy XyYy XxYxZx XzYz
faddp st(4),st(0) // Zy XyYy XxYxZx XzYzZz
faddp st(1),st(0) // XyYyZy XxYxZx XzYzZz
fstp dword ptr [edi+4]
fstp dword ptr [edi+0]
fstp dword ptr [edi+8]
}
}
#endif
#if DO_ASM
_inline void ASMTransformVector(const SCoord &Coords, const Vec3d& InVector, Vec3d& OutVector)
{
__asm
{
mov esi,[InVector]
mov edx,[Coords]
mov edi,[OutVector]
// get source
fld dword ptr [esi+0]
fld dword ptr [esi+4]
fxch st(1)
fld dword ptr [esi+8] // z x y
fxch st(1) // x z y
// triplicate X for transforming
fld st(0) // X X Z Y
fmul dword ptr [edx+12] // Xx X Z Y
fld st(1) // X Xx X Z Y
fmul dword ptr [edx+24] // Xy Xx X Z Y
fxch st(2)
fmul dword ptr [edx+36] // Xz Xx Xy Z Y
fxch st(4) // Y Xx Xy Z Xz
fld st(0) // Y Y Xx Xy Z Xz
fmul dword ptr [edx+16]
fld st(1) // Y Yx Y Xx Xy Z Xz
fmul dword ptr [edx+28]
fxch st(2) // Y Yx Yy Xx Xy Z Xz
fmul dword ptr [edx+40] // Yz Yx Yy Xx Xy Z Xz
fxch st(1) // Yx Yz Yy Xx Xy Z Xz
faddp st(3),st(0) // Yz Yy XxYx Xy Z Xz
faddp st(5),st(0) // Yy XxYx Xy Z XzYz
faddp st(2),st(0) // XxYx XyYy Z XzYz
fxch st(2) // Z XyYy XxYx XzYz
fld st(0) // Z Z XyYy XxYx XzYz
fmul dword ptr [edx+20]
fld st(1) // Z Zx Z XyYy XxYx XzYz
fmul dword ptr [edx+32]
fxch st(2) // Z Zx Zy
fmul dword ptr [edx+44] // Zz Zx Zy XyYy XxYx XzYz
fxch st(1) // Zx Zz Zy XyYy XxYx XzYz
faddp st(4),st(0) // Zz Zy XyYy XxYxZx XzYz
faddp st(4),st(0) // Zy XyYy XxYxZx XzYzZz
faddp st(1),st(0) // XyYyZy XxYxZx XzYzZz
fstp dword ptr [edi+4]
fstp dword ptr [edi+0]
fstp dword ptr [edi+8]
}
}
#endif
//
// Transform a point by a coordinate system, moving
// it by the coordinate system's origin if nonzero.
//
_inline void TransformPoint( const SCoord &Coords, Vec3d& in, Vec3d& out)
{
#if !DO_ASM
Vec3d Temp;
Temp = in - Coords.m_Org;
out[0] = Temp | Coords.m_Vecs[0];
out[1] = Temp | Coords.m_Vecs[1];
out[2] = Temp | Coords.m_Vecs[2];
#else
ASMTransformPoint( Coords, in, out);
#endif
}
//we need a better function-name for this exotic operation
//there already is a "TransformPoint" in Cry_Matrix.h
_inline void TransformPoint( const Matrix44 &Matr, Vec3d& inp, Vec3d& outp)
{
//T_CHANGED_BY_IVO
//Vec3d Temp = inp - *(Vec3d *)&Matr.m_values[3][0];
Vec3d Temp = inp - Matr.GetTranslationOLD();
//T_CHANGED_BY_IVO
//outp.x = Temp | *(Vec3d *)&Matr.m_values[0][0];
//outp.y = Temp | *(Vec3d *)&Matr.m_values[1][0];
//outp.z = Temp | *(Vec3d *)&Matr.m_values[2][0];
outp.x = Temp | Matr.GetOrtX();
outp.y = Temp | Matr.GetOrtY();
outp.z = Temp | Matr.GetOrtZ();
}
//
// Transform a directional vector by a coordinate system.
// Ignore's the coordinate system's origin.
//
_inline void TransformVector( SCoord Coords, Vec3d& in, Vec3d& out )
{
#if !DO_ASM
Vec3d Temp;
Temp = in;
out[0] = Temp | Coords.m_Vecs[0];
out[1] = Temp | Coords.m_Vecs[1];
out[2] = Temp | Coords.m_Vecs[2];
#else
ASMTransformVector( Coords, in, out);
#endif
}
_inline void TransformVec_ViewProj(Vec3d& v, Matrix44 viewmatr, Matrix44 projmatr, vec4_t vv, vec4_t pv)
{
int i;
for (i=0; i<4; i++)
{
vv[i] = viewmatr[0][i]*v[0] + viewmatr[1][i]*v[1] + viewmatr[2][i]*v[2] + viewmatr[3][i];
}
for (i=0; i<4; i++)
{
pv[i] = projmatr[0][i]*vv[0] + projmatr[1][i]*vv[1] + projmatr[2][i]*vv[2] + projmatr[3][i]*vv[3];
}
}
_inline void ProjectPoint(vec4_t pv, Vec3d& v3d, vec2_t v2d)
{
v3d[0] = pv[0] / pv[3];
v3d[1] = pv[1] / pv[3];
v3d[2] = (pv[2] + pv[3]) / (pv[2] + pv[3] + pv[3]);
v2d[0] = (float)QRound((v3d[0] + 1) * gRenDev->GetWidth() * 0.5f);
v2d[1] = (float)QRound((v3d[1] + 1) * gRenDev->GetHeight() * 0.5f);
v2d[0] = (float)QRound(v2d[0]);
v2d[1] = (float)QRound(v2d[1]);
}
_inline void TransformVector(Vec3d& out, Vec3d& in, Matrix44& m)
{
//T_CHANGED_BY_IVO
//out.x = in.x * m.m_values[0][0] + in.y * m.m_values[1][0] + in.z * m.m_values[2][0];
//out.y = in.x * m.m_values[0][1] + in.y * m.m_values[1][1] + in.z * m.m_values[2][1];
//out.z = in.x * m.m_values[0][2] + in.y * m.m_values[1][2] + in.z * m.m_values[2][2];
out.x = in.x * m(0,0) + in.y * m(1,0) + in.z * m(2,0);
out.y = in.x * m(0,1) + in.y * m(1,1) + in.z * m(2,1);
out.z = in.x * m(0,2) + in.y * m(1,2) + in.z * m(2,2);
}
_inline void TransformPosition(Vec3d& out, Vec3d& in, Matrix44& m)
{
//T_CHANGED_BY_IVO
//out.x = in.x * m.m_values[0][0] + in.y * m.m_values[1][0] + in.z * m.m_values[2][0] + m.m_values[3][0];
//out.y = in.x * m.m_values[0][1] + in.y * m.m_values[1][1] + in.z * m.m_values[2][1] + m.m_values[3][1];
//out.z = in.x * m.m_values[0][2] + in.y * m.m_values[1][2] + in.z * m.m_values[2][2] + m.m_values[3][2];
TransformVector (out, in, m);
out += m.GetTranslationOLD();
}
inline Plane TransformPlaneByUsingAdjointT( const Matrix44& M, const Matrix44& TA, const Plane plSrc)
{
//CHANGED_BY_IVO
//Vec3d newNorm = TA.TransformVector(plSrc.n);
Vec3d newNorm = GetTransposed44(TA)*(plSrc.n);
newNorm.Normalize();
if(M.Determinant() < 0.f) newNorm *= -1;
Plane plane;
plane.Set(newNorm, M.TransformPointOLD(plSrc.n * plSrc.d) | newNorm);
return plane;
}
inline Matrix44 TransposeAdjoint(const Matrix44& M)
{
Matrix44 ta;
ta(0,0) = M(1,1) * M(2,2) - M(1,2) * M(2,1);
ta(0,1) = M(1,2) * M(2,0) - M(1,0) * M(2,2);
ta(0,2) = M(1,0) * M(2,1) - M(1,1) * M(2,0);
ta(0,3) = 0.f;
ta(1,0) = M(2,1) * M(0,2) - M(2,2) * M(0,1);
ta(1,1) = M(2,2) * M(0,0) - M(2,0) * M(0,2);
ta(1,2) = M(2,0) * M(0,1) - M(2,1) * M(0,0);
ta(1,3) = 0.f;
ta(2,0) = M(0,1) * M(1,2) - M(0,2) * M(1,1);
ta(2,1) = M(0,2) * M(1,0) - M(0,0) * M(1,2);
ta(2,2) = M(0,0) * M(1,1) - M(0,1) * M(1,0);
ta(2,3) = 0.f;
ta(3,0) = 0.f;
ta(3,1) = 0.f;
ta(3,2) = 0.f;
ta(3,1) = 1.f;
return ta;
}
inline Plane TransformPlane( const Matrix44& M, const Plane& plSrc)
{
Matrix44 tmpTA = TransposeAdjoint(M);
return TransformPlaneByUsingAdjointT(M, tmpTA, plSrc);
}
// Homogeneous plane transform.
inline Plane TransformPlane2(const Matrix44& m, const Plane& src )
{
Plane plDst;
float v0=src.n.x, v1=src.n.y, v2=src.n.z, v3=src.d;
plDst.n.x = v0 * m[0][0] + v1 * m[0][1] + v2 * m[0][2] + v3 * m[0][3];
plDst.n.y = v0 * m[1][0] + v1 * m[1][1] + v2 * m[1][2] + v3 * m[1][3];
plDst.n.z = v0 * m[2][0] + v1 * m[2][1] + v2 * m[2][2] + v3 * m[2][3];
plDst.d = v0 * m[3][0] + v1 * m[3][1] + v2 * m[3][2] + v3 * m[3][3];
return plDst;
}
inline Plane TransformPlane2_NoTrans(const Matrix44& m, const Plane& src )
{
Plane plDst;
float v0=src.n.x, v1=src.n.y, v2=src.n.z;
plDst.n.x = v0 * m[0][0] + v1 * m[0][1] + v2 * m[0][2];
plDst.n.y = v0 * m[1][0] + v1 * m[1][1] + v2 * m[1][2];
plDst.n.z = v0 * m[2][0] + v1 * m[2][1] + v2 * m[2][2];
plDst.d = src.d;
return plDst;
}
inline Plane TransformPlane2Transposed(const Matrix44& m, const Plane& src )
{
Plane plDst;
float v0=src.n.x, v1=src.n.y, v2=src.n.z, v3=src.d;
plDst.n.x = v0 * m[0][0] + v1 * m[1][0] + v2 * m[2][0] + v3 * m[3][0];
plDst.n.y = v0 * m[0][1] + v1 * m[1][1] + v2 * m[2][1] + v3 * m[3][1];
plDst.n.z = v0 * m[0][2] + v1 * m[2][1] + v2 * m[2][2] + v3 * m[3][2];
plDst.d = v0 * m[0][3] + v1 * m[1][3] + v2 * m[2][3] + v3 * m[3][3];
return plDst;
}
//===============================================================================================
_inline int CullBoxByPlane (float *Mins, float *Maxs, SPlane *p)
{
float dist1, dist2;
int sides;
// fast axial cases
if (p->m_Type < 3)
{
return (p->m_Dist <= Mins[p->m_Type]) ? 1 : (p->m_Dist >= Maxs[p->m_Type]) ? 2 : 3;
}
// general case
switch (p->m_SignBits)
{
case 0:
dist1 = p->m_Normal[0]*Maxs[0] + p->m_Normal[1]*Maxs[1] + p->m_Normal[2]*Maxs[2];
dist2 = p->m_Normal[0]*Mins[0] + p->m_Normal[1]*Mins[1] + p->m_Normal[2]*Mins[2];
break;
case 1:
dist1 = p->m_Normal[0]*Mins[0] + p->m_Normal[1]*Maxs[1] + p->m_Normal[2]*Maxs[2];
dist2 = p->m_Normal[0]*Maxs[0] + p->m_Normal[1]*Mins[1] + p->m_Normal[2]*Mins[2];
break;
case 2:
dist1 = p->m_Normal[0]*Maxs[0] + p->m_Normal[1]*Mins[1] + p->m_Normal[2]*Maxs[2];
dist2 = p->m_Normal[0]*Mins[0] + p->m_Normal[1]*Maxs[1] + p->m_Normal[2]*Mins[2];
break;
case 3:
dist1 = p->m_Normal[0]*Mins[0] + p->m_Normal[1]*Mins[1] + p->m_Normal[2]*Maxs[2];
dist2 = p->m_Normal[0]*Maxs[0] + p->m_Normal[1]*Maxs[1] + p->m_Normal[2]*Mins[2];
break;
case 4:
dist1 = p->m_Normal[0]*Maxs[0] + p->m_Normal[1]*Maxs[1] + p->m_Normal[2]*Mins[2];
dist2 = p->m_Normal[0]*Mins[0] + p->m_Normal[1]*Mins[1] + p->m_Normal[2]*Maxs[2];
break;
case 5:
dist1 = p->m_Normal[0]*Mins[0] + p->m_Normal[1]*Maxs[1] + p->m_Normal[2]*Mins[2];
dist2 = p->m_Normal[0]*Maxs[0] + p->m_Normal[1]*Mins[1] + p->m_Normal[2]*Maxs[2];
break;
case 6:
dist1 = p->m_Normal[0]*Maxs[0] + p->m_Normal[1]*Mins[1] + p->m_Normal[2]*Mins[2];
dist2 = p->m_Normal[0]*Mins[0] + p->m_Normal[1]*Maxs[1] + p->m_Normal[2]*Maxs[2];
break;
case 7:
dist1 = p->m_Normal[0]*Mins[0] + p->m_Normal[1]*Mins[1] + p->m_Normal[2]*Mins[2];
dist2 = p->m_Normal[0]*Maxs[0] + p->m_Normal[1]*Maxs[1] + p->m_Normal[2]*Maxs[2];
break;
default:
dist1 = dist2 = 0; // shut up compiler
break;
}
sides = 0;
if (dist1 >= p->m_Dist)
sides = 1;
if (dist2 < p->m_Dist)
sides |= 2;
//ASSERT( sides != 0 );
return sides;
}
//===============================================================================================
// Interfaces from the Game
extern ILog *iLog;
extern IConsole *iConsole;
extern ITimer *iTimer;
extern ISystem *iSystem;
extern int *pTest_int;
extern IPhysicalWorld *pIPhysicalWorld;
#define MAX_PATH_LENGTH 512
//////////////////////////////////////////////////////////////////////////
// Report warning to validator.
//////////////////////////////////////////////////////////////////////////
inline void Warning( int flags,const char *filename,const char *format,... )
{
char buffer[MAX_WARNING_LENGTH];
va_list args;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
iSystem->Warning( VALIDATOR_MODULE_RENDERER,VALIDATOR_WARNING,flags,filename,"%s",buffer );
}
inline void _text_to_log(char * format, ...)
{
char buffer[MAX_PATH_LENGTH];
va_list args;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
iLog->Log(buffer);
if (gRenDev->CV_r_log == 3)
gRenDev->Logv(SRendItem::m_RecurseLevel, buffer);
}
inline void _text_to_logPlus(char * format, ...)
{
char buffer[MAX_PATH_LENGTH];
va_list args;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
iLog->LogPlus(buffer);
if (gRenDev->CV_r_log == 3)
gRenDev->Logv(SRendItem::m_RecurseLevel, buffer);
}
inline void _UpdateLoadingScreen(const char * format, ...)
{
if(format)
{
char buffer[MAX_PATH_LENGTH];
va_list args;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
iLog->Log(buffer);
if (gRenDev->CV_r_log == 3)
gRenDev->Logv(SRendItem::m_RecurseLevel, buffer);
}
//iConsole->Update();
//gRenDev->BeginFrame();
//iConsole->Draw();
//gRenDev->Update();
}
inline void _UpdateLoadingScreenPlus(const char * format, ...)
{
if(format)
{
char buffer[MAX_PATH_LENGTH];
va_list args;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
iLog->Log(buffer);
if (gRenDev->CV_r_log == 3)
gRenDev->Logv(SRendItem::m_RecurseLevel, buffer);
}
iConsole->Update();
gRenDev->BeginFrame();
iConsole->Draw();
gRenDev->Update();
}
_inline void _SetVar(const char *szVarName, int nVal)
{
ICVar *var = iConsole->GetCVar(szVarName);
if (var)
var->Set(nVal);
else
{
assert(0);
}
}
_inline char * Cry_strdup(const char * str)
{
char *memory;
if (!str)
return(NULL);
memory = (char *)malloc(strlen(str) + 1);
if (memory)
return(strcpy(memory,str));
return(NULL);
}
_inline void HeapCheck()
{
#if !defined(LINUX)
int Result = _heapchk();
assert(Result!=_HEAPBADBEGIN);
assert(Result!=_HEAPBADNODE);
assert(Result!=_HEAPBADPTR);
assert(Result!=_HEAPEMPTY);
assert(Result==_HEAPOK);
#endif
}
const char* GetExtension (const char *in);
void StripExtension (const char *in, char *out);
void AddExtension (char *path, char *extension);
void ConvertDOSToUnixName( char *dst, const char *src );
void ConvertUnixToDosName( char *dst, const char *src );
void UsePath (char *name, char *path, char *dst);
#define Vector2Copy(a,b) {b[0]=a[0];b[1]=a[1];}
//==================================================================
// Profiling
#ifdef WIN64
extern "C"
{
uint64 __rdtsc();
}
#pragma intrinsic(__rdtsc)
#endif
inline DWORD sCycles()
{
uint L;
#if defined(WIN32)
#if defined(WIN64)
L = __rdtsc();
#else
__asm
{
xor eax,eax // Required so that VC++ realizes EAX is modified.
_emit 0x0F // RDTSC - Pentium+ time stamp register to EDX:EAX.
_emit 0x31 // Use only 32 bits in EAX - even a Ghz cpu would have a 4+ sec period.
mov [L],eax // Save low value.
xor edx,edx // Required so that VC++ realizes EDX is modified.
}
#endif
#elif defined(LINUX)
rdtscl( L );
#endif
return L;
}
inline double sCycles2()
{
#if defined(WIN32) && !defined(WIN64)
uint L,H;
__asm
{
xor eax,eax // Required so that VC++ realizes EAX is modified.
xor edx,edx // Required so that VC++ realizes EDX is modified.
_emit 0x0F // RDTSC - Pentium+ time stamp register to EDX:EAX.
_emit 0x31 // Use only 32 bits in EAX - even a Ghz cpu would have a 4+ sec period.
mov [L],eax // Save low value.
mov [H],edx // Save high value.
}
return ((double)L + 4294967296.0 * (double)H);
#else
return __rdtsc();
#endif
}
//=========================================================================================
_inline void makeProjectionMatrix(float fovy, float aspect, float nearval, float farval, float *m)
{
float left, right, bottom, top;
top = nearval * cry_tanf(fovy * M_PI / 360.0f);
bottom = -top;
left = bottom * aspect;
right = top * aspect;
float x, y, a, b, c, d;
if ((nearval<=0.0 || farval<=0.0) || (nearval == farval) || (left == right) || (top == bottom))
{
iLog->Log("Warning: makeProjectionMatrix: (near or far)\n");
return;
}
x = (2.0f*nearval) / (right-left);
y = (2.0f*nearval) / (top-bottom);
a = (right+left) / (right-left);
b = (top+bottom) / (top-bottom);
c = -(farval+nearval) / ( farval-nearval);
d = -(2.0f*farval*nearval) / (farval-nearval);
#define M(row,col) m[col*4+row]
M(0,0) = x; M(0,1) = 0.0F; M(0,2) = a; M(0,3) = 0.0F;
M(1,0) = 0.0F; M(1,1) = y; M(1,2) = b; M(1,3) = 0.0F;
M(2,0) = 0.0F; M(2,1) = 0.0F; M(2,2) = c; M(2,3) = d;
M(3,0) = 0.0F; M(3,1) = 0.0F; M(3,2) = -1.0F; M(3,3) = 0.0F;
#undef M
}
//=========================================================================================
//
// Normal timing.
//
#define ticks(Timer) {Timer -= sCycles2();}
#define unticks(Timer) {Timer += sCycles2()+34;}
//=============================================================================
// the int 3 call for 32-bit version for .l-generated files.
#ifdef WIN64
#define LEX_DBG_BREAK
#else
#define LEX_DBG_BREAK DEBUG_BREAK
#endif
/*-----------------------------------------------------------------------------
The End.
-----------------------------------------------------------------------------*/
Reference in New Issue View Git Blame Copy Permalink