Dimensional Data

C++ Extension in VS Code 1.18 Release: Quick Fixes for missing header files, Extract to Function & More  Alexandra Kemper November 15th, 20231 1 The 1.18 version of the C++ Extension in Visual Studio Code has been released. With this version of the extension, we have added several new features such as:   Quick Fixes for missing header files  Extract to function/member function  Assistance acquiring a compiler   For the full list of changes, please reference the 1.18 release notes.   Quick Fixes for missing header files  Have you ever written C++ code and forgotten to add the right header? Gotten frustrated because of an IntelliSense error that turns out to just be a missing header file? We have now added a quick fix suggestion (lightbulb) to make the process of adding the correct header files to C++ files easier. If there is an unknown symbol in your C++ code and the C/C++ Extension identifies the correct header file in your workspace, you will now have a quick fix available. Select the quick fix and the necessary header file include will be added to the top of your current C++ file.   Extract to Function/Member Function  One of the most highly requested features for C++ in VS Code is support for extracting functions or member functions from code. With the 1.18 release, you can now select a section of your code, extract it into a separate function, and place a reference to the new function in the old location.   To try this feature, select the C++ code you would like to extract. A code action (lightbulb) will appear with the option Extract to Function. Otherwise, right click on the code and select Refactor > Extract or use the keyboard command Ctrl + Shift + R, Ctrl + E to get more information. As you can see below, you will then have the option to name the new function that has been created. The new function containing your highlighted code will be placed above the current function.  Upcoming improvements will further streamline the extraction process, such as being able to extract to a free function. Any feedback you have would be very valuable to share through our GitHub issues to help us build the best experience.   New C++ Compiler Acquisition Process  To streamline the C++ setup process, we have created an easier C++ compiler installation experience.   For Mac and Linux users, you can now use the Install Compiler button to install a C++ compiler quickly and easily. The button will install a default C++ compiler on your system through the VS Code command line. This compiler will be automatically configured for IntelliSense. On a Mac, the default compiler installed is clang, while for supported Linux distros it is gcc and g++.  To access this experience, you can use the C++ walkthrough or configuration quickpick.  To access the walkthrough, use the Open Walkthrough command in the command palette and select the Get Started with C++ Development option. Under the Set Up your C++ Environment, if you do not have a compiler already installed, you will see an Install Compiler button.   To access the IntelliSense configuration quick pick, enter the Select IntelliSense configuration command in the command palette. From the list, select the Install a Compiler option. A notification will open asking you to confirm the installation process. […]

