Lecture 11 Volumetric representation Animation

(1)

Information Coding / Computer Graphics, ISY, LiTH

Lecture 11

Volumetric representation

Animation

(2)

Last time: Almost-midcourse

evaluation

(3)

(4)

Time to decide on a project

• Should be preliminary decided wednesday the 3th

(second to last lecture)

• Final specification same day as last lecture (friday 5h)

Title

Participants

Brief summary

(5)

Project ideas:

• 3D labyrinth

• Interactive solar system • Robot with moveable limbs

• Driving simulator • Flight simulator

(6)

Information Coding / Computer Graphics, ISY, LiTH BEZ0,3 = (1-u)3 BEZ1,3 = 3u(1-u)2u BEZ2,3 = 3(1-u)u2 BEZ3,3 = u3 P0 P1 P2 P3 1 1

u

(7)

de Casteljau’s algorithm

Linear interpoations of linear interpolations

until only one point remains

(8)

Catmull-Rom splines

Specified only by control points on the curve

Calculated from 4 control points, define between the middle two!

P(u) = pk-1 (-u3/2 + u2 - u/2) +

pk (3u3/2 - 5u2/2 + 1) +

(9)

Continuity

Catmull-Rom

always

C

and G

continuous!

(10)

u

Bézier surfaces

Blending of the 16 control points as a

2-dimensional sum

P(u,v) = ∑ ∑ p

j,k

BEZ

j,3

(v) BEZ

k,3

(u)

k=0

j=0 3 3

(11)

Density volumes

3D grid of density values.

• Pre-computed blobby objects

• Voxelization of 3D models

(12)

Case of particular interest to

some students?

(13)

MRI of MIR

(14)

Rendering:

(15)

Recent projects on raymarching of

medical images

(16)

Marching Cubes

(17)

Example: Marching Squares

(18)

Ray marching relatively easy

Step to next potential voxel wall (3 possible in 3D)

Pick the closest, check neighbor space

Repeat until filled space is found.

(19)

Cheapass ray marching

(20)

Conclusions for density volumes

Usually considered for the advanced course - but

from 2018 supported as course project in TSBK07

primarily for students on the medical technology

program.

(21)

Animation

Essentially a question of flipping between

many still images, fast enough

(22)

Animation as a topic

• Page flipping, double-buffering

• Sprite animation

• Movement and posing

(23)

(24)

The double buffering problem

When animating a scene with many objects in real time, it is not just a question of showing images:

• Erase the entire scene

• Draw each visible object in new positions

(25)

Single buffered animation

Flicker

Screen update

beam

(26)

Solutions

1) Don’t erase-and-redraw near the update beam

Unreliable.

Doesn’t work on all screens.

2) Double buffering.

(27)

Double buffering

VRAM Buffer 1 Buffer 2 VRAM Buffer 1 Buffer 2 Choose buffer Copy

(28)

Double buffered animation

Tearing

Occurs if buffers switch while the screen is being redrawn.

Screen

(29)

Built-in VBL sync (vsync)

Modern systems have VBL sync built-in -

even mandatory double buffering. You

(30)

Double buffering in OpenGL

Double buffer

• Pass GLUT_DOUBLE to glutInitDisplayMode • glutSwapBuffers();

Repeated redraw

(31)

Sprite animation

2D animation based on 2D images.

(32)

Sprites in OpenGL

Use textured polygons with

transparency! (Like billboards but

without 3D.)

(33)

Take advantage of OpenGL in 2D!

High performance - use

high-performance effects

Particle systems

(34)

Pseudo-3D effects

Scaled sprites on background with perspective: Depth cue by size

Side-scrolling with parallax scroll: Depth cue by movement

(35)

(36)

(37)

Classic pseudo-3D game with depth

from shadows and depth from size

(38)

Depth from movement

Parallax scroll

(39)

Not only history

(40)

Pseudo-3D effects vs 3D

• Depth from size = perspective projection

• Parallax scroll: Comes for free to some extent,

but can be emphasized with cameras observing

the viewer

(41)

Animation techniques for moving

objects

• Procedural animation

• Physics-based animation

(42)

Procedural animation

Simple frame by frame movement

following some procedural rule.

What we are already doing in the labs!

x = x + 1

(43)

Animation paths

(44)

Character animation

• Pre-defined poses • Key-frame animation • Forward kinematics • Inverse kinematics

(45)

Key-frame animation

Pre-rendered animations

Key-frames are designed at suitable intervals

(46)

Kinematics

Kinematics = movement without forces Forward kinematics:

Specify poses by specifying rotation of joints. Easy to implement, but specifying poses is much

trial-and-error.

Inverse kinematics:

(47)

Motion capture

Extremely common in movies! • Record by natural visuals only • Tracking markers

• Active sensors on the body

(48)

Face animation

Hard problem - we are very sensitive to errors!

Animate by action units (muscle based) or face animation parameters (extreme detail)

(49)

Some advanced animation topics

• Bones and skinning systems

• Deformations

• Physics-based animation

• Quaternions, SLERP

(50)

Particle systems

Spectacular effects with little effort!

Many small moving objects.

• Explosions

• Water

• Fire

(51)

Particle system

(52)

Particle system

(53)

Particle system

• Initial position

• Initial speed (usually with some

randomness))

• Movement (usually independent, physically

realistic)

(54)

Particle system

Movement according to fundamental

physics:

acceleration = gravity + forces/mass

speed = speed + acceleration

(55)

Particle system on GPU

CPU-driven particle systems OK up to a

certain size

Data transfer (new positions) of all particles

can be a bottleneck

(56)

Texture based particle systems

Use textures to store x, y, z, dx, dy, dz

Store as color components (r, g, b)

Needs advanced texturing features (render

to texture, floating-point buffers)

(57)

Separate compute kernels for

particle systems

CUDA, OpenCL, Compute shaders

Free choice of data formats

(58)

Drawing particle systems

Large number of very simple models

(billboards)!

Modest demands on GPU, but very large

number of function calls!

(59)

Instancing

Draw a large number of the same model!

Each instance has an index, the instance number.

glDrawArraysInstanced(GL_TRIANGLES, 0, 3, 10);

draws a triangle 10 times!

(60)

Billboard instancing demo

#version 150

in vec3 in_Position; uniform mat4 myMatrix; uniform float angle; uniform float slope; out vec2 texCoord; void main(void) {

mat4 r;

float a = angle + gl_InstanceID * 0.5;

float rr = 1.0 - slope * gl_InstanceID * 0.01; r[0] = rr*vec4(cos(a), -sin(a), 0, 0);