Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
PSYQO SDK
psyqo::GTE::writeSafe
Function · 41 overloads
Function
Writes safe as part of Geometry Transformation Engine math and register operations.
Declaration 1 of 41
templateDeclaration
template <> inline void writeSafe<PseudoRegister::Color>(const Matrix33& in)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
in | const Matrix33 & | Value supplied for in. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// const Matrix33 & in
psyqo::GTE::writeSafe(in);Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size. Pointer/reference arguments are borrowed unless the source contract says otherwise; keep them valid for the complete operation and never assume null is accepted.
Declaration 2 of 41
templateDeclaration
template <> inline void writeSafe<PseudoRegister::Light>(const Matrix33& in)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
in | const Matrix33 & | Value supplied for in. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// const Matrix33 & in
psyqo::GTE::writeSafe(in);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size. Pointer/reference arguments are borrowed unless the source contract says otherwise; keep them valid for the complete operation and never assume null is accepted.
Declaration 3 of 41
templateDeclaration
template <> inline void writeSafe<PseudoRegister::Rotation>(const Matrix33& in)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
in | const Matrix33 & | Value supplied for in. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// const Matrix33 & in
psyqo::GTE::writeSafe(in);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size. Pointer/reference arguments are borrowed unless the source contract says otherwise; keep them valid for the complete operation and never assume null is accepted.
Declaration 4 of 41
templateDeclaration
template <> inline void writeSafe<PseudoRegister::ScreenOffset>(const Vec2& in)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
in | const Vec2 & | Value supplied for in. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// const Vec2 & in
psyqo::GTE::writeSafe(in);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size. Pointer/reference arguments are borrowed unless the source contract says otherwise; keep them valid for the complete operation and never assume null is accepted.
Declaration 5 of 41
templateDeclaration
template <> inline void writeSafe<PseudoRegister::Translation>(const Vec3& in)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
in | const Vec3 & | Value supplied for in. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// const Vec3 & in
psyqo::GTE::writeSafe(in);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size. Pointer/reference arguments are borrowed unless the source contract says otherwise; keep them valid for the complete operation and never assume null is accepted.
Declaration 6 of 41
templateDeclaration
template <> inline void writeSafe<PseudoRegister::V0>(const Vec3& in)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
in | const Vec3 & | Value supplied for in. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// const Vec3 & in
psyqo::GTE::writeSafe(in);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size. Pointer/reference arguments are borrowed unless the source contract says otherwise; keep them valid for the complete operation and never assume null is accepted.
Declaration 7 of 41
templateDeclaration
template <> inline void writeSafe<PseudoRegister::V1>(const Vec3& in)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
in | const Vec3 & | Value supplied for in. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// const Vec3 & in
psyqo::GTE::writeSafe(in);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size. Pointer/reference arguments are borrowed unless the source contract says otherwise; keep them valid for the complete operation and never assume null is accepted.
Declaration 8 of 41
templateDeclaration
template <> inline void writeSafe<PseudoRegister::V2>(const Vec3& in)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
in | const Vec3 & | Value supplied for in. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// const Vec3 & in
psyqo::GTE::writeSafe(in);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size. Pointer/reference arguments are borrowed unless the source contract says otherwise; keep them valid for the complete operation and never assume null is accepted.
Declaration 9 of 41
templateDeclaration
template <> inline void writeSafe<Register::IR0>(Short x_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
psyqo::GTE::writeSafe(x_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 10 of 41
templateDeclaration
template <> inline void writeSafe<Register::IR1>(Short x_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
psyqo::GTE::writeSafe(x_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 11 of 41
templateDeclaration
template <> inline void writeSafe<Register::IR2>(Short x_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
psyqo::GTE::writeSafe(x_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 12 of 41
templateDeclaration
template <> inline void writeSafe<Register::IR3>(Short x_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
psyqo::GTE::writeSafe(x_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 13 of 41
templateDeclaration
template <> inline void writeSafe<Register::L11L12>(Short x_, Short y_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
y_ | Short | Value supplied for y_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
// Short y_
psyqo::GTE::writeSafe(x_, y_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 14 of 41
templateDeclaration
template <> inline void writeSafe<Register::L13L21>(Short x_, Short y_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
y_ | Short | Value supplied for y_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
// Short y_
psyqo::GTE::writeSafe(x_, y_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 15 of 41
templateDeclaration
template <> inline void writeSafe<Register::L22L23>(Short x_, Short y_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
y_ | Short | Value supplied for y_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
// Short y_
psyqo::GTE::writeSafe(x_, y_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 16 of 41
templateDeclaration
template <> inline void writeSafe<Register::L31L32>(Short x_, Short y_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
y_ | Short | Value supplied for y_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
// Short y_
psyqo::GTE::writeSafe(x_, y_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 17 of 41
templateDeclaration
template <> inline void writeSafe<Register::L33>(Short z_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
z_ | Short | Value supplied for z_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short z_
psyqo::GTE::writeSafe(z_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 18 of 41
templateDeclaration
template <> inline void writeSafe<Register::LB1LB2>(Short x_, Short y_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
y_ | Short | Value supplied for y_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
// Short y_
psyqo::GTE::writeSafe(x_, y_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 19 of 41
templateDeclaration
template <> inline void writeSafe<Register::LB3>(Short z_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
z_ | Short | Value supplied for z_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short z_
psyqo::GTE::writeSafe(z_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 20 of 41
templateDeclaration
template <> inline void writeSafe<Register::LG2LG3>(Short x_, Short y_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
y_ | Short | Value supplied for y_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
// Short y_
psyqo::GTE::writeSafe(x_, y_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 21 of 41
templateDeclaration
template <> inline void writeSafe<Register::LR1LR2>(Short x_, Short y_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
y_ | Short | Value supplied for y_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
// Short y_
psyqo::GTE::writeSafe(x_, y_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 22 of 41
templateDeclaration
template <> inline void writeSafe<Register::LR3LG1>(Short x_, Short y_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
y_ | Short | Value supplied for y_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
// Short y_
psyqo::GTE::writeSafe(x_, y_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 23 of 41
templateDeclaration
template <> inline void writeSafe<Register::OTZ>(Short z_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
z_ | Short | Value supplied for z_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short z_
psyqo::GTE::writeSafe(z_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 24 of 41
templateDeclaration
template <> inline void writeSafe<Register::R11R12>(Short x_, Short y_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
y_ | Short | Value supplied for y_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
// Short y_
psyqo::GTE::writeSafe(x_, y_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 25 of 41
templateDeclaration
template <> inline void writeSafe<Register::R13R21>(Short x_, Short y_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
y_ | Short | Value supplied for y_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
// Short y_
psyqo::GTE::writeSafe(x_, y_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 26 of 41
templateDeclaration
template <> inline void writeSafe<Register::R22R23>(Short x_, Short y_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
y_ | Short | Value supplied for y_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
// Short y_
psyqo::GTE::writeSafe(x_, y_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 27 of 41
templateDeclaration
template <> inline void writeSafe<Register::R31R32>(Short x_, Short y_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
y_ | Short | Value supplied for y_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
// Short y_
psyqo::GTE::writeSafe(x_, y_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 28 of 41
templateDeclaration
template <> inline void writeSafe<Register::R33>(Short z_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
z_ | Short | Value supplied for z_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short z_
psyqo::GTE::writeSafe(z_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 29 of 41
templateDeclaration
template <> inline void writeSafe<Register::VXY0>(Short x_, Short y_)The following are template specializations for the various GTE registers.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
y_ | Short | Value supplied for y_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
// Short y_
psyqo::GTE::writeSafe(x_, y_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 30 of 41
templateDeclaration
template <> inline void writeSafe<Register::VXY1>(Short x_, Short y_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
y_ | Short | Value supplied for y_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
// Short y_
psyqo::GTE::writeSafe(x_, y_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 31 of 41
templateDeclaration
template <> inline void writeSafe<Register::VXY2>(Short x_, Short y_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
x_ | Short | Value supplied for x_. Keep referenced or pointed-to data valid for the complete call. |
y_ | Short | Value supplied for y_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short x_
// Short y_
psyqo::GTE::writeSafe(x_, y_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 32 of 41
templateDeclaration
template <> inline void writeSafe<Register::VZ0>(Short z_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
z_ | Short | Value supplied for z_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short z_
psyqo::GTE::writeSafe(z_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 33 of 41
templateDeclaration
template <> inline void writeSafe<Register::VZ1>(Short z_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
z_ | Short | Value supplied for z_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short z_
psyqo::GTE::writeSafe(z_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 34 of 41
templateDeclaration
template <> inline void writeSafe<Register::VZ2>(Short z_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
z_ | Short | Value supplied for z_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short z_
psyqo::GTE::writeSafe(z_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 35 of 41
templateDeclaration
template <> inline void writeSafe<Register::ZSF3>(Short z_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
z_ | Short | Value supplied for z_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short z_
psyqo::GTE::writeSafe(z_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 36 of 41
templateDeclaration
template <> inline void writeSafe<Register::ZSF4>(Short z_)Writes safe as part of Geometry Transformation Engine math and register operations.
| Parameter | Type | Meaning |
|---|---|---|
z_ | Short | Value supplied for z_. Keep referenced or pointed-to data valid for the complete call. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Assume these named values have been initialized with valid data:
// Short z_
psyqo::GTE::writeSafe(z_);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 37 of 41
static · templateDeclaration
template <PseudoRegister reg, bool valid = false> static inline void writeSafe(const Matrix33& in)Write a 3x3 matrix to a GTE pseudo register, adding nops after the operation.
| Parameter | Type | Meaning |
|---|---|---|
in | const Matrix33 & | The matrix to write. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Replace these template arguments with types or values accepted by the declaration:
// reg, valid
// Assume these named values have been initialized with valid data:
// const Matrix33 & in
psyqo::GTE::writeSafe<reg, valid>(in);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size. Pointer/reference arguments are borrowed unless the source contract says otherwise; keep them valid for the complete operation and never assume null is accepted.
Declaration 38 of 41
static · templateDeclaration
template <PseudoRegister reg, bool valid = false> static inline void writeSafe(const Vec2& in)Write a 2D vector to a GTE pseudo register, adding nops after the operation.
| Parameter | Type | Meaning |
|---|---|---|
in | const Vec2 & | The vector to write. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Replace these template arguments with types or values accepted by the declaration:
// reg, valid
// Assume these named values have been initialized with valid data:
// const Vec2 & in
psyqo::GTE::writeSafe<reg, valid>(in);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size. Pointer/reference arguments are borrowed unless the source contract says otherwise; keep them valid for the complete operation and never assume null is accepted.
Declaration 39 of 41
static · templateDeclaration
template <PseudoRegister reg, bool valid = false> static inline void writeSafe(const Vec3& in)Write a 3D vector to a GTE pseudo register, adding nops after the operation.
| Parameter | Type | Meaning |
|---|---|---|
in | const Vec3 & | The vector to write. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Replace these template arguments with types or values accepted by the declaration:
// reg, valid
// Assume these named values have been initialized with valid data:
// const Vec3 & in
psyqo::GTE::writeSafe<reg, valid>(in);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size. Pointer/reference arguments are borrowed unless the source contract says otherwise; keep them valid for the complete operation and never assume null is accepted.
Declaration 40 of 41
static · templateDeclaration
template <Register reg, bool valid = false> static inline void writeSafe(Short fp)Writes a 16-bits fixed point number to a GTE register, adding nops after the operation.
| Parameter | Type | Meaning |
|---|---|---|
fp | Short | The fixed point number to write. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Replace these template arguments with types or values accepted by the declaration:
// reg, valid
// Assume these named values have been initialized with valid data:
// Short fp
psyqo::GTE::writeSafe<reg, valid>(fp);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Declaration 41 of 41
static · templateDeclaration
template <Register reg, bool valid = false> static inline void writeSafe(Short low, Short hi)Writes two 16-bits fixed point numbers to a GTE register, adding nops after the operation.
| Parameter | Type | Meaning |
|---|---|---|
low | Short | The value to write to the lower 16 bits of the register. |
hi | Short | The value to write to the higher 16 bits of the register. |
Returns: Nothing (void).
Example
C++ example
#include "psyqo/gte-registers.hh"
// Replace these template arguments with types or values accepted by the declaration:
// reg, valid
// Assume these named values have been initialized with valid data:
// Short low
// Short hi
psyqo::GTE::writeSafe<reg, valid>(low, hi);Why use it
Template dispatch is resolved at compile time and normally adds no runtime indirection.
Trade-offs and warnings
Every instantiated type must satisfy the header's compile-time requirements; extra instantiations can increase code size.
Related members
adler32Computes the adler32 checksum of a buffer.Functionadler32_bytesComputes the adler32 checksum of a buffer, only reading bytes.Functionadler32_wordsComputes the adler32 checksum of a buffer, optimized for words.Functionavsz3AVSZ3 - Average of three Z values (for Triangles) zsf3 * (sz0 + sz1 + sz2) -> otz 5 cyclesFunctionavsz4AVSZ4 - Average of four Z values (for Quads) zsf4 * (sz0 + sz1 + sz2 + sz4) -> otz 6 cyclesFunctionbtoiPerforms `btoi` as part of the msf module.FunctionclearClear a GTE register.Function templatecubicCubic Bezier curve helper function.FunctiondDivPerforms `d div` as part of the fixed point module.FunctioniDivPerforms `i div` as part of the fixed point module.Functionoperator""_fpUser-defined literal for constructing a 20.12 fixed point number.FunctionprintIntPerforms `print int` as part of the fixed point module.Function