Vector¶

Imath.V2s¶

class Imath.V2s¶

short x

short y

V2s() → V2s¶

V2s(V2s v) → V2s

V2s(short a) → V2s

V2s(short a, short b) → V2s

V2s(table[2] t) → V2s

operator==(V2s v) const → boolean¶

operator!=(V2s v) const → boolean¶

operator+(V2s v) const → V2s¶

operator-(V2s v) const → V2s¶

operator-() const → V2s

operator*(V2s) const → V2s¶

operator*(short s) const → V2s

operator/(V2s v) const → V2s¶

operator/(short s) const → V2s

operator[](int idx) const → short¶

operator[](int idx, short value)

equalWithAbsError(V2s v, short e) const → boolean¶

equalWithRelError(V2s v, short e) const → boolean¶

dot(V2s v) → short¶

cross(V2s v) const → short¶

negate() → V2s&¶

length() const → short¶

length2() const → short¶

normalize() → V2s&¶

normalizeExc() → V2s&¶

normalizeNonNull() → V2s&¶

normalized() const → V2s¶

normalizedExc() const → V2s¶

normalizedNonNull() const → V2s¶

project(V2s v) const → V2s¶

orthogonal(V2s v) const → V2s¶

reflect(V2s v) const → V2s¶

toTable() const → table[2]¶

static dimensions() → int¶

static baseTypeMin() → short¶

static baseTypeMax() → short¶

static baseTypeSmallest() → short¶

static baseTypeEpsilon() → short¶

static closestVertex(V2s v0, V2s v1, V2s v2, V2s p) → V2s¶

Imath.V2i¶

class Imath.V2i¶

int x

int y

V2i() → V2i¶

V2i(V2i v) → V2i

V2i(int a) → V2i

V2i(int a, int b) → V2i

V2i(table[2] t) → V2i

operator==(V2i v) const → boolean¶

operator!=(V2i v) const → boolean¶

operator+(V2i v) const → V2i¶

operator-(V2i v) const → V2i¶

operator-() const → V2i

operator*(V2i) const → V2i¶

operator*(int s) const → V2i

operator/(V2i v) const → V2i¶

operator/(int s) const → V2i

operator[](int idx) const → int¶

operator[](int idx, int value)

equalWithAbsError(V2i v, int e) const → boolean¶

equalWithRelError(V2i v, int e) const → boolean¶

dot(V2i v) → int¶

cross(V2i v) const → int¶

negate() → V2i&¶

length() const → int¶

length2() const → int¶

normalize() → V2i&¶

normalizeExc() → V2i&¶

normalizeNonNull() → V2i&¶

normalized() const → V2i¶

normalizedExc() const → V2i¶

normalizedNonNull() const → V2i¶

project(V2i v) const → V2i¶

orthogonal(V2i v) const → V2i¶

reflect(V2i v) const → V2i¶

toTable() const → table[2]¶

static dimensions() → int¶

static baseTypeMin() → int¶

static baseTypeMax() → int¶

static baseTypeSmallest() → int¶

static baseTypeEpsilon() → int¶

static closestVertex(V2i v0, V2i v1, V2i v2, V2i p) → V2i¶

Imath.V2f¶

class Imath.V2f¶

float x

float y

V2f() → V2f¶

V2f(V2f v) → V2f

V2f(float a) → V2f

V2f(float a, float b) → V2f

V2f(table[2] t) → V2f

operator==(V2f v) const → boolean¶

operator!=(V2f v) const → boolean¶

operator+(V2f v) const → V2f¶

operator-(V2f v) const → V2f¶

operator-() const → V2f

operator*(V2f) const → V2f¶

operator*(float s) const → V2f

operator/(V2f v) const → V2f¶

operator/(float s) const → V2f

operator*(M33f m) const → V2f

operator[](int idx) const → float¶

operator[](int idx, float value)

equalWithAbsError(V2f v, float e) const → boolean¶

equalWithRelError(V2f v, float e) const → boolean¶

