2024-01-13 21:40:13 +00:00
|
|
|
/*
|
|
|
|
===========================================================================
|
2024-01-19 22:57:40 +00:00
|
|
|
Copyright (C) 2023-2024 Gian 'myT' Schellenbaum
|
2024-01-13 21:40:13 +00:00
|
|
|
|
|
|
|
This file is part of Challenge Quake 3 (CNQ3).
|
|
|
|
|
|
|
|
Challenge Quake 3 is free software; you can redistribute it
|
|
|
|
and/or modify it under the terms of the GNU General Public License as
|
|
|
|
published by the Free Software Foundation; either version 2 of the License,
|
|
|
|
or (at your option) any later version.
|
|
|
|
|
|
|
|
Challenge Quake 3 is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with Challenge Quake 3. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
===========================================================================
|
|
|
|
*/
|
|
|
|
// Cinematic Rendering Pipeline - opaque surfaces
|
|
|
|
|
|
|
|
|
|
|
|
#include "crp_local.h"
|
2024-01-14 21:43:20 +00:00
|
|
|
#include "compshaders/crp/opaque.h"
|
2024-02-06 22:15:31 +00:00
|
|
|
#include "compshaders/crp/wireframe_normals.h"
|
|
|
|
#include "compshaders/crp/add_light.h"
|
2024-01-13 21:40:13 +00:00
|
|
|
|
|
|
|
|
|
|
|
#pragma pack(push, 4)
|
|
|
|
|
|
|
|
struct OpaqueVertexRC : WorldVertexRC
|
|
|
|
{
|
|
|
|
};
|
|
|
|
|
|
|
|
struct OpaquePixelRC
|
|
|
|
{
|
|
|
|
// general
|
|
|
|
uint32_t textureIndex;
|
|
|
|
uint32_t samplerIndex;
|
|
|
|
uint32_t shaderIndexBufferIndex;
|
|
|
|
uint32_t alphaTest;
|
2024-02-06 22:15:31 +00:00
|
|
|
uint32_t lightTextureIndex;
|
|
|
|
uint32_t lightmapPass;
|
2024-01-13 21:40:13 +00:00
|
|
|
float greyscale;
|
|
|
|
|
|
|
|
// shader trace
|
2024-01-18 02:16:35 +00:00
|
|
|
uint32_t shaderTrace; // shader index: 14 - enable: 1
|
2024-01-13 21:40:13 +00:00
|
|
|
uint16_t centerPixelX;
|
|
|
|
uint16_t centerPixelY;
|
|
|
|
};
|
|
|
|
|
2024-02-06 22:15:31 +00:00
|
|
|
struct AddLightVertexRC : WorldVertexRC
|
|
|
|
{
|
|
|
|
};
|
|
|
|
|
2024-01-13 21:40:13 +00:00
|
|
|
#pragma pack(pop)
|
|
|
|
|
|
|
|
|
|
|
|
void WorldOpaque::Init()
|
|
|
|
{
|
|
|
|
psoCache.Init(psoCacheEntries, ARRAY_LEN(psoCacheEntries));
|
2024-02-06 22:15:31 +00:00
|
|
|
|
|
|
|
{
|
|
|
|
GraphicsPipelineDesc desc("Debug Normals");
|
|
|
|
desc.shortLifeTime = true;
|
|
|
|
desc.vertexShader.Set(g_wireframe_normals_vs);
|
|
|
|
desc.pixelShader.Set(g_wireframe_normals_ps);
|
|
|
|
desc.vertexLayout.AddAttribute(0, ShaderSemantic::Position, DataType::Float32, 3, 0);
|
|
|
|
desc.vertexLayout.AddAttribute(1, ShaderSemantic::Color, DataType::UNorm8, 4, 0);
|
|
|
|
desc.depthStencil.depthStencilFormat = TextureFormat::Depth32_Float;
|
|
|
|
desc.depthStencil.depthComparison = ComparisonFunction::GreaterEqual;
|
|
|
|
desc.depthStencil.enableDepthTest = true;
|
|
|
|
desc.depthStencil.enableDepthWrites = false;
|
|
|
|
desc.rasterizer.cullMode = CT_TWO_SIDED;
|
|
|
|
desc.rasterizer.polygonOffset = false;
|
|
|
|
desc.rasterizer.clampDepth = false;
|
|
|
|
desc.rasterizer.wireFrame = true;
|
|
|
|
desc.AddRenderTarget(0, crp.renderTargetFormat);
|
|
|
|
wireframeNormalsPipeline = CreateGraphicsPipeline(desc);
|
|
|
|
}
|
2024-01-13 21:40:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void WorldOpaque::Draw(const drawSceneViewCommand_t& cmd)
|
|
|
|
{
|
|
|
|
if(cmd.numDrawSurfs - cmd.numTranspSurfs <= 0)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
srp.renderMode = RenderMode::World;
|
|
|
|
|
|
|
|
backEnd.refdef = cmd.refdef;
|
|
|
|
backEnd.viewParms = cmd.viewParms;
|
|
|
|
|
|
|
|
CmdSetViewportAndScissor(backEnd.viewParms);
|
|
|
|
batchOldDepthHack = false;
|
|
|
|
batchDepthHack = false;
|
|
|
|
|
2024-01-15 16:10:36 +00:00
|
|
|
CmdBeginBarrier();
|
2024-01-19 22:57:40 +00:00
|
|
|
CmdTextureBarrier(crp.depthTexture, ResourceStates::DepthReadBit);
|
2024-02-06 22:15:31 +00:00
|
|
|
CmdTextureBarrier(crp.lightTexture, ResourceStates::PixelShaderAccessBit);
|
2024-03-29 03:19:27 +00:00
|
|
|
CmdTextureBarrier(crp.sunlightTexture, ResourceStates::PixelShaderAccessBit);
|
2024-01-15 16:10:36 +00:00
|
|
|
CmdBufferBarrier(srp.traceRenderBuffer, ResourceStates::UnorderedAccessBit);
|
|
|
|
CmdEndBarrier();
|
2024-01-13 21:40:13 +00:00
|
|
|
|
|
|
|
GeoBuffers& db = crp.dynBuffers[GetFrameIndex()];
|
|
|
|
db.BeginUpload();
|
|
|
|
|
|
|
|
SCOPED_RENDER_PASS("Opaque", 1.0f, 0.5f, 0.5f);
|
|
|
|
|
|
|
|
CmdBindRenderTargets(1, &crp.renderTarget, &crp.depthTexture);
|
|
|
|
CmdBindVertexBuffers(ARRAY_LEN(db.vertexBuffers), db.vertexBuffers, db.vertexBufferStrides, NULL);
|
|
|
|
CmdBindIndexBuffer(db.indexBuffer.buffer, IndexType::UInt32, 0);
|
|
|
|
|
|
|
|
const drawSurf_t* drawSurfs = cmd.drawSurfs;
|
|
|
|
const int surfCount = cmd.numDrawSurfs - cmd.numTranspSurfs;
|
|
|
|
const double originalTime = backEnd.refdef.floatTime;
|
|
|
|
|
|
|
|
const shader_t* shader = NULL;
|
|
|
|
const shader_t* oldShader = NULL;
|
|
|
|
int oldEntityNum = -1;
|
|
|
|
backEnd.currentEntity = &tr.worldEntity;
|
|
|
|
|
|
|
|
tess.numVertexes = 0;
|
|
|
|
tess.numIndexes = 0;
|
|
|
|
|
|
|
|
int ds;
|
|
|
|
const drawSurf_t* drawSurf;
|
|
|
|
for(ds = 0, drawSurf = drawSurfs; ds < surfCount; ++ds, ++drawSurf)
|
|
|
|
{
|
|
|
|
int entityNum;
|
|
|
|
R_DecomposeSort(drawSurf->sort, &entityNum, &shader);
|
|
|
|
Q_assert(shader != NULL);
|
|
|
|
Q_assert(shader->isOpaque);
|
|
|
|
|
|
|
|
// sky shaders can have no stages and be valid (box drawn with no clouds)
|
|
|
|
if(!shader->isSky)
|
|
|
|
{
|
|
|
|
if(shader->numPipelines == 0 ||
|
|
|
|
shader->pipelines[0].pipeline <= 0 ||
|
|
|
|
shader->pipelines[0].numStages <= 0)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const bool shaderChanged = shader != oldShader;
|
|
|
|
const bool entityChanged = entityNum != oldEntityNum;
|
|
|
|
if(shaderChanged || entityChanged)
|
|
|
|
{
|
|
|
|
oldShader = shader;
|
|
|
|
oldEntityNum = entityNum;
|
|
|
|
EndSkyBatch();
|
|
|
|
EndBatch();
|
|
|
|
BeginBatch(shader);
|
|
|
|
tess.greyscale = drawSurf->greyscale;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(entityChanged)
|
|
|
|
{
|
|
|
|
UpdateEntityData(batchDepthHack, entityNum, originalTime);
|
|
|
|
}
|
|
|
|
|
|
|
|
R_TessellateSurface(drawSurf->surface);
|
|
|
|
}
|
|
|
|
|
|
|
|
backEnd.refdef.floatTime = originalTime;
|
|
|
|
|
|
|
|
EndSkyBatch();
|
|
|
|
EndBatch();
|
|
|
|
|
|
|
|
db.EndUpload();
|
|
|
|
|
|
|
|
// restores the potentially "hacked" depth range as well
|
|
|
|
CmdSetViewportAndScissor(backEnd.viewParms);
|
|
|
|
batchOldDepthHack = false;
|
|
|
|
batchDepthHack = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void WorldOpaque::ProcessShader(shader_t& shader)
|
|
|
|
{
|
|
|
|
Q_assert(shader.isOpaque || shader.isSky);
|
|
|
|
|
|
|
|
if(shader.numStages < 1)
|
|
|
|
{
|
|
|
|
shader.numPipelines = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const bool clampDepth = r_depthClamp->integer != 0 || shader.isSky;
|
|
|
|
|
|
|
|
for(int s = 0; s < shader.numStages; ++s)
|
|
|
|
{
|
|
|
|
const shaderStage_t& stage = *shader.stages[s];
|
|
|
|
const unsigned int stateBits = stage.stateBits & (~GLS_POLYMODE_LINE);
|
|
|
|
int a = 0;
|
|
|
|
|
2024-01-22 00:40:31 +00:00
|
|
|
// @NOTE: we 0-init the struct so that padding bytes don't mess up comparisons in the PSO cache
|
2024-01-13 21:40:13 +00:00
|
|
|
GraphicsPipelineDesc desc = {};
|
|
|
|
desc.name = "opaque";
|
|
|
|
desc.rootSignature = RHI_MAKE_NULL_HANDLE();
|
|
|
|
desc.shortLifeTime = true; // the PSO cache is only valid for this map!
|
2024-01-22 00:40:31 +00:00
|
|
|
desc.vertexShader.Set(g_opaque_vs);
|
|
|
|
desc.pixelShader.Set(g_opaque_ps);
|
2024-01-13 21:40:13 +00:00
|
|
|
desc.vertexLayout.AddAttribute(a++, ShaderSemantic::Position, DataType::Float32, 3, 0);
|
2024-01-19 22:57:40 +00:00
|
|
|
desc.vertexLayout.AddAttribute(a++, ShaderSemantic::Normal, DataType::Float32, 3, 0);
|
2024-01-13 21:40:13 +00:00
|
|
|
desc.vertexLayout.AddAttribute(a++, ShaderSemantic::TexCoord, DataType::Float32, 2, 0);
|
|
|
|
desc.vertexLayout.AddAttribute(a++, ShaderSemantic::Color, DataType::UNorm8, 4, 0);
|
|
|
|
desc.depthStencil.depthStencilFormat = TextureFormat::Depth32_Float;
|
2024-01-19 22:57:40 +00:00
|
|
|
desc.depthStencil.depthComparison = shader.isSky ? ComparisonFunction::GreaterEqual : ComparisonFunction::Equal;
|
|
|
|
desc.depthStencil.enableDepthTest = true;
|
|
|
|
desc.depthStencil.enableDepthWrites = false;
|
2024-01-13 21:40:13 +00:00
|
|
|
desc.rasterizer.cullMode = shader.cullType;
|
|
|
|
desc.rasterizer.polygonOffset = shader.polygonOffset != 0;
|
|
|
|
desc.rasterizer.clampDepth = clampDepth;
|
|
|
|
desc.AddRenderTarget(stateBits & GLS_BLEND_BITS, crp.renderTargetFormat);
|
|
|
|
|
|
|
|
pipeline_t& p = shader.pipelines[s];
|
|
|
|
p.firstStage = s;
|
|
|
|
p.numStages = 1;
|
|
|
|
p.pipeline = psoCache.AddPipeline(desc, va("opaque %d %d", psoCache.entryCount, s + 1));
|
|
|
|
desc.rasterizer.cullMode = GetMirrorredCullType(desc.rasterizer.cullMode);
|
|
|
|
p.mirrorPipeline = psoCache.AddPipeline(desc, va("opaque %d %d mirrored", psoCache.entryCount, s + 1));
|
|
|
|
}
|
|
|
|
|
2024-02-06 22:15:31 +00:00
|
|
|
if(!shader.hasLightmapStage)
|
|
|
|
{
|
|
|
|
static int counter = 0;
|
|
|
|
GraphicsPipelineDesc desc = {};
|
|
|
|
desc.name = "Add Light";
|
|
|
|
desc.rootSignature = RHI_MAKE_NULL_HANDLE();
|
|
|
|
desc.shortLifeTime = true;
|
|
|
|
desc.vertexShader.Set(g_add_light_vs);
|
|
|
|
desc.pixelShader.Set(g_add_light_ps);
|
|
|
|
desc.vertexLayout.AddAttribute(0, ShaderSemantic::Position, DataType::Float32, 3, 0);
|
|
|
|
desc.depthStencil.depthStencilFormat = TextureFormat::Depth32_Float;
|
|
|
|
desc.depthStencil.depthComparison = shader.isSky ? ComparisonFunction::GreaterEqual : ComparisonFunction::Equal;
|
|
|
|
desc.depthStencil.enableDepthTest = true;
|
|
|
|
desc.depthStencil.enableDepthWrites = false;
|
|
|
|
desc.rasterizer.cullMode = shader.cullType;
|
|
|
|
desc.rasterizer.polygonOffset = shader.polygonOffset != 0;
|
|
|
|
desc.rasterizer.clampDepth = clampDepth;
|
|
|
|
desc.AddRenderTarget(GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ONE, crp.renderTargetFormat);
|
|
|
|
shader.addLightPipeline = psoCache.AddPipeline(desc, va("Add Light #%d", counter++ + 1));
|
|
|
|
}
|
|
|
|
|
2024-01-13 21:40:13 +00:00
|
|
|
shader.numPipelines = shader.numStages;
|
|
|
|
}
|
|
|
|
|
|
|
|
void WorldOpaque::TessellationOverflow()
|
|
|
|
{
|
|
|
|
EndBatch();
|
|
|
|
BeginBatch(tess.shader);
|
|
|
|
}
|
|
|
|
|
|
|
|
void WorldOpaque::BeginBatch(const shader_t* shader)
|
|
|
|
{
|
|
|
|
tess.tessellator = Tessellator::Opaque;
|
|
|
|
tess.numVertexes = 0;
|
|
|
|
tess.numIndexes = 0;
|
|
|
|
tess.depthFade = DFT_NONE;
|
|
|
|
tess.deformsPreApplied = qfalse;
|
|
|
|
tess.xstages = (const shaderStage_t**)shader->stages;
|
|
|
|
tess.shader = shader;
|
|
|
|
tess.shaderTime = backEnd.refdef.floatTime - tess.shader->timeOffset;
|
|
|
|
if(tess.shader->clampTime && tess.shaderTime >= tess.shader->clampTime)
|
|
|
|
{
|
|
|
|
tess.shaderTime = tess.shader->clampTime;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void WorldOpaque::EndBatch()
|
|
|
|
{
|
|
|
|
const int vertexCount = tess.numVertexes;
|
|
|
|
const int indexCount = tess.numIndexes;
|
|
|
|
if(vertexCount <= 0 ||
|
|
|
|
indexCount <= 0 ||
|
|
|
|
tess.shader->numStages == 0 ||
|
|
|
|
tess.shader->numPipelines <= 0)
|
|
|
|
{
|
|
|
|
goto clean_up;
|
|
|
|
}
|
|
|
|
|
|
|
|
const shader_t* const shader = tess.shader;
|
|
|
|
|
|
|
|
GeoBuffers& db = crp.dynBuffers[GetFrameIndex()];
|
|
|
|
if(!db.CanAdd(vertexCount, indexCount, shader->numStages))
|
|
|
|
{
|
|
|
|
Q_assert(!"World surface geometry buffer too small!");
|
|
|
|
goto clean_up;
|
|
|
|
}
|
|
|
|
|
|
|
|
RB_DeformTessGeometry(0, vertexCount, 0, indexCount);
|
|
|
|
db.UploadBase();
|
|
|
|
|
|
|
|
if(batchDepthHack != batchOldDepthHack)
|
|
|
|
{
|
|
|
|
const viewParms_t& vp = backEnd.viewParms;
|
|
|
|
CmdSetViewport(vp.viewportX, vp.viewportY, vp.viewportWidth, vp.viewportHeight, batchDepthHack ? 0.7f : 0.0f, 1.0f);
|
|
|
|
batchOldDepthHack = batchDepthHack;
|
|
|
|
}
|
|
|
|
|
|
|
|
OpaqueVertexRC vertexRC = {};
|
|
|
|
memcpy(vertexRC.modelViewMatrix, backEnd.orient.modelMatrix, sizeof(vertexRC.modelViewMatrix));
|
|
|
|
CmdSetGraphicsRootConstants(0, sizeof(vertexRC), &vertexRC);
|
|
|
|
|
|
|
|
for(int s = 0; s < shader->numStages; ++s)
|
|
|
|
{
|
|
|
|
const shaderStage_t* const stage = shader->stages[s];
|
|
|
|
|
|
|
|
R_ComputeColors(stage, tess.svars[0], 0, vertexCount);
|
|
|
|
R_ComputeTexCoords(stage, tess.svars[0], 0, vertexCount, qfalse);
|
|
|
|
db.UploadStage(0);
|
|
|
|
|
|
|
|
const pipeline_t& pipeline = shader->pipelines[s];
|
|
|
|
const int psoIndex = backEnd.viewParms.isMirror ? pipeline.mirrorPipeline : pipeline.pipeline;
|
|
|
|
Q_assert(psoIndex > 0);
|
|
|
|
CmdBindPipeline(psoCache.entries[psoIndex].handle);
|
|
|
|
|
|
|
|
const image_t* image = GetBundleImage(stage->bundle);
|
|
|
|
const uint32_t texIdx = image->textureIndex;
|
|
|
|
const uint32_t sampIdx = GetSamplerIndex(image);
|
|
|
|
const uint32_t alphaTest = AlphaTestShaderConstFromStateBits(stage->stateBits);
|
|
|
|
const uint32_t enableShaderTrace = tr.traceWorldShader && s == 0 ? 1 : 0;
|
|
|
|
const uint32_t bufferIndex = GetBufferIndexUAV(srp.traceRenderBuffer);
|
|
|
|
Q_assert(sampIdx < ARRAY_LEN(crp.samplers));
|
|
|
|
|
|
|
|
OpaquePixelRC pixelRC = {};
|
|
|
|
pixelRC.textureIndex = texIdx;
|
|
|
|
pixelRC.samplerIndex = sampIdx;
|
|
|
|
pixelRC.shaderIndexBufferIndex = bufferIndex;
|
|
|
|
pixelRC.alphaTest = alphaTest;
|
2024-02-06 22:15:31 +00:00
|
|
|
pixelRC.lightTextureIndex = GetTextureIndexSRV(crp.lightTexture);
|
|
|
|
pixelRC.lightmapPass = stage->type == ST_LIGHTMAP ? 1 : 0;
|
2024-01-13 21:40:13 +00:00
|
|
|
pixelRC.greyscale = tess.greyscale;
|
2024-01-18 02:16:35 +00:00
|
|
|
pixelRC.shaderTrace = ((uint32_t)shader->index << 1) | enableShaderTrace;
|
2024-01-13 21:40:13 +00:00
|
|
|
pixelRC.centerPixelX = glConfig.vidWidth / 2;
|
|
|
|
pixelRC.centerPixelY = glConfig.vidHeight / 2;
|
|
|
|
CmdSetGraphicsRootConstants(sizeof(vertexRC), sizeof(pixelRC), &pixelRC);
|
|
|
|
|
|
|
|
db.DrawStage(vertexCount, indexCount);
|
|
|
|
}
|
|
|
|
|
2024-02-06 22:15:31 +00:00
|
|
|
if(!shader->hasLightmapStage)
|
|
|
|
{
|
|
|
|
AddLightVertexRC rc = {};
|
|
|
|
memcpy(rc.modelViewMatrix, backEnd.orient.modelMatrix, sizeof(rc.modelViewMatrix));
|
|
|
|
CmdSetGraphicsRootConstants(0, sizeof(rc), &rc);
|
|
|
|
CmdBindPipeline(psoCache.entries[shader->addLightPipeline].handle);
|
|
|
|
db.DrawPositionOnly(vertexCount, indexCount);
|
|
|
|
}
|
|
|
|
|
2024-01-13 21:40:13 +00:00
|
|
|
db.EndBaseBatch(vertexCount);
|
|
|
|
|
2024-02-06 22:15:31 +00:00
|
|
|
if(crp_drawNormals->integer)
|
|
|
|
{
|
|
|
|
CmdBindPipeline(wireframeNormalsPipeline);
|
|
|
|
db.UploadAndDrawDebugNormals();
|
|
|
|
}
|
|
|
|
|
2024-01-13 21:40:13 +00:00
|
|
|
clean_up:
|
|
|
|
tess.tessellator = Tessellator::None;
|
|
|
|
tess.numVertexes = 0;
|
|
|
|
tess.numIndexes = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void WorldOpaque::EndSkyBatch()
|
|
|
|
{
|
|
|
|
// this only exists as a separate function from EndBatch so that
|
|
|
|
// we don't have to deal with recursion (through the call to RB_DrawSky)
|
|
|
|
|
|
|
|
if(tess.shader == NULL ||
|
|
|
|
!tess.shader->isSky ||
|
|
|
|
tess.numVertexes <= 0 ||
|
|
|
|
tess.numIndexes <= 0)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
SCOPED_RENDER_PASS("Sky", 0.0, 0.5f, 1.0f);
|
|
|
|
|
|
|
|
const viewParms_t& vp = backEnd.viewParms;
|
|
|
|
CmdSetViewport(vp.viewportX, vp.viewportY, vp.viewportWidth, vp.viewportHeight, 0.0f, 0.0f);
|
|
|
|
RB_DrawSky();
|
|
|
|
CmdSetViewport(vp.viewportX, vp.viewportY, vp.viewportWidth, vp.viewportHeight, 0.0f, 1.0f);
|
|
|
|
tess.numVertexes = 0;
|
|
|
|
tess.numIndexes = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void WorldOpaque::DrawSkyBox()
|
|
|
|
{
|
|
|
|
// force creation of a PSO for the temp shader
|
|
|
|
ProcessShader((shader_t&)*tess.shader);
|
|
|
|
|
|
|
|
tess.deformsPreApplied = qtrue;
|
|
|
|
EndBatch();
|
|
|
|
}
|
|
|
|
|
|
|
|
void WorldOpaque::DrawClouds()
|
|
|
|
{
|
|
|
|
EndBatch();
|
|
|
|
}
|