iPhone 3D Programming Chapter 02 Math and Metaphors

iPhone 3D
Programming
Chapter 02. Math and Metaphors

2012. 01. 26.
Sanghoon Lee

Sunday, December 9, 12

수학과 비유
Graphics Rendering Pipeline & Metaphor

Transforms

Matrix stack

Vector Beautiﬁcation with C++

HelloCone


What we’re going to study!


Different kind of topology


Different kind of topology

The ﬁrst argument speciﬁes the topology


Drawing rectangle


Properties with Vertices


Setting vertex properties examples


Homogeneous coordinates

Internally, the OpenGL implementation always converts it
into a 4D ﬂoating-point number.

It’s an artiﬁcial construction that allows all transformations to
be represented with matrix multiplication.

These 4D coordinates are known as homogeneous
coordinates.

So, shortly after entering the assembly line, all vertex
positions become 4D; don’t they need to become 2D at some
point? The answer is yes.


The Life of a Vertex

Perspective transform ( removal of w )


Vertex goes from 4D to 2D

Early life of a vertex. Top row is conceptual;
bottom row is OpenGL’s view


Vertex goes from 4D to 2D


The photography metaphor

1. Arrange the various dishes on the table.
2. Arrange one or more light sources.
3. Position the camera.
4. Aim the camera toward the food.
5. Adjust the zoom lens.
6. Snap the picture.

1. Adjust the camera’s ﬁeld-of-view angle. (projection matrix)
2. Position the camera and aim it in the appropriate direction.
(view matrix)
3. For each object:
a. Scale, rotate, and translate. (model matrix)
b. Render the object.


ES 1.1

ES 2.0


Matrix Multiplication


Model Matrix
The three most common operations when
positioning an object in a scene

Scale

Translation

Rotation


Setting the Model Matrix (Scale)


Setting the Model Matrix (Translation)


Setting the Model Matrix (Rotation ES 1.1)

glRotatef(m_currentAngle, 0, 0, 1);

counter-clockwise rotation about the Z-axis
angle in degrees
the latter three arguments deﬁne the axis of rotation


Setting the Model Matrix (Rotation ES 2.0)


Setting the Model Matrix (Rotation)

arbitrary axis rotation
* ES 1.1
glRotatef generates the matrix for you
glRotatef only rotates about the origin


Setting the Model Matrix (Rotation)

arbitrary axis rotation
* ES 2.0


What we have been through


Setting the View Transform


Setting the View Transform

The simplest way to create a view matrix


Setting the Projection Transform

think of the projection as being the camera's
"zoom lens"



ES 1.1



Perspective Orthographic

ES 2.0


Matrix stacks


Matrix stacks

Only ES 1.1 supports
You need to create by yourself in ES 2.0


Interpolations


Example of
easing equations


Quaternions

For position keyframes and color keyframes

It's easy

What if interpolating between two
orientations?


Quaternions

Storing an angle for each joint would be
insufﬁcient

you'd also need the axis of rotation

This is known as Axis-Angle notation

requires a total of four ﬂoating-point values for
each joint


Quaternions

insufﬁcient

you'd also need the axis of rotation
Quaternions
This is known as Axis-Angle notation

each joint


Quaternions

insufﬁcient
Study of rotation
you'd also need the axis
and
This is understand it!!
known as Axis-Angle notation

each joint


Vector Beautiﬁcation
template <typename T> Vector3 Cross(const Vector3& v) const
struct Vector3 { {
return Vector3(y * v.z - z * v.y,
Vector3() {} z * v.x - x * v.z,
Vector3(T x, T y, T z) : x(x), y(y), z(z) {} x * v.y - y * v.x);
void Normalize() }
{ T Dot(const Vector3& v) const
ﬂoat length = std::sqrt(x * x + y * y + z * z); {
x /= length; return x * v.x + y * v.y + z * v.z;
y /= length; }
z /= length; Vector3 operator-() const
} {
return Vector3(-x, -y, -z);
Vector3 Normalized() const }
{
Vector3 v = *this; bool operator==(const Vector3& v) const
v.Normalize(); {
return v; return x == v.x && y == v.y && z == v.z;
} }

T x;
T y;
T z;
};


Vector Beautiﬁcation
vec3 z;
normalize(&z, &(eye-target));

vec3 cross;
vec3 z = (eye - target).Normalized();
cross(&cross, &up, &z);
vec3 x;
vec3 x = up.Cross(z).Normalized();
normalize(&x, &cross);

vec3 y = z.Cross(x).Normalized();
cross(&cross, &up, &z);
vec3 y;
normalize(&y, &cross);


Hello Cone
Fixed Function


Hello Cone
Shaders


Further study

Graphics Rendering pipeline

Quaternion


Q/A


iPhone 3D Programming Chapter 02 Math and Metaphors

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Empfohlen

Empfohlen (20)

iPhone 3D Programming Chapter 02 Math and Metaphors