IMPORTANT: Users of 2024.5 should upgrade as soon as possible, or install the previous version 2024.4.
To get the latest version, visit our website now and download the new update.

Visual Assist 2024.6 brings two critical fixes for Visual Assist’s interaction with Visual Studio.

• The first fix in this release addresses a critical issue that could sometimes cause Visual Studio to crash when saving files. This fix enhances the stability of the IDE, ensuring a smoother and more reliable experience while working on your projects.
• Secondly, we have resolved an issue where the Visual Studio installer would crash on versions of Windows older than Windows 10. This fix ensures that users running older operating systems can install and update Visual Studio without encountering disruptions. This should provide a seamless setup experience across all supported Visual Assist-supported versions of Visual Studio.

We appreciate your patience and feedback as we continue to improve Visual Assist for all our users. Please continue to report issues and we will do our best to get them sorted out quickly.

The post Visual Assist 2024.6 release post – Important fixes for Visual Studio first appeared on Tomato Soup.

VA had significant improvements in 2024, particularly in the initial startup time for projects, as well as in the responsiveness of a few key features. It is not farfetched to say that performance has been the primary consideration for the development direction of the plugin.

Why? Because performant, responsive software is productive software, and fast interaction is key to you getting your work done.

We have a lot of solid, robust features based purely on providing not the kitchen sink, but what you need. We already had a reputation for being faster than other products. Now we are even faster: VA is a lean, mean, coding machine.

We’re midway through the year, and we’re summarizing all the recent performance updates in this handy update blog. Read on further to get a more complete picture of when and why these changes were introduced to VA.

Faster startup sequence

Whatever task you have, you first must open and launch Visual Studio—along with any installed plugins you have. Opening a Visual Studio-associated file initiates the startup process which starts loading the essential IDE assets, the solution files you have chosen, and ultimately any auxiliary components like Visual Assist.

While we cannot alter the core loadout of Visual Studio, we’ve worked on every facet of our tool that can be optimized for faster startup:

• Project initial parsing
  

  Project parsing is an extra step that code assistant plugins like Visual Assist need to undertake. VA uses its own parser independent of Visual Studio’s which allows it to pre-scan projects so it can be faster, smarter, and able to provide different functions.
  
  The release in January 2024 featured an overhaul of the parser, which reduced startup times for opening previously unparsed project files by up to 15 times.
  
  While an initial parse is only done the first time you open a project. The next time you open it, it will be instant. (This was an existing feature.) However, we made it 15x faster for those of you who are opening multiple new projects on a more frequent basis.

  For example, an Unreal Engine project with its typically massive code base previously took 15 minutes to parse. We’ve brought this down to a mere one minute of parsing.

  Tech details: Visual Assist implemented a cache for parsed directories to bypass slow Windows file IO API calls where the same call is expected to give the same result—this significantly reduced the initial parse time.

   

• Plugin load time
  

  This update refers to the time it takes for Visual Assist’s features to become functional. As mentioned above, the time-to-functional is the sum of all Visual Studio’s startup routine which includes loading in plugins.
  Every time you close and open a solution, VA’s features take a few moments to load—or at least that’s how it was before. With this update, time-to-functional is more or less instantaneous even in extremely large solutions! 

  As soon as Visual Studio calls on Visual Assist to start loading, you’ll immediately see coloring and syntax highlighting, and have access to all navigation and features. (Note: How Visual Studio initializes plugins and components is indeterminate; results may vary slightly depending on how many components it loads first before Visual Assist.)

  What these changes mean for you:

   

  Depending on how often you need it, the Visual Studio startup sequence and project load can be a part of your feedback cycle when testing and coding. And even a mere 30 seconds are painful and a threat to productivity when repeated, especially when they add up in a work week.

  This is even more pronounced when your work entails opening new projects multiple times in a week. Visual Assist is the best in-class plugin that offers significantly less startup time—giving you more time to be productive.

  READ: Visual Assist startup duration update

Search dialogs: Find References and File Finding

Since starting our crusade against a slow and unresponsive IDE,  there have been two updates that shortened the loading time for finding references and symbols. Utilizing techniques such as parallelism and removing extraneous string searches, you’ll  enjoy up to ten times faster search time.  

Furthermore, better accuracy and new functionality has been added for other search dialogs, including fuzzy search for Open File in Solution.

• Find references speed and responsiveness

Find references is a feature that looks for symbol usage within the current project or solution. Depending on the project size, there may be hundreds to thousands of symbol definitions in your solution, and many of those, tens of thousands of times they may be used. In order for code navigation to work, VA must scour its database for the correct results.

Find references time increases with the number of symbols in the database. However, VA’s feature has been greatly improved for performance and speed—almost ten times faster than before! That means that this performance improvement applies to many key features and navigations.

Some other common and key features in VA improved by this change: 

• Renaming finds references in order to rename them.
• Implement Methods finds methods in order to know which ones do and do not exist
• Change signature works similarly.
  
  

  Visual Assist’s Find references window. Takes significantly less time to find all references in 2024.3.

• Fuzzy search and uppercase search for opening files and searching symbols
  

  Fuzzy search is a technique used in searches and information retrieval to find approximate matches for a given query, accommodating variations like typos and misspellings. It employs string distance metrics to measure the similarity between strings.
  
  Apart from being fast, Open File in Solution and Find Symbol in Solution support this technique, so you can expect more meaningful results with fewer, less accurate search queries.
  
  Furthermore, beyond fuzzy searching for inexact matches, VA will also match capital letters. For example, if you have a class named MyClassName, searching for “mcn” would find it. Similarly, suppose you have a global variable named myGlobalVariable and type “mgv” – the lowercase “my” is treated as if it were MyGlobalVariable, providing expected results.
  

• Move Class feature
  

  Refactoring and moving entire classes can be a hassle. This feature has completed its beta phase to provide full support for porting an entire class to the file(s) of your choosing.

• Bonus QoL Change: Select all items in open file in solution (Ctrl + A)
  

  You can now select and highlight multiple files and open them simultaneously when using open file in solution. The usual shortcut Ctrl + A works.
  

  What these changes mean for you:

  As a C++ developer, you frequently search for files and symbols in massive projects. So even small reductions in wait times or interruptions cumulatively boost your overall productivity to a significant degree.

Summary

Performance improvements are and will remain the focus of Visual Assist in upcoming releases. As projects grow larger and C++ features grow in complexity, we too must adapt and scale our performance to meet the increasing workload and demands on our parser and product capabilities.

This is our most important aim: speedy performance and accurate responses so you can focus on thinking and problem solving—the crucial parts of coding.

We’re only halfway through the year, so let us know what we should improve upon next. Thank you for your continued use and support of Visual Assist!

The post Catching up with VA: Our most recent performance updates first appeared on Tomato Soup.

We hope you find this release useful. Visit our website to download the release.

ARM support

Big news for Visual Assist’s device support! Windows ARM is now supported starting this release, Visual Assist 2024.4. Visual Assist is now available as a fully ARM-native plugin, fully supported in Visual Studio’s ARM build. This means that Visual Assist is now fully compatible for those of you using Macs or Windows devices with an ARM processor. 

We first asked our community about ARM support some time ago. At the time, while it was clear ARM was growing for Macs, it was unclear how strongly it would grow for Windows and we planned support at a future time. Since then, we’ve seen growing interest and customer requests – and we’re happy to deliver! The appearance we see is that many people, including large companies, are increasingly interested in or using ARM for Windows.

There are many advantages to using Windows ARM devices, from battery usage to performance. One key one is that many developers target ARM devices and are used to debug remotely; while debugging on-device or on-simulator remains important, it can be slow and doing minute-to-minute development on a device that shares the same CPU architecture can be very useful.

ARM is a completely new front for us and we would like to know more about how we can improve the experience for ARM users. If you’re part of the group that would benefit from this update, please let us know more by answering this short survey.

Path “/” delimiter

This simple change adds an option for users who are used to using “/” as path delimiters for searching directories. This comes at the heel of users from different operating systems sharing how their default style of delimiter is not supported. 

With this change, you can now choose what the default delimiter will be used. This will apply to most of Visual Assist’s search windows such as Open file in solution and the like.

Bug fixes and improvements

Apart from the above major fixes, we have a couple of minor bug fixes and QoL changes. The highlights are a fix for recognizing one of the features in the standard library. 

The complete list is below: 

• Fixed issue where std::tuple would not be recognized in some cases.
• Move Class to New File will no longer jump to a new file before showing the dialog.
• Fixed broken Discord invite link.

Send us a message or start a thread on the user forums for bug reports or suggestions. Don’t forget to join our Discord too!

Visit our download page to update to the latest release manually. Happy coding!

The post Visual Assist 2024.4 release post – ARM Support first appeared on Tomato Soup.

Download the release now from our website.

Better find references results in multiple faster features

If you’ve updated to at least Visual Assist 2024.1, you may have been enjoying the benefits of the significantly improved parser performance that cut initial parsing time fifteenfold. In this release, we’ve added something even bigger: performance improvements not at startup, but all the time

