WindowTarget

Description

WindowTarget is an implementation of Target that represents a rendering destination attached to a platform-specific window.

The Target object is a rendering destination for the Renderer.

It contains a GPU surface texture attached to a platform-specific window or an offscreen texture for headless rendering (see TextureTarget).

Example

1 collapsed line
async fn run() -> Result<(), Box<dyn std::error::Error>> {

use fragmentcolor::{Renderer, Shader, Target};

// Use your platform's windowing system to create a window.
// We officially support Winit. Check the examples folder for details.
let window = fragmentcolor::headless_window([800, 600]);

let renderer = Renderer::new();
let target = renderer.create_target(window).await?;

renderer.render(&Shader::default(), &target)?;

5 collapsed lines
let s = target.size();
assert_eq!([s.width, s.height], [800, 600]);
Ok(())
}
fn main() -> Result<(), Box<dyn std::error::Error>> { pollster::block_on(run()) }

import { Renderer, Shader } from "fragmentcolor";

// Use your platform's windowing system to create a window.
// We officially support Winit. Check the examples folder for details.
const canvas = document.createElement('canvas');

const renderer = new Renderer();
const target = await renderer.createTarget(canvas);

renderer.render(new Shader(""), target);

from rendercanvas.auto import RenderCanvas, loop

from fragmentcolor import Renderer, Shader

# Use your platform's windowing system to create a window.
# We officially support Winit. Check the examples folder for details.
canvas = RenderCanvas(size=(800, 600))

renderer = Renderer()
target = renderer.create_target(canvas)

renderer.render(Shader(""), target)

// Swift placeholder â bindings WIP

// Kotlin placeholder â bindings WIP

Methods

WindowTarget::get_image()

This operation returns an empty array for WindowTarget.

Use a TextureTarget instead.

Example

1 collapsed line
async fn run() -> Result<(), Box<dyn std::error::Error>> {

use fragmentcolor::{Renderer, Target, Shader};

let renderer = Renderer::new();
let target = renderer.create_texture_target([16, 16]).await?;
renderer.render(&Shader::default(), &target)?;

let image = target.get_image();

4 collapsed lines
assert_eq!(image.len(), 16 * 16 * 4); // RGBA8
Ok(())
}
fn main() -> Result<(), Box<dyn std::error::Error>> { pollster::block_on(run()) }

import { Renderer, Shader } from "fragmentcolor";

const renderer = new Renderer();
const target = await renderer.createTextureTarget([16, 16]);
renderer.render(new Shader(""), target);

const image = target.getImage();

from rendercanvas.auto import RenderCanvas, loop

from fragmentcolor import Renderer, Shader

renderer = Renderer()
target = renderer.create_texture_target([16, 16])
renderer.render(Shader(""), target)

image = target.get_image()

// Swift placeholder â bindings WIP

// Kotlin placeholder â bindings WIP

WindowTarget::resize(size: [u32; 2] | (u32, u32))

Resizes the Target to the given width and height.

Example

1 collapsed line
async fn run() -> Result<(), Box<dyn std::error::Error>> {

use fragmentcolor::Renderer;

let renderer = Renderer::new();
let mut target = renderer.create_texture_target([64, 32]).await?;

target.resize([128, 64]);

4 collapsed lines
assert_eq!(target.size(), [128, 64]);
Ok(())
}
fn main() -> Result<(), Box<dyn std::error::Error>> { pollster::block_on(run()) }

import { Renderer } from "fragmentcolor";

const renderer = new Renderer();
const target = await renderer.createTextureTarget([64, 32]);

target.resize([128, 64]);

from fragmentcolor import Renderer

renderer = Renderer()
target = renderer.create_texture_target([64, 32])

target.resize([128, 64])

// Swift placeholder â bindings WIP

// Kotlin placeholder â bindings WIP

WindowTarget::size() -> [u32; 2]

Returns the size of the Target in pixels.

Example

1 collapsed line
async fn run() -> Result<(), Box<dyn std::error::Error>> {

use fragmentcolor::{Renderer, Shader};

let renderer = Renderer::new();
let target = renderer.create_texture_target([64, 32]).await?;

4 collapsed lines
assert_eq!(target.size(), [64, 32]);
Ok(())
}
fn main() -> Result<(), Box<dyn std::error::Error>> { pollster::block_on(run()) }

import { Renderer, Shader } from "fragmentcolor";

const renderer = new Renderer();
const target = await renderer.createTextureTarget([64, 32]);

from fragmentcolor import Renderer, Shader

renderer = Renderer()
target = renderer.create_texture_target([64, 32])

// Swift placeholder â bindings WIP

// Kotlin placeholder â bindings WIP