dot(V2f v) → float¶

cross(V2f v) const → float¶

negate() → V2f&¶

length() const → float¶

length2() const → float¶

normalize() → V2f&¶

normalizeExc() → V2f&¶

normalizeNonNull() → V2f&¶

normalized() const → V2f¶

normalizedExc() const → V2f¶

normalizedNonNull() const → V2f¶

project(V2f v) const → V2f¶

orthogonal(V2f v) const → V2f¶

reflect(V2f v) const → V2f¶

toTable() const → table[2]¶

static dimensions() → int¶

static baseTypeMin() → float¶

static baseTypeMax() → float¶

static baseTypeSmallest() → float¶

static baseTypeEpsilon() → float¶

static closestVertex(V2f v0, V2f v1, V2f v2, V2f p) → V2f¶

Imath.V2d¶

class Imath.V2d¶

double x

double y

V2d() → V2d¶

V2d(V2d v) → V2d

V2d(double a) → V2d

V2d(double a, double b) → V2d

V2d(table[2] t) → V2d

operator==(V2d v) const → boolean¶

operator!=(V2d v) const → boolean¶

operator+(V2d v) const → V2d¶

operator-(V2d v) const → V2d¶

operator-() const → V2d

operator*(V2d) const → V2d¶

operator*(double s) const → V2d

operator/(V2d v) const → V2d¶

operator/(double s) const → V2d

operator*(M33d m) const → V2d

operator[](int idx) const → double¶

operator[](int idx, double value)

equalWithAbsError(V2d v, double e) const → boolean¶

equalWithRelError(V2d v, double e) const → boolean¶

dot(V2d v) → double¶

cross(V2d v) const → double¶

negate() → V2d&¶

length() const → double¶

length2() const → double¶

normalize() → V2d&¶

normalizeExc() → V2d&¶

normalizeNonNull() → V2d&¶

normalized() const → V2d¶

normalizedExc() const → V2d¶

normalizedNonNull() const → V2d¶

project(V2d v) const → V2d¶

orthogonal(V2d v) const → V2d¶

reflect(V2d v) const → V2d¶

toTable() const → table[2]¶

static dimensions() → int¶

static baseTypeMin() → double¶

static baseTypeMax() → double¶

static baseTypeSmallest() → double¶

static baseTypeEpsilon() → double¶

static closestVertex(V2d v0, V2d v1, V2d v2, V2d p) → V2d¶

Imath.V3s¶

Imath.InfException¶

INF_EXCEPTION

class Imath.V3s¶

short x

short y

short z

V3s() → V3s¶

V3s(V3s v) → V3s

V3s(short a) → V3s

V3s(short a, short b, short c) → V3s

V3s(table[3] t) → V3s

V3s(V4s v) → V3s

V3s(V4s v, InfException) → V3s

operator==(V3s v) const → boolean¶

operator!=(V3s v) const → boolean¶

operator+(V3s v) const → V3s¶

operator-(V3s v) const → V3s¶

operator-() const → V3s

operator*(V3s) const → V3s¶

operator*(short s) const → V3s

operator/(V3s v) const → V3s¶

operator/(short s) const → V3s

operator[](int idx) const → short¶

operator[](int idx, short value)

equalWithAbsError(V3s v, short e) const → boolean¶

equalWithRelError(V3s v, short e) const → boolean¶

dot(V3s v) → short¶

cross(V3s v) const → V3s¶

negate() → V3s&¶

length() const → short¶

length2() const → short¶

normalize() → V3s&¶

normalizeExc() → V3s&¶

normalizeNonNull() → V3s&¶

normalized() const → V3s¶

normalizedExc() const → V3s¶

normalizedNonNull() const → V3s¶

project(V3s v) const → V3s¶

orthogonal(V3s v) const → V3s¶

reflect(V3s v) const → V3s¶

toTable() const → table[3]¶

static dimensions() → int¶

static baseTypeMin() → short¶

static baseTypeMax() → short¶