Functions View for Build Insights in Visual Studio 2022 17.8 Eve Silfanus November 17th, 20230 2 Introduction We are excited to unveil a new feature in Build Insights for Visual Studio: Functions View! This feature is available in Visual Studio 2022 version 17.8. Functions View offers essential insights into functions and forceinlines within your codebases. Download Visual Studio 2022 17.8 We extend our sincere thanks thanks to the developer community, especially our game studio partners, for actively providing feedback. Your contributions are invaluable in shaping this new feature. For more details about Build Insights and to explore other features like Included Files and Include Tree Views, please visit our initial announcement blogpost. Code Generation Insights with Functions View Functions View is a powerful tool that displays the impact of each function on the total build time by analyzing code generation times and forceinlines. Forceinlines, commonly used to boost runtime efficiency, can also influence build times. The following sample code is based on a public code sample by Aras Pranckevičius. We will use it to show you how you can optimize your builds with Functions View. To setup your project, create a C++ Console application and copy the following sample code: #include struct float4 { __m128 val; float4() { val = _mm_setzero_ps(); } float4(float x) { val = _mm_set1_ps(x); } float4(float x, float y) { val = _mm_set_ps(y, x, y, x); } float4(float x, float y, float z) { val = _mm_set_ps(0.f, z, y, x); } float4(float x, float y, float z, float w) { val = _mm_set_ps(w, z, y, x); } float4(__m128 v) { val = v; } }; static __forceinline float4 operator+(const float4& a, const float4& b) { return float4(_mm_add_ps(a.val, b.val)); } static __forceinline float4 operator-(const float4& a, const float4& b) { return float4(_mm_sub_ps(a.val, b.val)); } static __forceinline float4 operator*(const float4& a, const float4& b) { return float4(_mm_mul_ps(a.val, b.val)); } static __forceinline float4 operator/(const float4& a, const float4& b) { return float4(_mm_div_ps(a.val, b.val)); } static __forceinline float4 csum(const float4& p) { __m128 r = _mm_add_ps(p.val, _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(p.val), _MM_SHUFFLE(0, 3, 2, 1)))); return _mm_add_ps(r, _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(r), _MM_SHUFFLE(1, 0, 3, 2)))); } static __forceinline float4 dot(const float4& p0, const float4& p1) { return csum(p0 * p1); } static __forceinline float4 dot(const float4& p) { return dot(p, p); } static __forceinline float4 rsqrt(const float4& x) { #define C0 9.999998e-01f #define C1 3.0000002e+00f #define C2 .5f #define C3 340282346638528859811704183484516925440.f __m128 e = _mm_mul_ps(_mm_rsqrt_ps((__m128) x.val), _mm_set_ps(C0, C0, C0, C0)); e = _mm_min_ps(e, _mm_set_ps(C3, C3, C3, C3)); return _mm_mul_ps(_mm_mul_ps(e, _mm_set_ps(C2, C2, C2, C2)), _mm_sub_ps(_mm_set_ps(C1, C1, C1, C1), _mm_mul_ps(_mm_mul_ps(x.val, e), e))); } static __forceinline float4 normalize(const float4& v) { return v * rsqrt(dot(v)); } static __forceinline float4 ident() { return float4(0.f, 0.f, 0.f, 1.f); } static __forceinline float4 sampleFun1(const float4& x, const float4& y) { return csum(x) / x + y; } static __forceinline float4 sampleFun2(const float4& q1, const float4& q2) { return sampleFun1(q1 * q2, q2 – q1) * (q1 + q2); } static float4 sampleFun3(const float4& pq, const float4& mask) { const float c8 = 0.923879532511287f; const float s8 = 0.38268343236509f; const float g = 5.82842712474619f; float4 ch = float4(2) * (normalize(pq) – normalize(mask)); float4 sh = pq * normalize(ch); float4 r = ((g * sh * sh – ch * ch) + sh / float4(s8, s8, s8, c8)) * mask; return normalize(r); } struct matrix […]

Debug vcpkg portfiles in CMake script mode with Visual Studio Code Ben McMorran November 16th, 20230 0 We recently announced support for debugging the CMake language using the VS Code CMake Tools extension. Now in version 1.16 of the extension, you can fine-tune the debugger configuration using a launch.json file. This enables debugging in CMake script mode in addition to the existing debugging of CMake project generation.  CMake script mode is an alternative way of running CMake that does not generate a build system, but instead uses the CMake language as a general-purpose scripting language. While script mode is not widely used (although there are fun esoteric examples), it is the mechanism that powers vcpkg portfiles. vcpkg uses portfiles to know how to acquire, build, and install libraries. Through a combination of the new experimental “–x-cmake-debug” vcpkg option and CMake Tools, it’s now possible to debug these portfiles in VS Code. This is helpful when adding a library to the vcpkg catalog.  Debugging vcpkg portfiles As an example, we’ll explore how to debug the vcpkg portfile for zlib. First, ensure you have CMake Tools 1.16 and CMake 3.27 installed. Next, clone the vcpkg repo and open it in VS Code.  > git clone https://github.com/microsoft/vcpkg > cd vcpkg > .bootstrap-vcpkg.bat (or bootstrap-vcpkg.sh on Linux) > code . We’ll use a tasks.json to define a task that installs the zlib library with the –x-cmake-debug option and a launch.json file to configure CMake Tools to attach to the zlib portfile as it’s being run. In VS Code, create a new “.vscode” directory. Add the following tasks.json and launch.json files to this directory. tasks.json {      “version”: “2.0.0”,      “tasks”: [          {              “label”: “Reinstall zlib”,              “type”: “shell”,              “isBackground”: true,              “command”: “& “${workspaceFolder}/vcpkg.exe” remove zlib; & “${workspaceFolder}/vcpkg.exe” install zlib –no-binarycaching –x-cmake-debug \\.\pipe\portfile_debugging”,              “problemMatcher”: [                  {                      “pattern”: [                          {                              “regexp”: “”,                              “file”: 1,                              “location”: 2,                              “message”: 3                          }                      ],                      “background”: {                          “activeOnStart”: true,                          “beginsPattern”: “.”,                          “endsPattern”: “Waiting for debugger client to connect”                      }                  }              ]          }      ]  }  The important parts of the configuration are the command, which removes zlib if it’s already installed and then reinstalls it, and the endsPattern, which tells VS Code when it can consider the task complete. CMake will output the “Waiting for debugger client to connect” string as soon as it has finished initializing the debugger. The rest of the problemMatcher values are required to satisfy VS Code’s launch configuration schema but are not used in this example.  launch.json {      “version”: “0.2.0”,      “configurations”: [          {              “type”: “cmake”,              “request”: “launch”,              “name”: “Debug zlib portfile”,              “cmakeDebugType”: “external”,              “pipeName”: “\\.\pipe\portfile_debugging”,              “preLaunchTask”: “Reinstall zlib”          }      ]  }  This CMake Debugging configuration uses a cmakeDebugType of external, meaning the CMake Tools extension is not responsible for launching CMake (in this case vcpkg is launching CMake). Notice how we use the same pipe name as the vcpkg install task. Finally, open ports/zlib/portfile.cmake and set a breakpoint on line 2 (the call to vcpkg_from_github). In the VS Code Run and Debug view, select the Debug zlib portfile configuration and click the play button to start debugging. VS Code will automatically run the vcpkg install task […]

