TheZone/clay
1
0
Fork 0
mirror of https://github.com/nicbarker/clay.git synced 2025-04-14 02:08:04 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Cleanup

Browse Source
This commit is contained in:
Nic Barker 2025-03-21 14:38:21 +13:00
parent e83033fd2a
commit b52c0525b3
1 changed files with 19 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
clay.h
View File

@ -385,10 +385,6 @@ typedef struct {
// CLAY_TEXT_ALIGN_CENTER - Horizontally aligns wrapped lines of text to the center of their bounding box.
// CLAY_TEXT_ALIGN_RIGHT - Horizontally aligns wrapped lines of text to the right hand side of their bounding box.
Clay_TextAlignment textAlignment;
// When set to true, clay will hash the entire text contents of this string as an identifier for its internal
// text measurement cache, rather than just the pointer and length. This will incur significant performance cost for
// long bodies of text.
bool hashStringContents;
} Clay_TextElementConfig;
CLAY__WRAPPER_STRUCT(Clay_TextElementConfig);
@ -877,8 +873,7 @@ CLAY_DLL_EXPORT int32_t Clay_GetMaxMeasureTextCacheWordCount(void);
// Modifies the maximum number of measured "words" (whitespace seperated runs of characters) that Clay can store in its internal text measurement cache.
// This may require reallocating additional memory, and re-calling Clay_Initialize();
CLAY_DLL_EXPORT void Clay_SetMaxMeasureTextCacheWordCount(int32_t maxMeasureTextCacheWordCount);
// Resets Clay's internal text measurement cache, useful if memory to represent strings is being re-used.
// Similar behaviour can be achieved on an individual text element level by using Clay_TextElementConfig.hashStringContents
// Resets Clay's internal text measurement cache. Useful if font mappings have changed or fonts have been reloaded.
CLAY_DLL_EXPORT void Clay_ResetMeasureTextCache(void);
// Internal API functions required by macros ----------------------
@ -1350,18 +1345,15 @@ Clay_ElementId Clay__HashString(Clay_String key, const uint32_t offset, const ui
}
#if !defined(CLAY_DISABLE_SIMD) && (defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64))
// Rotate left in AVX (equivalent to _mm_rol_epi64 in AVX2)
static inline __m128i Clay__SIMDRotateLeft(__m128i x, int r) {
return _mm_or_si128(_mm_slli_epi64(x, r), _mm_srli_epi64(x, 64 - r));
}
// A simple ARX mix function (AVX)
static inline void Clay__SIMDARXMix(__m128i* a, __m128i* b) {
*a = _mm_add_epi64(*a, *b);
*b = _mm_xor_si128(Clay__SIMDRotateLeft(*b, 17), *a);
}
// SIMD ARX hash function (AVX)
uint64_t Clay__HashData(const uint8_t* data, size_t len) {
// Pinched these constants from the BLAKE implementation
__m128i v0 = _mm_set1_epi64x(0x6a09e667f3bcc908ULL);
@ -1409,19 +1401,16 @@ uint64_t Clay__HashData(const uint8_t* data, size_t len) {
return result[0] ^ result[1];
}
#elif !defined(CLAY_DISABLE_SIMD) && defined(__aarch64__)
// Rotate left in NEON (simulating _mm256_rol_epi64)
static inline uint64x2_t Clay__SIMDRotateLeft(uint64x2_t x, int r) {
return vorrq_u64(vshlq_n_u64(x, 17), vshrq_n_u64(x, 64 - 17));
}
// A simple ARX mix function
static inline void Clay__SIMDARXMix(uint64x2_t* a, uint64x2_t* b) {
*a = vaddq_u64(*a, *b);
*b = veorq_u64(Clay__SIMDRotateLeft(*b, 17), *a);
}
// SIMD ARX hash function (NEON)
uint64_t Clay__HashData(const uint8_t* data, size_t len) {
uint64_t Clay__HashData(const uint8_t* data, size_t length) {
// Pinched these constants from the BLAKE implementation
uint64x2_t v0 = vdupq_n_u64(0x6a09e667f3bcc908ULL);
uint64x2_t v1 = vdupq_n_u64(0xbb67ae8584caa73bULL);
@ -1431,31 +1420,30 @@ uint64_t Clay__HashData(const uint8_t* data, size_t len) {
uint8_t overflowBuffer[8] = { 0 };
// Process 16-byte chunks
while (len > 0) {
while (length > 0) {
uint64x2_t msg;
if (len > 16) {
if (length > 16) {
msg = vld1q_u64((const uint64_t*)data);
data += 16;
len -= 16;
length -= 16;
}
else if (len > 8) {
else if (length > 8) {
msg = vcombine_u64(vld1_u64((const uint64_t*)data), vdup_n_u64(0));
data += 8;
len -= 8;
length -= 8;
}
else {
for (int i = 0; i < len; i++) {
for (int i = 0; i < length; i++) {
overflowBuffer[i] = data[i];
}
uint8x8_t lower = vld1_u8(overflowBuffer); // Load up to 8 bytes
msg = vcombine_u8(lower, vdup_n_u8(0)); // Zero upper 8 bytes
len = 0;
uint8x8_t lower = vld1_u8(overflowBuffer);
msg = vcombine_u8(lower, vdup_n_u8(0));
length = 0;
}
v0 = veorq_u64(v0, msg);
Clay__SIMDARXMix(&v0, &v1);
Clay__SIMDARXMix(&v2, &v3);
// Cross-lane mixing
v0 = vaddq_u64(v0, v2);
v1 = vaddq_u64(v1, v3);
}
@ -1463,15 +1451,15 @@ uint64_t Clay__HashData(const uint8_t* data, size_t len) {
// Final mixing rounds
Clay__SIMDARXMix(&v0, &v1);
Clay__SIMDARXMix(&v2, &v3);
v0 = vaddq_u64(v0, v2);
v1 = vaddq_u64(v1, v3);
v0 = vaddq_u64(v0, v2);
v1 = vaddq_u64(v1, v3);
// Extract final hash
uint64_t result[2];
vst1q_u64(result, v0);
// Extract final hash
uint64_t result[2];
vst1q_u64(result, v0);
return result[0] ^ result[1];
}
return result[0] ^ result[1];
}
#else
uint64_t Clay__HashData(const uint8_t* data, size_t length) {
uint64_t hash = 0;
@ -1486,10 +1474,7 @@ uint64_t Clay__HashData(const uint8_t* data, size_t length) {
#endif
uint32_t Clay__HashStringContentsWithConfig(Clay_String *text, Clay_TextElementConfig *config) {
uint32_t hash = 0;
uintptr_t pointerAsNumber = (uintptr_t)text->chars;
hash = Clay__HashData((const uint8_t *)text->chars, text->length) % UINT32_MAX;
uint32_t hash = Clay__HashData((const uint8_t *)text->chars, text->length) % UINT32_MAX;
hash += config->fontId;
hash += (hash << 10);