Commit 6f264aab authored by D-AIRY's avatar D-AIRY

Removed dead code

parent 16e40778
......@@ -207,16 +207,6 @@
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="..\..\..\source\gcore\oc.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="..\..\..\source\gcore\shader.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
......@@ -241,7 +231,6 @@
<ClInclude Include="..\..\..\source\gcore\gcore_data.h" />
<ClInclude Include="..\..\..\source\gcore\gcore_utils.h" />
<ClInclude Include="..\..\..\source\gcore\LoaderTextures.h" />
<ClInclude Include="..\..\..\source\gcore\oc.h" />
<ClInclude Include="..\..\..\source\gcore\shader.h" />
<ClInclude Include="..\..\..\source\gcore\ShaderPreprocessor.h" />
<ClInclude Include="..\..\..\source\gcore\sxgcore.h" />
......
......@@ -25,9 +25,6 @@
<ClCompile Include="..\..\..\source\common\string_utils.cpp">
<Filter>Source</Filter>
</ClCompile>
<ClCompile Include="..\..\..\source\gcore\oc.cpp">
<Filter>Source</Filter>
</ClCompile>
<ClCompile Include="..\..\..\source\gcore\gcore_utils.cpp">
<Filter>Source</Filter>
</ClCompile>
......@@ -71,9 +68,6 @@
<ClInclude Include="..\..\..\source\common\string_utils.h">
<Filter>Header</Filter>
</ClInclude>
<ClInclude Include="..\..\..\source\gcore\oc.h">
<Filter>Header</Filter>
</ClInclude>
<ClInclude Include="..\..\..\source\gcore\gcore_utils.h">
<Filter>Header</Filter>
</ClInclude>
......
......@@ -75,9 +75,6 @@ See the license in LICENSE
/*! \name int register
@{*/
#define G_RI_INT_COUNT_POLY 0 /*!< общее количество полигонов */
#define G_RI_INT_COUNT_DIP 1 /*!< количество вызовов draw indexed primitive */
#define G_RI_INT_CURRIDLIGHT 2 /*!< текущий идентификатор источнкиа света */
#define G_RI_INT_RENDERSTATE 3 /*!< текущее состояние рендера */
#define G_RI_INT_TIMER_RENDER 4 /*!< время для рендера */
......
......@@ -394,8 +394,8 @@ void CCrosshair::render()
m_pDev->setRenderBuffer(m_pRenderBuffer);
m_pDev->setTexture(m_pTexture);
m_pDev->setDepthStencilState(m_pDepthState);
SGCore_DIP(GXPT_TRIANGLELIST, 0, 0, m_iVertexCount[m_u8ActiveBuffer], 0, m_iIndexCount[m_u8ActiveBuffer] / 3);
m_pDev->setPrimitiveTopology(GXPT_TRIANGLELIST);
m_pDev->drawIndexed(m_iVertexCount[m_u8ActiveBuffer], m_iIndexCount[m_u8ActiveBuffer] / 3);
}
void CCrosshair::onSync()
{
......
This diff is collapsed.
......@@ -13,111 +13,6 @@ See the license in LICENSE
void CreateCone(float fTopRadius, float fBottomRadius, float fHeight, IMesh ** ppMesh, IGXContext * pDevice, UINT iSideCount);
void CreateSphere(float fRadius, UINT iSideCount, UINT iStackCount, IMesh ** ppMesh, IGXContext * pDevice);
bool InPosition2D(const float3* min, const float3* max, const float3* pos);
bool InPositionAbs2D(float3* min,float3* max,float3* pos);
int CountPositionPoints2D(float3* min,float3* max,float3* p1,float3* p2,float3* p3);
int CountPositionPointsAbs2D(float3* min,float3* max,float3* p1,float3* p2,float3* p3);
bool InPositionPoints2D(float3* min,float3* max,float3* p1,float3* p2,float3* p3);
bool InPosition3D(float3* min,float3* max,float3* pos);
bool InPositionAbs3D(float3* min,float3* max,float3* pos);
int CountPositionPoints3D(float3* min,float3* max,float3* p1,float3* p2,float3* p3);
int CountPositionPointsAbs3D(float3* min,float3* max,float3* p1,float3* p2,float3* p3);
bool InPositionPoints3D(float3* min,float3* max,float3* p1,float3* p2,float3* p3);
void ComputeBoundingBoxArr8(ISXBound* bound,ISXBound** bound_arr);
void ComputeBoundingBoxArr4(ISXBound* bound,ISXBound** bound_arr);
void CreateBoundingBoxMesh(const float3* min, const float3* max, IMesh** bbmesh, IGXContext* device);
//простой объект с минимальным описанием
//для корректного использования необходимо сначала установить позицию/поворот/масштаб после чего CalculateWorld
class CTransObject : public virtual ITransObject
{
public:
CTransObject();
~CTransObject(){};
void Release(){ mem_del(this); };
SX_ALIGNED_OP_MEM
const float4x4* calcWorld();
void setPosition(const float3 *pPos);
void setRotation(const float3 *pRot);
void setScale(const float3 *pScale);
const float3* getPosition(float3 *pPos = 0);
const float3* getRotation(float3 *pRot = 0);
const float3* getScale(float3 *pScale = 0);
protected:
float3 m_vPosition; //!< позиция
float3 m_vRotation; //!< повороты
float3 m_vScale; //!< масштабирование
float4x4 m_mWorld; //!< мировая матрица на основе поворотов масштабирования и позиции
};
#define TRANSFORM_COORD_SCREEN2(point,sizemapdepth)\
point.x /= abs(point.w); \
point.y /= abs(point.w); \
point.z /= sizemapdepth->z; \
point.x = point.x * 0.5 + 0.5; \
point.y = point.y * (-0.5) + 0.5; \
point.x *= sizemapdepth->x; \
point.y *= sizemapdepth->y;
//класс ограничивающего объема
//для созданяи минимума и максимума необходимо вызвать CalculateBound
//SetMinMax, GetMinMax до вызова CalculateWorldAndTrans возвращают нетрансформирвоанные данные
//конечным этапом построения Bound и Object является CalculateWorldAndTrans
class CBound : public CTransObject, public virtual ISXBound
{
public:
CBound() :CTransObject(){};
~CBound(){};
void Release(){ mem_del(this); };
SX_ALIGNED_OP_MEM;
void calcBound(float3_t *pVertexBuffer, int iCountVertex, int iBytePerVertex) override;
void calcBoundIndex(float3_t *pVertexBuffer, uint32_t **ppArrIndex, uint32_t *pCountIndex, int iCountSubset, int iBytePerVertex) override;
//функция просчета мировой матрицы и трансформации минимума и максимума
//float4x4* calcWorldAndTrans();
void resetTransform();
//void getPosBBScreen(SXPosBBScreen *res, float3* campos, float3* sizemapdepth, float4x4* mat);
void setMinMax(const float3* min, const float3* max);
void getMinMax(float3* min, float3* max) const;
void setSphere(const float3* center, float radius);
void getSphere(float3* center, float* radius) const;
bool isPointInSphere(const float3* point) const;
bool isPointInBox(const float3* point) const;
void cloneFrom(ISXBound *pFrom);
protected:
float3 m_vMinTransform;
float3 m_vMaxTransform;
float3 m_vCenterTransform;
float m_fRadiusTransform;
float3 m_vMinOrigin;
float3 m_vMaxOrigin;
float3 m_vCenterOrigin;
float m_fRadiusOrigin;
};
#endif
\ No newline at end of file
#endif
......@@ -244,138 +244,3 @@ void InitToneMappingStates()
g_pSamplerFilterPoint = g_pDevice->createSamplerState(&samplerDesc);
}
void ToneMappingCom(DWORD timeDelta, float fFactorAdapted)
{
#if 0
static const int *r_win_width = GET_PCVAR_INT("r_win_width");
static const int *r_win_height = GET_PCVAR_INT("r_win_height");
ToneMappingGetArrDownScale4x4(*r_win_width, *r_win_height, gcore_data::rt_id::aHDRSampleOffsets);
IGXSurface *SurfSceneScale, *BackBuf;
SurfSceneScale = SGCore_RTGetTexture(gcore_data::rt_id::idLigthComScaled)->getMipmap();
BackBuf = g_pDevice->getColorTarget();
g_pDevice->setColorTarget(SurfSceneScale);
static ID s_idShader1 = SGCore_ShaderCreateKit(gcore_data::vs_id::idScreenOut, gcore_data::ps_id::idSampleLumIterative);
SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, gcore_data::ps_id::idSampleLumIterative, "g_aOffsets", &(gcore_data::rt_id::aHDRSampleOffsets));
SGCore_ShaderBind(s_idShader1);
g_pDevice->setTexture(SGCore_RTGetTexture(gcore_data::rt_id::idLigthCom));
SGCore_ScreenQuadDraw();
SGCore_ShaderUnBind();
mem_release(SurfSceneScale);
int CurrTexture = gcore_data::rt_id::iCountArrToneMaps - 1;
for (int i = 0; i < gcore_data::rt_id::iCountArrToneMaps; i++)
{
IGXTexture2D* tmptex = SGCore_RTGetTexture(gcore_data::rt_id::aToneMaps[i]);
gcore_data::rt_id::aSurfToneMap[i] = tmptex->getMipmap();
}
IGXTexture2D* tmptex = SGCore_RTGetTexture(gcore_data::rt_id::aToneMaps[CurrTexture]);
ToneMappingGetArrDownScale4x4(tmptex->getWidth(), tmptex->getHeight(), gcore_data::rt_id::aHDRSampleOffsets);
g_pDevice->setColorTarget(gcore_data::rt_id::aSurfToneMap[CurrTexture]);
g_pDevice->setTexture(SGCore_RTGetTexture(gcore_data::rt_id::idLigthComScaled));
g_pDevice->setBlendState(g_pToneMappingBS);
//g_pDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED);
//g_pDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
//g_pDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
//g_pDevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
//g_pDevice->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
g_pDevice->setSamplerState(g_pSamplerFilterLinear, 0);
g_pDevice->setSamplerState(g_pSamplerFilterLinear, 1);
static ID s_idShader2 = SGCore_ShaderCreateKit(gcore_data::vs_id::idScreenOut, gcore_data::ps_id::idSampleLumInit);
SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, gcore_data::ps_id::idSampleLumInit, "g_aOffsets", &(gcore_data::rt_id::aHDRSampleOffsets));
SGCore_ShaderBind(s_idShader2);
SGCore_ScreenQuadDraw();
SGCore_ShaderUnBind();
mem_release(gcore_data::rt_id::aSurfToneMap[CurrTexture]);
--CurrTexture;
IGXTexture2D *pTex;
g_pDevice->setSamplerState(g_pSamplerFilterPoint, 0);
//g_pDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
//g_pDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
SGCore_ShaderBind(s_idShader1);
while(CurrTexture >= 0)
{
IGXTexture2D *pTex = SGCore_RTGetTexture(gcore_data::rt_id::aToneMaps[CurrTexture + 1]);
ToneMappingGetArrDownScale4x4(pTex->getWidth(), pTex->getHeight(), gcore_data::rt_id::aHDRSampleOffsets);
SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, gcore_data::ps_id::idSampleLumIterative, "g_aOffsets", &(gcore_data::rt_id::aHDRSampleOffsets));
g_pDevice->setColorTarget(gcore_data::rt_id::aSurfToneMap[CurrTexture]);
g_pDevice->setTexture(pTex);
SGCore_ScreenQuadDraw();
CurrTexture--;
}
SGCore_ShaderUnBind();
// char *a = (char*)malloc(sizeof(char) * 5);
//IGXTexture2D* tmptex = SGCore_RTGetTexture(gcore_data::rt_id::aToneMaps[3]);
for (int i = 0; i < gcore_data::rt_id::iCountArrToneMaps - 1; i++)
{
IGXSurface* tmpsurf = gcore_data::rt_id::aSurfToneMap[i];
mem_release(gcore_data::rt_id::aSurfToneMap[i]);
}
// tmptex = SGCore_RTGetTexture(gcore_data::rt_id::aToneMaps[3]);
tmptex = SGCore_RTGetTexture(gcore_data::rt_id::aToneMaps[gcore_data::rt_id::iCountArrToneMaps - 1]);
gcore_data::rt_id::IncrAdaptedLum();
IGXSurface *SurfAdaptedLum = SGCore_RTGetTexture(gcore_data::rt_id::GetCurrAdaptedLum())->getMipmap();
g_pDevice->setColorTarget(SurfAdaptedLum);
g_pDevice->setTexture(SGCore_RTGetTexture(gcore_data::rt_id::GetLastAdaptedLum()));
g_pDevice->setTexture(SGCore_RTGetTexture(gcore_data::rt_id::aToneMaps[0]), 1);
//g_pDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
//g_pDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
//g_pDevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
//g_pDevice->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_POINT);
g_pDevice->setSamplerState(g_pSamplerFilterPoint, 0);
g_pDevice->setSamplerState(g_pSamplerFilterPoint, 1);
static ID s_idShader3 = SGCore_ShaderCreateKit(gcore_data::vs_id::idScreenOut, gcore_data::ps_id::idCalcAdaptedLum);
SGCore_ShaderBind(s_idShader3);
float ElapsedTime = float(timeDelta) * 0.001f * (fFactorAdapted * 1000.f);
SGCore_ShaderSetVRF(SHADER_TYPE_PIXEL, gcore_data::ps_id::idCalcAdaptedLum, "g_fElapsedTime", &(ElapsedTime));
SGCore_ScreenQuadDraw();
SGCore_ShaderUnBind();
mem_release(SurfAdaptedLum);
g_pDevice->setColorTarget(BackBuf);
mem_release(BackBuf);
g_pDevice->setBlendState(NULL);
//g_pDevice->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA);
#endif
}
/***********************************************************
Copyright Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018
Copyright © Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018
See the license in LICENSE
***********************************************************/
......@@ -27,30 +27,27 @@ extern IGXSamplerState *g_pSamplerFilterLinear;
//##########################################################################
//!
//! инициализация устройства
void InitDevice(SXWINDOW hWnd, int iWidth, int iHeight, bool isWindowed);
//!
//! инициализация отладочной инфы
void InitFPStext();
//!
//! инициализация полноэкранного квадрата
void InitFullScreenQuad();
//!
//! инициализация массива режимов монитора
void InitArrModes();
//!
//! инициализация рендер таргетов для
void InitRT4Gbuffer();
//!
//! загрузка шейдеров
void LoadShaders();
void InitToneMappingStates();
//! tone mapping
//! заполнение массива для tone mapping
void ToneMappingGetArrDownScale4x4(int iWidth, int iHeight, float2 aDS[]);
//! tone mapping
void ToneMappingCom(DWORD timeDelta, float fFactorAdapted);
#endif
\ No newline at end of file
This diff is collapsed.
/***********************************************************
Copyright © Vitaliy Buturlin, Evgeny Danilovich, 2017, 2018
See the license in LICENSE
***********************************************************/
#ifndef __OC_H
#define __OC_H
#include <gdefines.h>
#include <graphix/graphix.h>
#include <common/Math.h>
#include <mutex>
#include <gcore/sxgcore.h>
extern IGXContext *g_pDevice;
//! коэффициент размера буфера глубины occlusion culling
#define OC_SIZE_COEF 0.25f
//! дистанция (в метрах) при которой тест occlusion culling всегда будет давать true
#define OC_DIST_NEAR_NOT_CULL 4.f
//! погрешность разниц глубин для теста occlusion culling
//static float g_fOCbiasDepth = 0.0001f;
//! количество пикселей расширения треугольников для
const float g_fOCextTriangle = 2.f;
//! небольшео расширение бокса для теста occlusion culling
const float3 g_cvOCext(0.05f, 0.05f, 0.05f);
#define OC_MAX_MUTEX_COUNT 512
//##########################################################################
/*inline bool OC_RasterizeQuad(const float3 &vA, const float3 &vB, const float3 &vC, const float3 &vD, const float2 &vNearFar)
{
float3 vNormal = TriGetNormal(vA, vB, vC);
return (OC_TriangleRasterize(vA, vB, vC, false, vNormal, vNearFar) || OC_TriangleRasterize(vB, vC, vD, false, vNormal, vNearFar));
}*/
void SwapFloat3(float3 &vA, float3 &vB);
void TriGetSphere(const float3 &vA, const float3 &vB, const float3 &vC, float &fRadius, float2 &vCenter);
void QuadGetSphere(const float2 &vMin, const float2 &vMax, float &fRadius, float2 &vCenter);
//##########################################################################
class COcclusionCulling
{
public:
SX_ALIGNED_OP_MEM
COcclusionCulling();
~COcclusionCulling();
//! инициализация на основании размеров рендера
void init(int iWidth, int iHeight);
//! обработка потери устройства
void onLostDevice();
//! обработк сброса устройства
void onResetDevice(int iWidth, int iHeight);
//! установка включен/выключен тест
void setEnable(bool isEnable);
//! возвращает текущее состояния влюченности теста
bool getEnable();
/*! обновление данных теста
\param idDepthMap - идентификатор rt глубины
\param pFrustum - фрустум камеры
*/
void update(ID idDepthMap, const IFrustum *pFrustum);
//! репроекция старого буфера глубины на основании новых матриц
void reprojection();
//! просчет видимости бокса
bool comVisible(const float3 *pMax, const float3 *pMin);
void ensureUpdateDone();
protected:
class COCReprojection: public IParallelForBody
{
public:
COCReprojection(float4 *pArrWorldPos,
const float4x4 *mViewProj,
float _r_near,
float _r_far,
int iWidth,
int iHeight,
int iCountPixels,
float *pArrDepthBufferReProjection,
float *pArrDepthBufferRasterize,
std::mutex *pArrDepthBufferMutex
):
m_pArrWorldPos(pArrWorldPos),
m_mViewProj(*mViewProj),
r_near(_r_near),
r_far(_r_far),
m_iWidth(iWidth),
m_iHeight(iHeight),
m_iCountPixels(iCountPixels),
m_pArrDepthBufferReProjection(pArrDepthBufferReProjection),
m_pArrDepthBufferRasterize(pArrDepthBufferRasterize),
m_pArrDepthBufferMutex(pArrDepthBufferMutex)
{
}
void forLoop(int iStart, int iEnd) const
{
Core_PStartSection(PERF_SECTION_OC_REPROJECTION);
float4 vNewPos;
const float4x4 &mViewProj = m_mViewProj;
float2 vNewPos2;
for(int i = iStart; i < iEnd; ++i)
{
vNewPos = SMVector4Transform(m_pArrWorldPos[i], mViewProj);
vNewPos.x /= abs(vNewPos.w);
vNewPos.y /= abs(vNewPos.w);
vNewPos.z = (vNewPos.z + r_near) / r_far;
vNewPos.x = vNewPos.x * 0.5f + 0.5f;
vNewPos.y = (vNewPos.y * (-0.5f) + 0.5f);
//костыль решения проблем округления, без этого будут белые линии
vNewPos2.x = float(int(vNewPos.x * 10000.f) / 10000.f);
vNewPos2.y = float(int(vNewPos.y * 10000.f) / 10000.f);
if(vNewPos2.x == 0.f || vNewPos2.x == 1.f)
vNewPos.x = vNewPos2.x;
if(vNewPos2.y == 0.f || vNewPos2.y == 1.f)
vNewPos.y = vNewPos2.y;
//******************************************************************
if((vNewPos.x <= 1.f && vNewPos.x >= 0.f) && (vNewPos.y <= 1.f && vNewPos.y >= 0.f))
{
int x = floor(vNewPos.x * float(m_iWidth) + 0.5f);
int y = floor(vNewPos.y * m_iHeight + 0.5f);
int iPosPixel = int(y * m_iWidth) + x;
if(iPosPixel > m_iCountPixels)
int qwerty = 0;
else
{
//если в буфере репроекции нет записей для текущего пикселя, либо записанная глубина меньше чем новая
std::lock_guard<std::mutex> lock(m_pArrDepthBufferMutex[iPosPixel % OC_MAX_MUTEX_COUNT]);
if(m_pArrDepthBufferReProjection[iPosPixel] >= 1.f || vNewPos.z > m_pArrDepthBufferReProjection[iPosPixel])
m_pArrDepthBufferReProjection[iPosPixel] = vNewPos.z;
}
}
}
Core_PEndSection(PERF_SECTION_OC_REPROJECTION);
};
SX_ALIGNED_OP_MEM;
protected:
float4x4 m_mViewProj;
float4 *m_pArrWorldPos;
float r_near;
float r_far;
int m_iWidth;
int m_iHeight;
int m_iCountPixels;
float *m_pArrDepthBufferReProjection;
float *m_pArrDepthBufferRasterize;
std::mutex *m_pArrDepthBufferMutex;
};
class COCUpdate: public IParallelForBody
{
public:
COCUpdate(float4 *aWorldRays,
int iWidth,
int iHeight,
float3 *vObserverPos,
float4 *pArrWorldPos,
float *pArrDepthBuffer
):
m_iWidth(iWidth),
m_iHeight(iHeight),
m_vObserverPos(*vObserverPos),
m_pArrWorldPos(pArrWorldPos),
m_pArrDepthBuffer(pArrDepthBuffer)
{
m_aWorldRays[0] = aWorldRays[0];
m_aWorldRays[1] = aWorldRays[1];
m_aWorldRays[2] = aWorldRays[2];
m_aWorldRays[3] = aWorldRays[3];
}
void forLoop(int iStart, int iEnd) const
{
Core_PStartSection(PERF_SECTION_OC_UPDATE);
float4 vWorldRay0, vWorldRay1;
float4 vWorldPos;
float4 vEyeRay, vWorldRay;
for(int x = iStart; x < iEnd; ++x)
{
vWorldRay0 = SMVectorLerp(m_aWorldRays[0], m_aWorldRays[1], float(x) / m_iWidth);
vWorldRay1 = SMVectorLerp(m_aWorldRays[3], m_aWorldRays[2], float(x) / m_iWidth);
for(int y = 0; y < m_iHeight; ++y)
{
int iPosPixel = (y * m_iWidth) + x;
vWorldRay = SMVectorLerp(vWorldRay1, vWorldRay0, float(y) / m_iHeight);
vWorldPos = m_vObserverPos + vWorldRay * m_pArrDepthBuffer[iPosPixel];
vWorldPos.w = 1.f;
m_pArrWorldPos[iPosPixel] = vWorldPos;
}
}
Core_PEndSection(PERF_SECTION_OC_UPDATE);
};
SX_ALIGNED_OP_MEM;
protected:
float4 m_aWorldRays[4];
int m_iWidth;
int m_iHeight;
float3 m_vObserverPos;
float4 *m_pArrWorldPos;
float *m_pArrDepthBuffer;
};
bool triFrustumCulling(const float3 &vA, const float3 &vB, const float3 &vC);
bool triRasterize(const float4 &vA, const float4 &vB, const float4 &vC, bool isRasterize, const float3 &vNormal2, const float2_t &vNearFar);
void ensureReprojectionDone();
//! массив surfaces для обработки
IGXSurface *m_pSurfDepthBuffer[3];
//! массив глубины
float *m_pArrDepthBuffer = 0;
//! массив мировых координат
float4 *m_pArrWorldPos = 0;
//! массив репроекционной глубины
float *m_pArrDepthBufferReProjection = 0;
//! массив растеризации (debug)
float *m_pArrDepthBufferRasterize = 0;
//! массив замков синхронизации
std::mutex *m_pArrDepthBufferMutex = 0;
COCReprojection *m_pReprojectionCycle = 0;
ID m_idReprojectionCycle = -1;
COCUpdate *m_pUpdateCycle = 0;
ID m_idUpdateCycle = -1;
//! включен ли тест
bool m_isEnable = false;
//! прошлая видовая матрица
float4x4 m_mOldView;
//! прошлая проекционная матрица
float4x4 m_mOldProj;
//! общее количество пикселей в буфере для теста
int m_iCountPixels;
//! ширина буфера теста
int m_iWidth;
//! высота буфера теста
int m_iHeight;
//! массив ке глубин
ID m_aRTdepth[2];
//! текущий ключ массива #m_aRTdepth
int m_iCurrRTdepth;
ID m_idVS_ScreenOut;
ID m_idPS_ScreenOut;
ID m_idPS_FindMax9;
//! текущий фрустум камеры
const IFrustum *m_pFrustum;
int m_iCountFC;
int m_iCountFCfail;
float m_fBiasDepth;
};
#endif
\ No newline at end of file
This diff is collapsed.
This diff is collapsed.
......@@ -225,7 +225,7 @@ public:
float m_fShadowIntensity;
ISXBound *m_pBoundVolume;
void *m_pBoundVolume;
float4x4 m_mWorldMat;
bool m_isVSDataDirty = false;
IGXConstantBuffer *m_pVSData = NULL;
......
......@@ -582,11 +582,6 @@ SX_LIB_API void SMtrl_MtlSetTypeReflection(ID id, MTLTYPE_REFLECT type)
ArrMaterials->mtlSetTypeReflection(id, type);
}
SX_LIB_API MTLTYPE_REFLECT SMtrl_MtlGetTypeReflection(ID id)
{
ML_PRECOND(MTLTYPE_REFLECT_NONE);
return ArrMaterials->mtlGetTypeReflection(id);
}
//**************************************************************************
......
......@@ -708,9 +708,6 @@ SX_LIB_API bool SMtrl_MtlGetRefractivity(ID id);
//! установка типа отражений
SX_LIB_API void SMtrl_MtlSetTypeReflection(ID id, MTLTYPE_REFLECT type);
//! возвращает текущий тип отражений для материала
SX_LIB_API MTLTYPE_REFLECT SMtrl_MtlGetTypeReflection(ID id);
//!@}
/*! \name Детальность и микрорельеф
......
......@@ -112,10 +112,6 @@ bool XMETHODCALLTYPE CEngine::initGraphics(XWINDOW_OS_HANDLE hWindow, IXEngineCa
SGCore_0Create("sxgcore", (HWND)hWindow, *r_win_width, *r_win_height, *r_win_windowed, false);
SGCore_SetFunc_MtlIsTransparency((g_func_mtl_is_transparency)SMtrl_MtlIsTransparency);
SGCore_SetFunc_MtlGroupRenderIsSingly((g_func_mtl_group_render_is_singly)SMtrl_MtlGetTypeReflection);
SGCore_SetFunc_MtlGetPhysicType((g_func_mtl_get_physic_type)SMtrl_MtlGetPhysicMaterial);
LibReport(REPORT_MSG_LEVEL_NOTICE, "LIB gcore initialized\n");
SMtrl_DevSet(SGCore_GetDXDevice());
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment