Visual C Fp Fast Game Dev Average ratng: 3,8/5 472 votes

In C or C, does the compiler option of floating point precision really make a difference in real world (small/indie) games? From my observations, setting fp:fast is many times faster than fp:pr.

  • Free standard delivery. Free returns. NZ$143.95 Special pricing for eligible students, parents and teachers. Precisely sketch and shade with 4,096 pressure points that respond to the lightest touch. Ink flows from the tip to your screen with virtually no lag, and the rubber makes mistakes disappear.
  • Oct 19, 2015 If your App is a game, then some calculations need only be accurate enough to plot the right color on the right pixels (so a display of 2048 columns needs an accuracy of 1 part in a few thousand). With game Apps, it’s unlikely you would even see any difference in the display between /fp:fast and /fp:precise.
  • Depending on processor architecture and toolchain, this floating-point based approach could be either faster or slower than the integer-based implementation from newlib referenced in a different answer. I tested myroundf exhaustively against the newlib roundf implementation using Intel compiler version 13, with both /fp:strict and /fp:fast.
  • Visual Studio 15.4 not responding while debugging high CPU 1 Solution C incorrect code generation with /fp:fast 1 Solution VS2017 spent too much time on loading breakpoints information 1 Solution Test Explorer Window pops up after debugging 1 Solution.
  • Mar 19, 2019  The C compiler in Visual Studio 2019 includes several new optimizations and improvements geared towards increasing the performance of games and making game developers more productive by reducing the compilation time of large projects. Although the focus of this blog post is on the game industry.
-->

The Microsoft C/C++ compiler (MSVC) predefines certain preprocessor macros, depending on the language (C or C++), the compilation target, and the chosen compiler options.

MSVC supports the predefined preprocessor macros required by the ANSI/ISO C99 standard and the ISO C++14 and C++17 standards. The implementation also supports several more Microsoft-specific preprocessor macros. Some macros are defined only for specific build environments or compiler options. Except where noted, the macros are defined throughout a translation unit as if they were specified as /D compiler option arguments. When defined, the macros are expanded to the specified values by the preprocessor before compilation. The predefined macros take no arguments and can't be redefined.

Standard predefined identifier

The compiler supports this predefined identifier specified by ISO C99 and ISO C++11.

  • __func__ The unqualified and unadorned name of the enclosing function as a function-local static const array of char.

Standard predefined macros

The compiler supports these predefined macros specified by the ISO C99 and ISO C++17 standards.

  • __cplusplus Defined as an integer literal value when the translation unit is compiled as C++. Otherwise, undefined.

  • __DATE__ The compilation date of the current source file. The date is a constant length string literal of the form Mmm dd yyyy. The month name Mmm is the same as the abbreviated month name generated by the C Runtime Library (CRT) asctime function. The first character of date dd is a space if the value is less than 10. This macro is always defined.

  • __FILE__ The name of the current source file. __FILE__ expands to a character string literal. To ensure that the full path to the file is displayed, use /FC (Full Path of Source Code File in Diagnostics). This macro is always defined.

  • __LINE__ Defined as the integer line number in the current source file. The value of the __LINE__ macro can be changed by using a #line directive. This macro is always defined.

  • __STDC__ Defined as 1 only when compiled as C and if the /Za compiler option is specified. Otherwise, undefined.

  • __STDC_HOSTED__ Defined as 1 if the implementation is a hosted implementation, one that supports the entire required standard library. Otherwise, defined as 0.

  • __STDCPP_THREADS__ Defined as 1 if and only if a program can have more than one thread of execution, and compiled as C++. Otherwise, undefined.

  • __TIME__ The time of translation of the preprocessed translation unit. The time is a character string literal of the form hh:mm:ss, the same as the time returned by the CRT asctime function. This macro is always defined.

Microsoft-specific predefined macros

Visual C Fp Fast Game Device

MSVC supports these additional predefined macros.

  • __ATOM__ Defined as 1 when the /favor:ATOM compiler option is set and the compiler target is x86 or x64. Otherwise, undefined.

  • __AVX__ Defined as 1 when the /arch:AVX, /arch:AVX2 or /arch:AVX512 compiler options are set and the compiler target is x86 or x64. Otherwise, undefined.

  • __AVX2__ Defined as 1 when the /arch:AVX2 or /arch:AVX512 compiler option is set and the compiler target is x86 or x64. Otherwise, undefined.

  • __AVX512BW__ Defined as 1 when the /arch:AVX512 compiler option is set and the compiler target is x86 or x64. Otherwise, undefined.

  • __AVX512CD__ Defined as 1 when the /arch:AVX512 compiler option is set and the compiler target is x86 or x64. Otherwise, undefined.

  • __AVX512DQ__ Defined as 1 when the /arch:AVX512 compiler option is set and the compiler target is x86 or x64. Otherwise, undefined.

  • __AVX512F__ Defined as 1 when the /arch:AVX512 compiler option is set and the compiler target is x86 or x64. Otherwise, undefined.

  • __AVX512VL__ Defined as 1 when the /arch:AVX512 compiler option is set and the compiler target is x86 or x64. Otherwise, undefined.

  • _CHAR_UNSIGNED Defined as 1 if the default char type is unsigned. This value is defined when the /J (Default char Type Is unsigned) compiler option is set. Otherwise, undefined.

  • __CLR_VER Defined as an integer literal that represents the version of the Common Language Runtime (CLR) used to compile the app. The value is encoded in the form Mmmbbbbb, where M is the major version of the runtime, mm is the minor version of the runtime, and bbbbb is the build number. __CLR_VER is defined if the /clr compiler option is set. Otherwise, undefined.

  • _CONTROL_FLOW_GUARD Defined as 1 when the /guard:cf (Enable Control Flow Guard) compiler option is set. Otherwise, undefined.

  • __COUNTER__ Expands to an integer literal that starts at 0. The value is incremented by 1 every time it's used in a source file, or in included headers of the source file. __COUNTER__ remembers its state when you use precompiled headers. This macro is always defined.

    This example uses __COUNTER__ to assign unique identifiers to three different objects of the same type. The exampleClass constructor takes an integer as a parameter. In main, the application declares three objects of type exampleClass, using __COUNTER__ as the unique identifier parameter:

  • __cplusplus_cli Defined as the integer literal value 200406 when compiled as C++ and a /clr compiler option is set. Otherwise, undefined. When defined, __cplusplus_cli is in effect throughout the translation unit.

  • __cplusplus_winrt Defined as the integer literal value 201009 when compiled as C++ and the /ZW (Windows Runtime Compilation) compiler option is set. Otherwise, undefined.

  • _CPPRTTI Defined as 1 if the /GR (Enable Run-Time Type Information) compiler option is set. Otherwise, undefined.

  • _CPPUNWIND Defined as 1 if one or more of the /GX (Enable Exception Handling), /clr (Common Language Runtime Compilation), or /EH (Exception Handling Model) compiler options are set. Otherwise, undefined.

  • _DEBUG Defined as 1 when the /LDd, /MDd, or /MTd compiler option is set. Otherwise, undefined.

  • _DLL Defined as 1 when the /MD or /MDd (Multithreaded DLL) compiler option is set. Otherwise, undefined.

  • __FUNCDNAME__ Defined as a string literal that contains the decorated name of the enclosing function. The macro is defined only within a function. The __FUNCDNAME__ macro isn't expanded if you use the /EP or /P compiler option.

    This example uses the __FUNCDNAME__, __FUNCSIG__, and __FUNCTION__ macros to display function information.

  • __FUNCSIG__ Defined as a string literal that contains the signature of the enclosing function. The macro is defined only within a function. The __FUNCSIG__ macro isn't expanded if you use the /EP or /P compiler option. When compiled for a 64-bit target, the calling convention is __cdecl by default. For an example of usage, see the __FUNCDNAME__ macro.

  • __FUNCTION__ Defined as a string literal that contains the undecorated name of the enclosing function. The macro is defined only within a function. The __FUNCTION__ macro isn't expanded if you use the /EP or /P compiler option. For an example of usage, see the __FUNCDNAME__ macro.

  • _INTEGRAL_MAX_BITS Defined as the integer literal value 64, the maximum size (in bits) for a non-vector integral type. This macro is always defined.

  • __INTELLISENSE__ Defined as 1 during an IntelliSense compiler pass in the Visual Studio IDE. Sansamp free vst download. Otherwise, undefined. You can use this macro to guard code the IntelliSense compiler doesn't understand, or use it to toggle between the build and IntelliSense compiler. For more information, see Troubleshooting Tips for IntelliSense Slowness.

  • _ISO_VOLATILE Defined as 1 if the /volatile:iso compiler option is set. Otherwise, undefined.

  • _KERNEL_MODE Defined as 1 if the /kernel (Create Kernel Mode Binary) compiler option is set. Otherwise, undefined.

  • _M_AMD64 Defined as the integer literal value 100 for compilations that target x64 processors. Otherwise, undefined.

  • _M_ARM Defined as the integer literal value 7 for compilations that target ARM processors. Otherwise, undefined.

  • _M_ARM_ARMV7VE Defined as 1 when the /arch:ARMv7VE compiler option is set for compilations that target ARM processors. Otherwise, undefined.

  • _M_ARM_FP Defined as an integer literal value that indicates which /arch compiler option was set for ARM processor targets. Otherwise, undefined.

    • A value in the range 30-39 if no /arch ARM option was specified, indicating the default architecture for ARM was set (VFPv3).

    • A value in the range 40-49 if /arch:VFPv4 was set.

    • For more information, see /arch (ARM).

  • _M_ARM64 Defined as 1 for compilations that target 64-bit ARM processors. Otherwise, undefined.

  • _M_CEE Defined as 001 if any /clr (Common Language Runtime Compilation) compiler option is set. Otherwise, undefined.

  • _M_CEE_PURE Deprecated beginning in Visual Studio 2015. Defined as 001 if the /clr:pure compiler option is set. Otherwise, undefined.

  • _M_CEE_SAFE Deprecated beginning in Visual Studio 2015. Defined as 001 if the /clr:safe compiler option is set. Otherwise, undefined.

  • _M_FP_EXCEPT Defined as 1 if the /fp:except or /fp:strict compiler option is set. Otherwise, undefined.

  • _M_FP_FAST Defined as 1 if the /fp:fast compiler option is set. Otherwise, undefined.

  • _M_FP_PRECISE Defined as 1 if the /fp:precise compiler option is set. Otherwise, undefined.

  • _M_FP_STRICT Defined as 1 if the /fp:strict compiler option is set. Otherwise, undefined.

  • _M_IX86 Defined as the integer literal value 600 for compilations that target x86 processors. This macro isn't defined for x64 or ARM compilation targets.

  • _M_IX86_FP Defined as an integer literal value that indicates the /arch compiler option that was set, or the default. This macro is always defined when the compilation target is an x86 processor. Otherwise, undefined. When defined, the value is:

    • 0 if the /arch:IA32 compiler option was set.

    • 1 if the /arch:SSE compiler option was set.

    • 2 if the /arch:SSE2, /arch:AVX, /arch:AVX2, or /arch:AVX512 compiler option was set. This value is the default if an /arch compiler option wasn't specified. When /arch:AVX is specified, the macro __AVX__ is also defined. When /arch:AVX2 is specified, both __AVX__ and __AVX2__ are also defined. When /arch:AVX512 is specified, __AVX__, __AVX2__, __AVX512BW__, __AVX512CD__, __AVX512DQ__, __AVX512F__ and __AVX512VL__ are also defined.

    • For more information, see /arch (x86).

  • _M_X64 Defined as the integer literal value 100 for compilations that target x64 processors. Otherwise, undefined.

  • _MANAGED Defined as 1 when the /clr compiler option is set. Otherwise, undefined.

  • _MSC_BUILD Defined as an integer literal that contains the revision number element of the compiler's version number. The revision number is the fourth element of the period-delimited version number. For example, if the version number of the Microsoft C/C++ compiler is 15.00.20706.01, the _MSC_BUILD macro evaluates to 1. This macro is always defined.

  • _MSC_EXTENSIONS Defined as 1 if the on-by-default /Ze (Enable Language Extensions) compiler option is set. Otherwise, undefined.

  • _MSC_FULL_VER Defined as an integer literal that encodes the major, minor, and build number elements of the compiler's version number. The major number is the first element of the period-delimited version number, the minor number is the second element, and the build number is the third element. For example, if the version number of the Microsoft C/C++ compiler is 15.00.20706.01, the _MSC_FULL_VER macro evaluates to 150020706. Enter cl /? at the command line to view the compiler's version number. This macro is always defined.

  • _MSC_VER Defined as an integer literal that encodes the major and minor number elements of the compiler's version number. The major number is the first element of the period-delimited version number and the minor number is the second element. For example, if the version number of the Microsoft C/C++ compiler is 17.00.51106.1, the _MSC_VER macro evaluates to 1700. Enter cl /? at the command line to view the compiler's version number. This macro is always defined.

    Visual Studio version_MSC_VER
    Visual Studio 6.01200
    Visual Studio .NET 2002 (7.0)1300
    Visual Studio .NET 2003 (7.1)1310
    Visual Studio 2005 (8.0)1400
    Visual Studio 2008 (9.0)1500
    Visual Studio 2010 (10.0)1600
    Visual Studio 2012 (11.0)1700
    Visual Studio 2013 (12.0)1800
    Visual Studio 2015 (14.0)1900
    Visual Studio 2017 RTW (15.0)1910
    Visual Studio 2017 version 15.31911
    Visual Studio 2017 version 15.51912
    Visual Studio 2017 version 15.61913
    Visual Studio 2017 version 15.71914
    Visual Studio 2017 version 15.81915
    Visual Studio 2017 version 15.91916
    Visual Studio 2019 RTW (16.0)1920
    Visual Studio 2019 version 16.11921
    Visual Studio 2019 version 16.21922
    Visual Studio 2019 version 16.31923
    Visual Studio 2019 version 16.41924
    Visual Studio 2019 version 16.51925
    Visual Studio 2019 version 16.61926

    To test for compiler releases or updates in a given version of Visual Studio or after, use the >= operator. You can use it in a conditional directive to compare _MSC_VER against that known version. If you have several mutually exclusive versions to compare, order your comparisons in descending order of version number. For example, this code checks for compilers released in Visual Studio 2017 and later. Next, it checks for compilers released in or after Visual Studio 2015. Then it checks for all compilers released before Visual Studio 2015:

    For more information, see Visual C++ Compiler Version in the Microsoft C++ Team Blog.

  • _MSVC_LANG Defined as an integer literal that specifies the C++ language standard targeted by the compiler. It's set only in code compiled as C++. The macro is the integer literal value 201402L by default, or when the /std:c++14 compiler option is specified. The macro is set to 201703L if the /std:c++17 compiler option is specified. It's set to a higher, unspecified value when the /std:c++latest option is specified. Otherwise, the macro is undefined. The _MSVC_LANG macro and /std (Specify Language Standard Version) compiler options are available beginning in Visual Studio 2015 Update 3.

  • __MSVC_RUNTIME_CHECKS Defined as 1 when one of the /RTC compiler options is set. Otherwise, undefined.

  • _MSVC_TRADITIONAL Defined as 0 when the preprocessor conformance mode /experimental:preprocessor compiler option is set. Defined as 1 by default, or when the /experimental:preprocessor- compiler option is set, to indicate the traditional preprocessor is in use. The _MSVC_TRADITIONAL macro and /experimental:preprocessor (Enable preprocessor conformance mode) compiler option is available beginning in Visual Studio 2017 version 15.8.

  • _MT Defined as 1 when /MD or /MDd (Multithreaded DLL) or /MT or /MTd (Multithreaded) is specified. Otherwise, undefined.

  • _NATIVE_WCHAR_T_DEFINED Defined as 1 when the /Zc:wchar_t compiler option is set. Otherwise, undefined.

  • _OPENMP Defined as integer literal 200203, if the /openmp (Enable OpenMP 2.0 Support) compiler option is set. This value represents the date of the OpenMP specification implemented by MSVC. Otherwise, undefined.

  • _PREFAST_ Defined as 1 when the /analyze compiler option is set. Otherwise, undefined.

  • __TIMESTAMP__ Defined as a string literal that contains the date and time of the last modification of the current source file, in the abbreviated, constant length form returned by the CRT asctime function, for example, Fri 19 Aug 13:32:58 2016. This macro is always defined.

  • _VC_NODEFAULTLIB Defined as 1 when the /Zl (Omit Default Library Name) compiler option is set. Otherwise, undefined.

  • _WCHAR_T_DEFINED Defined as 1 when the default /Zc:wchar_t compiler option is set. The _WCHAR_T_DEFINED macro is defined but has no value if the /Zc:wchar_t- compiler option is set, and wchar_t is defined in a system header file included in your project. Otherwise, undefined.

  • _WIN32 Defined as 1 when the compilation target is 32-bit ARM, 64-bit ARM, x86, or x64. Otherwise, undefined.

  • _WIN64 Defined as 1 when the compilation target is 64-bit ARM or x64. Otherwise, undefined.

  • _WINRT_DLL Defined as 1 when compiled as C++ and both /ZW (Windows Runtime Compilation) and /LD or /LDd compiler options are set. Otherwise, undefined.

No preprocessor macros that identify the ATL or MFC library version are predefined by the compiler. ATL and MFC library headers define these version macros internally. They're undefined in preprocessor directives made before the required header is included.

  • _ATL_VER Defined in <atldef.h> as an integer literal that encodes the ATL version number.

  • _MFC_VER Defined in <afxver_.h> as an integer literal that encodes the MFC version number.

See also

Macros (C/C++)
Preprocessor operators
Preprocessor directives

-->

Summary

  • Visual Studio tools for DirectX game programming

If you use Visual Studio Ultimate to develop DirectX apps, there are additional tools available for creating, editing, previewing, and exporting image, model, and shader resources. There are also tools that you can use to convert resources at build time and debug DirectX graphics code.

This topic gives an overview of these graphics tools.

Image Editor

Use the Image Editor to work with the kinds of rich texture and image formats that DirectX uses. The Image Editor supports the following formats.

  • .png
  • .jpg, .jpeg, .jpe, .jfif
  • .dds
  • .gif
  • .bmp
  • .dib
  • .tif, .tiff
  • .tga

Create build customization files to convert these to .dds files at build time.

For more information, see Working with Textures and Images.

Note The Image Editor is not intended to be a replacement for a full feature image editing app, but is appropriate for many simple viewing and editing scenarios.

