Startsida Utforska Hjälp
Logga in
godotengine
/
godot-docs
spegling av https://github.com/godotengine/godot-docs
Bevaka 1
Stjärnmärk 1
Fork 0
Filer
Träd: 7913ae4496
Grenar Taggar
godot-docs
/
contributing
/
development
/
configuring_an_ide
/
clion.rst

clion.rst 4.3 KB
Historik Rå

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384 
  1. .. _doc_configuring_an_ide_clion:
    2. 

  2. 

  3. CLion
    4. 

  4. =====
    5. 

  5. 

  6. `CLion <https://www.jetbrains.com/clion/>`_ is a commercial
    7. 

  7. `JetBrains <https://www.jetbrains.com/>`_ IDE for C++.
    8. 

  8. 

  9. Importing the project
    10. 

  10. ---------------------
    11. 

  11. 

  12. CLion can import a project's `compilation database file <https://clang.llvm.org/docs/JSONCompilationDatabase.html>`_, commonly named ``compile_commands.json``. To generate the compilation database file, open the terminal, change to the Godot root directory, and run:
    13. 

  13. 

  14. ::
    15. 

  15. 

  16.     scons compiledb=yes
    17. 

  17. 

  18. Then, open the Godot root directory with CLion. CLion will import the compilation database, index the codebase, and provide autocompletion and other advanced code navigation and refactoring functionality.
    19. 

  19. 

  20. Compiling and debugging the project
    21. 

  21. -----------------------------------
    22. 

  22. 

  23. CLion does not support compiling and debugging Godot via SCons out of the box. This can be achieved by creating a custom build target and run configuration in CLion. Before creating a custom build target, you must :ref:`compile Godot <toc-devel-compiling>` once on the command line, to generate the Godot executable. Open the terminal, change into the Godot root directory, and execute:
    24. 

  24. 

  25. ::
    26. 

  26. 

  27.     scons dev_build=yes
    28. 

  28. 

  29. To add a custom build target that invokes SCons for compilation:
    30. 

  30. 

  31. - Open CLion and navigate to **Preferences > Build, Execution, Deployment > Custom Build Targets**
    32. 

  32. 

  33. .. figure:: img/clion-preferences.png
    34. 

  34.    :align: center
    35. 

  35. 

  36. - Click **Add target** and give the target a name, e.g. ``Godot debug``.
    37. 

  37. 

  38. .. figure:: img/clion-target.png
    39. 

  39.    :align: center
    40. 

  40. 

  41. - Click **...** next to the **Build:** selectbox, then click the **+** button in the **External Tools** dialog to add a new external tool.
    42. 

  42. 

  43. .. figure:: img/clion-external-tools.png
    44. 

  44.    :align: center
    45. 

  45. 

  46. - Give the tool a name, e.g. ``Build Godot debug``, set **Program** to ``scons``, set **Arguments** to the compilation settings you want (see :ref:`compiling Godot <toc-devel-compiling>`), and set the **Working directory** to ``$ProjectFileDir$``, which equals the Godot root directory. Click **OK** to create the tool.
    47. 

  47. 

  48.    .. note:: CLion does not expand shell commands like ``scons -j$(nproc)``. Use concrete values instead, e.g. ``scons -j8``.
    49. 

  49. 

  50. .. figure:: img/clion-create-build-tool.webp
    51. 

  51.    :align: center
    52. 

  52. 

  53. - Back in the **External Tools** dialog, click the **+** again to add a second external tool for cleaning the Godot build via SCons. Give the tool a name, e.g. ``Clean Godot debug``, set **Program** to ``scons``, set **Arguments** to ``-c`` (which will clean the build), and set the **Working directory** to ``$ProjectFileDir$``. Click **OK** to create the tool.
    54. 

  54. 

  55. .. figure:: img/clion-create-clean-tool.png
    56. 

  56.    :align: center
    57. 

  57. 

  58. - Close the **External Tools** dialog. In the **Custom Build Target** dialog for the custom ``Godot debug`` build target, select the **Build Godot debug** tool from the **Build** select box, and select the **Clean Godot debug** tool from the **Clean** select box. Click **OK** to create the custom build target.
    59. 

  59. 

  60. .. figure:: img/clion-select-tools.png
    61. 

  61.    :align: center
    62. 

  62. 

  63. - In the main IDE window, click **Add Configuration**.
    64. 

  64. 

  65. .. figure:: img/clion-add-configuration.png
    66. 

  66.    :align: center
    67. 

  67. 

  68. - In the **Run/Debug Configuration** dialog, click **Add new...**, then select **Custom Build Application** to create a new custom run/debug configuration.
    69. 

  69. 

  70. .. figure:: img/clion-add-custom-build-application.png
    71. 

  71.    :align: center
    72. 

  72. 

  73. - Give the run/debug configuration a name, e.g. ``Godot debug``, select the ``Godot debug`` custom build target as the **Target**. Select the Godot executable in the ``bin/`` folder as the **Executable**, and set the **Program arguments** to ``--editor --path path-to-your-project/``, where ``path-to-your-project/`` should be a path pointing to an existing Godot project. If you omit the ``--path`` argument, you will only be able to debug the Godot Project Manager window. Click **OK** to create the run/debug configuration.
    74. 

  74. 

  75. .. figure:: img/clion-run-configuration.png
    76. 

  76.    :align: center
    77. 

  77. 

  78. You can now build, run, debug, profile, and Valgrind check the Godot editor via the run configuration.
    79. 

  79. 

  80. .. figure:: img/clion-build-run.png
    81. 

  81.    :align: center
    82. 

  82. 

  83. When playing a scene, the Godot editor will spawn a separate process. You can debug this process in CLion by going to **Run > Attach to process...**, typing ``godot``, and selecting the Godot process with the highest **pid** (process ID), which will usually be the running project.
    84. 

  84.