static baseTypeSmallest() → short¶

static baseTypeEpsilon() → short¶

static closestVertex(V3s v0, V3s v1, V3s v2, V3s p) → V3s¶

Imath.V3i¶

class Imath.V3i¶

int x

int y

int z

V3i() → V3i¶

V3i(V3i v) → V3i

V3i(int a) → V3i

V3i(int a, int b, int c) → V3i

V3i(table[3] t) → V3i

V3i(V4i v) → V3i

V3i(V4i v, InfException) → V3i

operator==(V3i v) const → boolean¶

operator!=(V3i v) const → boolean¶

operator+(V3i v) const → V3i¶

operator-(V3i v) const → V3i¶

operator-() const → V3i

operator*(V3i) const → V3i¶

operator*(int s) const → V3i

operator/(V3i v) const → V3i¶

operator/(int s) const → V3i

operator[](int idx) const → int¶

operator[](int idx, int value)

equalWithAbsError(V3i v, int e) const → boolean¶

equalWithRelError(V3i v, int e) const → boolean¶

dot(V3i v) → int¶

cross(V3i v) const → V3i¶

negate() → V3i&¶

length() const → int¶

length2() const → int¶

normalize() → V3i&¶

normalizeExc() → V3i&¶

normalizeNonNull() → V3i&¶

normalized() const → V3i¶

normalizedExc() const → V3i¶

normalizedNonNull() const → V3i¶

project(V3i v) const → V3i¶

orthogonal(V3i v) const → V3i¶

reflect(V3i v) const → V3i¶

toTable() const → table[3]¶

static dimensions() → int¶

static baseTypeMin() → int¶

static baseTypeMax() → int¶

static baseTypeSmallest() → int¶

static baseTypeEpsilon() → int¶

static closestVertex(V3i v0, V3i v1, V3i v2, V3i p) → V3i¶

Imath.V3f¶

class Imath.V3f¶

float x

float y

float z

V3f() → V3f¶

V3f(V3f v) → V3f

V3f(float a) → V3f

V3f(float a, float b, float c) → V3f

V3f(table[3] t) → V3f

V3f(V4f v) → V3f

V3f(V4f v, InfException) → V3f

operator==(V3f v) const → boolean¶

operator!=(V3f v) const → boolean¶

operator+(V3f v) const → V3f¶

operator-(V3f v) const → V3f¶

operator-() const → V3f

operator*(V3f) const → V3f¶

operator*(float s) const → V3f

operator/(V3f v) const → V3f¶

operator/(float s) const → V3f

operator*(M33f m) const → V3f

operator*(M44f m) const → V3f

operator[](int idx) const → float¶

operator[](int idx, float value)

equalWithAbsError(V3f v, float e) const → boolean¶

equalWithRelError(V3f v, float e) const → boolean¶

dot(V3f v) → float¶

cross(V3f v) const → V3f¶

negate() → V3f&¶

length() const → float¶

length2() const → float¶

normalize() → V3f&¶

normalizeExc() → V3f&¶

normalizeNonNull() → V3f&¶

normalized() const → V3f¶

normalizedExc() const → V3f¶

normalizedNonNull() const → V3f¶

project(V3f v) const → V3f¶

orthogonal(V3f v) const → V3f¶

reflect(V3f v) const → V3f¶

toTable() const → table[3]¶

static dimensions() → int¶

static baseTypeMin() → float¶

static baseTypeMax() → float¶

static baseTypeSmallest() → float¶

static baseTypeEpsilon() → float¶

static closestVertex(V3f v0, V3f v1, V3f v2, V3f p) → V3f¶

Imath.V3d¶

class Imath.V3d¶

double x

double y

double z

V3d() → V3d¶

V3d(V3d v) → V3d

V3d(double a) → V3d

V3d(double a, double b, double c) → V3d

V3d(table[3] t) → V3d

V3d(V4d v) → V3d

V3d(V4d v, InfException) → V3d

operator==(V3d v) const → boolean¶

operator!=(V3d v) const → boolean¶

operator+(V3d v) const → V3d¶

operator-(V3d v) const → V3d¶

operator-() const → V3d

operator*(V3d) const → V3d¶

operator*(double s) const → V3d

operator/(V3d v) const → V3d¶

operator/(double s) const → V3d

operator*(M33d m) const → V3d

operator*(M44d m) const → V3d

operator[](int idx) const → double¶

operator[](int idx, double value)

equalWithAbsError(V3d v, double e) const → boolean¶

equalWithRelError(V3d v, double e) const → boolean¶

dot(V3d v) → double¶

cross(V3d v) const → V3d¶

negate() → V3d&¶

length() const → double¶

length2() const → double¶

normalize() → V3d&¶

normalizeExc() → V3d&¶

normalizeNonNull() → V3d&¶

normalized() const → V3d¶

normalizedExc() const → V3d¶

normalizedNonNull() const → V3d¶

project(V3d v) const → V3d¶

orthogonal(V3d v) const → V3d¶

reflect(V3d v) const → V3d¶

toTable() const → table[3]¶

static dimensions() → int¶

static baseTypeMin() → double¶

static baseTypeMax() → double¶

static baseTypeSmallest() → double¶

static baseTypeEpsilon() → double¶

static closestVertex(V3d v0, V3d v1, V3d v2, V3d p) → V3d¶

Imath.V4s¶

class Imath.V4s¶

short x

short y

short z

short w

V4s() → V4s¶

V4s(V4s v) → V4s

V4s(short a) → V4s

V4s(short a, short b, short c, short d) → V4s

V4s(table[4] t) → V4s

operator==(V4s v) const → boolean¶

operator!=(V4s v) const → boolean¶

operator+(V4s v) const → V4s¶

operator-(V4s v) const → V4s¶

operator-() const → V4s

operator*(V4s) const → V4s¶

operator*(short s) const → V4s

operator/(V4s v) const → V4s¶

operator/(short s) const → V4s

operator[](int idx) const → short¶

operator[](int idx, short value)

equalWithAbsError(V4s v, short e) const → boolean¶

equalWithRelError(V4s v, short e) const → boolean¶

dot(V4s v) → short¶

cross(V4s v) const → V4s¶

negate() → V4s&¶

length() const → short¶

length2() const → short¶

normalize() → V4s&¶

normalizeExc() → V4s&¶

normalizeNonNull() → V4s&¶

normalized() const → V4s¶

normalizedExc() const → V4s¶

normalizedNonNull() const → V4s¶

project(V4s v) const → V4s¶

orthogonal(V4s v) const → V4s¶

reflect(V4s v) const → V4s¶

toTable() const → table[4]¶

static dimensions() → int¶

static baseTypeMin() → short¶

static baseTypeMax() → short¶

static baseTypeSmallest() → short¶

static baseTypeEpsilon() → short¶

static closestVertex(V4s v0, V4s v1, V4s v2, V4s p) → V4s¶

Imath.V4i¶

class Imath.V4i¶

int x

int y

int z

int w

V4i() → V4i¶

V4i(V4i v) → V4i

V4i(int a) → V4i

V4i(int a, int b, int c, int d) → V4i

V4i(table[4] t) → V4i

operator==(V4i v) const → boolean¶

operator!=(V4i v) const → boolean¶

operator+(V4i v) const → V4i¶

operator-(V4i v) const → V4i¶

operator-() const → V4i

operator*(V4i) const → V4i¶

operator*(int s) const → V4i

operator/(V4i v) const → V4i¶

operator/(int s) const → V4i

operator[](int idx) const → int¶

operator[](int idx, int value)

equalWithAbsError(V4i v, int e) const → boolean¶

equalWithRelError(V4i v, int e) const → boolean¶

dot(V4i v) → int¶

cross(V4i v) const → V4i¶

negate() → V4i&¶

length() const → int¶

length2() const → int¶