Unreal Engine and C++ Game Development Made Easy with Visual Studio 2022 David Li November 14th, 20230 0 Introduction Creating amazing games just got easier. We are very happy to announce the latest Unreal Engine integrations and powerful C++ productivity features in Visual Studio 2022. Our team has been tirelessly working to incorporate your feedback and bring even more features that will enhance your game development experience whether you work on Unreal Engine or a proprietary engine. In this blog, we will explore how you can leverage the new Unreal Engine Test Adapter, which helps to streamline your testing process without leaving the IDE. Then, we will also show you how you can code faster with Unreal Engine snippets and macro specifier suggestions, as well as view in-memory bitmaps. Next, we have included a range of core C++ productivity features and debugger enhancements that will benefit not only those working on Unreal Engine but also anyone who works on their own engines. Lastly, we will round out the blog with updates on C++ IntelliSense and debugger launch performance improvements. Most of these productivity features are available in Visual Studio 2022 version 17.8, while some are available in the latest previews. We are confident that these features will help you be more productive and enable you to create even more amazing games. Download Visual Studio 2022 17.8 Latest Unreal Engine Integrations Setting Up Unreal Engine Integrations Unreal Engine integrations will only show up when you are working on an Unreal Engine project. To ensure these features are active, double check that the “IDE support for Unreal Engine” component is enabled in the “Game development for C++” workload in the Visual Studio Installer. Some integrations such as Blueprints support and Test Adapter will require the free “Visual Studio Integration Tool” Unreal Engine Plugin. Please see Visual Studio Tools for Unreal Engine for detailed setup instructions. Unreal Engine Test Adapter Special thanks to the folks at Rare who contributed tremendously to this feature. Streamline your testing process without leaving the IDE with Unreal Engine Test Adapter. You can now discover, run, manage, and debug your Unreal Engine tests. In Visual Studio 2022 version 17.8, you will automatically see your Unreal Engine Tests when you open Visual Studio. To see your tests, you can open Test Explorer with View > Test Explorer. The latest version of our free Visual Studio Tools for Unreal Engine plugin is required to use Unreal Engine Test Adapter. In addition, ensure the “Unreal Engine Test Adapter” component in the “Game development with C++” workload is enabled in the Visual Studio Installer. Unreal Engine Code Snippets Write code more efficiently with Unreal Engine Code Snippets. In Visual Studio 2022 version 17.8, you can find common Unreal Engine constructs as snippets in your member list. To begin, enter the name of any Unreal Engine construct, such as “uclass”. Then, press Tab or Enter to expand the snippet. We have also included exported versions of UCLASS (uclass, uclassexported), UINTERFACE (uinterface, uinterfaceexported), and USTRUCT (ustruct, ustructexported) for those working with exported APIs and plugins. In addition, we have included macros such as SWidget (swidget), TActorRange (tactorrange), TObjectRange (tobjectrage), and WITH_EDITOR (witheditor) based on your feedback. List of Supported Snippets uclass uclassexported uenum ufunction uinterface uinterfaceexported uproperty ustruct ustructexported uelog swidget tactoreange tobjectrange witheditor […]