Model Editor

You can use the Model Editor to create basic 3D models from scratch, or to view and modify more-complex 3D models from full-featured 3D modeling tools. The Model Editor supports several 3D model formats that are used in DirectX app development. You can create build customization files to convert these to .cmo files at build time.

  • .fbx
  • .dae
  • .obj

Here's a screenshot of a model in the editor with lighting applied.

For more information, see Working with 3-D Models.

Dev

Visual C Fp Fast Game Devices

Note The Model Editor is not intended to be a replacement for a full feature model editing app, but is appropriate for many simple viewing and editing scenarios.

Shader Designer

Use the Shader Designer to create custom visual effects for your game or app even if you don't know HLSL programming.

You create a shader visually as a graph. Each node displays a preview of the output up to that operation. Here's an example that applies Lambert lighting with a sphere preview.

Use the Shader Editor to design, edit, and save shaders in the .dgsl format. It also exports the following formats.

  • .hlsl (source code)
  • .cso (bytecode)
  • .h (HLSL bytecode array)

Create build customization files to convert any of these formats to .cso files at build time.

Visual C Fp Fast Game Dev 2017

Here is a portion of HLSL code that is exported by the Shader Editor. This is only the code for the Lambert lighting node.

For more information, see Working with Shaders.

Build customizations for 3D assets

You can add build customizations to your project so that Visual Studio converts resources to usable formats. After that, you can load the assets into your app and use them by creating and filling DirectX resources just like you would in any other DirectX app.

To add a build customization, you right-click on the project in the Solution Explorer and select Build Customizations... You can add the following types of build customizations to your project.

  • Image Content Pipeline takes image files as input and outputs DirectDraw Surface (.dds) files.
  • Mesh Content Pipeline takes mesh files (such as .fbx) and outputs .cmo mesh files.
  • Shader Content Pipeline takes Visual Shader Graph (.dgsl) from the Visual Studio Shader Editor and outputs a Compiled Shader Output (.cso) file.

Visual C Fp Fast Game Dev 2

For more information, see Using 3-D Assets in Your Game or App.

Debugging DirectX graphics

Visual Studio provides graphics-specific debugging tools. Use these tools to debug things like:

  • The graphics pipeline.
  • The event call stack.
  • The object table.
  • The device state.
  • Shader bugs.
  • Uninitialized or incorrect constant buffers and parameters.
  • DirectX version compatibility.
  • Limited Direct2D support.
  • Operating system and SDK requirements.

Learn How To Type Fast Game

For more information, see Debugging DirectX Graphics.