# FSRUpscaler

class in `three-gpu-pathtracer/webgpu`

```js
import { FSRUpscaler } from 'three-gpu-pathtracer/webgpu';
```

Upscales a path traced image to the drawing buffer size with FSR. Pass one to
"WebGPUPathTracer.setUpscaler".

The "Upscaler" class is passed in rather than imported so it does not become a dependency.

```js
import { Upscaler } from '@pmndrs/upscaler';
pathTracer.setUpscaler( new FSRUpscaler( { Upscaler } ) );
```

Example: Path tracing at half resolution and upscaling with FSR

```js
import { ACESFilmicToneMapping, Color, EquirectangularReflectionMapping } from 'three/webgpu';
import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
import { DRACOLoader } from 'three/addons/loaders/DRACOLoader.js';
import { HDRLoader } from 'three/addons/loaders/HDRLoader.js';
import { createFloor } from './floor.js';
import { Upscaler } from '@pmndrs/upscaler';
import { WebGPUPathTracer, FSRUpscaler } from 'three-gpu-pathtracer/webgpu';

// scene, camera and renderer are initialized here

const URL = 'https://raw.githubusercontent.com/gkjohnson/3d-demo-data/main/models/nasa-m2020/Perseverance.glb';
const ENV_URL = 'https://raw.githubusercontent.com/gkjohnson/3d-demo-data/main/hdri/chinese_garden_1k.hdr';

const { scene: model } = await new GLTFLoader()
	.setDRACOLoader( new DRACOLoader() )
	.loadAsync( URL );
const environment = await new HDRLoader().loadAsync( ENV_URL );

environment.mapping = EquirectangularReflectionMapping;
scene.environment = environment;
scene.background = new Color( 0xeeeeee );
renderer.toneMapping = ACESFilmicToneMapping;

model.position.z = - 0.32;
scene.add( model, createFloor() );

camera.position.set( - 3.2, 2.2, 4.6 );
controls.target.set( 0, 0.9, 0 );
controls.update();

const pathTracer = new WebGPUPathTracer( renderer );

// mobile GPUs are slower: fewer paths per frame keep frames fast, and fewer pixels converge sooner
if ( matchMedia( '(pointer: coarse)' ).matches ) {

	pathTracer.frameBudget = 50000;
	renderer.setPixelRatio( window.devicePixelRatio / 2 );

}
pathTracer.maxSamples = 32;
pathTracer.renderScale = 0.5;
pathTracer.setUpscaler( new FSRUpscaler( { Upscaler } ) );
pathTracer.setScene( scene, camera );
controls.addEventListener( 'change', () => pathTracer.updateCamera() );
window.addEventListener( 'resize', () => pathTracer.updateCamera() );
renderer.setAnimationLoop( () => pathTracer.renderSample() );
```

## Constructor

```js
new FSRUpscaler( options: Object )
```

Every field below can also be assigned after construction.

- `options`, `Object`
  - `Upscaler`, `function`: The `Upscaler` class from `@pmndrs/upscaler`.
  - `sharpness`, `number`, optional

## Methods

### .init

```js
.init( renderer: WebGPURenderer )
```

- `renderer`, `WebGPURenderer`

### .upscale

```js
.upscale( source: Texture, camera: Camera ): Texture
```

Upscales a texture to the renderer's drawing buffer size.

- `source`, `Texture`
- `camera`, `Camera`