Find references, the feature that looks for symbol usage within the current project or solution, has been greatly improved for performance and speed. But the Find References engine is used for many other common and key features in Visual Assist! Renaming finds references in order to rename them; implement methods finds methods in order to know which ones do and do not exist; and so forth. That means that this performance improvement applies to many key features and navigations; Rename, Change Signature, Implement Methods and more.

Visual Assist’s Find references window. Takes significantly less time to find all references in 2024.3.

Test Results

The development team ran a few tests to compare the performance of find references between the new Visual Assist version versus an older version of the same plugin. Furthermore, they also tested it against the performance of Visual Studio’s default Find References. 

The test was done on Unreal Engine 5.3 source code using Lyra game examples with two symbols: TOptional and MakeBox as the basis for which references are to be searched. The test was done using Visual Studio 2022 17.8 and Visual Assist 2024.3 & 2024.2. Time was measured from the start of Find References to all references found.

The result of the tests are as follows:

Setup 1 – TOptional:

Setup 2 – MakeBox:

As one can surmise from the results, the latest update brings Visual Assist’s symbol finding performance well above that of default Visual Studio’s and other similar plugins. Further testing on other platforms will be undertaken. Please refer back to this page later for more testing.

Exiting Beta: CUDA core development support & Move Class feature

Two VA features enter their stable phase and are now on general availability. If you have not tried these yet, we highly recommend trying them out as it provides a lot of usefulness that might not be readily apparent.

• CUDA support
  First added in 2023.4, CUDA support allowed Visual Assist to recognize CUDA files and parse and highlight them like regular C/C++ files. This feature now enters full supported status and you can reliably use Intellisense-like features for CUDA files.
• Move Class feature
  Refactoring and moving entire classes can sometimes be a hassle. This feature moves from beta to supported status and allows you to easily choose an entire class and port it over to file/s of your choosing.

Create File: specify a directory + auto implementation.

This is a tiny but useful quality of life change for creating files. Prior to this change, Visual Assist would sometimes display a failure error and ask you if you wanted to Create File or to stop if a target was not found. Now, it runs create file automatically and you can hit Cancel instead.

Furthermore, a bug fix for when using create file: Visual Assist will consistently move the implementation afterwards. (In the past, it sometimes failed to do so.) 

These two changes will hopefully make your experience more seamless and intuitive.

Discord link and feedback options in the Help menu

Introducing our newly opened Discord server for all Visual Assist users. We’re hoping for this hub to function like our forums wherein users can request for changes, report bugs, and share useful information and tips around the plugin.

As it’s a WIP, anyone who is interested in helping us manage and build the community is welcome to do so. Send us a message here if you’re interested.

Furthermore, we’ve added new feedback channels in one of our menus. Navigate to Help and browse new feedback options and let us know what you think!

Bug fixes and improvements

Apart from the above major fixes, we have a couple of minor bug fixes and QoL changes. The complete list is below: 

• Fixed issue where Move Implementation would not move the implementation if a new file needed to be created.
• Improved editor performance when editing C#.
• Fixed Add Include issue where C headers would sometimes be added instead of their C++ counterparts.
• Fixed issue where Move Class to New File would sometimes not be offered near macros.

Send us a message or start a thread on the user forums for bug reports or suggestions.

Visit our download page to update to the latest release manually. Happy coding!

The post Visual Assist 2024.3 release post first appeared on Tomato Soup.

Download the release now from our website.

Significantly faster plugin startup time—especially in large solutions.

This update refers to the time it takes for Visual Assist’s features to become functional. Every time you close and open a solution, the plugin’s features take a few moments to load—or at least that’s how it was before. With this update, time-to-functional is more or less instantaneous even in extremely large solutions! 

As soon as Visual Studio calls on Visual Assist to start loading, you can immediately see coloring, syntax highlighting, and all the navigation and features are accessible. (Note: How Visual Studio initializes plugins and components is indeterminate; results may vary slightly depending on how many components it loads first before Visual Assist.)

This is not to be confused with the initial parse time update that we did in VA 2024.1 which is only a one-time process that happens with each new solution.

Further improvement to our initial parse time.

As mentioned above, we made significant improvement with the initial project parsing. Most of the benefits from 2024.1 were the result of optimizing how Visual Assist goes through files as it traverses references and includes. 

To summarize, Visual Assist used a cache for parsed directories so that it does not have to access the hard disk when an include is referenced multiple times—this significantly reduced the initial parse time.

In 2022.2, however, the developers have squeezed more performance by optimizing smaller items such as string operations, parse logic, etc. This produced a relatively modest but still significant decrease in project parse time.The result is a up to 50% faster parse time versus the previous version. Or in absolute units, that means VA 2024.2 is around 20 seconds faster than VA 2024.1 in our test scenario, where the Lyra demo is now ready in under a minute.

Testing:

Initial parsing time is defined as the point where the Visual Assist starts parsing up to the end where it completes it. This project used the latest Visual Studio 2022 version 17.8.6, again on the Lyra sample game project provided by Epic Games. This is using the same high-end PC and laptop setup used to test the 2024.1 changes.

Setup 1:

Setup 2: 1.19x faster

Setup 3: 1.54x faster

Improved add include for Unreal Engine.

Adding includes when working with Unreal projects has been improved in two ways. First, add include formatting in C++ generally uses either alligator brackets or quotation marks. Generally, <> are for system includes and “” are for user includes, however, there is a stylistic convention when working with Unreal. 

This update adds logic such that when you’re adding includes in an Unreal project, Visual Assist will consistently choose quotations—the preferred style for Unreal development.

Second, the include directory that is used when adding includes will now produce more accurate paths. Visual Assist will try to make sense of directory paths, subfolders included. This is especially useful when working with Unreal Engine which is known to arbitrarily produce paths.

Unreal Engine changes how solutions are generated; and while these are not actually used to build your game, these incorrect include directories are still read and used to generate other include paths when adding new includes. VA adds includes perfectly for normal C++ projects, but this situation may pose issues with some UE solutions, because some solutions could have incorrect include paths set up. 

This manifests as very long and unwanted paths, such as this one when adding the player controller: #include “../../../../../../../Source/Runtime/Engine/Classes/GameFramework/PlayerController.h”

Now, VA instead traverses the directory structure and figures out the paths, instead of trusting the solution. We replaced our logic to mostly ignore the include directories given to use by the solution in lue of traversing the directory structure ourselves. This lets us build our own ‘effective’ list of include directories which we will use to generate include paths for new includes.

For the above example, it would now add: #include “GameFramework/PlayerController.h”—which is what you expect and want as a UE developer. 

Fix syntax coloring in C# for Visual Studio 2022.

A recent Visual Studio 2022 update changed an API that Visual Assist uses to provide coloring and syntax highlighting. This update broke Visual Assist’s coloring and syntax highlighting for C#. 

A near total rewrite has been implemented and syntax coloring should be working now. However, there may be a slight difference in how Visual Assist colors C# files as we reoptimize with the rewritten code.

Syntax highlighting and coloring in C++ has remained unaffected but Visual Assist plans on implementing the new API setup for it as well. This should also fix some minor coloring issues. 

Fixed compatibility issues with GitHub Copilot.

Visual Assist is now completely compatible with Copilot, Microsoft’s AI coding assistant. 

Earlier this year, a bug report was filed on our forums describing a situation where Visual Assist seems to be interfering with Copilot’s chat functionality. This has led to the unwanted situation wherein users have to disable either Copilot or Visual Assist, as some features may not work simultaneously.

All known incompatibility issues have been resolved and addressed in 2024.2. If you encounter any similar bugs, please send us a bug report.

Fixed Open File in Solution issue when the filter starts with a dot.

When starting a query with a dot (.), Open File in Solution may sometimes fail to display the expected results. 2024.2 fixed the ‘dot’ filtering which was a common user complaint.

Search filtering features are available by starting with a dot to find files that begin with the filter, or contain the dot and substring. A filter that ends with a dot matches the ends of file names. For example “string.” finds files whose base names end with “string”. This dot filtering is also possible in other dialogs of Visual Assist that support filtering.

Bug Fixes & General Improvements

Apart from the above major fixes, we have a couple of minor bug fixes and QoL changes. The complete list is below.

• Fixed UI conflict with GitHub Copilot.
• Fixed issue where Add Include would sometimes not add the new include.
• Fixed long Add Include paths for some symbols in Unreal Engine 5.3.x.
• Fixed issue where Open File in Solution would sometimes not display results when the filter starts with a dot.
• Fixed issue where C# syntax coloring would not be applied in Visual Studio 2022 17.9.0.
• Fixed issue where readability-magic-numbers Code Inspection would not properly underline hex numbers.
• Fixed issue where GoTo would not navigate to classes without a constructor.
• Fixed issue where suggestions could show suggestions for non-existent types.
• Updated Create Account link to point to the correct page.
• Added Alt+O to Recommended Keyboard Shortcuts as Visual Studio 2022 now uses that binding.

Send us a message or start a thread on the user forums for bug reports or suggestions.

Visit our download page to update to the latest release manually. Happy coding!

The post Visual Assist 2024.2 release post first appeared on Tomato Soup.

Why Visual Studio?

Visual Studio is the de facto IDE for editing Unreal’s C++ projects. Unreal Engine (UE) is designed to integrate smoothly with Visual Studio (VS), allowing you to make source code changes in your projects quickly and easily, and immediately see results upon compilation. Setting up VS to work with UE can help improve efficiency and the overall user experience for developers using UE.

Installing and Getting Set Up

Things You Need to Download Before Doing Everything:

• Visual Studio (VS22 Recommended)
• Epic Games Launcher for Unreal Engine (You download UE using the launcher)
• A sample game project (Optional downloadable from the UE marketplace)

Step 1: Installing Visual Studio

First up, you want to install Visual Studio, the IDE of choice for Unreal Game development. It is recommended to install the latest version of Visual Studio, or any version from VS 2022 to take advantage of 64-bit address space with virtually unlimited memory limit—this will be useful for working with Unreal’s project sizes.

You can pick between a professional (commercial for teams) and a community license (free for individuals). Download the bootstrap .exe and open it to start the installer.

You will then be shown a number of customization options for workloads, additional components, and installation location. For the workloads, which contain components you need for the programming language or platform that you’re using, we recommend installing the following: 

• .NET development
• Desktop development C++
• Game development C++.

Adding Visual Studio Tools for Unreal Engine

Make sure to tick the following items when choosing your workloads.

Visual Studio has come a long way with its integration with Unreal Engine’s features and dev tools. Microsoft has added extra support for Unreal that enables you to add UE classes, view UE logging, and more, all from within Visual Studio.

Step 2: Installing the Unreal Engine editor

Next up, you need to install the Unreal Engine editor. This allows you to open and run pre-cooked versions of the games you will develop. This allows you to run unsaved, uncompressed, and uncompiled programs using the Unreal Engine. This makes it easier to run, edit, tweak, demo, and overall quickly test things in your games.

To download the Unreal Engine editor, you first have to download the Epic Games launcher and follow the installation process. Once you have the Epic Games launcher installed, sign up for an Epic Games account using whatever login option you prefer.

Once you have logged in, you can navigate to the Unreal Engine tab and start downloading the Unreal Editor. This will also install the editor in your system automatically. The most common way to open the Unreal Editor will be through this launcher. You could also double click your *.uproject file or if you prefer, open the Visual Studio solution and then compile and run the editor from there. 

Use the dropdown on the top right to choose which version of Unreal you want to install (in most cases, the latest version will be the best choice.) Follow the instructions and customize your install locations and shortcut options if you prefer.

Tip: There is usually a prompt to associate UE with Visual Studio, but in case it has not followed the succeeding steps. In the “Edit” menu of the Unreal Editor, navigate to “Editor Preferences” and then navigate to the “Source Code” section. Choose the corresponding Visual Studio version as the preferred source code editor.

Step 3: Finding sample project files

Congratulations! You have installed the two primary programs needed for Unreal Engine development. At this point, you will decide whether you would like to use the blueprint visual scripting system or C++. For the purposes of this tutorial, we will go further and set up C++ project files. (Remember for when you progress: it is more efficient if you use both the blueprint system and C++ in tandem.) 

Creating a game from scratch is a gargantuan task. And even with a game engine handy, it may still feel overwhelming. Luckily, Epic provides a number of free sample projects so you can test the waters out and familiarize yourself first before starting a project entirely on your own.

Browse through the marketplace or the sample game projects available inside the Epic Games library. This catalog will include almost every genre of games, tech demos, and sample studios that you can think of. 

Epic Games has provided a number of sample games and projects so you can jump right in and practice your development skills.

For this tutorial, we chose the Lyra Starter game—a sample FPS game continuously updated with the latest UE has to offer. You can easily invest hundreds of hours just tweaking the gameplay, graphics, and user interface systems to get better at the complexities of the C++ integration.Choose and download your sample game of choice and save it on your system.  This will save the game files, preconfig files, and most importantly a *.uproject file—a text file that contains basic settings for your game project, which can be conveniently read by the Unreal Editor to launch your game. This will also be useful for the next step.

Choose your install location and click on create and wait for the process to complete. This will create the essential project files for editing the source code in Visual Studio.

Step 3: Building your first project files and opening for Visual Studio

To open the  downloaded game file source code in Visual Studio, you have to make a Visual Studio project file (or its collective known as solutions).

Navigate to where you created your project files.. If everything was installed correctly, this will have a *.uproject file that will have an entry for the associated source code. This allows you to generate a Visual Studio solution based on the UE Lyra Game source code. Right click on the *.uproject file and click on “Generate Visual Studio project files”.

Right click a *.uproject file to create source folder that contains .cpp and .h files.

This will build a Source folder that contains .cpp source files, .h header files, and a .sln Visual Studio solution file that you can open inside Visual Studio. 

Launch Visual Studio and open the corresponding solution. This will start a short loading process as your project initializes, but don’t worry; it’s just the initial pre-project parsing. Opening the same solutions in the future will take significantly less time.

This process maps out the entire network of source files and builds a database of symbols so that the IDEs navigation and search features work. If you’ve reached this far, congratulations! You have successfully set up Unreal Engine and integrated its source code for development in Visual Studio.

A Lyra game C++ header file opened in Visual Studio.
Note: Syntax highlighting and navigations are added by a nifty tool called Visual Assist—more on that later!

Making changes to your first project

After installation, you may want to start as simply as possible to familiarize yourself with the process of using the Unreal Editor in conjunction with Visual Studio C++ to change or add gameplay mechanics to your sample game. 

You will find that Visual Studio development comes with its own set of workflows before you can see actual results in the editor. You may be writing new code, debugging, or compiling projects. And it may be easy to lose track of what comes after which. 

If you want to get your hands dirty on an actual project, it is highly recommended to watch the following tutorial on how to add a powerup pickup to the sample shooter game. Watch and learn to set up projects, find project files, retrofit existing assets, and write and build your own C++ to make new content.

Watch and learn how a seasoned Unreal dev sets up Visual Studio + Unreal Engine. See how you can use C++ to add your own power up. Watch the tutorial here.

Removing false errors in Unreal Projects

When you first start working on an Unreal solution you will notice that there are syntax and symbols specific to Unreal development. Unfortunately, these symbols and functions can be mislabeled or flagged as false errors by Visual Studio as they are not part of the normal C++ workload. The C++ files will still compile but this caused a lot of confusion, especially among beginners. 

A group of game developers grew tired of the false errors and unresponsiveness of the IDE in large gaming projects, so they built their own tools tailored specifically for Unreal. The developers from Whole Tomato created a plugin called Visual Assist that understands Unreal Engine syntax—improving the frustrating situation they were in.

Overtime, the plugin grew from adding simple syntax comprehension and handy navigations to a full-fledged productivity augmentation for Visual Studio C++. The plugin developed a smart parser that understood what users were trying to accomplish, and thus was able to visually provide timely and contextual assistance in real time.

Red squiggles under source code signify errors. However, these are all normal Unreal Engine code mislabeled by the IDE.

Visual Assist remains one of the top productivity plugins for C++ and Unreal Engine work. It is responsive, performant, and parses your game files extremely fast so you can jump right in with complete support. You can download Visual Assist and try it out for yourself on freshly installed or existing Unreal projects.

The post Installing Unreal Engine 4/5 + Visual Studio: A complete step-by-step guide with pictures first appeared on Tomato Soup.

The makers and developers of Visual Assist will make their return to Moscone Center in San Francisco from March 18-22 for GDC 2024! Whole Tomato will be at booth number P1769 sharing space with a sister company, Assembla! Two of the best tools for game development in one booth—efficient!

GDC has always been one of the most awaited gaming events for video game professionals every year. It’s also one of the few opportunities for us to meet with daring new developers, colleagues in the industry, and of course enthusiastic users. That’s why we are excited to physically meet the community once again in this year’s GDC! 

We hope to see you there!

PS: We will be handing out exciting prizes and giveaways for our booth visitors!

Book an appointment with us

If you’re attending GDC and have access to the conference virtual platform, you can book a meeting with any of team members. Use the link below and navigate to the Teams section and take your pick among our dazzling booth members.

The post See you at San Francisco for GDC 2024! first appeared on Tomato Soup.

The post What’s New in Visual Assist 2024—Featuring lightning fast parser performance [Webinar] first appeared on Tomato Soup.

Great news! The Whole Tomato experience just got even more complete and well-rounded! 

The hobbies and recreational activities you do during your early days in school often become the gateway to the skills you’ll develop and use in the real world. It is no surprise, then, that the tools and machines you use when starting out as a complete novice influence how you grow from a curious enthusiast into a full-blown professional.

This also means that one of the biggest gatekeepers for novices and students learning the basics is access to tools and machines that are fundamental to learning a skill.

This is why Whole Tomato is proud to announce that we’ve recently launched our academic licensing program to help students—as well as their teachers—get a headstart in their programming career!

The benefits for students, instructors, and teaching departments

To help more people learn about the wonders of fast and efficient programming in C, C#, and C++, Whole Tomato is lowering the barriers to accessing its renowned Visual Assist plugin for Visual Studio. From now on, students and instructors can secure fully sponsored Visual Assist licenses.

Visual Assist is kicking off its foray into accessibility for young learners, instructors, and teachers.

For Students
Students can easily secure a license using a verified educational email address. They will be able to purchase discounted licenses—friendly to an apprentice’s allowance. And if a learner is only willing to test the waters, they can also opt for a monthly subscription plan. Just visit our webstore and follow the checkout process for students.

A student is someone who is enrolled in an accredited educational program. Students can also check with their university or program organizers if they have existing packages with Whole Tomato. 

For teachers, instructors, and departments
Sometimes a beginner needs a push in the right direction. Recommending Visual Assist to students has never been easier. If an instructor is looking to share Visual Assist with their class or department, they have access to a number of tiered options ranging from fully sponsored deals to specially tailored plans.

If you’re interested in sharing the unrivaled power of Visual Assist to a class or a group of learners, contact the Whole Tomato sales team to explore your options.

Why an academic licensing program?

Picture this: rolling out academic licenses could be a game-changer, especially with the new generation of developers and programmers in mind. Think of it as guiding the future workforce with a backstage pass to industry-grade tools while they’re still in school. This early exposure to efficient and optimized instruments and applications makes learning a more encouraging and satisfactory experience. 

Partnering up with schools and departments also means that we, as software providers, get a chance to know what the new wave of developers are interested in trying or what problems they are facing. This allows Visual Assist to grow alongside the ever-changing demands of C/C++ development. 

And you students, on the other hand, get a more suitable and optimized tool to help you become fast and efficient developers. You won’t need to train and study as much when you graduate, as well since you will already be accustomed to the tools in the industry. This makes you a more attractive candidate for the occasional picky recruiter.

Supporting young learners is also one of the initiatives that the community should always strive to promote. As an interdependent and ever-changing industry, developers and the software world must ensure that people remain interested in learning our craft. Offering software at student-friendly rates (or even sponsoring them completely) levels the playing field and makes it more accessible. It’s totally the way to go! ?

Why would students need Visual Assist?

Long loading times, incomplete prompts, incorrect suggestions, and missing navigations, among others. The Visual Studio IDE has gone through leaps and bounds to improve C development, however, there are still areas in C++ that are in dire need of improvement.

Visual Assist provides the necessary support  and tooling learners need in their journey to becoming developers. Visual Assist provides new tools and improves existing ones in VS to eliminate the frustration in C/C++ development.

The latest additions to Visual Assist

Visual Studio 2022 
Cash in on that sweet x64 process. With virtually limitless memory available to Visual Studio, your productivity plugins no longer have to squeeze themselves for the remaining memory allocation. Visual Assist has been tweaked to properly utilize the newfound bandwidth.

Extremely fast project parsing
Interruptions and long loading times can make a significant hit on productivity. Stop fighting your development environment. Visual Assist’s raw performance allows users to focus on thinking and coding.

Better coding support and tooling
It’s easier to teach new learners new things. Visual Assist keeps the development environment updated with the latest features available. Follow the latest C++ standards and conventions with VA’s 100+ New code inspection checks and updated LLVM Clang Tidy 15.0 engine.

Specialized support
Unreal Engine source, shader files, CUDA core development, you name it. Visual Assist adds special support for lookalike C++ code. Enable basic IDE features such as navigations, refactoring, and code completion for these applications.

 The best time to get Visual Assist

Visual Assist was running at a discounted price when we publicly launched academic licenses—but luckily for you, being a student or a teacher ain’t seasonal! Visual Assist academic licenses will be available continuously for students using our webstore. And if you’re an instructor looking to secure some seats for your students, just contact our sales team to browse your fully-sponsored options.

Not a student or a teacher but you’re looking for affordable sets of licenses? Not a problem! Contact us to check your available options for bulk and enterprise licensing.

The post Another reason to cheer: Visual Assist academic licenses! first appeared on Tomato Soup.

We also have a new code checker, support for two new C++ language features, and small but useful improvements to VA’s behavior. Read on further to get the complete details of the changes and improvements in this release, or download the release right away.

Share source code via email, GitHub, and more.

Starting from VA 2023.6, users can now highlight sections of code from the editor and open the Quick Actions and Refactoring (Shift + Alt + Q) menu, or right-click on the code and select the “Share with team member” option to instantly send code to other developers.

Select and share sections of code by highlighting it and using the Quick Actions
menu (Shift + Alt + Q).

Choose where and how you want to share your code. This new feature can work in conjunction with GitHub Gist and GitLab’s snippets feature, where you can instantly share and upload parts of your source code. You can also send your source code via email for more general-use purposes. 

Improvements to VA’s navigation features

This release provides a number of improvements and additional functionality to VA’s bread and butter navigation features, such as open file in solution and find symbol in solution.

• Fuzzy search and uppercase search for opening files and searching symbols
  Fuzzy search is a technique used in searches and information retrieval to find approximate matches for a given query, accommodating variations like typos and misspellings. It employs string distance metrics to measure the similarity between strings.
  
  Visual Assist’s open file in solution and find symbol in solution will now employ this algorithm, so you can expect more results with fewer, less accurate search queries.
  
  Furthermore, besides fuzzy searching for inexact matches, VA will also match capital letters. If you have a class named MyClassName, searching for “mcn” would find it. It works similarly if you have a global variable named myGlobalVariable and type “mgv”. It is smart enough to count the lowercase “my” as if it were MyGlobalVariable leading to expected results.
  
  

  Enable fuzzy search and see smarter search results using approximate string matching.

   

   

• Select all items in open file in solution (Ctrl + A)
  You can now select and highlight multiple files and open them simultaneously when using open file in solution. The usual shortcut Ctrl + A works.
  

  Select and open all files with the new select all shortcut.

Improved support for Braced Initialization Lists / Uniform initialization (C++ 11)

2023.6 also improves support for braced initialization of lists and/or uniform initialization. Brace initialization lists and uniform initialization provide a more consistent and flexible way to initialize objects in C++. 

These features  improve code readability and reduce the chances of certain types of errors. Visual Assist’s parser will recognize these lists and highlight and suggest auto corrections within them.

Improved support for constexpr, consteval and constinit  (C++ 20)

These features are related to compile-time evaluation and initialization. They have specific use cases and are used to enforce certain behaviors at compile time. If you haven’t been using these, here’s a quick breakdown:

• constexpr used to indicate that a function or variable can be evaluated at compile time.
• consteval a stricter version, ensuring that the function or expression is only evaluated at compile time and cannot be evaluated at runtime.
• constinit is used to indicate that a variable must be initialized at compile time and, once initialized, its value cannot be changed during the program’s lifetime.

When using these features, Visual Assist will recognize what you are trying to accomplish such as refactoring commands mainly. Refactorings such as Create From Usage will now properly handle these keywords.

New code inspection for detecting “magic-numbers”

This new Clang-based code inspection checks for instances of magic numbers—or numeric literals that are used without any definition—that are advised against by many coding guidelines for readability sake.

Enable code inspections by navigating to Extensions ->> VAssistX ->> Code Inspection ->> Enable code inspections.  This specific code inspection is disabled by default because some users may be intentionally using it and are not interested in “fixing” it.

Then you can either click on detected issues underlined in blue, use the Quick Refactoring Menu (Shift + Alt + Q) while on the highlighted issue, to allow VA to do it for you. In this case, there is no automatic fix so it will prompt you to define a variable with that number as its value and use the variable instead. 

Protip: VA can help do that for you with the introduce variable feature. If you highlight the number, then use the Quick Actions menu and select Introduce Variable it will ask you for a name and pull the number out into a variable for you.

You can read more about the readability-magic-numbers code checker on Clang’s documentation. 

New move class feature

You can now move entire classes into different files with the new move class feature included in 2023.6. 

For example, if you have a class named MyClass, with its declaration in MyClass.h and its definition in MyClass.cpp, you can move the entire class into a new pair of files, MyClassNew.h and MyClassNew.cpp. 

This is useful if you have a header and source file pair (.h and .cpp) that contain multiple classes and you want to break that up into multiple files.

Bug fixes and improvements

For this release, we have a couple of fixes based on user requests. The most notable of these improvements include a fix for file exclusion instructions using .json configs similar to a previous release, a parser improvement for Unreal Engine 5, and improved auto-detect logic for Unity.

• Fixed multiple issues with file exclusion logic when reading from “.vscode\settings.json” configs.  
• Our parser now better understands Unreal Engine 5.0 (specifically that build) types, such as FVector.
• Fixed Create from Usage behavior when used inside const inline methods. 
• Fixed coloring of [[fallthrough]] marked enum items. 
• Attempted to fix rare temporary hang when debugging C# Unity projects.
• Code Inspections options dialog now displays much more quickly. 
• Improved Unity engine auto detect logic to reduce false positives.

Thanks to those who submitted their feedback and bug reports. Please continue sending them our way. Send us a message or start a thread on the user forums for bug reports or suggestions.

You can also check our download page to manually update to the latest release. Happy coding!

The post Visual Assist 2023.6 release post first appeared on Tomato Soup.

As many of our readers know, Visual Assist is a productivity extension for Visual Studio that provides a set of intelligent refactoring, navigation, code highlighting and generation features for C++ development, along with tailored features that help game devs make the most of Visual Studio’s integration with Unreal Engine. For those who are newer to our blog, check out this article for a quick overview of how Visual Assist can make game dev with Unreal Engine easier. In addition, last month was the first version of Visual Assist to officially support Unity. Read more about it in the VA 2023.4 build announcement.

