Skip to content

Commit e23c674

Browse files
AnastaZIukCrisspl
AnastaZIuk
authored and
Crisspl
committed
Add hash class for finding std::pair accessor, clean code & adjust to comments, make some enums
1 parent 9994fda commit e23c674

File tree

2 files changed

+110
-48
lines changed

2 files changed

+110
-48
lines changed

‎include/nbl/asset/filters/CNormalMapToDerivativeFilter.h

Lines changed: 28 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -19,11 +19,11 @@ namespace nbl
1919
namespace asset
2020
{
2121

22-
template<typename Swizzle>
23-
class CNormalMapToDerivativeFilterBase : public impl::CSwizzleableAndDitherableFilterBase<false, false, Swizzle, IdentityDither>
22+
template<typename Swizzle, typename Dither>
23+
class CNormalMapToDerivativeFilterBase : public impl::CSwizzleableAndDitherableFilterBase<false, false, Swizzle, Dither>
2424
{
2525
public:
26-
class CNormalMapToDerivativeStateBase : public impl::CSwizzleableAndDitherableFilterBase<false, false, Swizzle, IdentityDither>::state_type
26+
class CNormalMapToDerivativeStateBase : public impl::CSwizzleableAndDitherableFilterBase<false, false, Swizzle, Dither>::state_type
2727
{
2828
public:
2929

@@ -50,19 +50,13 @@ class CNormalMapToDerivativeFilterBase : public impl::CSwizzleableAndDitherableF
5050
Layer ID is relative to outBaseLayer in state
5151
*/
5252

53-
enum E_SCALE_FACTOR
54-
{
55-
ESF_X,
56-
ESF_Y,
57-
ESF_COUNT
58-
};
59-
60-
const float getAbsoluteLayerScaleValue(size_t layer, E_SCALE_FACTOR scaleFactor)
53+
const core::vectorSIMDf getAbsoluteLayerScaleValues(size_t layer)
6154
{
6255
if (!scaleValuesPointer)
6356
{
64-
auto offset = layer * forcedScratchChannelAmount + scaleFactor == ESF_X ? 0 : 1;
65-
return *(scaleValuesPointer + offset);
57+
auto offset = layer * forcedScratchChannelAmount;
58+
auto* data = scaleValuesPointer + offset;
59+
return core::vectorSIMDf (*data, *(data + 1));
6660
}
6761
else
6862
return 0; // or maybe assert?
@@ -90,7 +84,7 @@ class CNormalMapToDerivativeFilterBase : public impl::CSwizzleableAndDitherableF
9084
if (state->scratchMemoryByteSize == 0)
9185
return false;
9286

93-
if (!impl::CSwizzleableAndDitherableFilterBase<false, false, Swizzle, IdentityDither>::validate(state))
87+
if (!impl::CSwizzleableAndDitherableFilterBase<false, false, Swizzle, Dither>::validate(state))
9488
return false;
9589

9690
return true;
@@ -102,13 +96,13 @@ class CNormalMapToDerivativeFilterBase : public impl::CSwizzleableAndDitherableF
10296
10397
*/
10498

105-
template<typename Swizzle = DefaultSwizzle>
106-
class CNormalMapToDerivativeFilter : public CMatchedSizeInOutImageFilterCommon, public CNormalMapToDerivativeFilterBase<Swizzle>
99+
template<typename Swizzle = DefaultSwizzle, typename Dither = IdentityDither>
100+
class CNormalMapToDerivativeFilter : public CMatchedSizeInOutImageFilterCommon, public CNormalMapToDerivativeFilterBase<Swizzle, Dither>
107101
{
108102
public:
109103
virtual ~CNormalMapToDerivativeFilter() {}
110104

111-
class CStateBase : public CMatchedSizeInOutImageFilterCommon::state_type, public CNormalMapToDerivativeFilterBase<Swizzle>::CNormalMapToDerivativeStateBase
105+
class CStateBase : public CMatchedSizeInOutImageFilterCommon::state_type, public CNormalMapToDerivativeFilterBase<Swizzle, Dither>::CNormalMapToDerivativeStateBase
112106
{
113107
public:
114108
CStateBase() = default;
@@ -135,7 +129,7 @@ class CNormalMapToDerivativeFilter : public CMatchedSizeInOutImageFilterCommon,
135129
if (!CMatchedSizeInOutImageFilterCommon::validate(state))
136130
return false;
137131

138-
if (!CNormalMapToDerivativeFilterBase<Swizzle>::validate(state))
132+
if (!CNormalMapToDerivativeFilterBase<Swizzle, Dither>::validate(state))
139133
return false;
140134

141135
const ICPUImage::SCreationParams& inParams = state->inImage->getCreationParameters();
@@ -194,7 +188,7 @@ class CNormalMapToDerivativeFilter : public CMatchedSizeInOutImageFilterCommon,
194188

195189
for (uint16_t w = 0u; w < copyLayerCount; ++w)
196190
{
197-
float* decodeAbsValuesOffset = state->scaleValuesPointer + (w * CNormalMapToDerivativeFilterBase<Swizzle>::CNormalMapToDerivativeStateBase::forcedScratchChannelAmount);
191+
float* decodeAbsValuesOffset = state->scaleValuesPointer + (w * CNormalMapToDerivativeFilterBase<Swizzle, Dither>::CNormalMapToDerivativeStateBase::forcedScratchChannelAmount);
198192

199193
auto& xMaxDecodeAbsValue = *decodeAbsValuesOffset;
200194
auto& yMaxDecodeAbsValue = *(decodeAbsValuesOffset + 1);
@@ -225,6 +219,15 @@ class CNormalMapToDerivativeFilter : public CMatchedSizeInOutImageFilterCommon,
225219

226220
*data = -xDecode / zDecode;
227221
*(data + 1) = -yDecode / zDecode;
222+
223+
auto absoluteX = core::abs(*data);
224+
auto absoluteY = core::abs(*(data + 1));
225+
226+
if (xMaxDecodeAbsValue < absoluteX)
227+
xMaxDecodeAbsValue = absoluteX;
228+
229+
if (yMaxDecodeAbsValue < absoluteY)
230+
yMaxDecodeAbsValue = absoluteY;
228231
}
229232
};
230233

@@ -237,35 +240,12 @@ class CNormalMapToDerivativeFilter : public CMatchedSizeInOutImageFilterCommon,
237240
}
238241

239242
{
240-
auto getScratchPixel = [&](core::vector4di32_SIMD readBlockPos) -> CNormalMapToDerivativeFilterBase<Swizzle>::CNormalMapToDerivativeStateBase::decodeType*
243+
auto getScratchPixel = [&](core::vector4di32_SIMD readBlockPos) -> CNormalMapToDerivativeFilterBase<Swizzle, Dither>::CNormalMapToDerivativeStateBase::decodeType*
241244
{
242245
const size_t scratchOffset = asset::IImage::SBufferCopy::getLocalByteOffset(core::vector3du32_SIMD(readBlockPos.x, readBlockPos.y, readBlockPos.z, 0), scratchByteStrides); // TODO
243-
return reinterpret_cast<CNormalMapToDerivativeFilterBase<Swizzle>::CNormalMapToDerivativeStateBase::decodeType*>(reinterpret_cast<uint8_t*>(state->scratchMemory) + scratchOffset);
244-
};
245-
246-
auto computeMaxAbs = [&](core::vectorSIMDi32 readBlockPos) -> void
247-
{
248-
auto* current = getScratchPixel(readBlockPos);
249-
auto& [x, y] = std::make_tuple(*current, *(current + 1));
250-
251-
auto absoluteX = core::abs(x);
252-
auto absoluteY = core::abs(y);
253-
254-
if (xMaxDecodeAbsValue < absoluteX)
255-
xMaxDecodeAbsValue = absoluteX;
256-
257-
if (yMaxDecodeAbsValue < absoluteY)
258-
yMaxDecodeAbsValue = absoluteY;
246+
return reinterpret_cast<CNormalMapToDerivativeFilterBase<Swizzle, Dither>::CNormalMapToDerivativeStateBase::decodeType*>(reinterpret_cast<uint8_t*>(state->scratchMemory) + scratchOffset);
259247
};
260248

261-
{
262-
core::vector3du32_SIMD localCoord;
263-
for (auto& z = localCoord[2] = 0u; z < state->extent.depth; ++z)
264-
for (auto& y = localCoord[1] = 0u; y < state->extent.height; ++y)
265-
for (auto& x = localCoord[0] = 0u; x < state->extent.width; ++x)
266-
computeMaxAbs(core::vectorSIMDu32(x, y, z));
267-
}
268-
269249
auto normalizeScratch = [&](bool isSigned)
270250
{
271251
core::vector3du32_SIMD localCoord;
@@ -274,13 +254,13 @@ class CNormalMapToDerivativeFilter : public CMatchedSizeInOutImageFilterCommon,
274254
for (auto& x = localCoord[0] = 0u; x < state->extent.width; ++x)
275255
{
276256
const size_t scratchOffset = asset::IImage::SBufferCopy::getLocalByteOffset(localCoord, scratchByteStrides);
277-
auto* entryScratchAdress = reinterpret_cast<CNormalMapToDerivativeFilterBase<Swizzle>::CNormalMapToDerivativeStateBase::decodeType*>(reinterpret_cast<uint8_t*>(state->scratchMemory) + scratchOffset);
257+
auto* entryScratchAdress = reinterpret_cast<CNormalMapToDerivativeFilterBase<Swizzle, Dither>::CNormalMapToDerivativeStateBase::decodeType*>(reinterpret_cast<uint8_t*>(state->scratchMemory) + scratchOffset);
278258

279259
if (isSigned)
280-
for (uint8_t channel = 0; channel < CNormalMapToDerivativeFilterBase<Swizzle>::CNormalMapToDerivativeStateBase::forcedScratchChannelAmount; ++channel)
260+
for (uint8_t channel = 0; channel < CNormalMapToDerivativeFilterBase<Swizzle, Dither>::CNormalMapToDerivativeStateBase::forcedScratchChannelAmount; ++channel)
281261
entryScratchAdress[channel] = entryScratchAdress[channel] / decodeAbsValuesOffset[channel];
282262
else
283-
for (uint8_t channel = 0; channel < CNormalMapToDerivativeFilterBase<Swizzle>::CNormalMapToDerivativeStateBase::forcedScratchChannelAmount; ++channel)
263+
for (uint8_t channel = 0; channel < CNormalMapToDerivativeFilterBase<Swizzle, Dither>::CNormalMapToDerivativeStateBase::forcedScratchChannelAmount; ++channel)
284264
entryScratchAdress[channel] = entryScratchAdress[channel] * 0.5f / decodeAbsValuesOffset[channel] + 0.5f;
285265
}
286266
};
@@ -301,7 +281,7 @@ class CNormalMapToDerivativeFilter : public CMatchedSizeInOutImageFilterCommon,
301281
const size_t offset = asset::IImage::SBufferCopy::getLocalByteOffset(localOutPos, scratchByteStrides);
302282
auto* data = reinterpret_cast<uint8_t*>(state->scratchMemory) + offset;
303283

304-
impl::CSwizzleAndConvertImageFilterBase<false, false, Swizzle, IdentityDither>::onEncode(outFormat, state, outDataAdress, data, localOutPos, 0, 0, CNormalMapToDerivativeFilterBase<Swizzle>::CNormalMapToDerivativeStateBase::forcedScratchChannelAmount); // overrrides texels, so region-overlapping case is fine
284+
impl::CSwizzleAndConvertImageFilterBase<false, false, Swizzle, IdentityDither>::onEncode(outFormat, state, outDataAdress, data, localOutPos, 0, 0, CNormalMapToDerivativeFilterBase<Swizzle, Dither>::CNormalMapToDerivativeStateBase::forcedScratchChannelAmount); // overrrides texels, so region-overlapping case is fine
305285
};
306286

307287
IImage::SSubresourceLayers subresource = { static_cast<IImage::E_ASPECT_FLAGS>(0u), state->outMipLevel, state->outBaseLayer, 1 };

‎src/nbl/asset/utils/CDerivativeMapCreator.cpp

Lines changed: 82 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -229,5 +229,87 @@ core::smart_refctd_ptr<asset::ICPUImageView> CDerivativeMapCreator::createDeriva
229229
return asset::ICPUImageView::create(std::move(params));
230230
}
231231

232+
core::smart_refctd_ptr<asset::ICPUImage> nbl::asset::CDerivativeMapCreator::createDerivativeMapFromNormalMap(asset::ICPUImage* _inImg)
233+
{
234+
core::smart_refctd_ptr<ICPUImage> newDerivativeNormalMapImage;
235+
{
236+
bool status = _inImg->getCreationParameters().type == IImage::E_TYPE::ET_2D;
237+
assert(status);
238+
}
239+
240+
auto cpuImageNormalTexture = _inImg;
241+
const auto referenceImageParams = cpuImageNormalTexture->getCreationParameters();
242+
const auto referenceBuffer = cpuImageNormalTexture->getBuffer();
243+
const auto referenceRegions = cpuImageNormalTexture->getRegions();
244+
const auto* referenceRegion = referenceRegions.begin();
245+
246+
auto newImageParams = referenceImageParams;
247+
newImageParams.format = getRGformat(referenceImageParams.format);
248+
249+
const uint32_t pitch = IImageAssetHandlerBase::calcPitchInBlocks(referenceImageParams.extent.width, asset::getTexelOrBlockBytesize(newImageParams.format));
250+
core::smart_refctd_ptr<ICPUBuffer> newCpuBuffer = core::make_smart_refctd_ptr<asset::ICPUBuffer>(asset::getTexelOrBlockBytesize(newImageParams.format) * pitch * newImageParams.extent.height);
251+
252+
asset::ICPUImage::SBufferCopy region;
253+
region.imageOffset = { 0,0,0 };
254+
region.imageExtent = newImageParams.extent;
255+
region.imageSubresource.baseArrayLayer = 0u;
256+
region.imageSubresource.layerCount = 1u;
257+
region.imageSubresource.mipLevel = 0u;
258+
region.bufferRowLength = pitch;
259+
region.bufferImageHeight = 0u;
260+
region.bufferOffset = 0u;
261+
262+
newDerivativeNormalMapImage = ICPUImage::create(std::move(newImageParams));
263+
newDerivativeNormalMapImage->setBufferAndRegions(std::move(newCpuBuffer), core::make_refctd_dynamic_array<core::smart_refctd_dynamic_array<IImage::SBufferCopy>>(1ull, region));
264+
265+
using DerivativeNormalMapFilter = CNormalMapToDerivativeFilter<asset::DefaultSwizzle, asset::IdentityDither>;
266+
DerivativeNormalMapFilter derivativeNormalFilter;
267+
DerivativeNormalMapFilter::state_type state;
268+
269+
state.inImage = cpuImageNormalTexture;
270+
state.outImage = newDerivativeNormalMapImage.get();
271+
state.inOffset = { 0, 0, 0 };
272+
state.inBaseLayer = 0;
273+
state.outOffset = { 0, 0, 0 };
274+
state.outBaseLayer = 0;
275+
state.extent = { referenceImageParams.extent.width, referenceImageParams.extent.height, referenceImageParams.extent.depth };
276+
state.layerCount = newDerivativeNormalMapImage->getCreationParameters().arrayLayers;
277+
278+
state.scratchMemoryByteSize = state.getRequiredScratchByteSize(state.layerCount, state.extent);
279+
state.scratchMemory = reinterpret_cast<uint8_t*>(_NBL_ALIGNED_MALLOC(state.scratchMemoryByteSize, 32));
280+
281+
state.inMipLevel = 0;
282+
state.outMipLevel = 0;
283+
284+
if (!derivativeNormalFilter.execute(&state))
285+
os::Printer::log("Something went wrong while performing derivative filter operations!", ELL_ERROR);
286+
287+
_NBL_ALIGNED_FREE(state.scratchMemory);
288+
289+
return core::smart_refctd_ptr<ICPUImage>(state.outImage);
290+
}
291+
292+
core::smart_refctd_ptr<asset::ICPUImageView> nbl::asset::CDerivativeMapCreator::createDerivativeMapViewFromNormalMap(asset::ICPUImage* _inImg)
293+
{
294+
auto cpuDerivativeImage = createDerivativeMapFromNormalMap(_inImg);
295+
296+
ICPUImageView::SCreationParams imageViewInfo;
297+
imageViewInfo.image = core::smart_refctd_ptr(cpuDerivativeImage);
298+
imageViewInfo.format = imageViewInfo.image->getCreationParameters().format;
299+
imageViewInfo.viewType = decltype(imageViewInfo.viewType)::ET_2D;
300+
imageViewInfo.flags = static_cast<ICPUImageView::E_CREATE_FLAGS>(0u);
301+
imageViewInfo.subresourceRange.baseArrayLayer = 0u;
302+
imageViewInfo.subresourceRange.baseMipLevel = 0u;
303+
imageViewInfo.subresourceRange.layerCount = imageViewInfo.image->getCreationParameters().arrayLayers;
304+
imageViewInfo.subresourceRange.levelCount = imageViewInfo.image->getCreationParameters().mipLevels;
305+
306+
auto imageView = ICPUImageView::create(std::move(imageViewInfo));
307+
308+
if (!imageView.get())
309+
os::Printer::log("Something went wrong while creating image view for derivative normal map!", ELL_ERROR);
310+
311+
return imageView;
312+
}
313+
232314
}
233315
}

0 commit comments

Comments
 (0)