1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
[](https://github.com/apitrace/apitrace/actions/workflows/build.yml)
[](https://ci.appveyor.com/project/jrfonseca/apitrace/branch/master)
# Requirements #
Requirements common for all platforms:
* C++ 17 compiler
* Python version 3.6 or newer
* Python Image Library
* CMake version 3.8 or newer
Optional dependencies:
* zlib 1.2.6 or higher
* libpng
The GUI also dependends on:
* Qt version 5.2.1 or higher (tested with version 5.4.0 and 5.3.0)
Qt will be required if `-DENABLE_GUI=TRUE` is passed to CMake, and never used
if `-DENABLE_GUI=FALSE` is passed instead. The implicit default is
`-DENABLE_GUI=AUTO`, which will build the GUI if Qt is available.
If you have Qt in a non-standard directory, you'll need to set
[`-DCMAKE_PREFIX_PATH`](https://doc.qt.io/qt-5/cmake-manual.html).
The code also depends on snappy libraries, but the bundled sources are always
used regardless of system availability, to make the wrapper shared-objects/DLL
self contained, and to prevent symbol collisions when tracing.
# Linux #
Optional dependencies:
* Xlib headers
* libprocps (procps development libraries)
* libdwarf
Build as:
cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=RelWithDebInfo
make -C build
Other possible values for `CMAKE_BUILD_TYPE` `Debug`, `Release`,
`RelWithDebInfo`, and `MinSizeRel`.
You can also build the 32-bits GL wrapper on a 64-bits distribution, provided
you have a multilib gcc and 32-bits X11 libraries, by doing:
cmake \
-S. -Bbuild32 \
-DCMAKE_C_FLAGS=-m32 \
-DCMAKE_CXX_FLAGS=-m32 \
-DCMAKE_SYSTEM_LIBRARY_PATH=/usr/lib32 \
-DENABLE_GUI=FALSE
make -C build32 glxtrace
The `/usr/lib32` refers to the path where the 32-bits shared objects are may
differ depending on the actual Linux distribution.
# Mac OS X #
First install Qt through [Homebrew](https://brew.sh/) like
brew install qt5
Then do:
cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_PREFIX_PATH=$(brew --prefix qt5)
make -C build
# Android #
Android is no longer supported. See https://git.io/vH2gW for more information.
# Windows #
## Microsoft Visual Studio ##
Additional requirements:
* CMake 3.7 or later
* Microsoft Visual Studio 2019 or later
* [Windows 10 SDK](https://dev.windows.com/en-us/downloads/windows-10-sdk)
for D3D11.3 headers.
### CMake GUI ###
To build with Visual Studio first open a Command Prompt window (*not* Visual
Studio Command Prompt window), change into the Apitrace source, and invoke
CMake GUI as:
cmake-gui -S. -Bbuild -DCMAKE_PREFIX_PATH=C:\Qt\QtX.Y.Z\X.Y\msvc2017
and press the _Configure_ button.
It will try to detect most required/optional dependencies automatically. When
not found automatically, you can manually specify the location of the
dependencies from the CMake GUI.
If the source/build/compiler/tools are spread across multiple drives, you might
need to [use absolute paths](https://github.com/apitrace/apitrace/issues/352).
After you've successfully configured, you can start the build by opening the
generated `build\apitrace.sln` solution file
### CMake CLI ###
Another option is to use the commandline to configure the project. First of all find out which
generators are available on your system:
cmake --help
At the end of the output, choose a generator and start configuring the project:
cmake -S. -Bbuild -G "Visual Studio 16 2019" -A Win32 -DCMAKE_PREFIX_PATH=C:\Qt\QtX.Y.Z\X.Y\msvc2017
Note as off Qt version 5.9.1 there's no `msvc2019` directory, only `msvc2017`
and `msvc2017_64`, but `msvc2017` should work as MSVC 2019 is binary backwards
compatible with MSVC 2017.
After you've successfully configured, you can start the build by invoking CMake as:
cmake --build build --config RelWithDebInfo
### Deployment ###
To run qapitrace, either ensure that `C:\Qt\QtX.Y.Z\X.Y\msvc????\bin` is in the system path, or use
[Qt's Windows deployment tool](https://doc.qt.io/qt-5/windows-deployment.html#the-windows-deployment-tool)
to copy all necessary DLLs, like:
set Path=C:\Qt\QtX.Y.Z\X.Y\msvc2017\bin;%Path%
windeployqt build\qapitrace.exe
### 64-bits ###
The steps to build 64-bits version are similar, but choosing `-A x64` instead
of `-A Win32`, and using `C:\Qt\QtX.Y.Z\X.Y\msvc2017_64` for Qt path.
### Windows XP ###
Windows XP is no longer supported. If you need Windows XP support, your best
bet is to user an [older version of the code](https://github.com/apitrace/apitrace/tree/windows-xp).
## MinGW ##
Additional requirements:
* [MinGW-w64](https://www.mingw-w64.org/) (tested with mingw-w64's gcc version 4.9)
* [DirectX headers](https://github.com/apitrace/dxsdk)
It's also possible to cross-compile Windows binaries from Linux with
[MinGW cross compilers](https://gitlab.kitware.com/cmake/community/-/wikis/doc/cmake/cross_compiling/Mingw).
|