Today, we’d like to introduce you to one of our partners, Assembla, and share how their Perforce hosting offerings can make game dev with Unreal and Unity even more efficient. Assembla provides a cloud-based source code management platform that brings project management, source code hosting, security solutions and other integrations under one roof to streamline your E2E dev pipeline. 

Assembla hosts Perforce Helix Core in the cloud under two solutions: Perforce Cloud, a quick-to-deploy SaaS platform, and Perforce Enterprise, where Assembla DevOps engineers set up Perforce Helix Core in a fully managed, dedicated AWS server or a custom network of servers to support global teams. With Assembla’s solutions, gaming studios save the overhead of managing their own on-prem or cloud solution and can focus on creating the best game possible rather than infrastructure. Additionally, teams can scale globally without worrying about how source control and file transfers will perform across locales.

Assembla was the first company to package Helix Core for the cloud and remains a leading expert today, bringing you the best features: 

• Fast commit performance
• Faster revisions, code testing and binary file handling 
• Automatic backups for every commit
• Virtually unlimited cloud repository storage
• Track and trace any code changes to identify security threats
• Native support for Unreal Engine and Unity
• Helix DAM to help speed up the creative process for your artists and designers
• Helix Swarm for code review

Assembla also supports Perforce’s third-party integrations with standard game dev tools such as Visual Studio, Jira, Adobe, Maya, Microsoft, and AWS. To further streamline your dev pipeline, Assembla recently launched a new CI/CD integration that supports GPU builds through Travis CI, improving the speed and efficiency of processing your games. 

Discover how Assembla can help you make the most of Perforce so you can create virtual worlds and immersive games by visiting their Gaming Development page.

The post Game Development Showcase: Visual Assist + Cloud Hosted Perforce from Assembla first appeared on Tomato Soup.

Std::maps is a staple in the C++ world for sure. It’s reliable and useful, but in this presentation, David Millington goes a level deeper and examines how other features offered beyond the standard library can be used to maximize the usefulness of the data structure. 

Quick Refresher on Maps

Maps are essentially a way to store key-value pairs in an ordered structure. This creates an associative array that can be used to lookup connected pieces of data. Maps are ubiquitous. Value-key lookup is used everywhere: filenames to files, index number to row/column, ID number to name, and the list goes on. 

Maps can be ordered or unordered. They are also similar to static arrays and vectors but they possess a few key differences such as memory management, performance, and appropriate types—watch this section of the webinar to learn more.

Things to Remember from the Webinar

• Where to use std::map and std::undordered_maps
• Difference between maps, static arrays, and vectors
• The many map implementation libraries available
• The importance of iterating in order
• Comparing performance of ordered and unordered maps

Slide Deck Presentation

Replay

The post Summer CodeFest: Magnificent or Malevolent: Maps! Measured, Monitored, & Magnified! [Mrecap] first appeared on Tomato Soup.

This release marks a major milestone in Visual Assist’s history as it starts its official support for Unity engine development. Also in this release: start of support for CUDA development for C/C++ and numerous parser improvements. Read on further to get the complete details of the changes and improvements in this release.

Start of official support for Unity

It’s been a long time coming but Whole Tomato is glad to announce that the upcoming 2023.4 build will feature the first of many Unity-specific features. Nope, not the hivemind—we are of course talking about the very versatile game engine and game development platform.

For those unaware, the Unity engine is the backbone of both 2D and 3D games ranging from wildly popular and suspicious games, all the way to full blown highly-acclaimed triple A titles.

Visual Assist has been popular for helping game developers deal with complex C++ code. Starting from the upcoming release, Visual Assist will expand its focus to C# game development. Users can expect VA staples such as refined navigation, intelligent autocomplete, code refactoring, and the like to work as well for C# work.

Furthermore, users can also submit feature requests specific for Unity development. We are starting with shaders—more on this below—but if you have any suggestions as to what features are missing in your Unity development, do let us know by emailing support.

Shaders for Unity

The start of official support for Unity development is headlined by shader file support. Similar to our previous addition of supporting HLSL, we are kicking off Unity updates by adding its shader files to our list of supported languages.

CUDA C/C++ Development

If you are a data scientist, software engineer, or a plain hobbyist looking to harness the power of your GPU for general purpose programming tasks, then you would most likely know about Compute Unified Device Architecture (CUDA). This programming model developed by Nvidia allows programmers to utilize the multi-core performance of graphics cards for other non-graphic applications (although it’s perfectly fine to use for 2D/3D too!)

If you are interested in CUDA, then rejoice! VA 2023.4 also marks the start of official support for CUDA development. Visual Assist’s can now parse and analyze CUDA related syntax, libraries, and APIs so you can have IntelliSense-like features, navigation, and highlighting for CUDA (.cu) files.

A CUDA file with proper syntax highlighting and code analysis features.

Parser Improvements: template functions with auto / trailing return type and std::tuple autocompletes 

With VA 2023.4 will now properly highlight and parse trailing return type features that bypasses a C++ limitation where the return type of a function template cannot be generalized if the return type depends on the types of the function arguments. This release specifically deals with some of the edge cases reported by our users.

Trailing return type features can be used by declaring a generic return type with the auto keyword before the function identifier, and specifying the exact return type after the function identifier. Learn more about it here.

The parser is aware of sum and proper syntax highlighting and navigation features are applied.

Also fixed in this release are initializations of std::tuple autocompletes. This improves how the VA parser handles certain templated types. In the end, users will find better completion suggestions when you are typing in your codebase, such as when typing std::tuple.

Better Add Include logic

Visual Assist can add include directives for headers that resolve unknown symbols in the current C++ source file. The underlying logic for add include has been improved for better context-awareness resulting in better predictions on where to place the new include.

Add include now inserts new lines in most logical place.

Add include can be accessed by hovering over unknown symbols and opening the quick actions and refactoring menu ( Shift + Alt + Q ).

Some other spring cleaning-type improvements

We’ve also made some changes to a few minor things to the UI and the options in the app that you should know about. Firstly, our shader support has been available for a few rounds of releases already and we’re excited to announce that it has finally finished its beta phase and will now be enabled by default. 

Secondly,  we’ve streamlined our game Development tab of our options dialog. This is to make room for upcoming additions (stay tuned!)

Thirdly, we’ve tweaked some tomatoes and icons along the way to better respond to your actions and better display what options are available to you. Relevant options and menus will be emphasized when they are needed; secondary options will subtly fade into the background otherwise. This is in line with our commitment to distraction free coding.

Lastly, if you’ve missed or haven’t installed the latest version yet, you may have noticed that the Visual Studio marketplace listings for the 32 and 64-bit versions of Visual Assist have now been combined. Versions 2010 – 2022 will now be accessible from one listing.

Bug Fixes

• Fix for ‘VaMenuPackage’ package error affecting VS2022 17.7.0 3.0 load
• Fixed issue where some types with leading macros before template definitions were not parsed correctly.
• Fixed issue where autocomplete of some types, such as std::tuple, would produce partial results.  
• Fixed rendering of suggestion list tomato icons in Visual Studio 2022. 
• Fixed issue where the VA Navigation Bar could become smaller than intended.
• Fixed Code Inspections error that could happen in some cases in Visual Studio 2022 17.6+. 

Thanks to those who submitted their feedback and bug reports. Keep ‘em coming. Send us a message or start a thread on the user forums for bug reports or suggestions.

Contrary to the preview blog statement, VA 2023.4 is a bit different as it will be released simultaneously—no rolling release mechanism as it includes some crucial updates we want to share to everyone as fast as possible. You can also check our download page to manually update to the latest release too. Happy coding!

The post Visual Assist 2023.4 now released first appeared on Tomato Soup.

What are code inspections?

Code inspections is a feature in Visual Assist that automatically checks source code for issues and code smells, and suggests the appropriate fix. The main benefit of using code inspection is better overall code quality with minimal effort.

Code inspections work by utilizing code checkers, sometimes referred to as static analyzers. These are tools that analyze your source code passively—it happens as you type your code. You do not need to actually compile and execute your code to detect a problem (i.e. finding bugs and errors using run-time techniques such as testing).

Code issues are underlined in blue. Line information and a description of the issue is also shown in the VA Code Inspection Results window.

It looks for common patterns, broken coding conventions, and potential bugs in the code using algorithms and special techniques. The purpose of code checkers is to catch problems early in the development process, which can save a lot of time and effort later on. 

What issues can it detect?

The issues and code smells that can be detected vary widely from stylistic infractions on coding convention, all the way to system critical errors.  Here are some of the common fixable issues:

• Detecting and updating obsolete coding syntax
• Highlights possible readability issues and broken coding conventions
• Checking type-related errors (such as making invalid type conversions or assigning values of incompatible types, using uninitialized variables, or.)
• Wasted resources due to inefficient memory allocation/deallocation.
• Other issues of non-obvious, but potentially dangerous, incorrectness

Visual Assist’s code inspection feature is based on LLVM’s /Clang-Tidy code analysis engine so you can be sure that it covers a variety of checks targeted at finding security and API usage bugs, dead code, and other logic errors. Additionally, we extend the functionality through the use of ‘evaluated’ checkers (more below).

READ: More examples from a blog by Bartek from C++ Stories

Evaluated and unevaluated checkers

Code checkers are added gradually to the list of Visual Assist code inspections. All checkers that are in the list are thoroughly evaluated, checked, and tested. Evaluated checkers often include changed functionality that is not in the base clang-tidy, making them more reliable and safe. This is a key part of the value of the checkers we include. Using evaluated checkers guarantees that the code will be refactored properly and any suggested fix will not break anything.

On the other hand, unevaluated checkers are still based on Clang-Tidy’s extensive list but have not undergone the same quality assurance tests as its counterparts. Almost a hundred unevaluated checkers have been added in Visual Assist 2023.2.

Note that unevaluated checkers will still suggest the recommended fix and behave like normal checks, but users are advised to manually ensure that everything is working correctly. The benefit that this brings is that developers can know what and where a potential issue lies—which is oftentimes the bulk of the work.

Why use code inspections to fix issues and refactor code?

Running code inspections lists down issues in a window for you to examine before implementing fixes.

Code inspections read source code line by line, analyzing the structure, logic, and syntax. It pays attention to specific patterns or coding conventions that may indicate potential issues. As they encounter a line of code, it uses a set of rules and algorithms to determine if the code adheres to best practices or if there are any deviations.

Using code inspections automates a lot of the manual checking and verification that developers would traditionally do. With it, it no longer matters how familiar a developer is on a project, or how large a solution is—it all goes under the same level of scrutiny.

it provides some of the following benefits as well:

• Be able to utilize modern coding practices without actually knowing them.
• Improve code quality with minimal refactoring risk.
• Detecting potential code issues early.

WATCH: Understand how code inspections are evaluated

How to use code inspections to eliminate code smells

First, make sure to enable it by navigating to Extensions -> VAssistX -> Code Inspection (beta) -> Enable code inspection. 

Then you can either click on detected issues underlined in blue, use the Quick Refactoring Menu (Shift + Alt + Q) while on the highlighted issue, or use the code inspection dialogue to implement changes in batches.

WATCH: Code inspections in action

Visual Assist by Whole Tomato: Filling Gaps in Visual Studio for C/C++ and C# Developers

Visual Assist is a productivity extension for Visual Studio development work. It provides a set of intelligent refactoring, navigation, code highlighting and generation features for C, C++, and C# development. With its highly-efficient memory management and minimal UI, Visual Assist gives developers uninterrupted access to advanced features without slowing down the IDE.

Visual Assist is one of the definitive plugins that conceptualized and shaped most of the current features you see now in Visual Studio. And to this day it continues to develop user-centric design for maximum productivity and usability.

Download Visual Assist here.

The post Everything you need to know about code inspections first appeared on Tomato Soup.

Our team of experts will take you on a tour of the new features, highlighting their benefits and demonstrating how they work. Whether you’re a game developer, designer, or engineer, you won’t want to miss this opportunity to unleash the full potential of Visual Assist.

Join us and discover how these new features can take your work to the next level!

This webinar has concluded. If you missed it,  you can scroll down and watch the replay, skim through the highlights, and access the presentation slide. 

Webinar Slides

Webinar replay and summary

• 0:00:00 – Presenter & Visual Assist Introduction
  Meet the presenters and learn about the primary features of Visual Assist.
• 0:06:21 – Webinar Rundown
  A brief rundown of the focus of this webinar, Visual Assist 2023.2.
• 0:08:40 – Code Inspections
  Learn about Visual Assist’s code inspections feature, how to use its features properly, and get an idea of how it became the feature it is today. Special mention to unevaluated code checkers—the star update of 2023.2
  Key takeaway: Refactoring via code inspections can catch severe errors that regular error highlighting can miss.
• 0:18:15 – Shaders Support
  Recap on when official support for shaders were added last year, and what new features have been added since then.
  Key takeaway: Exiting beta phase. Better reliability for even more shader files.
• 0:20:20 – Integrated Menu
  Explaining the rationale of why an integrated menu was necessary, and how to access and use it.
• 0:22:07 – Live Demo: Unevaluated code inspections and new shader support
  A demonstration of the key features in VA 2023.2: the 100+ added code inspections and new shader file features.
• 0:28:52 – Audience Q&A
  Chris and David answer questions from the audience. Question range from IDE usage, to feature clarifications, and even to future plans for the extension.

What’s Next?

Interested in learning more about Visual Assist and it’s many hidden features? Browse through our top 10 features, or for a more complete and comprehensive reference, please visit our documentation. And if you have any questions or clarifications, feel free to send support a message.

If you have something specific to request for the next webinar, send us your feedback at this email.

The post Tapping into Limitless Code Inspections: What’s New in Visual Assist 2023.2 [Webinar Recap] first appeared on Tomato Soup.

Greatly expanded code inspections with over 100 new Clang Tidy checks

The biggest item in this release is the added support for all code checks available from Clang Tidy. Code inspections are semi-automatic checks that prompt the user when Visual Assist’s engine recognizes outdated syntax or an otherwise correctable code issue. 

For context, Visual Assist’s code inspection is based on a series of checks from LLVM Clang Tidy. And before we add support for a new check, we rigorously test it for accuracy and compatibility. This process ensures that the check will give consistent suggestions for almost all use cases. In fact, this is the process undertaken for the two new added code inspections in this release—more on them later.

What we’ve added is the ability to use unevaluated Clang Tidy checkers as Code Inspections straight from Visual Assist. This greatly expands the types of code issues that can be detected with code inspections enabled. There is a slight tradeoff in that you may need to do some manual testing when using unvetted checks. Take a look at the full documented list of Clang Tidy checks.

The latest addition to our list of vetted code inspections are for bugprone-swapped-arguments and bugprone-argument-comment. These checks look for potentially swapped arguments by looking at implicit conversions and detect typos in argument comments and suggest automated fixes for them, respectively.

Lastly, we’re also announcing that code inspection is officially out of beta and is now running on Clang engine version 15.0. The beta label is mostly a formality and all functionality should function the same. If you haven’t, we highly advise enabling code inspections.

Protip: When running comprehensive code inspection checks in a file, you can sort and group issues by level. Code inspection levels refer to an arbitrary metric representing severity given to a code check. Level one signifies critical, level five being on the level of a reminder, and zero refers to unflagged checks.

Extended Shader File Customization

Due to consistent demand and great feedback, a significant portion has also been given to further improve our support for shader files. In fact, as of this release, it is in the last phases of beta testing and will most likely be available for general support very soon.

In this release, you can now use custom shader file extensions (there are no longer extensions considered “default”). Coloring and syntax highlighting has also been drastically improved, with almost all bugs ironed out as well.

Enable support for shader file parsing by accessing Visual Assist Options ->> Game Development ->> Enable support for shader files.

Integrated-style extensions menu (pre-Visual Studio 2019)

In Visual Studio 2019, the toolbars and plugins were rearranged. Instead of being able to access your plugins in the main toolbar, you had to instead go under the Extensions menu. 

For the most part, this made sense—it’s easier to find all installed plugins and access their features correspondingly. However, for users who had one or a handful of plugins or are more comfortable using the mouse instead of shortcuts, the extra step might be bothersome (e.g. mouse users with only VAX installed).

Some users expressed interest so we’ve added the option for an integrated-style menu for extensions (similar to the pre-VS 2019 setup). 

This new menu mode can be enabled via Extensions ->> VAssistX ->> Visual Assist Options ->> Display ->> Switch to Legacy Style Main Menu.

Implement Virtual Methods context menu option to check / uncheck all.

The last of the new features in this release is a quality of life change. Inheriting from other classes is made much easier and intuitive using the Implement Virtual Methods feature.

While in the dialog, we added a small tweak that allows users to check and uncheck all possible methods using a simple checkbox. Neat little addition, we hope.

Visual Assist’s Implement Virtual Methods feature provides a neat little dialog to make inheriting from other classes quick and intuitive.

Bug Fixes

• Fixed issue where installer exe could report errors after a successful install.
• Improved auto type deduction for const, pointers and chained function calls.
• Fixed issue where Code Inspections could fail with the latest MSVC includes.
• Fixed issue where shader coloring may not be applied to the correct file extensions.
• Fixed issue where shader coloring sometimes not applied to files opened automatically on solution load.
• Fixed issues which could lead to the VA Navigation Bar being drawn incorrectly.  
• Fixed issues which could lead to missing icons.
• Improved tab completion in C# to interact better with build in tooling.
• Fixed minor visual theming issues in various VA dialogs. 

Much thanks to those who submitted their feedback and bug reports. Keep ‘em coming. Send us a message or start a thread on the user forums for bug reports or suggestions. Happy coding!

The post Visual Assist 2023.2 released first appeared on Tomato Soup.

What Is C++ Refactoring?

Refactoring is the process of improving or updating existing code without changing the functionality of the program. In the process of refactoring, you can improve the design, structure, and implementation of the software, and clean up unnecessary dependencies, code duplications, and other types of confusion.

In software development, development teams are constantly extending the code and adding new functionalities. Over time, the quality of the code can deteriorate, which causes difficulties in its understanding and the occurrence of errors. Code refactoring makes it possible to improve the readability of the code, simplify it, create a modern architecture, simplify the maintenance process, and reduce the number of errors.

