Home » Documentation » Manual » Making rendering prettier
Previous: Background (skybox, sky and ground)
Next: Blending
Manual

Fog

Fog can be added and configured using the TCastleFog component. The component is available in CGE editor, so you add and configure your fog even without writing any code.

The usage is simple:

  1. Add a fog component anywhere to the design using "Add Non-Visual Component → Fog (TCastleFog)" in editor.

    Adding fog component

  2. Set the fog as active for given viewport by adjusting the TCastleViewport.Fog property.

    Making fog component active on viewport

  3. Adjust the fog parameters, like TCastleFog.Color and TCastleFog.VisibilityRange.

    Adjust fog parameters

  4. Optionally, also adjust the background color to match the fog color. The fog looks most natural in this case.

    For example adjust the TCastleViewport.BackgroundColor and leave TCastleViewport.Background empty (nil) for a simple background color.

    Or can make background horizon color, or background skybox, visually match the fog. See more about backgrounds.

    Fog and background colors matching
Note
 The fog is applied in the final (sRGB) color space, this allows to match fog color perfectly to background color or UI easily. This means that Linear color space (gamma correction) doesn’t affect fog application.

To improve this documentation just edit this page and create a pull request to cge-www repository.

Previous: Background (skybox, sky and ground)
Next: Blending
Manual
Documentation
  1. Tutorial: 3D physics fun
    1. Manual
      1. Install
      2. Build your first application
      3. Designing user interface and handling events (press, update) within the view
        1. Managing Views
      4. Viewport with scenes, camera, navigation
        1. Tutorial: Designing a 3D world
        2. Tutorial: Designing a 2D world
        3. Camera
        4. Navigation
        5. Writing code to modify scenes and transformations
        6. Behaviors
        7. Multiple viewports to display one world
        8. Expose scene elements, like children transformations as TCastleScene children
      5. User interface
        1. Text and fonts
        2. Customize loading image
        3. Custom drawn 2D controls: player HUD
      6. Editor
        1. Custom Components in Editor
        2. Components to reuse a design in other designs
      7. 2D games
        1. Sprite sheets
        2. Images
        3. Tiled maps
        4. How to render 2D games with images and sprites
      8. Physics
      9. Sound
        1. OpenAL
        2. FMOD
      10. Persistent data (user preferences, savegames)
      11. Save screen (screenshot)
      12. Network, downloading and using URLs
      13. Logging
      14. Cross-platform (desktop, mobile, consoles...) projects
        1. Data directory and castle-data:/ URL protocol
        2. CastleEngineManifest​.xml
        3. Customize UI scaling, font, warmup cache by CastleSettings.xml
        4. Build Tool
        5. Touch Input
      15. Platforms details
        1. Android
        2. Android FAQ
        3. Android Services (Google Play Games and many more...)
        4. Adding New Android Services
        5. iOS
        6. iOS Services (Apple Game Center and many more...)
        7. In-App Purchases (Android, iOS)
        8. Nintendo Switch
        9. macOS
      16. Optimization
        1. Occlusion Culling
        2. Profiling Using Valgrind
        3. Detecting Memory Leaks
      17. Making rendering prettier
        1. Bump Mapping (Normal Maps)
        2. Shadow Volumes
        3. Background (skybox, sky and ground)
        4. Fog
        5. Blending
        6. Color Space (Gamma Correction)
        7. Alpha Bleeding
        8. Sketchfab
      18. Engine on a form (VCL, FMX, LCL) using TCastleControl
      19. Automatic Builds (Continuous Integration and Delivery)
        1. GitHub Actions (automatic builds for GitHub projects)
        2. GitLab CI/CD (automatic builds for GitLab projects)
        3. Docker (easily get CGE, compilers, texture compression tools)
        4. Jenkins (automatic builds by your Jenkins server)
      20. Pascal IDEs
        1. Lazarus
        2. Delphi
          1. Delphi packages
          2. Delphi for Linux
        3. Visual Studio Code
      21. Miscellaneous
        1. Steam
        2. Which way is up?
        3. Transformation hierarchy
        4. CastleWindow Backends
        5. Threads
        6. Compiling from source
        7. Supported compilers and IDEs
        8. Coding Traps
        9. Units Map
        10. Dedicated GPU
        11. fpcupdeluxe
        12. FpMake and FpPkg
        13. License
      22. Helping in engine development
        1. Donate
        2. Roadmap
        3. Coding Conventions
      23. Deprecated: Utilities for typical 3D games
        1. Overview
        2. Loading game level
        3. Player
        4. Defining creatures and items
        5. Using creatures and items
        6. Extending creatures and items classes
    2. Creating Game Data
      1. API Reference
      2. Why Pascal?
      3. Modern Object Pascal Introduction
        1. Overview for Unity Developers
        2. Scene Graph: X3D nodes
          1. Conferences

            Copyright Michalis Kamburelis and Castle Game Engine Contributors.

            This webpage is also open-source and we welcome pull requests to improve it.

            We use cookies for analytics. See our privacy policy. Scarf Analytics