#pragma it is a float32 literal not a double64 you pillock : 1

commit a445b2af0809ef6b5dd8e4be4eb6048b25f27558 (HEAD -> master)
Author: j.smith <j.smith@example.com>
Date: Thu Aug 31 11:03:05 2023 +0200

Doctors appointment. Back in 2 hours

diff --git a/base.h b/base.h
index 4697686..fe8753a 100644
--- a/base.h
+++ b/base.h
@@ -1,7 +1,7 @@
// License: Apache 2.0. See LICENSE file in root directory.
// Copyright(c) 2015 Intel Corporation. All Rights Reserved.

-// Breaktime! .
+// Breaktime! .

#pragma once

@castano @meuns HLSL -> Metal by default goes through fxc and then via HLSLcc. But often better code these days you can get by using dxc which then goes through spirv-cross. Add “#pragma use_dxc metal” to your shader

Today's `gcc` bug https://gcc.gnu.org/PR111051 is a case where `gcc` stopped recognizing some `avx2` primitives on `avx512` code (all on `highway-1.0.6` code again):

#include <immintrin.h>

#pragma GCC target("avx512vl,avx512dq")

void bug(__m256i i) {
volatile auto v1 = _mm256_cvtepi64_pd(i);
}

and failed as `error: inlining failed in call to 'always_inline' '__m256d _mm256_setzero_pd()': target specific option mismatch`

#gcc #bug

@foone let alone #pragma

#pragma twice

:oneofthem: :twoofthem:

@lethalbit #pragma once, shame on you. #pragma twice, shame on me.

@TransGal4872 @chjara #pragma deleting your files is totally compliant, as long as you say about it somewhere in the docs :hehehe:

One of these days I’ll get out to #pragma

Getting debug shaders was a little bit messy, I had to insert '#pragma enable_d3d11_debug_symbols' into Common.hlsl and trigger a reload. Anyone know of a better way to get debug symbols for built in shaders?

24 hours until the CfP for "#Pragma Conference" closes: https://pragmaconference.com/speakers.html

@7331 @foone have you got a moment to hear the Good News about “#pragma once”?

@sibin I was thinking the compiler could keep a list of content hashes for includes that have #pragma once..

@nicklockwood there should be an option to the compiler to eliminate that warning. For specific instances, you can use:
#pragma diagnostic disable <something>

Langage C : la directive #pragma pack https://xpresso.ddns.net/cgi-bin/xpresso_lire_article.cgi?site=valerian&article=106 #blog #blogging #blogger #Linux #France

@regehr #pragma memcpy

@lunareclipse #pragma once is supported by every C compiler released since about 2010 :P

@Doomed_Daniel @regehr @griotspeak e.g. in C use #pragma stdc fp_contract off

@MaxStriebel Yes, I use #pragma pack(1) to remove alignment requirements and have everything tightly packed.

It's hard to say how unaligned accesses affect performance. Data access is actually a bit more involved, with the need to do some shifting or masking, as seen here:

https://github.com/wolfpld/tracy/blob/993c78f045cce8d4875923a82588da7a0f3565fb/server/TracyEvent.hpp#L202-L223

If you do everything else right, you will see data access as a hotspot, regardless of whether you have aligned or unaligned accesses. Mem/cache latency overshadows the cost of simple arithmetic ops.

Unity supports .cpp files as plugins when building for IL2CPP, which is exactly what we need here.
We can add a .cpp file with:
```
#include <winsqlite/winsqlite3.h>

#pragma comment(lib, "winsqlite3.lib")
```

which will get auto-included in the generated C++ project. Now the linker should be able to find all the sqlite functions.
And sure enough, this compiles and runs fine on my Windows 11 machine!