normalize() → V4i&¶

normalizeExc() → V4i&¶

normalizeNonNull() → V4i&¶

normalized() const → V4i¶

normalizedExc() const → V4i¶

normalizedNonNull() const → V4i¶

project(V4i v) const → V4i¶

orthogonal(V4i v) const → V4i¶

reflect(V4i v) const → V4i¶

toTable() const → table[4]¶

static dimensions() → int¶

static baseTypeMin() → int¶

static baseTypeMax() → int¶

static baseTypeSmallest() → int¶

static baseTypeEpsilon() → int¶

static closestVertex(V4i v0, V4i v1, V4i v2, V4i p) → V4i¶

Imath.V4f¶

class Imath.V4f¶

float x

float y

float z

float w

V4f() → V4f¶

V4f(V4f v) → V4f

V4f(float a) → V4f

V4f(float a, float b, float c, float d) → V4f

V4f(table[4] t) → V4f

operator==(V4f v) const → boolean¶

operator!=(V4f v) const → boolean¶

operator+(V4f v) const → V4f¶

operator-(V4f v) const → V4f¶

operator-() const → V4f

operator*(V4f) const → V4f¶

operator*(float s) const → V4f

operator/(V4f v) const → V4f¶

operator/(float s) const → V4f

operator*(M44f m) const → V4f

operator[](int idx) const → float¶

operator[](int idx, float value)

equalWithAbsError(V4f v, float e) const → boolean¶

equalWithRelError(V4f v, float e) const → boolean¶

dot(V4f v) → float¶

cross(V4f v) const → V4f¶

negate() → V4f&¶

length() const → float¶

length2() const → float¶

normalize() → V4f&¶

normalizeExc() → V4f&¶

normalizeNonNull() → V4f&¶

normalized() const → V4f¶

normalizedExc() const → V4f¶

normalizedNonNull() const → V4f¶

project(V4f v) const → V4f¶

orthogonal(V4f v) const → V4f¶

reflect(V4f v) const → V4f¶

toTable() const → table[4]¶

static dimensions() → int¶

static baseTypeMin() → float¶

static baseTypeMax() → float¶

static baseTypeSmallest() → float¶

static baseTypeEpsilon() → float¶

static closestVertex(V4f v0, V4f v1, V4f v2, V4f p) → V4f¶

Imath.V4d¶

class Imath.V4d¶

double x

double y

double z

double w

V4d() → V4d¶

V4d(V4d v) → V4d

V4d(double a) → V4d

V4d(double a, double b, double c, double d) → V4d

V4d(table[4] t) → V4d

operator==(V4d v) const → boolean¶

operator!=(V4d v) const → boolean¶

operator+(V4d v) const → V4d¶

operator-(V4d v) const → V4d¶

operator-() const → V4d

operator*(V4d) const → V4d¶

operator*(double s) const → V4d

operator/(V4d v) const → V4d¶

operator/(double s) const → V4d

operator*(M44d m) const → V4d

operator[](int idx) const → double¶

operator[](int idx, double value)

equalWithAbsError(V4d v, double e) const → boolean¶

equalWithRelError(V4d v, double e) const → boolean¶

dot(V4d v) → double¶

cross(V4d v) const → V4d¶

negate() → V4d&¶

length() const → double¶

length2() const → double¶

normalize() → V4d&¶

normalizeExc() → V4d&¶

normalizeNonNull() → V4d&¶

normalized() const → V4d¶

normalizedExc() const → V4d¶

normalizedNonNull() const → V4d¶

project(V4d v) const → V4d¶

orthogonal(V4d v) const → V4d¶

reflect(V4d v) const → V4d¶

toTable() const → table[4]¶

static dimensions() → int¶

static baseTypeMin() → double¶

static baseTypeMax() → double¶

static baseTypeSmallest() → double¶

static baseTypeEpsilon() → double¶

static closestVertex(V4d v0, V4d v1, V4d v2, V4d p) → V4d¶