What Are The Advantages Of C++ Refactoring?

• Making code easier to understand and analyze.
• Simplifying the addition of new functionality to software results in increased development efficiency.
• Improvement of software architecture.
• Optimizing resource usage.
• Increased security.
• Productivity improvement.
• Simplifying the process of finding and fixing errors.
• Reducing the number of errors.

When Should We Start Refactoring A Code?

For effective refactoring, the developers must be familiar with the code. In addition, to avoid errors in the refactoring process, it is important to have sufficient code coverage with automated tests.

You should think about code refactoring in the following cases:

• The code is hard to understand. In this case, the process of updating the code and finding errors becomes longer, and it is possible to create duplicates, unnecessary dependencies, and even more complexity of the code.
• Software slowdown. When the code is complex and has many dependencies, it can slow down the software. This leads to dissatisfaction among end users who may refuse to use it.
• The presence of a large number of errors in the code. If the code is complex and confusing, the debugging process becomes much more difficult. Fixing one error may cause others to appear. To avoid this, it is important to refactor the code to simplify it as much as possible.
• Code duplication. Each element of the program must be unique. If there are duplications in the code, it increases the time to read it and makes it difficult to understand, as well as increases the probability of errors.

What Are C++ Refactoring Best Practices?

• Before refactoring, it is important to cover the code with automated tests.
• Refactor incrementally, making small changes to the code while keeping the program in a working state.
• Separate the processes of refactoring and creation of new functionality. No new features should be added during refactoring.
• The result of refactoring should be simpler and more understandable code.
• For testing a few refactoring iterations, use not only unit tests but manual testing too.
• Follow the coding standard used by your company.
• Remove deprecated code such as dynamic exception specification.

How To Refactor Code Easily?

Visual Assist is a productivity extension for Visual Studio that provides advanced code refactoring tools, quick navigation, rendering, correction, code maintenance, and code inspection functions. Using the Visual Assist C++ extension, you can easily improve code readability, simplify it, and fix broken code. You can refactor separate class or several dependent classes simultaneously.

How To Access Refactoring Commands?

You can access the refactoring commands in several ways:

• Go to the desired symbol and open the context-sensitive quick action and refactoring menu using the Shift+Alt+Q short keys.

• Use the context menu of the text editor to open a complete list of refactoring commands.
• Place the cursor over the desired symbol to display the icon, then click the icon to open the context menu.

How To Change The Signature Of A Method?

Visual Assist allows you to change the method name, return type, visibility, names, types, number, and order of parameters in a simple dialog box. Automatic signature change is possible in all inherited and overridden methods, as well as in all method references.

How To Encapsulate The Field?

With Visual Assist, you can create accessors to a member field by encapsulating the field. Accessories are created and assigned automatically. You can create accessor methods next to the declaration in the header file and can stay in the header file or implement them in the source file.

How To Extract The Method?

You can quickly simplify long methods and make them easier to read and understand. To do this, highlight the required code segment and call the Extract Method refactoring. Visual Assist automatically detects the method signature, moves the selected code segment into the new method, and replaces the segment with a call to the new method.

How To Move Implementation?

In C/C++, you can easily move a method implementation from the source to the header file and vice versa. To do this, select the desired method, call up the refactoring context menu, and select the move command.

In addition, it is possible to move all methods from the header file to the source file in one operation. To do this, call the move command from the class name. This will bring up a dialog where you can select the methods you want to move.

How To Rename?

Visual Assist provides the ability to quickly and accurately rename symbol definitions and declarations, all references to them, and occurrences in comments and lines in the active project and throughout the solution. You can rename classes, enums, fields, macros, methods, method parameters, and variables. To do this, choose Rename from the refactoring menu, specify a new name, and use the preview to determine which occurrences of the symbol need to be renamed.

You can also rename the document and related files without breaking the build. Visual Assist automatically updates files, projects, and solutions and then propagates the renames through source control systems that integrate with Microsoft Visual Studio.

How to automatically inspect your code?

Visual Assist provides a function to check the code for certain quality issues based on LLVM Clang tidy. It diagnoses and corrects common programming errors, such as style violations, misuse of the interface, and errors that can be detected by static analysis. The code inspection function runs in a process separate from the Visual Studio process. This avoids reducing IDE performance.

Enable code inspection in the Visual Assist options to highlight code issues in the Visual Studio text editor. Code inspections will appear as a blue line on the line where an issue is found. You can click on this to accept the suggestion. You can also scan an entire file and make batch edits.

Here are some of the code inspection checks available in Visual Assist. If you want the complete list, head on over the list of code inspections.

Are you interested in how to improve developer productivity in Visual Studio using Visual Assist and C++ refactoring? Download a free trial of Visual Assist today.

The post C++ Refactoring Tips And Tricks first appeared on Tomato Soup.

What Is Visual Studio?

Visual Studio 2022 is one of the most powerful and popular IDEs (Integrated Development Environments) among .Net and C++ developers. It can be used for the development of various types of software, including websites, web services, mobile, desktop, web apps, games, and so on.

Visual Studio provides many features that speed up and simplify the process of writing and testing code, including a code editor with IntelliSense and code refactoring, an integrated debugger that can work as a source-level and machine-level debugger, tools for creating the user interface, a code profiler, etc.

You can download the Visual Studio installer from the official website.

How To Use Visual Studio For C++?

C++ is a popular low-level, high-performance programming language that can be used to create many different types of applications. Visual Studio has all the tools you need to easily write C++ applications.

Visual Studio supports various versions of the standard for the C++ programming language and allows you to use all its modern features. With Visual Studio C++, you can perform classic Microsoft Windows desktop development or universal Windows applications for HoloLens, Surface Hub, PC, and Xbox development.

In addition, you can use Microsoft Visual C++ for Linux development, mobile, and game development.

What Are The Most Common Visual Studio C++ Pain Points?

Although Visual Studio offers many useful tools and is a great solution for C++ development, there are pain points that developers who use it occasionally run into.

Poor performance

While it is designed for C++, these projects can sometimes be extra complex and Visual Studio may struggle performance-wise. It would require more resources such as disk space and operating system memory. This is especially noticeable when working with large projects.

Long build time and slow compilation

The process of building projects takes a lot of time. The compilation is slow, which greatly complicates and slows down the process of finding and correcting bugs in the source code.

Stutters and freezes during coding

Sometimes there are cases where the machine freezes during coding, which leads to the need to reboot it. In this case, the programmers need to start over the unfinished work should they be unlucky enough to have forgotten to save.

Chaotic file organization

When working with C++ files in Visual Studio, you need to first create folders and files on the computer disk. Then you need to create a project in Visual Studio and add the already created files and folders to it. The project only lists the names and paths of files and folders that should already exist on your drive. This is different from how Visual Studio works with other programming languages and is awkward and confusing, especially on collaborative projects or complex solutions.

Understanding Complex C++ Language

C++ is a complex programming language that supports higher-order types, a standard library for CPU cache line sizing, dimensional analysis, and other functional paradigms. Even experienced C++ developers have to learn hidden features and discover new ways to optimize their development.

So, it’s time to solve the most common Visual Studio pain points.

What Are The Visual Studio Extensions Available In The Market?

Visual Studio Marketplace [1] provides a wide range of extensions to enhance the capabilities of Visual Studio. GitHub Extension for Visual Studio, CodeMaid, and Visual Assist are very popular among the developer community.

By making it simple to connect to and collaborate with your repositories on GitHub and GitHub Enterprise, GitHub Extension improves Visual Studio 2015 and Visual Studio 2017. It creates new repositories or clones existing ones to get working together.

Our C#, C++, F#, VB, PHP, PowerShell, R, JSON, XAML, XML, ASP, HTML, CSS, LESS, SCSS, JavaScript, and TypeScript coding may be cleaned up and made simpler with the help of the open source CodeMaid Visual Studio extension.

More extensions are available in the marketplace to enhance the capabilities of Visual Studio and improve productivity. However, Visual Assist provides solutions for most Visual Studio C++ pain points mentioned earlier. The following section will discuss it in detail.

The Pain Killer You Need – Visual Assist

Visual Assist is a productivity extension for Visual Studio that has many features for refactoring, quick navigation, code generation, and much more. It provides tools for the automatic detection and correction of errors in the code, automatic understanding, and completion of the code, syntax highlighting, and improved debugging functions. Using Visual Assist greatly simplifies the process of coding in Visual Studio C++ and increases development productivity.

Advantages of Using Whole Tomato –  Visual Assist

Let’s list the main benefits of using Whole Tomato Visual Assist.

Increase Your Productivity

Visual Assist offers advanced navigation features that let you quickly go to any file, method, reference, or code symbol in your projects or solutions. You can also automate code refactoring activities. Advanced features of automatic code generation make the process of writing code as fast as possible, which significantly increases development productivity.

Fast & Responsive Tooling

All Visual Assist commands and tools are responsive and work quickly, which allows you to use them even when working with large and complex projects.

Helps Optimize Workflows

With Visual Assist tools that make code generation and debugging easier, you can optimize and streamline your project workflows.

Adds Support (Fills Gaps)

