mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-21 08:02:39 +08:00
Merge branch 'v3.1.1' into mrege_v311
This commit is contained in:
@@ -0,0 +1,2 @@
|
||||
# ignore third_party code from clang-format checks
|
||||
./cocos/bindings/auto/*
|
||||
@@ -100,7 +100,12 @@ void PhysXSharedBody::setType(ERigidBodyType v) {
|
||||
if (_mType == v) return;
|
||||
_mType = v;
|
||||
initActor();
|
||||
_mImpl.ptr = isStatic() ? reinterpret_cast<uintptr_t>(_mStaticActor) : reinterpret_cast<uintptr_t>(_mDynamicActor);
|
||||
if (isStatic()) {
|
||||
_mImpl.ptr = reinterpret_cast<uintptr_t>(_mStaticActor);
|
||||
} else {
|
||||
_mImpl.ptr = reinterpret_cast<uintptr_t>(_mDynamicActor);
|
||||
_mImpl.rigidDynamic->setRigidBodyFlag(physx::PxRigidBodyFlag::eKINEMATIC, _mType == ERigidBodyType::KINEMATIC);
|
||||
}
|
||||
}
|
||||
|
||||
void PhysXSharedBody::reference(bool v) {
|
||||
|
||||
@@ -25,6 +25,7 @@
|
||||
|
||||
#include "MTLStd.h"
|
||||
|
||||
#include <QuartzCore/CAMetalLayer.h>
|
||||
#include "MTLBuffer.h"
|
||||
#include "MTLCommandBuffer.h"
|
||||
#include "MTLDescriptorSet.h"
|
||||
@@ -35,7 +36,6 @@
|
||||
#include "MTLRenderPass.h"
|
||||
#include "MTLSampler.h"
|
||||
#include "MTLTexture.h"
|
||||
#include <QuartzCore/CAMetalLayer.h>
|
||||
|
||||
namespace cc {
|
||||
namespace gfx {
|
||||
@@ -43,7 +43,7 @@ namespace gfx {
|
||||
CCMTLCommandBuffer::CCMTLCommandBuffer()
|
||||
: CommandBuffer(),
|
||||
_mtlDevice(CCMTLDevice::getInstance()) {
|
||||
_mtlCommandQueue = id<MTLCommandQueue>(_mtlDevice->getMTLCommandQueue());
|
||||
_mtlCommandQueue = id<MTLCommandQueue>(_mtlDevice->getMTLCommandQueue());
|
||||
_indirectDrawSuppotred = _mtlDevice->isIndirectDrawSupported();
|
||||
|
||||
const auto setCount = _mtlDevice->bindingMappingInfo().bufferOffsets.size();
|
||||
@@ -81,15 +81,14 @@ void CCMTLCommandBuffer::begin(RenderPass *renderPass, uint subpass, Framebuffer
|
||||
// Only primary command buffer should request command buffer explicitly
|
||||
_mtlCommandBuffer = [[_mtlCommandQueue commandBuffer] retain];
|
||||
[_mtlCommandBuffer enqueue];
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
// Secondary command buffer is likely to be recorded in a separated thread
|
||||
if (_autoreleasePool) {
|
||||
[_autoreleasePool drain];
|
||||
_autoreleasePool = nil;
|
||||
}
|
||||
_autoreleasePool = [[NSAutoreleasePool alloc] init];
|
||||
// CC_LOG_INFO("%d CB POOL: %p ALLOCED for %p", [NSThread currentThread], _autoreleasePool, this);
|
||||
// CC_LOG_INFO("%d CB POOL: %p ALLOCED for %p", [NSThread currentThread], _autoreleasePool, this);
|
||||
}
|
||||
_numTriangles = 0;
|
||||
_numDrawCalls = 0;
|
||||
@@ -100,7 +99,7 @@ void CCMTLCommandBuffer::begin(RenderPass *renderPass, uint subpass, Framebuffer
|
||||
dynamicOffset.clear();
|
||||
}
|
||||
_firstDirtyDescriptorSet = UINT_MAX;
|
||||
_commandBufferBegan = true;
|
||||
_commandBufferBegan = true;
|
||||
}
|
||||
|
||||
void CCMTLCommandBuffer::end() {
|
||||
@@ -115,7 +114,7 @@ void CCMTLCommandBuffer::end() {
|
||||
_renderEncoder.endEncoding();
|
||||
|
||||
if (_autoreleasePool) {
|
||||
// CC_LOG_INFO("%d CB POOL: %p RELEASED for %p", [NSThread currentThread], _autoreleasePool, this);
|
||||
// CC_LOG_INFO("%d CB POOL: %p RELEASED for %p", [NSThread currentThread], _autoreleasePool, this);
|
||||
[_autoreleasePool drain];
|
||||
_autoreleasePool = nullptr;
|
||||
}
|
||||
@@ -124,37 +123,48 @@ void CCMTLCommandBuffer::end() {
|
||||
|
||||
void CCMTLCommandBuffer::beginRenderPass(RenderPass *renderPass, Framebuffer *fbo, const Rect &renderArea, const Color *colors, float depth, int stencil, CommandBuffer *const *secondaryCBs, uint secondaryCBCount) {
|
||||
// Sub CommandBuffer shouldn't call begin render pass
|
||||
if (_isSecondary)
|
||||
{
|
||||
if (_isSecondary) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
auto *ccMtlRenderPass = static_cast<CCMTLRenderPass *>(renderPass);
|
||||
auto isOffscreen = static_cast<CCMTLFramebuffer *>(fbo)->isOffscreen();
|
||||
auto isOffscreen = static_cast<CCMTLFramebuffer *>(fbo)->isOffscreen();
|
||||
if (!isOffscreen) {
|
||||
id<CAMetalDrawable> drawable = (id<CAMetalDrawable>)_mtlDevice->getCurrentDrawable();
|
||||
id<MTLTexture> dssTex = (id<MTLTexture>)_mtlDevice->getDSSTexture();
|
||||
id<MTLTexture> dssTex = (id<MTLTexture>)_mtlDevice->getDSSTexture();
|
||||
ccMtlRenderPass->setColorAttachment(0, drawable.texture, 0);
|
||||
ccMtlRenderPass->setDepthStencilAttachment(dssTex, 0);
|
||||
} else {
|
||||
const TextureList &colorTextures = fbo->getColorTextures();
|
||||
for (uint i = 0; i < colorTextures.size(); i++) {
|
||||
auto *ccMtlTexture = static_cast<CCMTLTexture *>(colorTextures[i]);
|
||||
ccMtlRenderPass->setColorAttachment(i, ccMtlTexture->getMTLTexture(), 0);
|
||||
}
|
||||
|
||||
Texture *dsTexture = fbo->getDepthStencilTexture();
|
||||
if (dsTexture) {
|
||||
auto *ccMtlTexture = static_cast<CCMTLTexture *>(dsTexture);
|
||||
ccMtlRenderPass->setDepthStencilAttachment(ccMtlTexture->getMTLTexture(), 0);
|
||||
}
|
||||
}
|
||||
MTLRenderPassDescriptor *mtlRenderPassDescriptor = static_cast<CCMTLRenderPass *>(renderPass)->getMTLRenderPassDescriptor();
|
||||
if (!isRenderingEntireDrawable(renderArea, static_cast<CCMTLRenderPass *>(renderPass))) {
|
||||
//Metal doesn't apply the viewports and scissors to renderpass load-action clearing.
|
||||
mu::clearRenderArea(_mtlDevice, _mtlCommandBuffer, renderPass, renderArea, colors, depth, stencil);
|
||||
} else {
|
||||
const auto &colorAttachments = renderPass->getColorAttachments();
|
||||
const auto colorAttachmentCount = colorAttachments.size();
|
||||
const auto &colorAttachments = renderPass->getColorAttachments();
|
||||
const auto colorAttachmentCount = colorAttachments.size();
|
||||
for (size_t slot = 0U; slot < colorAttachmentCount; slot++) {
|
||||
mtlRenderPassDescriptor.colorAttachments[slot].clearColor = mu::toMTLClearColor(colors[slot]);
|
||||
mtlRenderPassDescriptor.colorAttachments[slot].loadAction = colorAttachments[slot].loadOp == LoadOp::CLEAR ? MTLLoadActionClear : MTLLoadActionLoad;
|
||||
}
|
||||
//Metal limits clearDepth at range [0.0, 1.0]
|
||||
//to keep consistent with OpenGL, assume passed value ranges in [-1, 1];
|
||||
depth = clampf(depth / 2 + 0.5f, 0.0f, 1.0f);
|
||||
mtlRenderPassDescriptor.depthAttachment.clearDepth = depth;
|
||||
depth = clampf(depth / 2 + 0.5f, 0.0f, 1.0f);
|
||||
mtlRenderPassDescriptor.depthAttachment.clearDepth = depth;
|
||||
mtlRenderPassDescriptor.stencilAttachment.clearStencil = stencil;
|
||||
}
|
||||
|
||||
|
||||
if (secondaryCBCount > 0) {
|
||||
_parallelEncoder = [[_mtlCommandBuffer parallelRenderCommandEncoderWithDescriptor:mtlRenderPassDescriptor] retain];
|
||||
// Create command encoders from parallel encoder and assign to command buffers
|
||||
@@ -163,12 +173,11 @@ void CCMTLCommandBuffer::beginRenderPass(RenderPass *renderPass, Framebuffer *fb
|
||||
cmdBuff->_renderEncoder.initialize(_parallelEncoder);
|
||||
cmdBuff->_mtlCommandBuffer = _mtlCommandBuffer;
|
||||
}
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
_renderEncoder.initialize(_mtlCommandBuffer, mtlRenderPassDescriptor);
|
||||
}
|
||||
|
||||
Rect scissorArea = renderArea;
|
||||
Rect scissorArea = renderArea;
|
||||
#if defined(CC_DEBUG) && (CC_DEBUG > 0)
|
||||
const Vec2 renderTargetSize = ccMtlRenderPass->getRenderTargetSizes()[0];
|
||||
scissorArea.width = MIN(scissorArea.width, renderTargetSize.x - scissorArea.x);
|
||||
@@ -183,8 +192,7 @@ void CCMTLCommandBuffer::endRenderPass() {
|
||||
[_parallelEncoder endEncoding];
|
||||
[_parallelEncoder release];
|
||||
_parallelEncoder = nil;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
_renderEncoder.endEncoding();
|
||||
}
|
||||
}
|
||||
@@ -279,8 +287,8 @@ void CCMTLCommandBuffer::draw(const DrawInfo &info) {
|
||||
}
|
||||
|
||||
const auto *indirectBuffer = static_cast<CCMTLBuffer *>(_inputAssembler->getIndirectBuffer());
|
||||
const auto *indexBuffer = static_cast<CCMTLBuffer *>(_inputAssembler->getIndexBuffer());
|
||||
auto mtlEncoder = _renderEncoder.getMTLEncoder();
|
||||
const auto *indexBuffer = static_cast<CCMTLBuffer *>(_inputAssembler->getIndexBuffer());
|
||||
auto mtlEncoder = _renderEncoder.getMTLEncoder();
|
||||
|
||||
if (indirectBuffer) {
|
||||
const auto indirectMTLBuffer = indirectBuffer->getMTLBuffer();
|
||||
@@ -290,20 +298,20 @@ void CCMTLCommandBuffer::draw(const DrawInfo &info) {
|
||||
if (indirectBuffer->isDrawIndirectByIndex()) {
|
||||
[mtlEncoder drawIndexedPrimitives:_mtlPrimitiveType
|
||||
indexType:indexBuffer->getIndexType()
|
||||
indexBuffer:indexBuffer->getMTLBuffer()
|
||||
indexBuffer:indexBuffer->getMTLBuffer()
|
||||
indexBufferOffset:0
|
||||
indirectBuffer:indirectMTLBuffer
|
||||
indirectBufferOffset:0];
|
||||
indirectBuffer:indirectMTLBuffer
|
||||
indirectBufferOffset:0];
|
||||
} else {
|
||||
[mtlEncoder drawPrimitives:_mtlPrimitiveType
|
||||
indirectBuffer:indirectMTLBuffer
|
||||
indirectBufferOffset:0];
|
||||
indirectBufferOffset:0];
|
||||
}
|
||||
} else {
|
||||
uint stride = indirectBuffer->getStride();
|
||||
uint offset = 0;
|
||||
uint drawInfoCount = indirectBuffer->getCount();
|
||||
const auto &drawInfos = indirectBuffer->getDrawInfos();
|
||||
uint stride = indirectBuffer->getStride();
|
||||
uint offset = 0;
|
||||
uint drawInfoCount = indirectBuffer->getCount();
|
||||
const auto &drawInfos = indirectBuffer->getDrawInfos();
|
||||
_numDrawCalls += drawInfoCount;
|
||||
|
||||
for (uint i = 0; i < drawInfoCount; ++i) {
|
||||
@@ -312,28 +320,28 @@ void CCMTLCommandBuffer::draw(const DrawInfo &info) {
|
||||
if (indirectBuffer->isDrawIndirectByIndex()) {
|
||||
if (drawInfo.instanceCount == 0) {
|
||||
[mtlEncoder drawIndexedPrimitives:_mtlPrimitiveType
|
||||
indexCount:drawInfo.indexCount
|
||||
indexCount:drawInfo.indexCount
|
||||
indexType:indexBuffer->getIndexType()
|
||||
indexBuffer:indexBuffer->getMTLBuffer()
|
||||
indexBuffer:indexBuffer->getMTLBuffer()
|
||||
indexBufferOffset:offset];
|
||||
} else {
|
||||
[mtlEncoder drawIndexedPrimitives:_mtlPrimitiveType
|
||||
indexCount:drawInfo.indexCount
|
||||
indexCount:drawInfo.indexCount
|
||||
indexType:indexBuffer->getIndexType()
|
||||
indexBuffer:indexBuffer->getMTLBuffer()
|
||||
indexBuffer:indexBuffer->getMTLBuffer()
|
||||
indexBufferOffset:offset
|
||||
instanceCount:drawInfo.instanceCount];
|
||||
}
|
||||
} else {
|
||||
if (drawInfo.instanceCount == 0) {
|
||||
[mtlEncoder drawPrimitives:_mtlPrimitiveType
|
||||
vertexStart:drawInfo.firstIndex
|
||||
vertexCount:drawInfo.vertexCount];
|
||||
vertexStart:drawInfo.firstIndex
|
||||
vertexCount:drawInfo.vertexCount];
|
||||
} else {
|
||||
[mtlEncoder drawPrimitives:_mtlPrimitiveType
|
||||
vertexStart:drawInfo.firstIndex
|
||||
vertexCount:drawInfo.vertexCount
|
||||
instanceCount:drawInfo.instanceCount];
|
||||
vertexStart:drawInfo.firstIndex
|
||||
vertexCount:drawInfo.vertexCount
|
||||
instanceCount:drawInfo.instanceCount];
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -344,28 +352,28 @@ void CCMTLCommandBuffer::draw(const DrawInfo &info) {
|
||||
offset += info.firstIndex * indexBuffer->getStride();
|
||||
if (info.instanceCount == 0) {
|
||||
[mtlEncoder drawIndexedPrimitives:_mtlPrimitiveType
|
||||
indexCount:info.indexCount
|
||||
indexCount:info.indexCount
|
||||
indexType:indexBuffer->getIndexType()
|
||||
indexBuffer:indexBuffer->getMTLBuffer()
|
||||
indexBuffer:indexBuffer->getMTLBuffer()
|
||||
indexBufferOffset:offset];
|
||||
} else {
|
||||
[mtlEncoder drawIndexedPrimitives:_mtlPrimitiveType
|
||||
indexCount:info.indexCount
|
||||
indexCount:info.indexCount
|
||||
indexType:indexBuffer->getIndexType()
|
||||
indexBuffer:indexBuffer->getMTLBuffer()
|
||||
indexBuffer:indexBuffer->getMTLBuffer()
|
||||
indexBufferOffset:offset
|
||||
instanceCount:info.instanceCount];
|
||||
}
|
||||
} else if (info.vertexCount) {
|
||||
if (info.instanceCount == 0) {
|
||||
[mtlEncoder drawPrimitives:_mtlPrimitiveType
|
||||
vertexStart:info.firstIndex
|
||||
vertexCount:info.vertexCount];
|
||||
vertexStart:info.firstIndex
|
||||
vertexCount:info.vertexCount];
|
||||
} else {
|
||||
[mtlEncoder drawPrimitives:_mtlPrimitiveType
|
||||
vertexStart:info.firstIndex
|
||||
vertexCount:info.vertexCount
|
||||
instanceCount:info.instanceCount];
|
||||
vertexStart:info.firstIndex
|
||||
vertexCount:info.vertexCount
|
||||
instanceCount:info.instanceCount];
|
||||
}
|
||||
}
|
||||
|
||||
@@ -411,41 +419,41 @@ void CCMTLCommandBuffer::copyBuffersToTexture(const uint8_t *const *buffers, Tex
|
||||
return;
|
||||
}
|
||||
|
||||
uint totalSize = 0;
|
||||
vector<uint> bufferSize(count);
|
||||
uint totalSize = 0;
|
||||
vector<uint> bufferSize(count);
|
||||
vector<CCMTLGPUBufferImageCopy> stagingRegions(count);
|
||||
auto format = texture->getFormat();
|
||||
auto *mtlTexture = static_cast<CCMTLTexture *>(texture);
|
||||
auto convertedFormat = mtlTexture->getConvertedFormat();
|
||||
auto format = texture->getFormat();
|
||||
auto * mtlTexture = static_cast<CCMTLTexture *>(texture);
|
||||
auto convertedFormat = mtlTexture->getConvertedFormat();
|
||||
for (size_t i = 0; i < count; i++) {
|
||||
const auto ®ion = regions[i];
|
||||
auto &stagingRegion = stagingRegions[i];
|
||||
auto w = region.buffStride > 0 ? region.buffStride : region.texExtent.width;
|
||||
auto h = region.buffTexHeight > 0 ? region.buffTexHeight : region.texExtent.height;
|
||||
bufferSize[i] = w * h;
|
||||
stagingRegion.sourceBytesPerRow = mu::getBytesPerRow(convertedFormat, w);
|
||||
const auto ®ion = regions[i];
|
||||
auto & stagingRegion = stagingRegions[i];
|
||||
auto w = region.buffStride > 0 ? region.buffStride : region.texExtent.width;
|
||||
auto h = region.buffTexHeight > 0 ? region.buffTexHeight : region.texExtent.height;
|
||||
bufferSize[i] = w * h;
|
||||
stagingRegion.sourceBytesPerRow = mu::getBytesPerRow(convertedFormat, w);
|
||||
stagingRegion.sourceBytesPerImage = formatSize(convertedFormat, w, h, region.texExtent.depth);
|
||||
stagingRegion.sourceSize = {w, h, region.texExtent.depth};
|
||||
stagingRegion.destinationSlice = region.texSubres.baseArrayLayer;
|
||||
stagingRegion.destinationLevel = region.texSubres.mipLevel;
|
||||
stagingRegion.destinationOrigin = {
|
||||
stagingRegion.sourceSize = {w, h, region.texExtent.depth};
|
||||
stagingRegion.destinationSlice = region.texSubres.baseArrayLayer;
|
||||
stagingRegion.destinationLevel = region.texSubres.mipLevel;
|
||||
stagingRegion.destinationOrigin = {
|
||||
static_cast<uint>(region.texOffset.x),
|
||||
static_cast<uint>(region.texOffset.y),
|
||||
static_cast<uint>(region.texOffset.z)};
|
||||
totalSize += stagingRegion.sourceBytesPerImage;
|
||||
}
|
||||
|
||||
size_t offset = 0;
|
||||
id<MTLBlitCommandEncoder> encoder = [_mtlCommandBuffer blitCommandEncoder];
|
||||
id<MTLTexture> dstTexture = mtlTexture->getMTLTexture();
|
||||
const bool isArrayTexture = mtlTexture->isArray();
|
||||
size_t offset = 0;
|
||||
id<MTLBlitCommandEncoder> encoder = [_mtlCommandBuffer blitCommandEncoder];
|
||||
id<MTLTexture> dstTexture = mtlTexture->getMTLTexture();
|
||||
const bool isArrayTexture = mtlTexture->isArray();
|
||||
for (size_t i = 0; i < count; i++) {
|
||||
const auto &stagingRegion = stagingRegions[i];
|
||||
const auto *convertedData = mu::convertData(buffers[i], bufferSize[i], format);
|
||||
const auto sourceBytesPerImage = isArrayTexture ? stagingRegion.sourceBytesPerImage : 0;
|
||||
MTLRegion region = {stagingRegion.destinationOrigin, stagingRegion.sourceSize};
|
||||
auto bytesPerRow = mtlTexture->isPVRTC() ? 0 : stagingRegion.sourceBytesPerRow;
|
||||
auto bytesPerImage = mtlTexture->isPVRTC() ? 0 : sourceBytesPerImage;
|
||||
const auto &stagingRegion = stagingRegions[i];
|
||||
const auto *convertedData = mu::convertData(buffers[i], bufferSize[i], format);
|
||||
const auto sourceBytesPerImage = isArrayTexture ? stagingRegion.sourceBytesPerImage : 0;
|
||||
MTLRegion region = {stagingRegion.destinationOrigin, stagingRegion.sourceSize};
|
||||
auto bytesPerRow = mtlTexture->isPVRTC() ? 0 : stagingRegion.sourceBytesPerRow;
|
||||
auto bytesPerImage = mtlTexture->isPVRTC() ? 0 : sourceBytesPerImage;
|
||||
[dstTexture replaceRegion:region
|
||||
mipmapLevel:stagingRegion.destinationLevel
|
||||
slice:stagingRegion.destinationSlice
|
||||
@@ -476,30 +484,30 @@ void CCMTLCommandBuffer::execute(CommandBuffer *const *commandBuffs, uint32_t co
|
||||
void CCMTLCommandBuffer::bindDescriptorSets() {
|
||||
const auto &vertexBuffers = _inputAssembler->getVertexBuffers();
|
||||
for (const auto &bindingInfo : _gpuPipelineState->vertexBufferBindingInfo) {
|
||||
auto index = std::get<0>(bindingInfo);
|
||||
auto index = std::get<0>(bindingInfo);
|
||||
auto stream = std::get<1>(bindingInfo);
|
||||
static_cast<CCMTLBuffer *>(vertexBuffers[stream])->encodeBuffer(_renderEncoder, 0, index, ShaderStageFlagBit::VERTEX);
|
||||
}
|
||||
|
||||
const auto &dynamicOffsetIndices = _gpuPipelineState->gpuPipelineLayout->dynamicOffsetIndices;
|
||||
const auto &blocks = _gpuPipelineState->gpuShader->blocks;
|
||||
const auto &blocks = _gpuPipelineState->gpuShader->blocks;
|
||||
for (const auto &iter : blocks) {
|
||||
const auto &block = iter.second;
|
||||
|
||||
const auto *gpuDescriptorSet = _GPUDescriptorSets[block.set];
|
||||
const auto descriptorIndex = gpuDescriptorSet->descriptorIndices->at(block.binding);
|
||||
const auto &gpuDescriptor = gpuDescriptorSet->gpuDescriptors[descriptorIndex];
|
||||
const auto descriptorIndex = gpuDescriptorSet->descriptorIndices->at(block.binding);
|
||||
const auto &gpuDescriptor = gpuDescriptorSet->gpuDescriptors[descriptorIndex];
|
||||
if (!gpuDescriptor.buffer) {
|
||||
CC_LOG_ERROR("Buffer binding %s at set %d binding %d is not bounded.", block.name.c_str(), block.set, block.binding);
|
||||
continue;
|
||||
}
|
||||
|
||||
const auto &dynamicOffset = dynamicOffsetIndices[block.set];
|
||||
auto dynamicOffsetIndex = (block.binding < dynamicOffset.size()) ? dynamicOffset[block.binding] : -1;
|
||||
const auto &dynamicOffset = dynamicOffsetIndices[block.set];
|
||||
auto dynamicOffsetIndex = (block.binding < dynamicOffset.size()) ? dynamicOffset[block.binding] : -1;
|
||||
if (gpuDescriptor.buffer) {
|
||||
uint offset = (dynamicOffsetIndex >= 0) ? _dynamicOffsets[block.set][dynamicOffsetIndex] : 0;
|
||||
// compute pipeline and render pipeline mutually exlusive
|
||||
if(_gpuPipelineState->mtlComputePipelineState) {
|
||||
if (_gpuPipelineState->mtlComputePipelineState) {
|
||||
gpuDescriptor.buffer->encodeBuffer(_computeEncoder,
|
||||
offset,
|
||||
block.mappedBinding,
|
||||
@@ -518,8 +526,8 @@ void CCMTLCommandBuffer::bindDescriptorSets() {
|
||||
const auto &sampler = iter.second;
|
||||
|
||||
const auto *gpuDescriptorSet = _GPUDescriptorSets[sampler.set];
|
||||
const auto descriptorIndex = gpuDescriptorSet->descriptorIndices->at(sampler.binding);
|
||||
const auto &gpuDescriptor = gpuDescriptorSet->gpuDescriptors[descriptorIndex];
|
||||
const auto descriptorIndex = gpuDescriptorSet->descriptorIndices->at(sampler.binding);
|
||||
const auto &gpuDescriptor = gpuDescriptorSet->gpuDescriptors[descriptorIndex];
|
||||
|
||||
if (!gpuDescriptor.texture || !gpuDescriptor.sampler) {
|
||||
CC_LOG_ERROR("Sampler binding %s at set %d binding %d is not bounded.", sampler.name.c_str(), sampler.set, sampler.binding);
|
||||
@@ -536,26 +544,26 @@ void CCMTLCommandBuffer::bindDescriptorSets() {
|
||||
_renderEncoder.setFragmentSampler(gpuDescriptor.sampler->getMTLSamplerState(), sampler.samplerBinding);
|
||||
}
|
||||
|
||||
if(hasFlag(sampler.stages, ShaderStageFlagBit::COMPUTE)) {
|
||||
if (hasFlag(sampler.stages, ShaderStageFlagBit::COMPUTE)) {
|
||||
_computeEncoder.setTexture(gpuDescriptor.texture->getMTLTexture(), sampler.textureBinding);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CCMTLCommandBuffer::blitTexture(Texture *srcTexture, Texture *dstTexture, const TextureBlit *regions, uint count, Filter filter) {
|
||||
if(srcTexture && regions) {
|
||||
if (srcTexture && regions) {
|
||||
id<MTLBlitCommandEncoder> encoder = [_mtlCommandBuffer blitCommandEncoder];
|
||||
id<MTLTexture> src = static_cast<CCMTLTexture*>(srcTexture)->getMTLTexture();
|
||||
id<MTLTexture> dst = nil;
|
||||
CCMTLDevice* device = CCMTLDevice::getInstance();
|
||||
if(!dstTexture) {
|
||||
id<MTLTexture> src = static_cast<CCMTLTexture *>(srcTexture)->getMTLTexture();
|
||||
id<MTLTexture> dst = nil;
|
||||
CCMTLDevice * device = CCMTLDevice::getInstance();
|
||||
if (!dstTexture) {
|
||||
id<CAMetalDrawable> currentDrawable = (id<CAMetalDrawable>)device->getCurrentDrawable();
|
||||
dst = [currentDrawable texture];
|
||||
dst = [currentDrawable texture];
|
||||
} else {
|
||||
dst = static_cast<CCMTLTexture*>(dstTexture)->getMTLTexture();
|
||||
dst = static_cast<CCMTLTexture *>(dstTexture)->getMTLTexture();
|
||||
}
|
||||
|
||||
if([src pixelFormat] != device->preferredPixelFormat()) {
|
||||
if ([src pixelFormat] != device->preferredPixelFormat()) {
|
||||
src = [src newTextureViewWithPixelFormat:(MTLPixelFormat)device->preferredPixelFormat()];
|
||||
}
|
||||
|
||||
@@ -575,14 +583,13 @@ void CCMTLCommandBuffer::blitTexture(Texture *srcTexture, Texture *dstTexture, c
|
||||
}
|
||||
|
||||
void CCMTLCommandBuffer::dispatch(const DispatchInfo &info) {
|
||||
if(_firstDirtyDescriptorSet < _GPUDescriptorSets.size()) {
|
||||
if (_firstDirtyDescriptorSet < _GPUDescriptorSets.size()) {
|
||||
bindDescriptorSets();
|
||||
}
|
||||
MTLSize groupsPerGrid = MTLSizeMake(info.groupCountX, info.groupCountY, info.groupCountZ);
|
||||
if(info.indirectBuffer) {
|
||||
_computeEncoder.dispatch(((CCMTLBuffer*)info.indirectBuffer)->getMTLBuffer(), info.indirectOffset, groupsPerGrid);
|
||||
}
|
||||
else {
|
||||
if (info.indirectBuffer) {
|
||||
_computeEncoder.dispatch(((CCMTLBuffer *)info.indirectBuffer)->getMTLBuffer(), info.indirectOffset, groupsPerGrid);
|
||||
} else {
|
||||
_computeEncoder.dispatch(groupsPerGrid);
|
||||
}
|
||||
_computeEncoder.endEncoding();
|
||||
|
||||
@@ -545,6 +545,11 @@ uint nextPow2(uint val) {
|
||||
return val;
|
||||
}
|
||||
|
||||
bool supportsHalfFloatTexture(gfx::Device *device) {
|
||||
return device->hasFeature(gfx::Feature::COLOR_HALF_FLOAT) &&
|
||||
device->hasFeature(gfx::Feature::TEXTURE_HALF_FLOAT);
|
||||
}
|
||||
|
||||
uint getPhaseID(const String &phase) {
|
||||
se::Object *globalObj = se::ScriptEngine::getInstance()->getGlobalObject();
|
||||
|
||||
|
||||
@@ -53,7 +53,7 @@ struct CC_DLL RenderObject {
|
||||
float depth = 0;
|
||||
const ModelView *model = nullptr;
|
||||
};
|
||||
using RenderObjectList = vector<struct RenderObject>;
|
||||
using RenderObjectList = vector<struct RenderObject>;
|
||||
|
||||
struct CC_DLL RenderTargetInfo {
|
||||
uint width = 0;
|
||||
@@ -69,7 +69,7 @@ struct CC_DLL RenderPass {
|
||||
};
|
||||
using RenderPassList = vector<RenderPass>;
|
||||
|
||||
using ColorDesc = gfx::ColorAttachment;
|
||||
using ColorDesc = gfx::ColorAttachment;
|
||||
using ColorDescList = vector<ColorDesc>;
|
||||
|
||||
using DepthStencilDesc = gfx::DepthStencilAttachment;
|
||||
@@ -106,9 +106,9 @@ enum class RenderFlowType : uint8_t {
|
||||
};
|
||||
|
||||
using RenderStageList = vector<RenderStage *>;
|
||||
using RenderFlowList = vector<RenderFlow *>;
|
||||
using LightList = vector<Light *>;
|
||||
using UintList = vector<uint>;
|
||||
using RenderFlowList = vector<RenderFlow *>;
|
||||
using LightList = vector<Light *>;
|
||||
using UintList = vector<uint>;
|
||||
|
||||
enum class CC_DLL RenderPassStage {
|
||||
DEFAULT = 100,
|
||||
@@ -178,6 +178,31 @@ CC_INLINE bool transparentCompareFn(const RenderPass &a, const RenderPass &b) {
|
||||
return a.shaderID < b.shaderID;
|
||||
}
|
||||
|
||||
CC_INLINE uint convertPhase(const StringArray &stages) {
|
||||
uint phase = 0;
|
||||
for (const auto &stage : stages) {
|
||||
phase |= getPhaseID(stage);
|
||||
}
|
||||
return phase;
|
||||
}
|
||||
|
||||
using RenderQueueSortFunc = std::function<int(const RenderPass &, const RenderPass &)>;
|
||||
|
||||
CC_INLINE RenderQueueSortFunc convertQueueSortFunc(const RenderQueueSortMode &mode) {
|
||||
std::function<int(const RenderPass &, const RenderPass &)> sortFunc = opaqueCompareFn;
|
||||
switch (mode) {
|
||||
case RenderQueueSortMode::BACK_TO_FRONT:
|
||||
sortFunc = transparentCompareFn;
|
||||
break;
|
||||
case RenderQueueSortMode::FRONT_TO_BACK:
|
||||
sortFunc = opaqueCompareFn;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return sortFunc;
|
||||
}
|
||||
|
||||
enum class CC_DLL PipelineGlobalBindings {
|
||||
UBO_GLOBAL,
|
||||
UBO_CAMERA,
|
||||
@@ -385,16 +410,16 @@ struct CC_DLL UBOCamera : public Object {
|
||||
};
|
||||
|
||||
struct CC_DLL UBOShadow : public Object {
|
||||
static constexpr uint MAT_LIGHT_PLANE_PROJ_OFFSET = 0;
|
||||
static constexpr uint MAT_LIGHT_VIEW_OFFSET = MAT_LIGHT_PLANE_PROJ_OFFSET + 16;
|
||||
static constexpr uint MAT_LIGHT_VIEW_PROJ_OFFSET = UBOShadow::MAT_LIGHT_VIEW_OFFSET + 16;
|
||||
static constexpr uint SHADOW_NEAR_FAR_LINEAR_SELF_INFO_OFFSET = UBOShadow::MAT_LIGHT_VIEW_PROJ_OFFSET + 16;
|
||||
static constexpr uint SHADOW_WIDTH_HEIGHT_PCF_BIAS_INFO_OFFSET = UBOShadow::SHADOW_NEAR_FAR_LINEAR_SELF_INFO_OFFSET + 4;
|
||||
static constexpr uint MAT_LIGHT_PLANE_PROJ_OFFSET = 0;
|
||||
static constexpr uint MAT_LIGHT_VIEW_OFFSET = MAT_LIGHT_PLANE_PROJ_OFFSET + 16;
|
||||
static constexpr uint MAT_LIGHT_VIEW_PROJ_OFFSET = UBOShadow::MAT_LIGHT_VIEW_OFFSET + 16;
|
||||
static constexpr uint SHADOW_NEAR_FAR_LINEAR_SELF_INFO_OFFSET = UBOShadow::MAT_LIGHT_VIEW_PROJ_OFFSET + 16;
|
||||
static constexpr uint SHADOW_WIDTH_HEIGHT_PCF_BIAS_INFO_OFFSET = UBOShadow::SHADOW_NEAR_FAR_LINEAR_SELF_INFO_OFFSET + 4;
|
||||
static constexpr uint SHADOW_LIGHT_PACKING_NBIAS_NULL_INFO_OFFSET = UBOShadow::SHADOW_WIDTH_HEIGHT_PCF_BIAS_INFO_OFFSET + 4;
|
||||
static constexpr uint SHADOW_COLOR_OFFSET = UBOShadow::SHADOW_LIGHT_PACKING_NBIAS_NULL_INFO_OFFSET + 4;
|
||||
static constexpr uint COUNT = UBOShadow::SHADOW_COLOR_OFFSET + 4;
|
||||
static constexpr uint SIZE = UBOShadow::COUNT * 4;
|
||||
static constexpr uint BINDING = static_cast<uint>(PipelineGlobalBindings::UBO_SHADOW);
|
||||
static constexpr uint SHADOW_COLOR_OFFSET = UBOShadow::SHADOW_LIGHT_PACKING_NBIAS_NULL_INFO_OFFSET + 4;
|
||||
static constexpr uint COUNT = UBOShadow::SHADOW_COLOR_OFFSET + 4;
|
||||
static constexpr uint SIZE = UBOShadow::COUNT * 4;
|
||||
static constexpr uint BINDING = static_cast<uint>(PipelineGlobalBindings::UBO_SHADOW);
|
||||
static const gfx::DescriptorSetLayoutBinding DESCRIPTOR;
|
||||
static const gfx::UniformBlock LAYOUT;
|
||||
static const String NAME;
|
||||
@@ -405,7 +430,7 @@ public:
|
||||
static gfx::Sampler *getSampler(uint hash);
|
||||
static uint genSamplerHash(const gfx::SamplerInfo &info);
|
||||
|
||||
static void destroyAll();
|
||||
static void destroyAll();
|
||||
|
||||
protected:
|
||||
static uint defaultSamplerHash;
|
||||
@@ -441,7 +466,9 @@ const uint CAMERA_DEFAULT_MASK = ~static_cast<uint>(LayerList::UI_2D) & ~static_
|
||||
|
||||
uint nextPow2(uint val);
|
||||
|
||||
extern CC_DLL uint skyboxFlag;
|
||||
bool supportsHalfFloatTexture(gfx::Device *device);
|
||||
|
||||
extern CC_DLL uint skyboxFlag;
|
||||
|
||||
struct CC_DLL SHADOWMAP : public Object {
|
||||
static constexpr uint BINDING = static_cast<uint>(PipelineGlobalBindings::SAMPLER_SHADOWMAP);
|
||||
|
||||
@@ -140,7 +140,7 @@ void PipelineUBO::updateCameraUBOView(const RenderPipeline *pipeline, std::array
|
||||
memcpy(uboCameraView.data() + UBOCamera::MAT_VIEW_INV_OFFSET, camera->getNode()->worldMatrix.m, sizeof(cc::Mat4));
|
||||
TO_VEC3(uboCameraView, camera->position, UBOCamera::CAMERA_POS_OFFSET);
|
||||
|
||||
|
||||
|
||||
memcpy(uboCameraView.data() + UBOCamera::MAT_PROJ_OFFSET, camera->matProj.m, sizeof(cc::Mat4));
|
||||
memcpy(uboCameraView.data() + UBOCamera::MAT_PROJ_INV_OFFSET, camera->matProjInv.m, sizeof(cc::Mat4));
|
||||
memcpy(uboCameraView.data() + UBOCamera::MAT_VIEW_PROJ_OFFSET, camera->matViewProj.m, sizeof(cc::Mat4));
|
||||
@@ -208,16 +208,16 @@ void PipelineUBO::updateShadowUBOView(const RenderPipeline *pipeline, std::array
|
||||
matShadowViewProj.multiply(matShadowView);
|
||||
memcpy(shadowUBO.data() + UBOShadow::MAT_LIGHT_VIEW_PROJ_OFFSET, matShadowViewProj.m, sizeof(matShadowViewProj));
|
||||
|
||||
const auto isTextureHalfFloat = device->hasFeature(cc::gfx::Feature::TEXTURE_HALF_FLOAT);
|
||||
const auto linear = (static_cast<bool>(shadowInfo->linear) && isTextureHalfFloat) ? 1.0F : 0.0F;
|
||||
const auto isSupportHalfFloat = supportsHalfFloatTexture(device);
|
||||
const auto linear = (static_cast<bool>(shadowInfo->linear) && isSupportHalfFloat) ? 1.0F : 0.0F;
|
||||
float shadowNFLSInfos[4] = {shadowInfo->nearValue, farClamp, linear, static_cast<float>(shadowInfo->selfShadow)};
|
||||
memcpy(shadowUBO.data() + UBOShadow::SHADOW_NEAR_FAR_LINEAR_SELF_INFO_OFFSET, &shadowNFLSInfos, sizeof(shadowNFLSInfos));
|
||||
|
||||
float shadowWHPBInfos[4] = {shadowInfo->size.x, shadowInfo->size.y, static_cast<float>(shadowInfo->pcfType), shadowInfo->bias};
|
||||
memcpy(shadowUBO.data() + UBOShadow::SHADOW_WIDTH_HEIGHT_PCF_BIAS_INFO_OFFSET, &shadowWHPBInfos, sizeof(shadowWHPBInfos));
|
||||
|
||||
const auto packing = static_cast<bool>(shadowInfo->packing) ? 1.0F : (isTextureHalfFloat ? 0.0F : 1.0F);
|
||||
float shadowLPNNInfos[4] = {0.0F, packing, shadowInfo->normalBias, 0.0F};
|
||||
const auto packing = static_cast<bool>(shadowInfo->packing) ? 1.0F : (isSupportHalfFloat ? 0.0F : 1.0F);
|
||||
float shadowLPNNInfos[4] = {0.0F, packing, shadowInfo->normalBias, 0.0F};
|
||||
memcpy(shadowUBO.data() + UBOShadow::SHADOW_LIGHT_PACKING_NBIAS_NULL_INFO_OFFSET, &shadowLPNNInfos, sizeof(shadowLPNNInfos));
|
||||
} else if (mainLight && shadowInfo->getShadowType() == ShadowType::PLANAR) {
|
||||
updateDirLight(shadowInfo, mainLight, shadowUBO);
|
||||
@@ -234,9 +234,9 @@ void PipelineUBO::updateShadowUBOLightView(const RenderPipeline *pipeline, std::
|
||||
auto * device = gfx::Device::getInstance();
|
||||
auto * sphere = sceneData->getSphere();
|
||||
auto & shadowUBO = bufferView;
|
||||
const auto isTextureHalfFloat = device->hasFeature(cc::gfx::Feature::TEXTURE_HALF_FLOAT);
|
||||
const auto linear = (static_cast<bool>(shadowInfo->linear) && isTextureHalfFloat) ? 1.0F : 0.0F;
|
||||
const auto packing = static_cast<bool>(shadowInfo->packing) ? 1.0F : (isTextureHalfFloat ? 0.0F : 1.0F);
|
||||
const auto isSupportHalfFloat = supportsHalfFloatTexture(device);
|
||||
const auto linear = (static_cast<bool>(shadowInfo->linear) && isSupportHalfFloat) ? 1.0F : 0.0F;
|
||||
const auto packing = static_cast<bool>(shadowInfo->packing) ? 1.0F : (isSupportHalfFloat ? 0.0F : 1.0F);
|
||||
switch (light->getType()) {
|
||||
case LightType::DIRECTIONAL: {
|
||||
cc::Mat4 matShadowCamera;
|
||||
|
||||
@@ -323,9 +323,9 @@ void RenderAdditiveLightQueue::updateLightDescriptorSet(const Camera *camera, gf
|
||||
auto * shadowInfo = sceneData->getSharedData()->getShadows();
|
||||
const auto *const scene = camera->getScene();
|
||||
auto * device = gfx::Device::getInstance();
|
||||
const auto isTextureHalfFloat = device->hasFeature(cc::gfx::Feature::TEXTURE_HALF_FLOAT);
|
||||
const auto linear = (static_cast<bool>(shadowInfo->linear) && isTextureHalfFloat) ? 1.0F : 0.0F;
|
||||
const auto packing = static_cast<bool>(shadowInfo->packing) ? 1.0F : (isTextureHalfFloat ? 0.0F : 1.0F);
|
||||
const auto isSupportHalfFloat = supportsHalfFloatTexture(device);
|
||||
const auto linear = (static_cast<bool>(shadowInfo->linear) && isSupportHalfFloat) ? 1.0F : 0.0F;
|
||||
const auto packing = static_cast<bool>(shadowInfo->packing) ? 1.0F : (isSupportHalfFloat ? 0.0F : 1.0F);
|
||||
const Light * mainLight = nullptr;
|
||||
if (scene->mainLightID) mainLight = scene->getMainLight();
|
||||
|
||||
|
||||
@@ -152,100 +152,33 @@ void DeferredPipeline::updateQuadVertexData(const gfx::Rect &renderArea) {
|
||||
float vbData[16] = {0};
|
||||
genQuadVertexData(gfx::SurfaceTransform::IDENTITY, renderArea, vbData);
|
||||
_commandBuffers[0]->updateBuffer(_quadVBOffscreen, vbData);
|
||||
|
||||
genQuadVertexData(_device->getSurfaceTransform(), renderArea, vbData);
|
||||
_commandBuffers[0]->updateBuffer(_quadVBOnscreen, vbData);
|
||||
}
|
||||
|
||||
void DeferredPipeline::genQuadVertexData(gfx::SurfaceTransform surfaceTransform, const gfx::Rect &renderArea, float *vbData) {
|
||||
float minX = float(renderArea.x) / _device->getWidth();
|
||||
float maxX = float(renderArea.x + renderArea.width) / _device->getWidth();
|
||||
float minY = float(renderArea.y) / _device->getHeight();
|
||||
float maxY = float(renderArea.y + renderArea.height) / _device->getHeight();
|
||||
void DeferredPipeline::genQuadVertexData(gfx::SurfaceTransform /*surfaceTransform*/, const gfx::Rect &renderArea, float *vbData) {
|
||||
float minX = float(renderArea.x) / _width;
|
||||
float maxX = float(renderArea.x + renderArea.width) / _width;
|
||||
float minY = float(renderArea.y) / _height;
|
||||
float maxY = float(renderArea.y + renderArea.height) / _height;
|
||||
if (_device->getCapabilities().screenSpaceSignY > 0) {
|
||||
std::swap(minY, maxY);
|
||||
}
|
||||
int n = 0;
|
||||
switch (surfaceTransform) {
|
||||
case (gfx::SurfaceTransform::IDENTITY):
|
||||
n = 0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = minX; // uv
|
||||
vbData[n++] = maxY;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = maxX;
|
||||
vbData[n++] = maxY;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = minX;
|
||||
vbData[n++] = minY;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = maxX;
|
||||
vbData[n++] = minY;
|
||||
break;
|
||||
case (gfx::SurfaceTransform::ROTATE_90):
|
||||
n = 0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = maxX; // uv
|
||||
vbData[n++] = maxY;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = maxX;
|
||||
vbData[n++] = minY;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = minX;
|
||||
vbData[n++] = maxY;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = minX;
|
||||
vbData[n++] = minY;
|
||||
break;
|
||||
case (gfx::SurfaceTransform::ROTATE_180):
|
||||
n = 0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = minX; // uv
|
||||
vbData[n++] = minY;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = maxX;
|
||||
vbData[n++] = minY;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = minX;
|
||||
vbData[n++] = maxY;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = maxX;
|
||||
vbData[n++] = maxY;
|
||||
break;
|
||||
case (gfx::SurfaceTransform::ROTATE_270):
|
||||
n = 0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = minX; // uv
|
||||
vbData[n++] = minY;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = minX;
|
||||
vbData[n++] = maxY;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = maxX;
|
||||
vbData[n++] = minY;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = maxX;
|
||||
vbData[n++] = maxY;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
int n = 0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = minX; // uv
|
||||
vbData[n++] = maxY;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = maxX;
|
||||
vbData[n++] = maxY;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = minX;
|
||||
vbData[n++] = minY;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = maxX;
|
||||
vbData[n++] = minY;
|
||||
}
|
||||
|
||||
bool DeferredPipeline::createQuadInputAssembler(gfx::Buffer **quadIB, gfx::Buffer **quadVB, gfx::InputAssembler **quadIA) {
|
||||
@@ -312,21 +245,11 @@ void DeferredPipeline::destroyQuadInputAssembler() {
|
||||
_quadIB = nullptr;
|
||||
}
|
||||
|
||||
if (_quadVBOnscreen) {
|
||||
_quadVBOnscreen->destroy();
|
||||
_quadVBOnscreen = nullptr;
|
||||
}
|
||||
|
||||
if (_quadVBOffscreen) {
|
||||
_quadVBOffscreen->destroy();
|
||||
_quadVBOffscreen = nullptr;
|
||||
}
|
||||
|
||||
if (_quadIAOnscreen) {
|
||||
_quadIAOnscreen->destroy();
|
||||
_quadIAOnscreen = nullptr;
|
||||
}
|
||||
|
||||
if (_quadIAOffscreen) {
|
||||
_quadIAOffscreen->destroy();
|
||||
_quadIAOffscreen = nullptr;
|
||||
@@ -366,10 +289,6 @@ bool DeferredPipeline::activeRenderer() {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!createQuadInputAssembler(&_quadIB, &_quadVBOnscreen, &_quadIAOnscreen)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
gfx::RenderPassInfo gbufferPass;
|
||||
|
||||
gfx::ColorAttachment color = {
|
||||
@@ -421,14 +340,8 @@ bool DeferredPipeline::activeRenderer() {
|
||||
|
||||
_lightingRenderPass = _device->createRenderPass(lightPass);
|
||||
|
||||
if (_device->getSurfaceTransform() == gfx::SurfaceTransform::IDENTITY ||
|
||||
_device->getSurfaceTransform() == gfx::SurfaceTransform::ROTATE_180) {
|
||||
_width = _device->getWidth();
|
||||
_height = _device->getHeight();
|
||||
} else {
|
||||
_width = _device->getHeight();
|
||||
_height = _device->getWidth();
|
||||
}
|
||||
_width = _device->getWidth();
|
||||
_height = _device->getHeight();
|
||||
|
||||
generateDeferredRenderData();
|
||||
|
||||
@@ -564,9 +477,9 @@ void DeferredPipeline::destroyDeferredData() {
|
||||
_deferredRenderData->depthTex = nullptr;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < _deferredRenderData->gbufferRenderTargets.size(); i++) {
|
||||
_deferredRenderData->gbufferRenderTargets[i]->destroy();
|
||||
CC_DELETE(_deferredRenderData->gbufferRenderTargets[i]);
|
||||
for (auto *target : _deferredRenderData->gbufferRenderTargets) {
|
||||
target->destroy();
|
||||
CC_DELETE(target);
|
||||
}
|
||||
_deferredRenderData->gbufferRenderTargets.clear();
|
||||
|
||||
|
||||
@@ -70,7 +70,6 @@ public:
|
||||
CC_INLINE const gfx::BufferList &getLightBuffers() const { return _lightBuffers; }
|
||||
CC_INLINE const UintList &getLightIndexOffsets() const { return _lightIndexOffsets; }
|
||||
CC_INLINE const UintList &getLightIndices() const { return _lightIndices; }
|
||||
gfx::InputAssembler * getQuadIAOnScreen() { return _quadIAOnscreen; }
|
||||
gfx::InputAssembler * getQuadIAOffScreen() { return _quadIAOffscreen; }
|
||||
gfx::Rect getRenderArea(Camera *camera, bool onScreen);
|
||||
CC_INLINE DeferredRenderData *getDeferredRenderData() { return _deferredRenderData; };
|
||||
@@ -94,9 +93,7 @@ private:
|
||||
|
||||
// light stage
|
||||
gfx::Buffer * _quadIB = nullptr;
|
||||
gfx::Buffer * _quadVBOnscreen = nullptr;
|
||||
gfx::Buffer * _quadVBOffscreen = nullptr;
|
||||
gfx::InputAssembler *_quadIAOnscreen = nullptr;
|
||||
gfx::InputAssembler *_quadIAOffscreen = nullptr;
|
||||
|
||||
DeferredRenderData *_deferredRenderData = nullptr;
|
||||
|
||||
@@ -24,7 +24,6 @@
|
||||
****************************************************************************/
|
||||
|
||||
#include "GbufferStage.h"
|
||||
#include "GbufferFlow.h"
|
||||
#include "../BatchedBuffer.h"
|
||||
#include "../InstancedBuffer.h"
|
||||
#include "../PlanarShadowQueue.h"
|
||||
@@ -33,6 +32,7 @@
|
||||
#include "../RenderQueue.h"
|
||||
#include "../helper/SharedMemory.h"
|
||||
#include "DeferredPipeline.h"
|
||||
#include "GbufferFlow.h"
|
||||
#include "gfx-base/GFXCommandBuffer.h"
|
||||
#include "gfx-base/GFXDevice.h"
|
||||
#include "gfx-base/GFXFramebuffer.h"
|
||||
@@ -63,7 +63,7 @@ RenderStageInfo GbufferStage::initInfo = {
|
||||
const RenderStageInfo &GbufferStage::getInitializeInfo() { return GbufferStage::initInfo; }
|
||||
|
||||
GbufferStage::GbufferStage() {
|
||||
_batchedQueue = CC_NEW(RenderBatchedQueue);
|
||||
_batchedQueue = CC_NEW(RenderBatchedQueue);
|
||||
_instancedQueue = CC_NEW(RenderInstancedQueue);
|
||||
}
|
||||
|
||||
@@ -72,33 +72,19 @@ GbufferStage::~GbufferStage() = default;
|
||||
bool GbufferStage::initialize(const RenderStageInfo &info) {
|
||||
RenderStage::initialize(info);
|
||||
_renderQueueDescriptors = info.renderQueues;
|
||||
_phaseID = getPhaseID("deferred");
|
||||
_phaseID = getPhaseID("deferred");
|
||||
return true;
|
||||
}
|
||||
|
||||
void GbufferStage::activate(RenderPipeline *pipeline, RenderFlow *flow) {
|
||||
RenderStage::activate(pipeline, flow);
|
||||
|
||||
for (const auto &descriptor : _renderQueueDescriptors) {
|
||||
uint phase = 0;
|
||||
for (const auto &stage : descriptor.stages) {
|
||||
phase |= getPhaseID(stage);
|
||||
}
|
||||
|
||||
std::function<int(const RenderPass &, const RenderPass &)> sortFunc = opaqueCompareFn;
|
||||
switch (descriptor.sortMode) {
|
||||
case RenderQueueSortMode::BACK_TO_FRONT:
|
||||
sortFunc = transparentCompareFn;
|
||||
break;
|
||||
case RenderQueueSortMode::FRONT_TO_BACK:
|
||||
sortFunc = opaqueCompareFn;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
RenderQueueCreateInfo info = {descriptor.isTransparent, phase, sortFunc};
|
||||
uint phase = convertPhase(descriptor.stages);
|
||||
RenderQueueSortFunc sortFunc = convertQueueSortFunc(descriptor.sortMode);
|
||||
RenderQueueCreateInfo info = {descriptor.isTransparent, phase, sortFunc};
|
||||
_renderQueues.emplace_back(CC_NEW(RenderQueue(std::move(info))));
|
||||
}
|
||||
|
||||
_planarShadowQueue = CC_NEW(PlanarShadowQueue(_pipeline));
|
||||
}
|
||||
|
||||
@@ -112,7 +98,7 @@ void GbufferStage::destroy() {
|
||||
void GbufferStage::render(Camera *camera) {
|
||||
_instancedQueue->clear();
|
||||
_batchedQueue->clear();
|
||||
auto *pipeline = static_cast<DeferredPipeline *>(_pipeline);
|
||||
auto * pipeline = static_cast<DeferredPipeline *>(_pipeline);
|
||||
const auto &renderObjects = _pipeline->getPipelineSceneData()->getRenderObjects();
|
||||
if (renderObjects.empty()) {
|
||||
return;
|
||||
@@ -122,13 +108,13 @@ void GbufferStage::render(Camera *camera) {
|
||||
queue->clear();
|
||||
}
|
||||
|
||||
uint m = 0;
|
||||
uint p = 0;
|
||||
uint m = 0;
|
||||
uint p = 0;
|
||||
size_t k = 0;
|
||||
for (auto ro : renderObjects) {
|
||||
const auto *const model = ro.model;
|
||||
const auto *const subModelID = model->getSubModelID();
|
||||
const auto subModelCount = subModelID[0];
|
||||
const auto *const model = ro.model;
|
||||
const auto *const subModelID = model->getSubModelID();
|
||||
const auto subModelCount = subModelID[0];
|
||||
for (m = 1; m <= subModelCount; ++m) {
|
||||
const auto *const subModel = cc::pipeline::ModelView::getSubModelView(subModelID[m]);
|
||||
for (p = 0; p < subModel->passCount; ++p) {
|
||||
@@ -164,8 +150,8 @@ void GbufferStage::render(Camera *camera) {
|
||||
_renderArea = pipeline->getRenderArea(camera, false);
|
||||
pipeline->updateQuadVertexData(_renderArea);
|
||||
auto *const deferredData = pipeline->getDeferredRenderData();
|
||||
auto *framebuffer = deferredData->gbufferFrameBuffer;
|
||||
auto *renderPass = framebuffer->getRenderPass();
|
||||
auto * framebuffer = deferredData->gbufferFrameBuffer;
|
||||
auto * renderPass = framebuffer->getRenderPass();
|
||||
|
||||
cmdBuff->beginRenderPass(renderPass, framebuffer, _renderArea, _clearColors, camera->clearDepth, camera->clearStencil);
|
||||
cmdBuff->bindDescriptorSet(globalSet, _pipeline->getDescriptorSet());
|
||||
|
||||
@@ -24,21 +24,21 @@
|
||||
****************************************************************************/
|
||||
|
||||
#include "LightingStage.h"
|
||||
#include "LightingFlow.h"
|
||||
#include "../BatchedBuffer.h"
|
||||
#include "../InstancedBuffer.h"
|
||||
#include "../PipelineStateManager.h"
|
||||
#include "../PlanarShadowQueue.h"
|
||||
#include "../RenderBatchedQueue.h"
|
||||
#include "../RenderInstancedQueue.h"
|
||||
#include "../RenderQueue.h"
|
||||
#include "../helper/SharedMemory.h"
|
||||
#include "DeferredPipeline.h"
|
||||
#include "LightingFlow.h"
|
||||
#include "gfx-base/GFXCommandBuffer.h"
|
||||
#include "gfx-base/GFXDescriptorSet.h"
|
||||
#include "gfx-base/GFXDevice.h"
|
||||
#include "gfx-base/GFXFramebuffer.h"
|
||||
#include "gfx-base/GFXQueue.h"
|
||||
#include "gfx-base/GFXDescriptorSet.h"
|
||||
#include "../PipelineStateManager.h"
|
||||
|
||||
namespace cc {
|
||||
namespace pipeline {
|
||||
@@ -64,7 +64,7 @@ RenderStageInfo LightingStage::initInfo = {
|
||||
|
||||
const RenderStageInfo &LightingStage::getInitializeInfo() { return LightingStage::initInfo; }
|
||||
|
||||
LightingStage::LightingStage() = default;
|
||||
LightingStage::LightingStage() = default;
|
||||
|
||||
LightingStage::~LightingStage() {
|
||||
_deferredLitsBufs->destroy();
|
||||
@@ -76,7 +76,8 @@ LightingStage::~LightingStage() {
|
||||
bool LightingStage::initialize(const RenderStageInfo &info) {
|
||||
RenderStage::initialize(info);
|
||||
_renderQueueDescriptors = info.renderQueues;
|
||||
_phaseID = getPhaseID("default");
|
||||
_phaseID = getPhaseID("default");
|
||||
_defPhaseID = getPhaseID("deferred");
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -86,34 +87,34 @@ void LightingStage::gatherLights(Camera *camera) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto *const sceneData = _pipeline->getPipelineSceneData();
|
||||
auto *const sceneData = _pipeline->getPipelineSceneData();
|
||||
auto *const sharedData = sceneData->getSharedData();
|
||||
|
||||
gfx::CommandBuffer *cmdBuf = pipeline->getCommandBuffers()[0];
|
||||
const auto *scene = camera->getScene();
|
||||
const auto *const sphereLightArrayID = scene->getSphereLightArrayID();
|
||||
auto sphereCount = sphereLightArrayID ? sphereLightArrayID[0] : 0;
|
||||
const auto *const spotLightArrayID = scene->getSpotLightArrayID();
|
||||
auto spotCount = spotLightArrayID ? spotLightArrayID[0] : 0;
|
||||
gfx::CommandBuffer *cmdBuf = pipeline->getCommandBuffers()[0];
|
||||
const auto * scene = camera->getScene();
|
||||
const auto *const sphereLightArrayID = scene->getSphereLightArrayID();
|
||||
auto sphereCount = sphereLightArrayID ? sphereLightArrayID[0] : 0;
|
||||
const auto *const spotLightArrayID = scene->getSpotLightArrayID();
|
||||
auto spotCount = spotLightArrayID ? spotLightArrayID[0] : 0;
|
||||
|
||||
Sphere sphere;
|
||||
auto exposure = camera->exposure;
|
||||
uint idx = 0;
|
||||
int elementLen = sizeof(cc::Vec4) / sizeof(float);
|
||||
uint fieldLen = elementLen * _maxDeferredLights;
|
||||
uint offset = 0;
|
||||
Sphere sphere;
|
||||
auto exposure = camera->exposure;
|
||||
uint idx = 0;
|
||||
int elementLen = sizeof(cc::Vec4) / sizeof(float);
|
||||
uint fieldLen = elementLen * _maxDeferredLights;
|
||||
uint offset = 0;
|
||||
cc::Vec4 tmpArray;
|
||||
|
||||
for (uint i = 1; i <= sphereCount && idx < _maxDeferredLights; i++, idx++) {
|
||||
const auto *const light = scene->getSphereLight(sphereLightArrayID[i]);
|
||||
const auto *const light = cc::pipeline::Scene::getSphereLight(sphereLightArrayID[i]);
|
||||
sphere.setCenter(light->position);
|
||||
sphere.setRadius(light->range);
|
||||
if (!sphere_frustum(&sphere, camera->getFrustum())) {
|
||||
continue;
|
||||
}
|
||||
// position
|
||||
offset = idx * elementLen;
|
||||
_lightBufferData[offset] = light->position.x;
|
||||
offset = idx * elementLen;
|
||||
_lightBufferData[offset] = light->position.x;
|
||||
_lightBufferData[offset + 1] = light->position.y;
|
||||
_lightBufferData[offset + 2] = light->position.z;
|
||||
_lightBufferData[offset + 3] = 0;
|
||||
@@ -139,22 +140,22 @@ void LightingStage::gatherLights(Camera *camera) {
|
||||
_lightBufferData[offset + 3] = tmpArray.w;
|
||||
|
||||
// size range angle
|
||||
offset = idx * elementLen + fieldLen * 2;
|
||||
_lightBufferData[offset] = light->size;
|
||||
offset = idx * elementLen + fieldLen * 2;
|
||||
_lightBufferData[offset] = light->size;
|
||||
_lightBufferData[offset + 1] = light->range;
|
||||
_lightBufferData[offset + 2] = 0;
|
||||
}
|
||||
|
||||
for (uint i = 1; i <= spotCount && idx < _maxDeferredLights; i++, idx++) {
|
||||
const auto *const light = scene->getSpotLight(spotLightArrayID[i]);
|
||||
const auto *const light = cc::pipeline::Scene::getSpotLight(spotLightArrayID[i]);
|
||||
sphere.setCenter(light->position);
|
||||
sphere.setRadius(light->range);
|
||||
if (!sphere_frustum(&sphere, camera->getFrustum())) {
|
||||
continue;
|
||||
}
|
||||
// position
|
||||
offset = idx * elementLen;
|
||||
_lightBufferData[offset] = light->position.x;
|
||||
offset = idx * elementLen;
|
||||
_lightBufferData[offset] = light->position.x;
|
||||
_lightBufferData[offset + 1] = light->position.y;
|
||||
_lightBufferData[offset + 2] = light->position.z;
|
||||
_lightBufferData[offset + 3] = 1;
|
||||
@@ -180,14 +181,14 @@ void LightingStage::gatherLights(Camera *camera) {
|
||||
_lightBufferData[offset + 3] = tmpArray.w;
|
||||
|
||||
// size range angle
|
||||
offset = idx * elementLen + fieldLen * 2;
|
||||
_lightBufferData[offset] = light->size;
|
||||
offset = idx * elementLen + fieldLen * 2;
|
||||
_lightBufferData[offset] = light->size;
|
||||
_lightBufferData[offset + 1] = light->range;
|
||||
_lightBufferData[offset + 2] = light->spotAngle;
|
||||
|
||||
// dir
|
||||
offset = idx * elementLen + fieldLen * 3;
|
||||
_lightBufferData[offset] = light->direction.x;
|
||||
offset = idx * elementLen + fieldLen * 3;
|
||||
_lightBufferData[offset] = light->direction.x;
|
||||
_lightBufferData[offset + 1] = light->direction.y;
|
||||
_lightBufferData[offset + 2] = light->direction.z;
|
||||
}
|
||||
@@ -218,7 +219,7 @@ void LightingStage::initLightingBuffer() {
|
||||
|
||||
if (_deferredLitsBufView == nullptr) {
|
||||
gfx::BufferViewInfo bvInfo = {_deferredLitsBufs, 0, totalSize};
|
||||
_deferredLitsBufView = device->createBuffer(bvInfo);
|
||||
_deferredLitsBufView = device->createBuffer(bvInfo);
|
||||
assert(_deferredLitsBufView != nullptr);
|
||||
_descriptorSet->bindBuffer(static_cast<uint>(ModelLocalBindings::UBO_FORWARD_LIGHTS), _deferredLitsBufView);
|
||||
}
|
||||
@@ -231,12 +232,19 @@ void LightingStage::activate(RenderPipeline *pipeline, RenderFlow *flow) {
|
||||
|
||||
auto *const device = pipeline->getDevice();
|
||||
|
||||
for (const auto &descriptor : _renderQueueDescriptors) {
|
||||
uint phase = convertPhase(descriptor.stages);
|
||||
RenderQueueSortFunc sortFunc = convertQueueSortFunc(descriptor.sortMode);
|
||||
RenderQueueCreateInfo info = {descriptor.isTransparent, phase, sortFunc};
|
||||
_renderQueues.emplace_back(CC_NEW(RenderQueue(std::move(info))));
|
||||
}
|
||||
|
||||
// create descriptorset/layout
|
||||
gfx::DescriptorSetLayoutInfo layoutInfo = {localDescriptorSetLayout.bindings};
|
||||
_descLayout = device->createDescriptorSetLayout(layoutInfo);
|
||||
_descLayout = device->createDescriptorSetLayout(layoutInfo);
|
||||
|
||||
gfx::DescriptorSetInfo setInfo = {_descLayout};
|
||||
_descriptorSet = device->createDescriptorSet(setInfo);
|
||||
_descriptorSet = device->createDescriptorSet(setInfo);
|
||||
|
||||
// create lighting buffer and view
|
||||
initLightingBuffer();
|
||||
@@ -250,9 +258,9 @@ void LightingStage::destroy() {
|
||||
}
|
||||
|
||||
void LightingStage::render(Camera *camera) {
|
||||
auto *pipeline = static_cast<DeferredPipeline *>(_pipeline);
|
||||
auto *const sceneData = _pipeline->getPipelineSceneData();
|
||||
auto *const sharedData = sceneData->getSharedData();
|
||||
auto * pipeline = static_cast<DeferredPipeline *>(_pipeline);
|
||||
auto *const sceneData = _pipeline->getPipelineSceneData();
|
||||
auto *const sharedData = sceneData->getSharedData();
|
||||
const auto &renderObjects = sceneData->getRenderObjects();
|
||||
|
||||
if (renderObjects.empty()) {
|
||||
@@ -272,7 +280,7 @@ void LightingStage::render(Camera *camera) {
|
||||
gfx::Rect renderArea = pipeline->getRenderArea(camera, false);
|
||||
|
||||
gfx::Color clearColor = {0.0, 0.0, 0.0, 1.0};
|
||||
if (camera->clearFlag & static_cast<uint>( gfx::ClearFlagBit::COLOR)) {
|
||||
if (camera->clearFlag & static_cast<uint>(gfx::ClearFlagBit::COLOR)) {
|
||||
if (sharedData->isHDR) {
|
||||
srgbToLinear(&clearColor, camera->clearColor);
|
||||
const auto scale = sharedData->fpScale / camera->exposure;
|
||||
@@ -285,22 +293,22 @@ void LightingStage::render(Camera *camera) {
|
||||
}
|
||||
|
||||
clearColor.w = 0;
|
||||
|
||||
|
||||
auto *const deferredData = pipeline->getDeferredRenderData();
|
||||
auto *frameBuffer = deferredData->lightingFrameBuff;
|
||||
auto *renderPass = frameBuffer->getRenderPass();
|
||||
auto * frameBuffer = deferredData->lightingFrameBuff;
|
||||
auto * renderPass = frameBuffer->getRenderPass();
|
||||
|
||||
cmdBuff->beginRenderPass(renderPass, frameBuffer, renderArea, &clearColor,
|
||||
camera->clearDepth, camera->clearStencil);
|
||||
camera->clearDepth, camera->clearStencil);
|
||||
|
||||
cmdBuff->bindDescriptorSet(static_cast<uint>(SetIndex::GLOBAL), pipeline->getDescriptorSet());
|
||||
|
||||
// get pso and draw quad
|
||||
PassView *pass = sceneData->getSharedData()->getDeferredLightPass();
|
||||
PassView * pass = sceneData->getSharedData()->getDeferredLightPass();
|
||||
gfx::Shader *shader = sceneData->getSharedData()->getDeferredLightPassShader();
|
||||
|
||||
gfx::InputAssembler* inputAssembler = pipeline->getQuadIAOffScreen();
|
||||
gfx::PipelineState *pState = PipelineStateManager::getOrCreatePipelineState(
|
||||
gfx::InputAssembler *inputAssembler = pipeline->getQuadIAOffScreen();
|
||||
gfx::PipelineState * pState = PipelineStateManager::getOrCreatePipelineState(
|
||||
pass, shader, inputAssembler, renderPass);
|
||||
assert(pState != nullptr);
|
||||
|
||||
@@ -308,6 +316,36 @@ void LightingStage::render(Camera *camera) {
|
||||
cmdBuff->bindInputAssembler(inputAssembler);
|
||||
cmdBuff->draw(inputAssembler);
|
||||
|
||||
// transparent
|
||||
for (auto *queue : _renderQueues) {
|
||||
queue->clear();
|
||||
}
|
||||
|
||||
uint m = 0;
|
||||
uint p = 0;
|
||||
size_t k = 0;
|
||||
for (auto ro : renderObjects) {
|
||||
const auto *const model = ro.model;
|
||||
const auto *const subModelID = model->getSubModelID();
|
||||
const auto subModelCount = subModelID[0];
|
||||
for (m = 1; m <= subModelCount; ++m) {
|
||||
const auto *subModel = cc::pipeline::ModelView::getSubModelView(subModelID[m]);
|
||||
for (p = 0; p < subModel->passCount; ++p) {
|
||||
const PassView *pass = subModel->getPassView(p);
|
||||
// TODO(xwx): need fallback of unlit and gizmo material.
|
||||
if (pass->phase != _phaseID && pass->phase != _defPhaseID) continue;
|
||||
for (k = 0; k < _renderQueues.size(); k++) {
|
||||
_renderQueues[k]->insertRenderPass(ro, m, p);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (auto *queue : _renderQueues) {
|
||||
queue->sort();
|
||||
queue->recordCommandBuffer(_device, renderPass, cmdBuff);
|
||||
}
|
||||
|
||||
// planerQueue
|
||||
_planarShadowQueue->recordCommandBuffer(_device, renderPass, cmdBuff);
|
||||
|
||||
|
||||
@@ -54,21 +54,22 @@ public:
|
||||
|
||||
private:
|
||||
void gatherLights(Camera *camera);
|
||||
|
||||
static RenderStageInfo initInfo;
|
||||
PlanarShadowQueue *_planarShadowQueue = nullptr;
|
||||
gfx::Rect _renderArea;
|
||||
uint _phaseID = 0;
|
||||
|
||||
gfx::Buffer *_deferredLitsBufs = nullptr;
|
||||
gfx::Buffer *_deferredLitsBufView = nullptr;
|
||||
std::vector<float> _lightBufferData;
|
||||
uint _lightBufferStride = 0;
|
||||
uint _lightBufferElementCount = 0;
|
||||
float _lightMeterScale = 10000.0;
|
||||
gfx::DescriptorSet *_descriptorSet = nullptr;
|
||||
gfx::DescriptorSetLayout *_descLayout = nullptr;
|
||||
uint _maxDeferredLights = UBODeferredLight::LIGHTS_PER_PASS;
|
||||
static RenderStageInfo initInfo;
|
||||
PlanarShadowQueue * _planarShadowQueue = nullptr;
|
||||
gfx::Rect _renderArea;
|
||||
uint _phaseID = 0;
|
||||
uint _defPhaseID = 0;
|
||||
|
||||
gfx::Buffer * _deferredLitsBufs = nullptr;
|
||||
gfx::Buffer * _deferredLitsBufView = nullptr;
|
||||
std::vector<float> _lightBufferData;
|
||||
uint _lightBufferStride = 0;
|
||||
uint _lightBufferElementCount = 0;
|
||||
float _lightMeterScale = 10000.0;
|
||||
gfx::DescriptorSet * _descriptorSet = nullptr;
|
||||
gfx::DescriptorSetLayout *_descLayout = nullptr;
|
||||
uint _maxDeferredLights = UBODeferredLight::LIGHTS_PER_PASS;
|
||||
};
|
||||
|
||||
} // namespace pipeline
|
||||
|
||||
@@ -24,14 +24,14 @@
|
||||
****************************************************************************/
|
||||
|
||||
#include "PostprocessStage.h"
|
||||
#include "DeferredPipeline.h"
|
||||
#include "gfx-base/GFXFramebuffer.h"
|
||||
#include "gfx-base/GFXCommandBuffer.h"
|
||||
#include "../helper/SharedMemory.h"
|
||||
#include "../PipelineStateManager.h"
|
||||
#include "gfx-base/GFXDevice.h"
|
||||
#include "../forward/UIPhase.h"
|
||||
#include "../RenderQueue.h"
|
||||
#include "../forward/UIPhase.h"
|
||||
#include "../helper/SharedMemory.h"
|
||||
#include "DeferredPipeline.h"
|
||||
#include "gfx-base/GFXCommandBuffer.h"
|
||||
#include "gfx-base/GFXDevice.h"
|
||||
#include "gfx-base/GFXFramebuffer.h"
|
||||
|
||||
namespace cc {
|
||||
namespace pipeline {
|
||||
@@ -42,7 +42,7 @@ RenderStageInfo PostprocessStage::initInfo = {
|
||||
{{true, RenderQueueSortMode::BACK_TO_FRONT, {"default"}}},
|
||||
};
|
||||
|
||||
PostprocessStage::PostprocessStage() {
|
||||
PostprocessStage::PostprocessStage() {
|
||||
_uiPhase = CC_NEW(UIPhase);
|
||||
}
|
||||
|
||||
@@ -85,8 +85,8 @@ void PostprocessStage::destroy() {
|
||||
void PostprocessStage::render(Camera *camera) {
|
||||
auto *pp = dynamic_cast<DeferredPipeline *>(_pipeline);
|
||||
assert(pp != nullptr);
|
||||
gfx::Device *device = pp->getDevice();
|
||||
gfx::CommandBuffer *cmdBf = pp->getCommandBuffers()[0];
|
||||
gfx::Device * device = pp->getDevice();
|
||||
gfx::CommandBuffer *cmdBf = pp->getCommandBuffers()[0];
|
||||
|
||||
_pipeline->getPipelineUBO()->updateCameraUBO(camera);
|
||||
gfx::Rect renderArea = pp->getRenderArea(camera, !camera->getWindow()->hasOffScreenAttachments);
|
||||
@@ -99,23 +99,22 @@ void PostprocessStage::render(Camera *camera) {
|
||||
|
||||
_clearColors[0].w = camera->clearColor.w;
|
||||
|
||||
gfx::Framebuffer *fb = camera->getWindow()->getFramebuffer();
|
||||
const auto &colorTextures = fb->getColorTextures();
|
||||
gfx::RenderPass *rp = !colorTextures.empty() && colorTextures[0] ?
|
||||
fb->getRenderPass() : pp->getOrCreateRenderPass(static_cast<gfx::ClearFlags>(camera->clearFlag));
|
||||
gfx::Framebuffer *fb = camera->getWindow()->getFramebuffer();
|
||||
const auto & colorTextures = fb->getColorTextures();
|
||||
gfx::RenderPass * rp = !colorTextures.empty() && colorTextures[0] ? fb->getRenderPass() : pp->getOrCreateRenderPass(static_cast<gfx::ClearFlags>(camera->clearFlag));
|
||||
|
||||
cmdBf->beginRenderPass(rp, fb, renderArea, _clearColors, camera->clearDepth, camera->clearStencil);
|
||||
cmdBf->bindDescriptorSet(static_cast<uint>(SetIndex::GLOBAL), pp->getDescriptorSet());
|
||||
|
||||
// post proces
|
||||
auto *const sceneData = _pipeline->getPipelineSceneData();
|
||||
PassView *pv = sceneData->getSharedData()->getDeferredPostPass();
|
||||
gfx::Shader *sd = sceneData->getSharedData()->getDeferredPostPassShader();
|
||||
const auto &renderObjects = sceneData->getRenderObjects();
|
||||
auto *const sceneData = _pipeline->getPipelineSceneData();
|
||||
PassView * pv = sceneData->getSharedData()->getDeferredPostPass();
|
||||
gfx::Shader *sd = sceneData->getSharedData()->getDeferredPostPassShader();
|
||||
const auto & renderObjects = sceneData->getRenderObjects();
|
||||
|
||||
if (!renderObjects.empty()) {
|
||||
gfx::InputAssembler *ia = camera->getWindow()->hasOffScreenAttachments ? pp->getQuadIAOffScreen() : pp->getQuadIAOnScreen();
|
||||
gfx::PipelineState *pso = PipelineStateManager::getOrCreatePipelineState(pv, sd, ia, rp);
|
||||
gfx::InputAssembler *ia = pp->getQuadIAOffScreen();
|
||||
gfx::PipelineState * pso = PipelineStateManager::getOrCreatePipelineState(pv, sd, ia, rp);
|
||||
assert(pso != nullptr);
|
||||
|
||||
cmdBf->bindPipelineState(pso);
|
||||
@@ -123,36 +122,6 @@ void PostprocessStage::render(Camera *camera) {
|
||||
cmdBf->draw(ia);
|
||||
}
|
||||
|
||||
// transparent
|
||||
for (auto *queue : _renderQueues) {
|
||||
queue->clear();
|
||||
}
|
||||
|
||||
uint m = 0;
|
||||
uint p = 0;
|
||||
size_t k = 0;
|
||||
for (auto ro : renderObjects) {
|
||||
const auto *const model = ro.model;
|
||||
const auto *const subModelID = model->getSubModelID();
|
||||
const auto subModelCount = subModelID[0];
|
||||
for (m = 1; m <= subModelCount; ++m) {
|
||||
const auto *subModel = cc::pipeline::ModelView::getSubModelView(subModelID[m]);
|
||||
for (p = 0; p < subModel->passCount; ++p) {
|
||||
const PassView *pass = subModel->getPassView(p);
|
||||
// TODO(xwx): need fallback of ulit and gizmo material.
|
||||
if (pass->phase != _phaseID) continue;
|
||||
for (k = 0; k < _renderQueues.size(); k++) {
|
||||
_renderQueues[k]->insertRenderPass(ro, m, p);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (auto *queue : _renderQueues) {
|
||||
queue->sort();
|
||||
queue->recordCommandBuffer(_device, rp, cmdBf);
|
||||
}
|
||||
|
||||
_uiPhase->render(camera, rp);
|
||||
cmdBf->endRenderPass();
|
||||
}
|
||||
|
||||
@@ -33,11 +33,11 @@
|
||||
#include "../RenderQueue.h"
|
||||
#include "../helper/SharedMemory.h"
|
||||
#include "ForwardPipeline.h"
|
||||
#include "UIPhase.h"
|
||||
#include "gfx-base/GFXCommandBuffer.h"
|
||||
#include "gfx-base/GFXDevice.h"
|
||||
#include "gfx-base/GFXFramebuffer.h"
|
||||
#include "gfx-base/GFXQueue.h"
|
||||
#include "UIPhase.h"
|
||||
|
||||
namespace cc {
|
||||
namespace pipeline {
|
||||
@@ -63,10 +63,10 @@ RenderStageInfo ForwardStage::initInfo = {
|
||||
{true, RenderQueueSortMode::BACK_TO_FRONT, {"default", "planarShadow"}}}};
|
||||
const RenderStageInfo &ForwardStage::getInitializeInfo() { return ForwardStage::initInfo; }
|
||||
|
||||
ForwardStage::ForwardStage() {
|
||||
_batchedQueue = CC_NEW(RenderBatchedQueue);
|
||||
ForwardStage::ForwardStage() {
|
||||
_batchedQueue = CC_NEW(RenderBatchedQueue);
|
||||
_instancedQueue = CC_NEW(RenderInstancedQueue);
|
||||
_uiPhase = CC_NEW(UIPhase);
|
||||
_uiPhase = CC_NEW(UIPhase);
|
||||
}
|
||||
|
||||
ForwardStage::~ForwardStage() = default;
|
||||
@@ -74,36 +74,22 @@ ForwardStage::~ForwardStage() = default;
|
||||
bool ForwardStage::initialize(const RenderStageInfo &info) {
|
||||
RenderStage::initialize(info);
|
||||
_renderQueueDescriptors = info.renderQueues;
|
||||
_phaseID = getPhaseID("default");
|
||||
_phaseID = getPhaseID("default");
|
||||
return true;
|
||||
}
|
||||
|
||||
void ForwardStage::activate(RenderPipeline *pipeline, RenderFlow *flow) {
|
||||
RenderStage::activate(pipeline, flow);
|
||||
|
||||
for (const auto &descriptor : _renderQueueDescriptors) {
|
||||
uint phase = 0;
|
||||
for (const auto &stage : descriptor.stages) {
|
||||
phase |= getPhaseID(stage);
|
||||
}
|
||||
|
||||
std::function<int(const RenderPass &, const RenderPass &)> sortFunc = opaqueCompareFn;
|
||||
switch (descriptor.sortMode) {
|
||||
case RenderQueueSortMode::BACK_TO_FRONT:
|
||||
sortFunc = transparentCompareFn;
|
||||
break;
|
||||
case RenderQueueSortMode::FRONT_TO_BACK:
|
||||
sortFunc = opaqueCompareFn;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
RenderQueueCreateInfo info = {descriptor.isTransparent, phase, sortFunc};
|
||||
uint phase = convertPhase(descriptor.stages);
|
||||
RenderQueueSortFunc sortFunc = convertQueueSortFunc(descriptor.sortMode);
|
||||
RenderQueueCreateInfo info = {descriptor.isTransparent, phase, sortFunc};
|
||||
_renderQueues.emplace_back(CC_NEW(RenderQueue(std::move(info))));
|
||||
}
|
||||
|
||||
_additiveLightQueue = CC_NEW(RenderAdditiveLightQueue(_pipeline));
|
||||
_planarShadowQueue = CC_NEW(PlanarShadowQueue(_pipeline));
|
||||
_planarShadowQueue = CC_NEW(PlanarShadowQueue(_pipeline));
|
||||
_uiPhase->activate(pipeline);
|
||||
}
|
||||
|
||||
@@ -119,22 +105,22 @@ void ForwardStage::destroy() {
|
||||
void ForwardStage::render(Camera *camera) {
|
||||
_instancedQueue->clear();
|
||||
_batchedQueue->clear();
|
||||
auto *pipeline = static_cast<ForwardPipeline *>(_pipeline);
|
||||
auto *const sceneData = _pipeline->getPipelineSceneData();
|
||||
auto *const sharedData = sceneData->getSharedData();
|
||||
auto * pipeline = static_cast<ForwardPipeline *>(_pipeline);
|
||||
auto *const sceneData = _pipeline->getPipelineSceneData();
|
||||
auto *const sharedData = sceneData->getSharedData();
|
||||
const auto &renderObjects = sceneData->getRenderObjects();
|
||||
|
||||
for (auto *queue : _renderQueues) {
|
||||
queue->clear();
|
||||
}
|
||||
|
||||
uint m = 0;
|
||||
uint p = 0;
|
||||
uint m = 0;
|
||||
uint p = 0;
|
||||
size_t k = 0;
|
||||
for (auto ro : renderObjects) {
|
||||
const auto *const model = ro.model;
|
||||
const auto *const subModelID = model->getSubModelID();
|
||||
const auto subModelCount = subModelID[0];
|
||||
const auto *const model = ro.model;
|
||||
const auto *const subModelID = model->getSubModelID();
|
||||
const auto subModelCount = subModelID[0];
|
||||
for (m = 1; m <= subModelCount; ++m) {
|
||||
const auto *subModel = cc::pipeline::ModelView::getSubModelView(subModelID[m]);
|
||||
for (p = 0; p < subModel->passCount; ++p) {
|
||||
@@ -169,11 +155,11 @@ void ForwardStage::render(Camera *camera) {
|
||||
_planarShadowQueue->gatherShadowPasses(camera, cmdBuff);
|
||||
|
||||
// render area is not oriented
|
||||
uint w = camera->getWindow()->hasOnScreenAttachments && static_cast<uint>(_device->getSurfaceTransform()) % 2 ? camera->height : camera->width;
|
||||
uint h = camera->getWindow()->hasOnScreenAttachments && static_cast<uint>(_device->getSurfaceTransform()) % 2 ? camera->width : camera->height;
|
||||
_renderArea.x = static_cast<int>(camera->viewportX * w);
|
||||
_renderArea.y = static_cast<int>(camera->viewportY * h);
|
||||
_renderArea.width = static_cast<uint>(camera->viewportWidth * w * sharedData->shadingScale);
|
||||
uint w = camera->getWindow()->hasOnScreenAttachments && static_cast<uint>(_device->getSurfaceTransform()) % 2 ? camera->height : camera->width;
|
||||
uint h = camera->getWindow()->hasOnScreenAttachments && static_cast<uint>(_device->getSurfaceTransform()) % 2 ? camera->width : camera->height;
|
||||
_renderArea.x = static_cast<int>(camera->viewportX * w);
|
||||
_renderArea.y = static_cast<int>(camera->viewportY * h);
|
||||
_renderArea.width = static_cast<uint>(camera->viewportWidth * w * sharedData->shadingScale);
|
||||
_renderArea.height = static_cast<uint>(camera->viewportHeight * h * sharedData->shadingScale);
|
||||
|
||||
if (hasFlag(static_cast<gfx::ClearFlags>(camera->clearFlag), gfx::ClearFlagBit::COLOR)) {
|
||||
@@ -192,7 +178,7 @@ void ForwardStage::render(Camera *camera) {
|
||||
|
||||
_clearColors[0].w = camera->clearColor.w;
|
||||
|
||||
auto *framebuffer = camera->getWindow()->getFramebuffer();
|
||||
auto * framebuffer = camera->getWindow()->getFramebuffer();
|
||||
const auto &colorTextures = framebuffer->getColorTextures();
|
||||
|
||||
auto *renderPass = !colorTextures.empty() && colorTextures[0] ? framebuffer->getRenderPass() : pipeline->getOrCreateRenderPass(static_cast<gfx::ClearFlagBit>(camera->clearFlag));
|
||||
|
||||
@@ -117,7 +117,7 @@ void ShadowFlow::resizeShadowMap(const Light *light, const Shadows *shadowInfo){
|
||||
auto * device = gfx::Device::getInstance();
|
||||
const auto width = static_cast<uint>(shadowInfo->size.x);
|
||||
const auto height = static_cast<uint>(shadowInfo->size.y);
|
||||
const auto format = device->hasFeature(gfx::Feature::TEXTURE_HALF_FLOAT)
|
||||
const auto format = supportsHalfFloatTexture(device)
|
||||
? (shadowInfo->packing ? gfx::Format::RGBA8 : gfx::Format::RGBA16F)
|
||||
: gfx::Format::RGBA8;
|
||||
|
||||
@@ -172,7 +172,7 @@ void ShadowFlow::initShadowFrameBuffer(RenderPipeline *pipeline, const Light *li
|
||||
const auto shadowMapSize = shadowInfo->size;
|
||||
const auto width = static_cast<uint>(shadowMapSize.x);
|
||||
const auto height = static_cast<uint>(shadowMapSize.y);
|
||||
const auto format = device->hasFeature(gfx::Feature::TEXTURE_HALF_FLOAT)
|
||||
const auto format = supportsHalfFloatTexture(device)
|
||||
? (shadowInfo->packing ? gfx::Format::RGBA8 : gfx::Format::RGBA16F)
|
||||
: gfx::Format::RGBA8;
|
||||
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
"common": [
|
||||
".browserslistrc",
|
||||
".clang-format",
|
||||
".clang-format-ignore",
|
||||
".clang-tidy",
|
||||
".github/workflows/clang-format.yml",
|
||||
".github/workflows/clangtidy-android.yml",
|
||||
|
||||
@@ -31,7 +31,7 @@
|
||||
#include "cocos/bindings/manual/jsb_module_register.h"
|
||||
|
||||
#if (CC_PLATFORM == CC_PLATFORM_MAC_IOS)
|
||||
#include "platform/device.h"
|
||||
#include "platform/Device.h"
|
||||
#endif
|
||||
|
||||
Game::Game(int width, int height) : cc::Application(width, height) {}
|
||||
|
||||
@@ -49,7 +49,7 @@ skip = ForwardPipeline::[getOrCreateRenderPass getLightsUBO getValidLights getLi
|
||||
ShadowFlow::[initialize activate destroy render],
|
||||
ShadowStage::[initialize activate destroy render clearFramebuffer],
|
||||
InstancedBuffer::[merge uploadBuffers clear getInstances getPass hasPendingModels dynamicOffsets],
|
||||
DeferredPipeline::[getOrCreateRenderPass getLightsUBO getValidLights getLightBuffers getLightIndexOffsets getLightIndices getQuadIAOnScreen getQuadIAOffScreen setDepth getDepth getRenderArea createQuadInputAssembler destroyQuadInputAssembler getDeferredRenderData updateQuadVertexData genQuadVertexData],
|
||||
DeferredPipeline::[getOrCreateRenderPass getLightsUBO getValidLights getLightBuffers getLightIndexOffsets getLightIndices getQuadIAOffScreen setDepth getDepth getRenderArea createQuadInputAssembler destroyQuadInputAssembler getDeferredRenderData updateQuadVertexData genQuadVertexData],
|
||||
GbufferFlow::[initialize activate destroy render getFrameBuffer createRenderPass createRenderTargets],
|
||||
GbufferStage::[initialize activate destroy render],
|
||||
LightingFlow::[initialize activate destroy render createRenderPass createFrameBuffer getLightingFrameBuffer],
|
||||
|
||||
@@ -84,7 +84,9 @@ function build_android()
|
||||
sed -i "s@^APPLICATION_ID.*@APPLICATION_ID=com.cocos.android@g" gradle.properties
|
||||
sed -i "s@^RES_PATH.*@RES_PATH=$ASSET_DIR@g" gradle.properties
|
||||
sed -i "s@^COCOS_ENGINE_PATH.*@COCOS_ENGINE_PATH=$COCOS2DX_ROOT@g" gradle.properties
|
||||
sed -i "s@^PROP_APP_ABI.*@PROP_APP_ABI=armeabi-v7a:arm64-v8a:x86@g" gradle.properties
|
||||
# To speedup CI, compile arm64-v8a only
|
||||
# sed -i "s@^PROP_APP_ABI.*@PROP_APP_ABI=armeabi-v7a:arm64-v8a:x86@g" gradle.properties
|
||||
sed -i "s@^PROP_APP_ABI.*@PROP_APP_ABI=arm64-v8a@g" gradle.properties
|
||||
|
||||
#echo "Compile Android - ndk-build ..."
|
||||
#./gradlew assembleDebug --quiet
|
||||
@@ -191,10 +193,10 @@ function build_windows()
|
||||
cd build-win32
|
||||
RES_DIR=$COCOS2DX_ROOT/templates/win32/build-win32
|
||||
cmake ../ -G"Visual Studio 15 2017" -DRES_DIR=$RES_DIR -DCOCOS_X_PATH=$COCOS2DX_ROOT
|
||||
cmake --build . --config Debug
|
||||
echo "Compile Win32 Debug Done!"
|
||||
# cmake --build . --config Debug
|
||||
# echo "Compile Win32 Debug Done!"
|
||||
cmake --build . --config Release
|
||||
echo "Compile Win32 Debug Done!"
|
||||
echo "Compile Win32 Release Done!"
|
||||
}
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user