mirror of
https://github.com/jmarshall23/DoomRTX.git
synced 2026-08-19 20:19:50 +02:00
Doom 3 RTX Initial Checkin.
This commit is contained in:
Justin Marshall
@@ -0,0 +1,475 @@
|
||||
/*
|
||||
* Copyright (c) 2022-2025 NVIDIA CORPORATION. All rights reserved
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string.h>
|
||||
#include <vector>
|
||||
|
||||
#define FEATURE_SPECIFIC_BUFFER_TYPE_ID(feature, number) feature << 16 | number
|
||||
|
||||
#include "sl.h"
|
||||
#include "sl_consts.h"
|
||||
#include "sl_reflex.h"
|
||||
#include "sl_pcl.h"
|
||||
#include "sl_dlss.h"
|
||||
#include "sl_nis.h"
|
||||
#include "sl_dlss_d.h"
|
||||
#include "sl_dlss_g.h"
|
||||
|
||||
#if defined(__clang__)
|
||||
#define SL_DISABLE_DEPRECATED_WARNINGS \
|
||||
_Pragma("clang diagnostic push") \
|
||||
_Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
|
||||
#define SL_RESTORE_DEPRECATED_WARNINGS \
|
||||
_Pragma("clang diagnostic pop")
|
||||
|
||||
#elif defined(_MSC_VER)
|
||||
#define SL_DISABLE_DEPRECATED_WARNINGS \
|
||||
__pragma(warning(push)) \
|
||||
__pragma(warning(disable: 4996))
|
||||
#define SL_RESTORE_DEPRECATED_WARNINGS \
|
||||
__pragma(warning(pop))
|
||||
|
||||
#else
|
||||
#define SL_DISABLE_DEPRECATED_WARNINGS
|
||||
#define SL_RESTORE_DEPRECATED_WARNINGS
|
||||
#endif
|
||||
|
||||
|
||||
namespace sl
|
||||
{
|
||||
|
||||
inline float4x4 transpose(const float4x4& m)
|
||||
{
|
||||
float4x4 r;
|
||||
r[0] = { m[0].x, m[1].x, m[2].x, m[3].x };
|
||||
r[1] = { m[0].y, m[1].y, m[2].y, m[3].y };
|
||||
r[2] = { m[0].z, m[1].z, m[2].z, m[3].z };
|
||||
r[3] = { m[0].w, m[1].w, m[2].w, m[3].w };
|
||||
return r;
|
||||
};
|
||||
|
||||
#define SL_CASE_STR(a) case a : return #a;
|
||||
|
||||
// Check for c++17 features
|
||||
#if __cplusplus >= 201703L
|
||||
#define SL_FALLTHROUGH [[fallthrough]];
|
||||
#else
|
||||
#define SL_FALLTHROUGH
|
||||
#endif
|
||||
|
||||
inline const char* getResultAsStr(Result v)
|
||||
{
|
||||
switch (v)
|
||||
{
|
||||
SL_CASE_STR(Result::eOk);
|
||||
SL_CASE_STR(Result::eErrorIO);
|
||||
SL_CASE_STR(Result::eErrorDriverOutOfDate);
|
||||
SL_CASE_STR(Result::eErrorOSOutOfDate);
|
||||
SL_CASE_STR(Result::eErrorOSDisabledHWS);
|
||||
SL_CASE_STR(Result::eErrorDeviceNotCreated);
|
||||
SL_CASE_STR(Result::eErrorNoSupportedAdapterFound);
|
||||
SL_CASE_STR(Result::eErrorAdapterNotSupported);
|
||||
SL_CASE_STR(Result::eErrorNoPlugins);
|
||||
SL_CASE_STR(Result::eErrorVulkanAPI);
|
||||
SL_CASE_STR(Result::eErrorDXGIAPI);
|
||||
SL_CASE_STR(Result::eErrorD3DAPI);
|
||||
SL_CASE_STR(Result::eErrorNRDAPI);
|
||||
SL_CASE_STR(Result::eErrorNVAPI);
|
||||
SL_CASE_STR(Result::eErrorReflexAPI);
|
||||
SL_CASE_STR(Result::eErrorNGXFailed);
|
||||
SL_CASE_STR(Result::eErrorJSONParsing);
|
||||
SL_CASE_STR(Result::eErrorMissingProxy);
|
||||
SL_CASE_STR(Result::eErrorMissingResourceState);
|
||||
SL_CASE_STR(Result::eErrorInvalidIntegration);
|
||||
SL_CASE_STR(Result::eErrorMissingInputParameter);
|
||||
SL_CASE_STR(Result::eErrorNotInitialized);
|
||||
SL_CASE_STR(Result::eErrorComputeFailed);
|
||||
SL_CASE_STR(Result::eErrorInitNotCalled);
|
||||
SL_CASE_STR(Result::eErrorExceptionHandler);
|
||||
SL_CASE_STR(Result::eErrorInvalidParameter);
|
||||
SL_CASE_STR(Result::eErrorMissingConstants);
|
||||
SL_CASE_STR(Result::eErrorDuplicatedConstants);
|
||||
SL_CASE_STR(Result::eErrorMissingOrInvalidAPI);
|
||||
SL_CASE_STR(Result::eErrorCommonConstantsMissing);
|
||||
SL_CASE_STR(Result::eErrorUnsupportedInterface);
|
||||
SL_CASE_STR(Result::eErrorFeatureMissing);
|
||||
SL_CASE_STR(Result::eErrorFeatureNotSupported);
|
||||
SL_CASE_STR(Result::eErrorFeatureMissingHooks);
|
||||
SL_CASE_STR(Result::eErrorFeatureFailedToLoad);
|
||||
SL_CASE_STR(Result::eErrorFeatureWrongPriority);
|
||||
SL_CASE_STR(Result::eErrorFeatureMissingDependency);
|
||||
SL_CASE_STR(Result::eErrorFeatureManagerInvalidState);
|
||||
SL_CASE_STR(Result::eErrorInvalidState);
|
||||
SL_CASE_STR(Result::eWarnOutOfVRAM);
|
||||
};
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
inline const char* getNISModeAsStr(NISMode v)
|
||||
{
|
||||
switch (v)
|
||||
{
|
||||
SL_CASE_STR(NISMode::eOff);
|
||||
SL_CASE_STR(NISMode::eScaler);
|
||||
SL_CASE_STR(NISMode::eSharpen);
|
||||
case NISMode::eCount: break;
|
||||
};
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
inline const char* getNISHDRAsStr(NISHDR v)
|
||||
{
|
||||
switch (v)
|
||||
{
|
||||
SL_CASE_STR(NISHDR::eNone);
|
||||
SL_CASE_STR(NISHDR::eLinear);
|
||||
SL_CASE_STR(NISHDR::ePQ);
|
||||
case NISHDR::eCount: break;
|
||||
};
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
inline const char* getReflexModeAsStr(ReflexMode mode)
|
||||
{
|
||||
switch (mode)
|
||||
{
|
||||
SL_CASE_STR(ReflexMode::eOff);
|
||||
SL_CASE_STR(ReflexMode::eLowLatency);
|
||||
SL_CASE_STR(ReflexMode::eLowLatencyWithBoost);
|
||||
case ReflexMode::ReflexMode_eCount: break;
|
||||
};
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
inline const char* getPCLMarkerAsStr(PCLMarker marker)
|
||||
{
|
||||
switch (marker)
|
||||
{
|
||||
SL_CASE_STR(PCLMarker::eSimulationStart);
|
||||
SL_CASE_STR(PCLMarker::eSimulationEnd);
|
||||
SL_CASE_STR(PCLMarker::eRenderSubmitStart);
|
||||
SL_CASE_STR(PCLMarker::eRenderSubmitEnd);
|
||||
SL_CASE_STR(PCLMarker::ePresentStart);
|
||||
SL_CASE_STR(PCLMarker::ePresentEnd);
|
||||
SL_CASE_STR(PCLMarker::eTriggerFlash);
|
||||
SL_CASE_STR(PCLMarker::ePCLatencyPing);
|
||||
SL_CASE_STR(PCLMarker::eOutOfBandRenderSubmitStart);
|
||||
SL_CASE_STR(PCLMarker::eOutOfBandRenderSubmitEnd);
|
||||
SL_CASE_STR(PCLMarker::eOutOfBandPresentStart);
|
||||
SL_CASE_STR(PCLMarker::eOutOfBandPresentEnd);
|
||||
SL_CASE_STR(PCLMarker::eControllerInputSample);
|
||||
SL_CASE_STR(PCLMarker::eDeltaTCalculation);
|
||||
SL_CASE_STR(PCLMarker::eLateWarpPresentStart);
|
||||
SL_CASE_STR(PCLMarker::eLateWarpPresentEnd);
|
||||
SL_CASE_STR(PCLMarker::eCameraConstructed);
|
||||
SL_CASE_STR(PCLMarker::eLateWarpRenderSubmitStart);
|
||||
SL_CASE_STR(PCLMarker::eLateWarpRenderSubmitEnd);
|
||||
case PCLMarker::eMaximum: break;
|
||||
};
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
inline const char* getDLSSModeAsStr(DLSSMode mode)
|
||||
{
|
||||
switch (mode)
|
||||
{
|
||||
SL_CASE_STR(DLSSMode::eOff);
|
||||
SL_CASE_STR(DLSSMode::eDLAA);
|
||||
SL_CASE_STR(DLSSMode::eMaxPerformance);
|
||||
SL_CASE_STR(DLSSMode::eBalanced);
|
||||
SL_CASE_STR(DLSSMode::eMaxQuality);
|
||||
SL_CASE_STR(DLSSMode::eUltraPerformance);
|
||||
SL_CASE_STR(DLSSMode::eUltraQuality);
|
||||
case DLSSMode::eCount: break;
|
||||
};
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
inline const char* getDLSSGModeAsStr(DLSSGMode mode)
|
||||
{
|
||||
switch (mode)
|
||||
{
|
||||
SL_CASE_STR(sl::DLSSGMode::eOff);
|
||||
SL_CASE_STR(sl::DLSSGMode::eOn);
|
||||
SL_CASE_STR(sl::DLSSGMode::eAuto);
|
||||
case DLSSGMode::eCount: break;
|
||||
};
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
inline const char* getBufferTypeAsStr(BufferType buf)
|
||||
{
|
||||
switch (buf)
|
||||
{
|
||||
SL_CASE_STR(kBufferTypeDepth);
|
||||
SL_CASE_STR(kBufferTypeMotionVectors);
|
||||
SL_CASE_STR(kBufferTypeHUDLessColor);
|
||||
SL_CASE_STR(kBufferTypeScalingInputColor);
|
||||
SL_CASE_STR(kBufferTypeScalingOutputColor);
|
||||
SL_CASE_STR(kBufferTypeNormals);
|
||||
SL_CASE_STR(kBufferTypeRoughness);
|
||||
SL_CASE_STR(kBufferTypeAlbedo);
|
||||
SL_CASE_STR(kBufferTypeSpecularAlbedo);
|
||||
SL_CASE_STR(kBufferTypeIndirectAlbedo);
|
||||
SL_CASE_STR(kBufferTypeSpecularMotionVectors);
|
||||
SL_CASE_STR(kBufferTypeDisocclusionMask);
|
||||
SL_CASE_STR(kBufferTypeEmissive);
|
||||
SL_CASE_STR(kBufferTypeExposure);
|
||||
SL_CASE_STR(kBufferTypeNormalRoughness);
|
||||
SL_CASE_STR(kBufferTypeDiffuseHitNoisy);
|
||||
SL_CASE_STR(kBufferTypeDiffuseHitDenoised);
|
||||
SL_CASE_STR(kBufferTypeSpecularHitNoisy);
|
||||
SL_CASE_STR(kBufferTypeSpecularHitDenoised);
|
||||
SL_CASE_STR(kBufferTypeShadowNoisy);
|
||||
SL_CASE_STR(kBufferTypeShadowDenoised);
|
||||
SL_CASE_STR(kBufferTypeAmbientOcclusionNoisy);
|
||||
SL_CASE_STR(kBufferTypeAmbientOcclusionDenoised);
|
||||
SL_CASE_STR(kBufferTypeUIColorAndAlpha);
|
||||
SL_CASE_STR(kBufferTypeShadowHint);
|
||||
SL_CASE_STR(kBufferTypeReflectionHint);
|
||||
SL_CASE_STR(kBufferTypeParticleHint);
|
||||
SL_CASE_STR(kBufferTypeTransparencyHint);
|
||||
SL_CASE_STR(kBufferTypeAnimatedTextureHint);
|
||||
SL_CASE_STR(kBufferTypeBiasCurrentColorHint);
|
||||
SL_CASE_STR(kBufferTypeRaytracingDistance);
|
||||
SL_CASE_STR(kBufferTypeReflectionMotionVectors);
|
||||
SL_CASE_STR(kBufferTypePosition);
|
||||
SL_CASE_STR(kBufferTypeInvalidDepthMotionHint);
|
||||
SL_CASE_STR(kBufferTypeAlpha);
|
||||
SL_CASE_STR(kBufferTypeOpaqueColor);
|
||||
SL_CASE_STR(kBufferTypeReactiveMaskHint);
|
||||
SL_CASE_STR(kBufferTypeTransparencyAndCompositionMaskHint);
|
||||
SL_CASE_STR(kBufferTypeReflectedAlbedo);
|
||||
SL_CASE_STR(kBufferTypeColorBeforeParticles);
|
||||
SL_CASE_STR(kBufferTypeColorBeforeTransparency);
|
||||
SL_CASE_STR(kBufferTypeColorBeforeFog);
|
||||
SL_CASE_STR(kBufferTypeSpecularHitDistance);
|
||||
SL_CASE_STR(kBufferTypeSpecularRayDirectionHitDistance);
|
||||
SL_CASE_STR(kBufferTypeSpecularRayDirection);
|
||||
SL_CASE_STR(kBufferTypeDiffuseHitDistance);
|
||||
SL_CASE_STR(kBufferTypeDiffuseRayDirectionHitDistance);
|
||||
SL_CASE_STR(kBufferTypeDiffuseRayDirection);
|
||||
SL_CASE_STR(kBufferTypeHiResDepth);
|
||||
SL_CASE_STR(kBufferTypeLinearDepth);
|
||||
SL_CASE_STR(kBufferTypeColorAfterParticles);
|
||||
SL_CASE_STR(kBufferTypeColorAfterTransparency);
|
||||
SL_CASE_STR(kBufferTypeColorAfterFog);
|
||||
SL_CASE_STR(kBufferTypeScreenSpaceSubsurfaceScatteringGuide);
|
||||
SL_CASE_STR(kBufferTypeColorBeforeScreenSpaceSubsurfaceScattering);
|
||||
SL_CASE_STR(kBufferTypeColorAfterScreenSpaceSubsurfaceScattering);
|
||||
SL_CASE_STR(kBufferTypeScreenSpaceRefractionGuide);
|
||||
SL_CASE_STR(kBufferTypeColorBeforeScreenSpaceRefraction);
|
||||
SL_CASE_STR(kBufferTypeColorAfterScreenSpaceRefraction);
|
||||
SL_CASE_STR(kBufferTypeDepthOfFieldGuide);
|
||||
SL_CASE_STR(kBufferTypeColorBeforeDepthOfField);
|
||||
SL_CASE_STR(kBufferTypeColorAfterDepthOfField);
|
||||
SL_CASE_STR(kBufferTypeScalingOutputAlpha);
|
||||
SL_CASE_STR(kBufferTypeBidirectionalDistortionField);
|
||||
SL_CASE_STR(kBufferTypeTransparencyLayer);
|
||||
SL_CASE_STR(kBufferTypeTransparencyLayerOpacity);
|
||||
SL_CASE_STR(kBufferTypeBackbuffer);
|
||||
SL_CASE_STR(kBufferTypeNoWarpMask);
|
||||
};
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
inline const char* getFeatureAsStr(Feature f)
|
||||
{
|
||||
switch (f)
|
||||
{
|
||||
SL_CASE_STR(kFeatureDLSS);
|
||||
SL_CASE_STR(kFeatureNIS);
|
||||
SL_CASE_STR(kFeatureReflex);
|
||||
SL_CASE_STR(kFeaturePCL);
|
||||
SL_CASE_STR(kFeatureDLSS_G);
|
||||
SL_CASE_STR(kFeatureNvPerf);
|
||||
SL_CASE_STR(kFeatureImGUI);
|
||||
SL_CASE_STR(kFeatureCommon);
|
||||
SL_CASE_STR(kFeatureDLSS_RR);
|
||||
SL_CASE_STR(kFeatureDeepDVC);
|
||||
SL_CASE_STR(kFeatureDirectSR);
|
||||
SL_CASE_STR(kFeatureLatewarp);
|
||||
// Removed features
|
||||
case kFeatureNRD_INVALID: break;
|
||||
}
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
// Get the feature file name as a string. For a given feature kFeatureDLSS with
|
||||
// a plugin name sl.dlss.dll the value "dlss" will be returned
|
||||
inline const char* getFeatureFilenameAsStrNoSL(Feature f)
|
||||
{
|
||||
switch (f)
|
||||
{
|
||||
case kFeatureDLSS: return "dlss";
|
||||
case kFeatureNIS: return "nis";
|
||||
case kFeatureReflex: return "reflex";
|
||||
case kFeaturePCL: return "pcl";
|
||||
case kFeatureDLSS_G: return "dlss_g";
|
||||
case kFeatureNvPerf: return "nvperf";
|
||||
case kFeatureDeepDVC: return "deepdvc";
|
||||
case kFeatureImGUI: return "imgui";
|
||||
case kFeatureCommon: return "common";
|
||||
case kFeatureDLSS_RR: return "dlss_d";
|
||||
case kFeatureDirectSR: return "directsr";
|
||||
case kFeatureLatewarp: return "latewarp";
|
||||
case kFeatureNRD_INVALID: break;
|
||||
}
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
inline const char* getLogLevelAsStr(LogLevel v)
|
||||
{
|
||||
switch (v)
|
||||
{
|
||||
SL_CASE_STR(LogLevel::eOff);
|
||||
SL_CASE_STR(LogLevel::eDefault);
|
||||
SL_CASE_STR(LogLevel::eVerbose);
|
||||
case LogLevel::eCount: break;
|
||||
};
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
inline const char* getResourceTypeAsStr(ResourceType v)
|
||||
{
|
||||
switch (v)
|
||||
{
|
||||
SL_CASE_STR(ResourceType::eTex2d);
|
||||
SL_CASE_STR(ResourceType::eBuffer);
|
||||
SL_CASE_STR(ResourceType::eCommandQueue);
|
||||
SL_CASE_STR(ResourceType::eCommandBuffer);
|
||||
SL_CASE_STR(ResourceType::eCommandPool);
|
||||
SL_CASE_STR(ResourceType::eFence);
|
||||
SL_CASE_STR(ResourceType::eSwapchain);
|
||||
SL_CASE_STR(ResourceType::eHostFence);
|
||||
case ResourceType::eUnknown: break;
|
||||
case ResourceType::eCount: break;
|
||||
};
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
inline const char* getResourceLifecycleAsStr(ResourceLifecycle v)
|
||||
{
|
||||
switch (v)
|
||||
{
|
||||
SL_CASE_STR(ResourceLifecycle::eOnlyValidNow);
|
||||
SL_CASE_STR(ResourceLifecycle::eValidUntilPresent);
|
||||
SL_CASE_STR(ResourceLifecycle::eValidUntilEvaluate);
|
||||
};
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
SL_DISABLE_DEPRECATED_WARNINGS
|
||||
inline DLSSPreset resolveDLSSPreset(DLSSPreset preset)
|
||||
{
|
||||
switch (preset)
|
||||
{
|
||||
case DLSSPreset::ePresetF:
|
||||
case DLSSPreset::ePresetJ:
|
||||
case DLSSPreset::ePresetK:
|
||||
return preset;
|
||||
default:
|
||||
return DLSSPreset::eDefault;
|
||||
}
|
||||
}
|
||||
SL_RESTORE_DEPRECATED_WARNINGS
|
||||
|
||||
inline DLSSDPreset resolveDLSSDPreset(DLSSDPreset preset)
|
||||
{
|
||||
return static_cast<DLSSDPreset>(resolveDLSSPreset(static_cast<DLSSPreset>(preset)));
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Advanced/internal functions that are not useful or necessary in the vast majority of integrations
|
||||
// and would just pollute the namespace and/or cause distractions.
|
||||
// But, may be useful in e.g. intermediary game engine integrations, etc.
|
||||
#ifndef __INTELLISENSE__
|
||||
|
||||
//! Find a struct of type T
|
||||
template<typename T>
|
||||
T* findStruct(const void* ptr)
|
||||
{
|
||||
auto base = static_cast<const BaseStructure*>(ptr);
|
||||
while (base && base->structType != T::s_structType)
|
||||
{
|
||||
base = base->next;
|
||||
}
|
||||
return (T*)base;
|
||||
}
|
||||
|
||||
//! Find a struct of type T, but stop the search if we find a struct of type S
|
||||
template<typename T, typename S>
|
||||
T* findStruct(const void* ptr)
|
||||
{
|
||||
auto base = static_cast<const BaseStructure*>(ptr);
|
||||
while (base && base->structType != T::s_structType)
|
||||
{
|
||||
base = base->next;
|
||||
|
||||
// If we find a struct of type S, we know should stop the search
|
||||
if (base->structType == S::s_structType)
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
return (T*)base;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T* findStruct(const void** ptr, uint32_t count)
|
||||
{
|
||||
const BaseStructure* base{};
|
||||
for (uint32_t i = 0; base == nullptr && i < count; i++)
|
||||
{
|
||||
base = static_cast<const BaseStructure*>(ptr[i]);
|
||||
while (base && base->structType != T::s_structType)
|
||||
{
|
||||
base = base->next;
|
||||
}
|
||||
}
|
||||
return (T*)base;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool findStructs(const void** ptr, uint32_t count, std::vector<T*>& structs)
|
||||
{
|
||||
for (uint32_t i = 0; i < count; i++)
|
||||
{
|
||||
auto base = static_cast<const BaseStructure*>(ptr[i]);
|
||||
while (base)
|
||||
{
|
||||
if (base->structType == T::s_structType)
|
||||
{
|
||||
structs.push_back((T*)base);
|
||||
}
|
||||
base = base->next;
|
||||
}
|
||||
}
|
||||
return structs.size() > 0;
|
||||
}
|
||||
|
||||
#endif // __INTELLISENSE__
|
||||
|
||||
} // namespace sl
|
||||
Reference in New Issue
Block a user