If you have any problems with Visual Assist, you can use our knowledge base or search for a solution to your problem in the forum. In addition, there is technical support where you can get answers to all questions about working with the Visual Assist extension.

Everything Becomes Customizable

You can fully customize Visual Assist to your liking. This includes customizing colors and shortcuts.

Final Verdict

Visual Assist is the best extension for Visual Studio C++ development, which has numerous advantages and makes the coding process quick and easy. Give Whole Tomato a spin. Sign up for free.

FAQ

Which Visual Studio is Best for C++?

Visual Studio is a widely used IDE that is excellent for development in C++ and supports various standards of this programming language. Another popular Microsoft product used for C++ coding is Visual Studio Code. It is an open-source, cross-platform code editor that offers “Microsoft C/C++” extensions for C++ programming.

How do I Find Build Errors in Visual Studio?

To find build errors in Visual Studio you should choose View -> Error list or use the shortcut Ctrl+\, E. In addition to errors, you can also view a list of warnings and other messages.

How do I Resolve to Build Errors in Visual Studio?

Select the error message in Visual Studio and press F1. Visual Studio will open the documentation page for this error, where you can find workarounds.

[1] https://marketplace.visualstudio.com/

The post Solving The Most Common Visual Studio C++ Pain Points first appeared on Tomato Soup.

Luckily, there are certain techniques and technology that developers can utilize to make it a bit easier. Learn more about how cloud-hosted Perforce is something you should be capitalizing on for collaborative Unreal game development in this webinar co-hosted by Whole Tomato and Assembla.

Expect the following in this webinar:

• Know about the benefits of collaborative asset management and remotely managing them.
• Build familiarity with web-based version control and source code management software
• Set up an Unreal game project to sync with remotely hosted perforce server and productivity tools

The webinar is happening on February 22nd, Wednesday 10 AM CST and will be presented by Whole Tomato’s own lead engineer and product manager, Chris Gardner and David Millington. Completing the trio is Chris Hughes from Assembla.

—

This webinar has concluded. If you missed it,  you can scroll down and watch the replay, skim through the highlights, and access the presentation slide. 

Slides

Webinar replay and summary

Timestamps and Section Summary

• 0:00:00 Introduction and Agenda
  A brief introduction of the presentation’s agenda and what the audience can expect to learn from the presentation.
• 0:04:15 Assembla Feature Highlight
  Learn about what Assembla is, and what powerful features it provides with an explainer from Assembla PM himself. Learn more about Projects, spaces, issues, and the possible integrations available in the platform.
• 0:09:44 Where to Use Assembla
  Setting Assembla with Unreal Engine is the core of this webinar but there are many different possible use cases for it depending on how you set up your workspace and views. It could be an all-encompassing project manager and planner, or it could be an internal help desk ticketing solution. Chris explains the possible setups in detail in this section.
• 00:14:09 Using cloud-hosted Perforce with Assembla
  Apart from providing a cloud-based system, Assembla also provides users access to a support and devtools team ready to assist. Chris provides an explainer.
• 00:15:55 Intro to Cloud-based management and Source Control
  In this section, Chris G. gives a rundown of his part of the webinar. He explains the process of downloading and uploading to cloud-based systems. And he explains that the process remains the same whether it’s source code, or even gigabyte huge assets. If you want to set up your own cloud-based Perforce system for Unreal and don’t know where to start, it would be best to begin here.
• 00:17:40 Source control: Definition and Benefits
  What is source control and what are the following factors to consider when choosing a platform? Learn more about it in this section. Chris also talks about regression, version security, and historical recall in this section.
• 00:21:30 Unreal Engine 5 & Perforce (Helix Core)
  Why does Unreal have specific integration and built-in support for Perforce? What features does Unreal provide that makes this integration easier? Chris talks about the scripting features inside Unreal and how you can set this up to connect to servers and automatically sync changes internally and externally among team members.
• 00:23:18 Partner Shoutout: Visual Assist
  While not directly related to setting up Perforce with Unreal, Visual Assist is something that Unreal Engine developers should have. Get a brief intro to one of the best C++ Visual Studio plugins in this section by the lead developer of the tool himself.
• 00:25:17 Demo Start: Unreal Engine 5 source control
  The main event of the presentation. Chris G. takes us step by step into how to set up Unreal Engine with Assembla—from initializing Perforce, all the way to setting up your first space and first repository, and finally to your first commits.
• 00:25:49 Demo: Adding a repository
  The very first thing you need to do to sync to Assembla is initialize a P4 repository in your space. This section discusses how to set your first repository, find the connecting link on Perforce, and logging in to your Assembla instance.
• 00:27:27 Demo: Create a workspace
  After connecting to Assembla, you will need a place to upload your files and assets to. Chris opens up Perforce and sets the main stream in this part of the demo.
• 00:30:11 Demo: Summary of process
  Few reminders and things to keep in mind before you are all set and ready to go. He also opens the Unreal editor to check if the initialization was successful.
• 00:31:28 Demo: Verifying integration via Unreal Editor
  Check to see if you did the setup correctly by verifying the integration inside the Unreal Editor/Perforce P4. Chris commits a sample change using a blueprint file.
• 00:34:25 Demo: Final checks
  Some other tips and reminders for using other integrations such as Visual Studio plugins and hookups. Afterwards, you just have to share the repository with teammates and everyone should be able to collaborate.
• 00:38:50 Question and Answer
  Here are some of the questions from the Q&A
  – Is Assembla beginner friendly?
  – Does version control work for binaries?
  – Supported languages for security scans?
  – License costs?
  – Perforce client vs Assembla web client?

What’s Next?

Interested in getting started with Assembla and its Perforce integration for game development? Get started by visiting Assembla’s game development web page.

And if you’re using Unreal Engine, give Visual Assist a try. It’s the perfect plugin to pair with Assembla for faster and easier development.

If you have something specific to request for the next webinar, send your feedback to this email.

The post Setting up cloud-hosted Perforce source control for Unreal Engine [Webinar Recap] first appeared on Tomato Soup.

Improved parser auto type deduction for pointers

This release updates how Visual Assist handles auto type specifiers, particularly when reference is coming from a pointer. Previously, there was a change that when auto assignments are used, any flags (such as const) may be ignored. With this release, VA now has better pointer deduction avoiding such instances.

Parser support C# tuple deconstruction

This update is useful for those using the C# equivalent of the previously released tuple deconstruction for C++  to avoid verbose initialization of variables.

What this update does is that when you assign multiple variables at once using a predefined struct, VA will be able to recognize those variables. Consequently, this allows its features such as syntax highlighting and navigations to function properly. 

Add parser support for C++ 17’s structured binding from a constructor

This is a simple fix for an edge case for structured bindings that happens when a constructor is used. Similar to the last fix on tuple deconstruction, what this update does is that when you use the auto function to assign variables from a struct, it will now function properly even when a constructor is called.

Support for custom shader file extensions

When we added shader language and HLSL support, one of the most prominent user requests was to be able to enable support for non-standard/custom shader extensions. 

With 2023.1 you can now add custom files by adding the extension in a text field under Options ->> VAssistX ->> Game Development ->> General.

Better code formatting and behavior for Unreal Engine copy-paste

Users can recall that when typing Unreal-specific code, there is unintended indentation behavior as a result of VS not understanding UE specifiers such as UFUNCTION and UMACROS.  

With Visual Assist enabled, the automatic indentation present in default Visual Studio is disabled. And in this release, we’ve improved on this behavior by extending it to copy-paste. What this means is that when copying or cutting blocks of Unreal Engine code, the pasted code will still have the correct indentation in place.

New UI in Find References results

Previously, when using find references, the default scope of the search was the currently opened project or file. This update is for those who found that results shown by find references seem to be incomplete— it is now more apparent that you have the option to specify the scope of the search (ie. just the open project or the entire solution).

In this release, there is a newly added notification after every search that prompts the user to redo the operation for the whole solution.

Code inspections for bugprone-inaccurate-erase and bugprone-bool-pointer-implicit-conversion

Lastly, we’ve added two new code inspections based on clang tidy for bugprone-inaccurate-erase and bugprone-bool-pointer-implicit-conversion.

The first one is useful if you use std::vector and you are using remove() or erase() which often uses hard to read/type syntax. This inspection makes sure that when you use erase(), it works properly. 

The second one is useful when you have a pointer as an argument to an if statement (or anything resembling a bool). This is because it has to be dereferenced first or else it will default to a True. This check notifies the user if the pointer has not been dereferenced. 

Both of these checks are useful because in both of these instances, the code will still compile successfully—giving a false impression that everything would work as intended.

Bug Fixes

We also have a couple of bug fixes. And although they are small bugs, we hope this would be beneficial to users who encountered problems around the following:

• Fixed issue where icons may be missing in Visual Studio 2022.
• Fixed issue where folders / JSON files may be unnecessarily created when hovering the mouse cursor over symbols.
• Fixed convert suggestion listbox keyboard shortcut display to update when the shortcut is changed. Note: shortcuts shown are now dynamic.

Keep the reports coming. Send us a message or start a thread on the user forums for bug reports or suggestions. Happy coding!

The post Visual Assist 2023.1 released first appeared on Tomato Soup.