render textures but for godot

[outer sorrel]

I'm trying to make render textures from unity into godot. (Render textures are where you can take a camera's output and apply it to a texture). I read online about using viewports but I am totally confused by those and have no idea how you can make render textures from that. Please help this confused game dev 🥺

please help anyone

why does no one ever answer my questions

no matter where I ask no one cares 😢

[left cipher]

You are waiting like 15 min, chill out

Show how it looks now and how you want to looks like, your problem isn't popular

I will tell you already, I don't have single idea how to repair your problem xd

[outer sorrel]

i dont have anything right now

because I dont know how to implement it

[tropic sequoia]

You can use viewports in Godot to achieve something similar to Unity's render textures. A viewport is essentially a window into your game world, and you can use it to render a portion of your scene to a texture. Here is an example of how you can use viewports to create a render texture in Godot:

    Create a new viewport as a child of the root node of your scene.

    Set the viewport's size and position to match the area of the scene you want to render to a texture.

    Add a Camera as a child of the viewport, and set its properties as desired.

    Add a CanvasItem as a child of the viewport, and set its texture property to a new ImageTexture. This will be the texture that the viewport renders to.

    In the viewport's properties, set the render target to the ImageTexture you created in the previous step.

    Use the viewport and its children (the camera and canvas item) as you would any other node in your scene. When the viewport is rendered, it will output the rendered image to the ImageTexture.

# Create a new viewport as a child of the root node
var viewport = Viewport.new()
get_tree().get_root().add_child(viewport)

# Set the size and position of the viewport
viewport.set_size(Vector2(200, 200))
viewport.set_position(Vector2(100, 100))

# Add a Camera as a child of the viewport
var camera = Camera.new()
viewport.add_child(camera)

# Add a CanvasItem as a child of the viewport
var canvas_item = CanvasItem.new()
viewport.add_child(canvas_item)

# Create a new ImageTexture and set it as the texture for the CanvasItem
var texture = ImageTexture.new()
canvas_item.texture = texture

# Set the viewport's render target to the ImageTexture
viewport.render_target = texture

This code will create a new viewport that is 200x200 pixels in size and positioned at (100, 100) in the scene. It will then add a camera and a canvas item as children of the viewport, and set the canvas item's texture to a new ImageTexture. Finally, it will set the viewport's render target to the ImageTexture, so that the viewport will render to the texture when it is drawn.

Are there nodes that I should add to the scene tree to achieve this code logic?

The code I provided creates all the necessary nodes in the scene tree dynamically, rather than adding them to the tree manually. The root node of the scene is accessed using get_tree().get_root(), and the viewport, camera, and canvas item nodes are all created using the new() method and added as children of the root node or the viewport using the add_child() method.

Here is a visual representation of the resulting scene tree:

RootNode
|- Viewport
   |- Camera
   |- CanvasItem

If you want to add the nodes to the scene tree manually, you can do so by dragging and dropping them from the Godot editor's "Create New" tab into the scene tree panel. You can then set their properties using the Inspector panel on the right side of the editor.

Give another example of how a game developer would employ this same concept.

Sure! Here is another example of how a game developer might use viewports to create a render texture in Godot:

Imagine that you are making a top-down strategy game, and you want to display a minimap in the corner of the screen that shows the entire game world. One way to do this would be to use a viewport to render a scaled-down version of the game world to a texture, and then display the texture on the minimap.

Here is some example code in GDScript that shows how you might do this:

# Create a new viewport as a child of the root node
var minimap_viewport = Viewport.new()
get_tree().get_root().add_child(minimap_viewport)

# Set the size and position of the viewport
minimap_viewport.set_size(Vector2(200, 200))
minimap_viewport.set_position(Vector2(100, 100))

# Add a Camera as a child of the viewport
var minimap_camera = Camera.new()
minimap_viewport.add_child(minimap_camera)

# Set the Camera's properties to match the desired view for the minimap
minimap_camera.set_orthogonal(10, 1) # Set the camera to use an orthogonal projection
minimap_camera.set_global_transform(Transform(Basis(), Vector3(50, 50, 0))) # Set the camera's position and rotation

# Add a CanvasItem as a child of the viewport
var minimap_canvas_item = CanvasItem.new()
minimap_viewport.add_child(minimap_canvas_item)

# Create a new ImageTexture and set it as the texture for the CanvasItem
var minimap_texture = ImageTexture.new()
minimap_canvas_item.texture = minimap_texture

# Set the viewport's render target to the ImageTexture
minimap_viewport.render_target = minimap_texture

# Add a Sprite to the scene, and set its texture to the minimap texture
var minimap_sprite = Sprite.new()
get_tree().get_root().add_child(minimap_sprite)
minimap_sprite.texture = minimap_texture

This code creates a new viewport and adds a camera and canvas item as children, just as in the previous example. However, in this case, the camera is set to use an orthogonal projection and is positioned and rotated to give a top-down view of the game world. The viewport is then set to render to the minimap texture, and a sprite is added to the scene and set to display the texture. As a result, the sprite will display the view of the game world captured by the viewport's camera.