# How to Use ImVec2 Math Operators with `IMGUI_DEFINE_MATH_OPERATORS` in Dear ImGui

> Learn to use ImVec2 math operators in Dear ImGui by defining IMGUI_DEFINE_MATH_OPERATORS. Enhance your custom vector math with ease and efficiency.

- Repository: [omar/imgui](https://github.com/ocornut/imgui)
- Tags: how-to-guide
- Published: 2026-07-15

---

**Define `IMGUI_DEFINE_MATH_OPERATORS` before including [`imgui.h`](https://github.com/ocornut/imgui/blob/main/imgui.h) to enable arithmetic operators (+, -, \*, /) for `ImVec2` and `ImVec4` vectors.**

Dear ImGui (ocornut/imgui) provides lightweight `ImVec2` and `ImVec4` structures for 2D and 4D vector data. By default, the library only exposes data members (`x`, `y`) and minimal utility functions to maintain portability and fast compile times. To write expressive vector arithmetic like `pos = a + b * scale;` instead of verbose member-wise operations, you must explicitly enable the optional **ImVec2 math operators** through a compile-time macro.

## Enabling ImVec2 Math Operators

The arithmetic operators are implemented as inline functions guarded by the `IMGUI_DEFINE_MATH_OPERATORS` macro in [`imgui.h`](https://github.com/ocornut/imgui/blob/main/imgui.h) (around lines 2918–2930). Enabling them requires defining this macro in exactly one of two locations.

### Global Configuration via imconfig.h

For project-wide availability, add the definition to your [`imconfig.h`](https://github.com/ocornut/imgui/blob/main/imconfig.h) file, which Dear ImGui automatically includes:

```cpp
// imconfig.h
#define IMGUI_DEFINE_MATH_OPERATORS

```

This approach ensures every source file that includes [`imgui.h`](https://github.com/ocornut/imgui/blob/main/imgui.h) has access to the operators without additional boilerplate.

### Local Configuration in Source Files

To enable operators only in specific translation units, define the macro immediately before the ImGui header inclusion:

```cpp
#define IMGUI_DEFINE_MATH_OPERATORS
#include "imgui.h"

void example() {
    ImVec2 a(10.0f, 20.0f);
    ImVec2 b(5.0f, 5.0f);
    float scale = 2.0f;
    
    // Now available: +, -, *, /, unary minus, and compound assignments
    ImVec2 c = a + b * scale;        // (20, 30)
    ImVec2 d = (a - b) / scale;      // (2.5, 7.5)
}

```

**Important:** The macro must be defined **before** the first inclusion of [`imgui.h`](https://github.com/ocornut/imgui/blob/main/imgui.h). Defining it after inclusion has no effect, as the operator definitions are conditionally compiled at parse time.

## Using Operators with Custom Vector Types

You can leverage the enabled **ImVec2 math operators** with your own vector classes by providing implicit conversion constructors. This allows seamless interoperability without requiring additional operator overloads for your custom type.

### Implementation Pattern

Provide a constructor that accepts `ImVec2` and a conversion operator to `ImVec2`:

```cpp
struct MyVec2 {
    float x, y;
    MyVec2() = default;
    MyVec2(float _x, float _y) : x(_x), y(_y) {}
    
    // Implicit conversion from ImVec2
    MyVec2(const ImVec2& v) : x(v.x), y(v.y) {}
    
    // Implicit conversion to ImVec2
    operator ImVec2() const { return ImVec2(x, y); }
};

#define IMGUI_DEFINE_MATH_OPERATORS
#include "imgui.h"

void demo() {
    MyVec2 position(1.0f, 2.0f);
    MyVec2 velocity(3.0f, 4.0f);
    ImVec2 offset(5.0f, 5.0f);
    
    // Works thanks to implicit conversions:
    MyVec2 result = position + velocity * 0.5f + offset;  // (7.5, 9.0)
}

```

Because `MyVec2` converts to and from `ImVec2`, the compiler can utilize the operators defined in [`imgui_internal.h`](https://github.com/ocornut/imgui/blob/main/imgui_internal.h) (referenced from [`imgui.h`](https://github.com/ocornut/imgui/blob/main/imgui.h)) to perform arithmetic on your custom type. These operators are purely syntactic sugar forwarding to internal inline functions, incurring **zero runtime overhead** compared to manual member-wise operations.

**Note:** If you encounter ambiguous overload resolution with complex expressions, use explicit casting (`ImVec2(myVec)`) rather than relying on implicit conversions, or provide explicit operator overloads for your specific type.

## Where the Implementation Lives

According to the ocornut/imgui source code, the operator implementations are structured as follows:

- **Declaration guard:** Located in [`imgui.h`](https://github.com/ocornut/imgui/blob/main/imgui.h) (~line 2918) under `#ifdef IMGUI_DEFINE_MATH_OPERATORS`
- **Inline definitions:** Fwd to utilities in [`imgui_internal.h`](https://github.com/ocornut/imgui/blob/main/imgui_internal.h) (~line 115), which provides the actual `operator+`, `operator-`, `operator*`, and `operator/` implementations
- **Configuration template:** [`imconfig.h`](https://github.com/ocornut/imgui/blob/main/imconfig.h) serves as the recommended location for project-wide macro definitions

## Summary

- **Define `IMGUI_DEFINE_MATH_OPERATORS`** before including [`imgui.h`](https://github.com/ocornut/imgui/blob/main/imgui.h) to enable arithmetic operators for `ImVec2` and `ImVec4`.
- **Place the definition** in [`imconfig.h`](https://github.com/ocornut/imgui/blob/main/imconfig.h) for global availability, or at the top of specific `.cpp` files for local use.
- **Integrate custom types** by providing implicit conversion constructors to/from `ImVec2`, allowing the built-in operators to work seamlessly.
- **Operators are zero-cost** abstractions that compile to the same instructions as manual member-wise math.

## Frequently Asked Questions

### Where should I define `IMGUI_DEFINE_MATH_OPERATORS`?

Define it in your [`imconfig.h`](https://github.com/ocornut/imgui/blob/main/imconfig.h) file for project-wide availability, or at the top of any source file before `#include "imgui.h"` if you only need the operators in specific translation units. Never define it in a header that might be included after [`imgui.h`](https://github.com/ocornut/imgui/blob/main/imgui.h), as the macro must be active when the header is first parsed.

### Do the math operators add performance overhead?

No. The operators are inline functions defined in [`imgui_internal.h`](https://github.com/ocornut/imgui/blob/main/imgui_internal.h) that compile to identical machine code as manual operations like `ImVec2(a.x + b.x, a.y + b.y)`. They provide syntactic convenience without runtime cost.

### Can I use these operators with ImVec4 as well?

Yes. Defining `IMGUI_DEFINE_MATH_OPERATORS` enables operators for both `ImVec2` and `ImVec4` structures simultaneously, including addition, subtraction, multiplication, division, and unary negation for both types.

### Why aren't these operators enabled by default?

Dear ImGui prioritizes minimal compile times and avoids potential symbol conflicts with user-defined math libraries. By guarding the operators behind `IMGUI_DEFINE_MATH_OPERATORS`, the library remains portable while allowing opt-in convenience for developers who need expressive vector arithmetic.