When a contract is assigned for administration under Subpart 42.2, the contract administration office (CAO) shall perform contract administration functions in accordance with 48 CFR Chapter 1, the contract terms, and, unless otherwise agreed to in an interagency agreement (see 42.002), the applicable regulations of the servicing agency.
(a) The contracting officer normally delegates the following contract administration functions to a CAO. The contracting officer may retain any of these functions, except those in paragraphs (a)(5), (a)(9), (a)(11) and (a)(12) of this section, unless the cognizant Federal agency (see 2.101) has designated the contracting officer to perform these functions.
(1) Review the contractor’s compensation structure.
(2) Review the contractor’s insurance plans.
(3) Conduct post-award orientation conferences.
(4) Review and evaluate contractors’ proposals under Subpart 15.4 and, when negotiation will be accomplished by the contracting officer, furnish comments and recommendations to that officer.
(5) Negotiate forward pricing rate agreements (see 15.407-3).
(6) Negotiate advance agreements applicable to treatment of costs under contracts currently assigned for administration (see 31.109).
(7) Determine the allowability of costs suspended or disapproved as required (see Subpart 42.8), direct the suspension or disapproval of costs when there is reason to believe they should be suspended or disapproved, and approve final vouchers.
(8) Issue Notices of Intent to Disallow or not Recognize Costs (see Subpart 42.8).
(9) Establish final indirect cost rates and billing rates for those contractors meeting the criteria for contracting officer determination in Subpart 42.7.
(10) Attempt to resolve issues in controversy, using ADR procedures when appropriate (see Subpart 33.2); prepare findings of fact and issue decisions under the Disputes clause on matters in which the administrative contracting officer (ACO) has the authority to take definitive action.
(11) In connection with Cost Accounting Standards (see 30.601 and 48 CFR Chapter 99 (FAR Appendix))—
(i) Determine the adequacy of the contractor’s disclosure statements;
(ii) Determine whether disclosure statements are in compliance with Cost Accounting Standards and Part 31;
(iii) Determine the contractor’s compliance with Cost Accounting Standards and disclosure statements, if applicable; and
(iv) Negotiate price adjustments and execute supplemental agreements under the Cost Accounting Standards clauses at 52.230-2, 52.230-3, 52.230-4, 52.230-5, and 52.230-6.
(12) Determine the adequacy of the contractor’s accounting system. The contractor’s accounting system should be adequate during the entire period of contract performance. The adequacy of the contractor’s accounting system and its associated internal control system, as well as contractor compliance with the Cost Accounting Standards (CAS), affect the quality and validity of the contractor data upon which the Government must rely for its management oversight of the contractor and contract performance.
(13) Review and approve or disapprove the contractor’s requests for payments under the progress payments or performance-based payments clauses.
(14) Make payments on assigned contracts when prescribed in agency acquisition regulations.
(15) Manage special bank accounts.
(16) Ensure timely notification by the contractor of any anticipated overrun or underrun of the estimated cost under cost-reimbursement contracts.
(17) Monitor the contractor’s financial condition and advise the contracting officer when it jeopardizes contract performance.
(18) Analyze quarterly limitation on payments statements and take action in accordance with Subpart 32.6 to recover overpayments from the contractor.
(19) Issue tax exemption forms.
(20) Ensure processing and execution of duty-free entry certificates.
(21) For classified contracts, administer those portions of the applicable industrial security program delegated to the CAO (see Subpart 4.4).
(22) Issue work requests under maintenance, overhaul, and modification contracts.
(23) Negotiate prices and execute supplemental agreements for spare parts and other items selected through provisioning procedures when prescribed by agency acquisition regulations.
(24) Negotiate and execute contractual documents for settlement of partial and complete contract terminations for convenience, except as otherwise prescribed by Part 49.
(25) Negotiate and execute contractual documents settling cancellation charges under multiyear contracts.
(26) Process and execute novation and change of name agreements under Subpart 42.12.
(27) Perform property administration (see Part 45).
(28) Perform necessary screening, redistribution, and disposal of contractor inventory.
(29) Issue contract modifications requiring the contractor to provide packing, crating, and handling services on excess Government property. When the ACO determines it to be in the Government’s interests, the services may be secured from a contractor other than the contractor in possession of the property.
(30) When contractors request Government property—
(i) Evaluate the contractor’s requests for Government property and for changes to existing Government property and provide appropriate recommendations to the contracting officer;
(ii) Ensure required screening of Government property before acquisition by the contractor;
(iii) Evaluate the use of Government property on a non-interference basis in accordance with the clause at 52.245-9, Use and Charges;
(iv) Ensure payment by the contractor of any rental due; and
(v) Modify contracts to reflect the addition of Government-furnished property and ensure appropriate consideration.
(31) Perform production support, surveillance, and status reporting, including timely reporting of potential and actual slippages in contract delivery schedules.
(32) Perform preaward surveys (see Subpart 9.1).
(33) Advise and assist contractors regarding their priorities and allocations responsibilities and assist contracting offices in processing requests for special assistance and for priority ratings for privately owned capital equipment.
(34) Monitor contractor industrial labor relations matters under the contract; apprise the contracting officer and, if designated by the agency, the cognizant labor relations advisor, of actual or potential labor disputes; and coordinate the removal of urgently required material from the strikebound contractor’s plant upon instruction from, and authorization of, the contracting officer.
(35) Perform traffic management services, including issuance and control of Government bills of lading and other transportation documents.
(36) Review the adequacy of the contractor’s traffic operations.
(37) Review and evaluate preservation, packaging, and packing.
(38) Ensure contractor compliance with contractual quality assurance requirements (see Part 46).
(39) Ensure contractor compliance with contractual safety requirements.
(40) Perform engineering surveillance to assess compliance with contractual terms for schedule, cost, and technical performance in the areas of design, development, and production.
(41) Evaluate for adequacy and perform surveillance of contractor engineering efforts and management systems that relate to design, development, production, engineering changes, subcontractors, tests, management of engineering resources, reliability and maintainability, data control systems, configuration management, and independent research and development.
(42) Review and evaluate for technical adequacy the contractor’s logistics support, maintenance, and modification programs.
(43) Report to the contracting office any inadequacies noted in specifications.
(44) Perform engineering analyses of contractor cost proposals.
(45) Review and analyze contractor-proposed engineering and design studies and submit comments and recommendations to the contracting office, as required.
(46) Review engineering change proposals for proper classification, and when required, for need, technical adequacy of design, producibility, and impact on quality, reliability, schedule, and cost; submit comments to the contracting office.
(47) Assist in evaluating and make recommendations for acceptance or rejection of waivers and deviations.
(48) Evaluate and monitor the contractor’s procedures for complying with procedures regarding restrictive markings on data.
(49) Monitor the contractor’s value engineering program.
(50) Review, approve or disapprove, and maintain surveillance of the contractor’s purchasing system (see Part 44).
(51) Consent to the placement of subcontracts.
(52) Review, evaluate, and approve plant or division-wide small, small disadvantaged, women-owned, veteran-owned, HUBZone, and service-disabled veteran-owned small business master subcontracting plans.
(53) Obtain the contractor’s currently approved company- or division-wide plans for small, small disadvantaged, women-owned, veteran-owned, HUBZone, and service-disabled veteran-owned small business subcontracting for its commercial products, or, if there is no currently approved plan, assist the contracting officer in evaluating the plans for those products.
(54) Assist the contracting officer, upon request, in evaluating an offeror’s proposed small, small disadvantaged women-owned, veteran-owned, HUBZone, and service-disabled veteran-owned small business subcontracting plans, including documentation of compliance with similar plans under prior contracts.
(55) By periodic surveillance, ensure the contractor’s compliance with small, small disadvantaged, women-owned, veteran-owned, HUBZone, and service-disabled veteran-owned small business subcontracting plans and any labor surplus area contractual requirements; maintain documentation of the contractor’s performance under and compliance with these plans and requirements; and provide advice and assistance to the firms involved, as appropriate.
(56) Maintain surveillance of flight operations.
(57) Assign and perform supporting contract administration.
(58) Ensure timely submission of required reports.
(59) Issue administrative changes, correcting errors or omissions in typing, contractor address, facility or activity code, remittance address, computations which do not require additional contract funds, and other such changes (see 43.101).
(60) Cause release of shipments from contractor’s plants according to the shipping instructions. When applicable, the order of assigned priority shall be followed; shipments within the same priority shall be determined by date of the instruction.
(61) Obtain contractor proposals for any contract price adjustments resulting from amended shipping instructions. Review all amended shipping instructions on a periodic, consolidated basis to ensure that adjustments are timely made. Except when the ACO has settlement authority, the ACO shall forward the proposal to the contracting officer for contract modification. The ACO shall not delay shipments pending completion and formalization of negotiations of revised shipping instructions.
(62) Negotiate and/or execute supplemental agreements, as required, making changes in packaging subcontractors or contract shipping points.
(63) Cancel unilateral purchase orders when notified of nonacceptance by the contractor. The CAO shall notify the contracting officer when the purchase order is canceled.
(64) Negotiate and execute one-time supplemental agreements providing for the extension of contract delivery schedules up to 90 days on contracts with an assigned Criticality Designator of C (see 42.1105). Notification that the contract delivery schedule is being extended shall be provided to the contracting office. Subsequent extensions on any individual contract shall be authorized only upon concurrence of the contracting office.
(65) Accomplish administrative closeout procedures (see 4.804-5).
(66) Determine that the contractor has a drug-free workplace program and drug-free awareness program (see Subpart 23.5).
(67) Support the program, product, and project offices regarding program reviews, program status, program performance and actual or anticipated program problems.
(68) Monitor the contractor’s environmental practices for adverse impact on contract performance or contract cost, and for compliance with environmental requirements specified in the contract. ACO responsibilities include—
(i) Requesting environmental technical assistance, if needed;
(ii) Monitoring contractor compliance with specifications or other contractual requirements requiring the delivery or use of environmentally preferable products, energy-efficient products, products containing recovered materials, and biobased products. This must occur as part of the quality assurance procedures set forth in Part 46; and
(iii) As required in the contract, ensuring that the contractor complies with the reporting requirements relating to recovered material content utilized in contract performance (see Subpart 23.4).
(69) Administer commercial financing provisions and monitor contractor security to ensure its continued adequacy to cover outstanding payments, when on-site review is required.
(70) Deobligate excess funds after final price determination.
(71) Ensure that the contractor has implemented the requirements of 52.203-13, Contractor Code of Business Ethics and Conduct.
(b) The CAO shall perform the following functions only when and to the extent specifically authorized by the contracting office:
(1) Negotiate or negotiate and execute supplemental agreements incorporating contractor proposals resulting from change orders issued under the Changes clause. Before completing negotiations, coordinate any delivery schedule change with the contracting office.
(2) Negotiate prices and execute priced exhibits for unpriced orders issued by the contracting officer under basic ordering agreements.
(3) Negotiate or negotiate and execute supplemental agreements changing contract delivery schedules.
(4) Negotiate or negotiate and execute supplemental agreements providing for the deobligation of unexpended dollar balances considered excess to known contract requirements.
(5) Issue amended shipping instructions and, when necessary, negotiate and execute supplemental agreements incorporating contractor proposals resulting from these instructions.
(6) Negotiate changes to interim billing prices.
(7) Negotiate and definitize adjustments to contract prices resulting from exercise of an economic price adjustment clause (see Subpart 16.2).
(8) Issue change orders and negotiate and execute resulting supplemental agreements under contracts for ship construction, conversion, and repair.
(9) Execute supplemental agreements on firm-fixed-price supply contracts to reduce required contract line item quantities and deobligate excess funds when notified by the contractor of an inconsequential delivery shortage, and it is determined that such action is in the best interests of the Government, notwithstanding the default provisions of the contract. Such action will be taken only upon the written request of the contractor and, in no event, shall the total downward contract price adjustment resulting from an inconsequential delivery shortage exceed $250.00 or 5 percent of the contract price, whichever is less.
(10) Execute supplemental agreements to permit a change in place of inspection at origin specified in firm-fixed-price supply contracts awarded to nonmanufacturers, as deemed necessary to protect the Government’s interests.
(11) Prepare evaluations of contractor performance in accordance with Subpart 42.15.
(c) Any additional contract administration functions not listed in 42.302(a) and (b), or not otherwise delegated, remain the responsibility of the contracting office.


Get advice from your council on safe walking and cycling routes to your child’s school.
For example SW1A 2AA
Find a postcode on Royal Mail's postcode finder
Last updated: 7 March 2017


 Select the organization that you want to use: {% endblocktrans %}
{% if organization_list %}{% trans "You aren't currently a member of any organizations." %}
{% endif %}


Test Cases for Capture Agents
This document describes a set of simple test cases which can be used to test new capture agents. As a vendor, you might want to use these to test new devices before their release.
They are meant for a setup where the capture agent is firmly installed in a venue, it runs 24/7 and automatically captures scheduled lectures.
| Test | Expected Result |
|---|---|
| Connection to Opencast Server | Agent shows up at Opencast's admin interface with status online |
| Manual recording on agent | Event successfully recorded and uploaded |
| Schedule recording | Event successfully recorded and uploaded |
| Schedule multiple recordings | Events successfully recorded and uploaded |
| Record 6 hours | Event successfully recorded and uploaded |
| Network loss before recording starts | Recording starts and stops without network connection |
| Network loss while recording | Event successfully recorded and uploaded |
| Power loss | The capture agent starts up again |
| Change input signal during recording | Event successfully recorded and uploaded |
| HTTPS | Devices supports HTTPS connections to Opencast |
Test Servers
You can use Opencast's official test servers like stable.opencast.org , but keep in mind that these servers are reset on a daily basis at about 2am (Europe/Berlin timezone).
The default credentials for these servers are:
- User interface
- user:
admin
- password:
opencast
- user:
- Capture agent
- user:
opencast_system_account
- password:
CHANGE_ME
- user:


Display Options
| Number of columns | |
| Dial width | |
| Default folder |
Advanced Options
Incorrect application of these settings can break the speed dial.
| Thumbnailing service |
[URL] token will be replaced by the speed dial URL |
| Number of columns | |
| Dial width | |
| Default folder |
Incorrect application of these settings can break the speed dial.
| Thumbnailing service |
[URL] token will be replaced by the speed dial URL |


--- title: deformationGradientTensor sidebar: function_reference_sidebar permalink: deformationGradientTensor.deformationGradientTensor.html folder: function_reference toc: false ---
The deformation gradient F contains the full information about the local rotation and deformation of the material. It also shows, for example, how a small line segment in the undeformed body, dX, is rotated and stretched into a line segment in the deformed body, dx, since dx = F dX. As F is volume preserving this implies that det F = 1.


<script src="RGraph.common.core.js"></script> <script src="RGraph.drawing.xaxis.js"></script> <script src="RGraph.scteter.js"></script>Put this where you want the chart to show up:
<canvas id="cvs" width="1000" height="200"> [No canvas support] </canvas>This is the code that generates the chart - it should be placed AFTER the canvas tag(s):


A blog about programming (usually scientific python), mathematics (usually game theory) and learning (usually student centred pedagogic approaches).
Iterating over many lists at the same time in Python with `zip`
2018-11-23
When programming it is often necessary to iterate over two (or more) lists. This post will describe zip
: a fantastic tool for doing this in a clear and concise way.
As a running example, let us assume we would like to check if 3 numbers $a, b, c$ form a pythagorean triplet, in other words:
$$ a ^ 2 + b ^ 2 = c ^ 2 $$For the purpose of this example let us start by randomly creating 3 lists of numbers:
import random
random.seed(0)
upper_value = 50
number_of_values = 10 ** 5
list_of_a_values = [random.randint(1, upper_value + 1) for _ in range(number_of_values)]
list_of_b_values = [random.randint(1, upper_value + 1) for _ in range(number_of_values)]
list_of_c_values = [random.randint(1, upper_value + 1) for _ in range(number_of_values)]
Here are our first 5 values of $a$:
list_of_a_values[:5]
A common approach¶
One commone approach would be to create a dummy variable that will keep track of a position that goes through all 3 lists:
pythagorian_triplets = []
for i in range(number_of_values):
if list_of_a_values[i] ** 2 + list_of_b_values[i] ** 2 == list_of_c_values[i] ** 2:
pythagorian_triplets.append(
(
list_of_a_values[i],
list_of_b_values[i],
list_of_c_values[i],
)
)
pythagorian_triplets
Zipping our lists together¶
Another approach is to use python's zip
command, this will essentially "zip" the three lists together
pythagorian_triplets = []
for item in zip(list_of_a_values, list_of_b_values, list_of_c_values):
if item[0] ** 2 + item[1] ** 2 == item[2] ** 2:
pythagorian_triplets.append(item)
pythagorian_triplets
What zip
is doing here is taking a list of inputs, in this case list_of_a_values, list_of_b_values, list_of_c_values
(it can take any number of inputs) and returning a python object that can be iterated over. Each iteration takes an element from each of the inputs.
We can use python unpacking and list comprehensions to write this in a more compact way:
pythagorian_triplets = [(a, b, c) for a, b, c in zip(list_of_a_values, list_of_b_values, list_of_c_values)
if a ** 2 + b ** 2 == c ** 2]
pythagorian_triplets
Unpacking and zipping¶
Using numpy we can in fact make this slightly more efficient as we can generate a large 3 by N array of random integers (note that numpy's random number generator does not follow the same seeded path as python's standard lib):
import numpy as np
np.random.seed(0)
random_integers = np.random.randint(1, upper_value, (3, number_of_values))
random_integers
We can now use python unpacking with the *
command to pass each row of our array directly to zip
without having to name them:
pythagorian_triplets = [(a, b, c) for a, b, c in zip(*random_integers)
if a ** 2 + b ** 2 == c ** 2]
pythagorian_triplets
zip
is one of those super handy python commands that once you've gotten the hang off you never want to be without, enumerate
is another such tool.


cpupower
Tools regarding CPU power and tuning options.
This command is available as part of the `cpupower` package, or as part of `kernel-tools` on Fedora.
More information: home page
- List CPUs:
sudo cpupower --cpu all info
- Print information about all cores:
sudo cpupower --cpu all info
- Set all CPUs to a power-saving frequency governor:
sudo cpupower --cpu all frequency-set --governor powersave
- Print CPU 0's available frequency [g]overnors:
sudo cpupower --cpu 0 frequency-info g | grep "analyzing\|governors"
- Print CPU 4's frequency from the hardware, in a human-readable format:
sudo cpupower --cpu 4 frequency-info --hwfreq --human


Implement a basic dense matrix multiplication routine.
Before starting this lab, make sure that:
You have completed "Vector Addition" MP
You have completed all week 1 lecture videos
Edit the code in the code tab to perform the following:
Instructions about where to place each part of the code is
demarcated by the //@@
comment lines.


--- layout: home title: Ryan McKenna subtitle: This where I will share my academic publications, articles, projects. ---
Support my work


Constructor
new Matrix()
Creates a Matrix.
The arguments can be:
- Nothing: The Matrix will have 0 rows and 0 columns
- One Matrix: In this case this is a copy constructor
- One Vector, bool: The matrix will represent the Vector. if the bool argument is ommited or false the vector is treated as a row vector, if the bool === true the vector is treated as a column vector
- A series of Objectswhiches can define a Vector: Creates Vectors from the Objects, and then creates a Matrix of those Vectors
- An Array of the above: Works as the above
- A JSON string of the above works the same
- arguments[0] == 'init': arguments[1] an array where arguments[1][0] is the number of rows and the arguments[1][1] is the number of columns of this matrix (every dimension's vaule is arguments[2] or 0 if omitted)
- arguments[0] an integer: arguments[0] as the number of columns then one number parameter for every element. The given numbers will be the element values from left to right then from top to bottom (the rest will be == 0)
Members
colNum
Returns the number of columns this matrix has
colNum
Extends or shrinks the matrix to possess the given number of columns
isSquareMatrix
Returns whether or not this matrix is a square matrix
rowNum
Extends or shrinks the matrix to possess the given number of rows
rowNum
Returns the number of rows this matrix has
size
Extends or shrinks the matrix to possess the given number of rows and columns
size
Returns it's size as an object
It's y property is the number of rows and the x is the number of columns this matrix has
sizeAsArr
Returns it's size as an Array
The first number is the number of columns and the second is the number of rows this matrix has
sizeAsVec
Returns it's size as a Vector
It's y property is the number of rows and the x is the number of columns this matrix has
Methods
(static) add(matrix1, matrix2)
Returns the copy of the sum of the two arguments' Matrix representations if there is such
Parameters:
| Name | Type | Description |
|---|---|---|
matrix1 |
Matrixify-able | |
matrix2 |
Matrixify-able | float |
(static) determinant(matrix)
Returns the determinant of the given parameter's matrix representation if there is such.
If the matrix is not a square matrix, it's biggest top most square part of it will be used instead.
Parameters:
| Name | Type | Description |
|---|---|---|
matrix |
Matrixify-able |
(static) div(matrix, divisional)
Returns the copy of the divided value of the first argument's Matrix representation if there is such
Parameters:
| Name | Type | Description |
|---|---|---|
matrix |
Matrixify-able | |
divisional |
float |
(static) isMatrix(matrixCandidate)
Returns if the parameter is an instance of Vector
Parameters:
| Name | Type | Description |
|---|---|---|
matrixCandidate |
* |
(static) map(matrix, func, thisArg)
Returns the copy of matrix.map(func, args)
Parameters:
| Name | Type | Description |
|---|---|---|
matrix |
Vector | |
func |
function | |
thisArg |
Array | null by default |
(static) matrixify(matrixCandidate, isColVector)
If the parameter is a(n)
- Matrix: Returns it's reference
- Vector, bool: Converts the Vector to a Matrix. Treats the Vector as a row vector by default, and a column vector if isColVector === true
- Object: Attemps to convert it to a Matrix
- else: Throws an error
Parameters:
| Name | Type | Default | Description |
|---|---|---|---|
matrixCandidate |
Matrix | Vector | Object | ||
isColVector |
bool | false |
(static) maxSize(…args)
Returns the smallest size that every given Matrix can fit in as a Vector
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
args |
Vector | Array.<Vector> |
<repeatable> |
(static) minSize(…args)
Returns the smallest size that every given Matrix has as a part as a Vector
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
args |
Vector | Array.<Vector> |
<repeatable> |
(static) mod(matrix, mod)
Returns copy of the the mod value of the first the argument's Matrix representation if there is such
Parameters:
| Name | Type | Description |
|---|---|---|
matrix |
Matrixify-able | |
mod |
int |
(static) mul(matrix1, matrix2)
Returns the copy of the product of the two arguments' Matrix representations if there is such
Parameters:
| Name | Type | Description |
|---|---|---|
matrix1 |
Matrixify-able | |
matrix2 |
Matrixify-able |
(static) negate(matrix)
Returns the copy of the argument's negated Matrix representations if there is such
Parameters:
| Name | Type | Description |
|---|---|---|
matrix |
Matrixify-able |
(static) remove(matrix, row, column, rowCount, columnCount)
Returns a copy of the given argument's matrix representation without the removed row and column
Parameters:
| Name | Type | Default | Description |
|---|---|---|---|
matrix |
Matrixify-able | ||
row |
int | ||
column |
int | ||
rowCount |
int | 1 | 1 by default |
columnCount |
int | 1 | 1 by default |
(static) removeCol(matrix, column, columnCount)
Returns a copy of the given argument's matrix representation without the removed column
Parameters:
| Name | Type | Default | Description |
|---|---|---|---|
matrix |
Matrixify-able | ||
column |
int | ||
columnCount |
int | 1 | 1 by default |
(static) removeRow(matrix, row, rowCount)
Returns a copy of the given argument's matrix representation without the removed row
Parameters:
| Name | Type | Default | Description |
|---|---|---|---|
matrix |
Matrixify-able | ||
row |
int | ||
rowCount |
int | 1 | 1 by default |
(static) squarify(matrix)
Returns a copy of the matrix where the minimum amount of elements have been removed to become a square matrix
Parameters:
| Name | Type | Description |
|---|---|---|
matrix |
Matrixify-able |
(static) squarifyUp(matrix)
Returns a copy of the matrix where the minimum amount of elements have been added to become a square matrix
Parameters:
| Name | Type | Description |
|---|---|---|
matrix |
Matrixify-able |
(static) sub(matrix1, matrix2)
Returns the copy of the difference of the two arguments' Matrix representations if there is such
Parameters:
| Name | Type | Description |
|---|---|---|
matrix1 |
Matrixify-able | |
matrix2 |
Matrixify-able | float |
(static) transpose(matrix)
Returns the copy of the transposed value of the argument's Matrix representation if there is such
Parameters:
| Name | Type | Description |
|---|---|---|
matrix |
Matrixify-able |
(static) weakMatrixify(matrixCandidate)
If the parameter is a(n)
- Matrix: Returns it's reference
- Vector, bool: Converts the Vector to a Matrix. Treats the Vector as a row vector by default, and a column vector if isColVector === true
- Object: Attemps to convert it to a Matrix
- else: Returns it's reference
Parameters:
| Name | Type | Description |
|---|---|---|
matrixCandidate |
* |
(static) weakSquarify(matrix)
If the matrix is not a square matrix, this returns a copy of the matrix where the minimum amount of elements have been removed to become a square matrix.
Otherwise this returns the copy of the matrix
Parameters:
| Name | Type | Description |
|---|---|---|
matrix |
Matrixify-able |
(static) weakSquarifyUp(matrix)
If the matrix is not a square matrix, this returns a copy of the matrix where the minimum amount of elements have been added to become a square matrix.
Otherwise this returns the copy of the matrix
Parameters:
| Name | Type | Description |
|---|---|---|
matrix |
Matrixify-able |
add(addition, num, isColVector)
Adds the given parameter to this.
If the arguments are a(n):
- Matrix: Adds the given matrix's elements to this matrix's elements one by one. Extends this matrix if it has to.
- Object: Attemps to convert it to a Matrix then proceeds as it was one.
- Vectorify-able, int, bool: Adds the given vector's coordinates to this matrix's "num"th row or column one by one (row by default, and column if the 3rd parameter === true). Extends the matrix if it has to.
- Number: The number will be added to the matrix's every element.
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
addition |
Matrix | Vector | Object | float | |
num |
int | |
isColVector |
bool |
addColVec(vector, column)
Adds the given vector's coordinates to this matrix's given column one by one.
Extends this matrix if it has to.
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
vector |
Vector | |
column |
int |
addRowVec(vector, row)
Adds the given vector's coordinates to this matrix's given row one by one.
Extends this matrix if it has to.
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
vector |
Vector | |
row |
int |
addVec(vector, num, isColVector)
Adds the given vector's coordinates to this matrix one by one.
Extends this matrix if it has to.
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
vector |
Vector | |
num |
int | Which row / col |
isColVector |
bool |
constructorForCopy(matrix)
Helper for the constructor (not for outer useage)
Constructor: Copy
Parameters:
| Name | Type | Description |
|---|---|---|
matrix |
Matrix |
constructorForEmpty()
Helper for the constructor (not for outer useage)
Constructor: Empty
constructorForInit(size, defaultValue)
Helper for the constructor (not for outer useage)
Constructor: Init
Parameters:
| Name | Type | Default | Description |
|---|---|---|---|
size |
Array | ||
defaultValue |
float | 0 |
constructorForNumbers(columns, …elementArr)
Helper for the constructor (not for outer useage)
Constructor: Numbers
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
columns |
int | ||
elementArr |
float |
<repeatable> |
constructorForObjects(…objectArr)
Helper for the constructor (not for outer useage)
Constructor: Object
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
objectArr |
Object |
<repeatable> |
determinant()
Returns the determinant of this matrix
If this matrix is not a square matrix, it's biggest top most square part of it will be used instead.
div(divisional)
Div function for every element one by one
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
divisional |
float |
equals(matrix)
Returns true if the matrix is seemingly identical in every element
Parameters:
| Name | Type | Description |
|---|---|---|
matrix |
Matrixify-able |
equalsExactly(matrix)
Returns true if the given matrix has the same size "by nature" and are seemingly identical in every element
Parameters:
| Name | Type | Description |
|---|---|---|
matrix |
Matrixify-able |
expand(rows, columns)
Adds the minimum number of rows and coulumns to the matrix so there wouldn't be less then the given amount
Parameters:
| Name | Type | Description |
|---|---|---|
rows |
* | |
columns |
* |
expandCols(columns)
Adds the minimum number of coulumns to the matrix so there wouldn't be less then the given amount
Parameters:
| Name | Type | Description |
|---|---|---|
columns |
* |
expandRows(rows)
Adds the minimum number of rows to the matrix so there wouldn't be less then the given amount
Parameters:
| Name | Type | Description |
|---|---|---|
rows |
* |
getColVector(column)
Returns a copy of the desired column as a Vector
Parameters:
| Name | Type | Description |
|---|---|---|
column |
int |
getColVectorAsArray(column)
Returns a copy of the desired column as an Array
Parameters:
| Name | Type | Description |
|---|---|---|
column |
int |
getElement(row, column)
Returns a given element (counts from 0,0)
If the parameters are greater then this matrix's sizes or less then 0 then this returns 0
Parameters:
| Name | Type | Description |
|---|---|---|
row |
int | |
column |
int |
getRowVector(row)
Returns a copy of the desired row as a Vector
Parameters:
| Name | Type | Description |
|---|---|---|
row |
int |
getRowVectorAsArray(row)
Returns a copy of the desired row as an Array
Parameters:
| Name | Type | Description |
|---|---|---|
row |
int |
getSubMatrix(start, end)
Returns the copy of this matrix's given submatrix (follows the rules of the Array.slice function)
If the parameters are ommited, the copy of the whole vector will be returned
Parameters:
| Name | Type | Description |
|---|---|---|
start |
Vectorify-able | |
end |
Vectorify-able |
insert(row, column, value, rowCount, columnCount)
Inserts a new row and column filled with the given value
Returns itself so the function is chainable
Parameters:
| Name | Type | Default | Description |
|---|---|---|---|
row |
int | ||
column |
int | ||
value |
float | 0 | 0 by default |
rowCount |
int | 1 | 1 by default |
columnCount |
int | 1 | 1 by default |
insertCol(column, value)
Inserts a new column filled with the given value (0 by default)
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
column |
int | |
value |
Vectorify-able | float |
insertRow(row, value)
Inserts a new row filled with the given value (0 by default)
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
row |
int | |
value |
Vectorify-able | float |
map(func, thisArg)
Applyes the "func" function to every element one by one.
The "func" function's arguments are:
- current element
- the row index of the element
- the col index of the element
The "func" function's "this" will be the thisArg argument
If the "func" function has no return value / would return undefined, the element will remain unchanged
Parameters:
| Name | Type | Default | Description |
|---|---|---|---|
func |
function | ||
thisArg |
Array | null | null by default |
mod(mod)
Modulo function for every element one by one
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
mod |
int |
mul(multiplier, fromLeft)
Multiplies this with the given parameter.
If the argument is a(n):
- Matrix: Returns the cross product of this and the k vectors in order. In case of k vector, the result will be k+2 dimensional and the calculation uses k+2 dimensions from all of them. The cross product is NOT commutative, thus the order of the vectors count.
- k Vector|Object: Attemps to convert the Objects to Vectors then proceeds as they were one.
- Number: Every dimension will be multiplied with the given number.
Returns itself so the function is chainable
Parameters:
| Name | Type | Default | Description |
|---|---|---|---|
multiplier |
Matrixify-able | float | ||
fromLeft |
bool | false |
negate()
Negates its elements' values.
remove(row, column, rowCount, columnCount)
Removes the given rows and columns
Returns itself so the function is chainable
Parameters:
| Name | Type | Default | Description |
|---|---|---|---|
row |
int | ||
column |
int | ||
rowCount |
int | 1 | 1 by default |
columnCount |
int | 1 | 1 by default |
removeCol(column, columnCount)
Removes the given columns
Returns itself so the function is chainable
Parameters:
| Name | Type | Default | Description |
|---|---|---|---|
column |
int | ||
columnCount |
int | 1 | 1 by default |
removeRow(row, rowCount)
Removes the given rows
Returns itself so the function is chainable
Parameters:
| Name | Type | Default | Description |
|---|---|---|---|
row |
int | ||
rowCount |
int | 1 | 1 by default |
setColNum(colNum)
Extends or shrinks the matrix to possess the given number of columns
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
colNum |
int |
setColVector(colNum, colVec)
Changes the given column to the copy of the given vector
- If the given vector is too short it will be filled with 0s
- If the given vector is too long, the matrix will be expanded to that size
Parameters:
| Name | Type | Description |
|---|---|---|
colNum |
int | |
colVec |
Vectorify-able |
setElement(row, column, value)
Sets the given element to the given value
Extends this matrix if it has to.
Parameters:
| Name | Type | Description |
|---|---|---|
row |
int | |
column |
int | |
value |
float |
setRowNum(rowNum)
Extends or shrinks the matrix to possess the given number of rows
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
rowNum |
int |
setRowVector(rowNum, rowVec)
Changes the given row to the copy of the given vector
- If the given vector is too short it will be filled with 0s
- If the given vector is too long, the matrix will be expanded to that size
Parameters:
| Name | Type | Description |
|---|---|---|
rowNum |
int | |
rowVec |
Vectorify-able |
setSize(size)
Extends or shrinks the matrix to possess the given number of rows and columns
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
size |
Vectorify-able |
shrink(rows, columns)
Removes the minimum number of rows and coulumns from the matrix so there wouldn't be more then the given amount
Parameters:
| Name | Type | Description |
|---|---|---|
rows |
* | |
columns |
* |
shrinkCols(columns)
Removes the minimum number of coulumns from the matrix so there wouldn't be more then the given amount
Parameters:
| Name | Type | Description |
|---|---|---|
columns |
* |
shrinkRows(rows)
Removes the minimum number of rows from the matrix so there wouldn't be more then the given amount
Parameters:
| Name | Type | Description |
|---|---|---|
rows |
* |
spliceCols(start, removeCount, …newCols)
Follows the rules of Array.splice, except it returns the removed elements as a marix
Returns the removed elements as a matrix
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
start |
int | ||
removeCount |
int | ||
newCols |
Vectory-able | float |
<repeatable> |
spliceRows(start, removeCount, …newRows)
Follows the rules of Array.splice, except it returns the removed elements as a marix
Returns the removed elements as a matrix
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
start |
int | ||
removeCount |
int | ||
newRows |
Vectory-able | float |
<repeatable> |
squarify()
Removes the minimum amount of elements to become a square matrix
Returns itself so the function is chainable
squarifyUp()
Adds the minimum amount of elements to become a square matrix
Returns itself so the function is chainable
sub(substraction, num, isColVector)
Subs the given parameter from this.
If the arguments are a(n):
- Matrix: Subs the given matrix's elements from this matrix's elements one by one. Extends this matrix if it has to.
- Object: Attemps to convert it to a Matrix then proceeds as it was one.
- Vectorify-able, int, bool: Subs the given vector's coordinates from this matrix's "num"th row or column one by one (row by default, and column if the 3rd parameter === true). Extends the matrix if it has to.
- Number: The number will be subbed from the matrix's every element.
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
substraction |
Matrix | Vector | Object | float | |
num |
int | |
isColVector |
bool |
subColVec(vector, column)
Adds the given vector's coordinates to this matrix's given column one by one.
Extends this matrix if it has to.
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
vector |
Vector | |
column |
int |
subMat(matrix)
Subs the given matrix's elements from this matrix's elements one by one.
Extends this matrix if it has to.
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
matrix |
Matrix |
subMatrix(start, end)
Changes this to the copy of this matrix's given submatrix (follows the rules of the Array.slice function)
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
start |
Vectorify-able | |
end |
Vectorify-able |
subNum(number)
The number will be subbed from the matrix's every element.
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
number |
float |
subRowVec(vector, row)
Adds the given vector's coordinates to this matrix's given row one by one.
Extends this matrix if it has to.
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
vector |
Vector | |
row |
int |
subVec(vector, num, isColVector)
Subs the given vector's coordinates from this matrix's "num"th row or column one by one (row by default, and column if the 3rd parameter === true).
Extends the matrix if it has to.
Returns itself so the function is chainable
Parameters:
| Name | Type | Description |
|---|---|---|
vector |
Vector | |
num |
int | |
isColVector |
bool |
toArray(start, end)
Returns the array representation of this matrix's given submatrix (follows the rules of the Array.slice function)
If the parameters are ommited, the whole vector will be converted
Parameters:
| Name | Type | Description |
|---|---|---|
start |
Vectorify-able | |
end |
Vectorify-able |
toString()
Returns the string representation of this matrix
transpose()
Transposes the matrix
Returns itself so the function is chainable


The default message notification threshold.
var DefaultMessageNotification: number
The default notification level for this guild. A value that is either 0
or 1
.
| Level | Integer | Description |
|---|---|---|
ALL_MESSAGES |
0 |
Be notified about all messages |
ONLY_MENTIONS |
1 |
Only be notified about messages where the user is specifically mentioned |
| Creating a Guild Instance |
|


Result fields are interpreted as follows:
- featureTestVersion: the version number of this test code itself.
- runDate: local browser time of when the test was run.
- appVersion: passes navigator.appVersion.
- platform: passes navigator.platform.
- userAgent: passes navigator.userAgent.
- From the user agent string, several heuristic guesses are made to deduce human-readable information about the browser. This information is carried in the userAgentExplained object:
- userAgentExplained.platform: Makes a guess of the user's specific hardware platform, e.g. 'PC', 'Mac', 'iPhone', 'iPad', 'Nexus', 'Samsung' and so on.
- userAgentExplained.bitness: Specifies the browser and operating system CPU bit width. This is either 32, 64, or '32-on-64' if running a 32bit browser on a 64bit OS.
- userAgentExplained.arch: Tries to determine the CPU architecture of the current system.
- userAgentExplained.formFactor: One of 'Desktop', 'Mobile', 'Tablet' or 'TV'.
- userAgentExplained.os: Name of the user's operating system (e.g. 'Windows', 'Mac OS', 'Linux', 'Android', 'iOS')
- userAgentExplained.osVersion: Version number or name of the OS.
- userAgentExplained.browserVendor: Name of the company who authored the browser: 'Mozilla', 'Google', 'Microsoft', 'Apple'. Note that this could also be 'Opera' or 'Samsung' for companies who are distributing variants of Chrome. See the userAgentExplained.productComponents field if there is a need to distinguish Chromium-based browsers specifically.
- userAgentExplained.browserProduct: Marketing name for the browser: 'Firefox', 'Edge', 'Internet Explorer', 'Safari', 'Chrome', ...
- userAgentExplained.productComponents: A tokenized array of product name, version pairs which determine the compatibility of the browser.
- vendor: passes navigator.vendor.
- vendorSub: passes navigator.vendorSub.
- product: passes navigator.product.
- productSub: passes navigator.productSub.
- language: passes navigator.language.
- appCodeName: passes navigator.appCodeName.
- appName: passes navigator.appName.
- maxTouchPoints: passes navigator.maxTouchPoints.
- pointerEnabled: passes navigator.pointerEnabled.
- cpuClass: passes navigator.cpuClass.
- contiguousSystemMemory: The maximum amount of memory that JavaScript code is able to allocate in one contiguous block, in bytes. The maximum contiguous allocation size is 2GB.
- displayRefreshRate: measures the rate at which the requestAnimationFrame() callbacks ticks forward, i.e. the vsync rate of the display.
- windowDevicePixelRatio: passes window.devicePixelRatio.
- screenWidth: passes screen.width. This is the pixel width of the display in logical CSS pixel units.
- screenHeight: passes screen.height. This is the pixel height of the display in logical CSS pixel units.
- physicalScreenWidth: computes the actual display pixel width in hardware pixels.
- physicalScreenHeight: computes the actual display pixel height in hardware pixels.
- hardwareConcurrency: passes navigator.hardwareConcurrency. If this is not supported, '0' is returned here.
- singleCoreMips: measures the single core clock speed of the processor, in fictional performance units.
- webGLSupport: Enumerates the support status of WebGL 1 and WebGL 2 and software vs hardware acceleration support. If some of these are not supported, this object specifies the error reasons.
- supportedApis: lists the various Web APIs that are supported by the browser.
- unsupportedApis: lists all the remaining Web APIs that were tested for, but support is not present.
- canonicalizesNansInsideAsmModule: tests whether the browser is able to carry payload data in floating point NaN values inside an asm.js module.
- canonicalizesNansOutsideAsmModule: tests whether the browser is able to carry payload data in floating point NaN values in regular handwritten JavaScript code.
- canonicalF32NanValueInsideAsmModule: specifies the bit pattern of the canonical single-precision floating point NaN value inside an asm.js module.
- canonicalF32NanValueOutsideAsmModule: specifies the bit pattern of the canonical single-precision floating point NaN value in regular handwritten JavaScript code.
- canonicalF64NanValueInsideAsmModule: specifies the bit pattern of the canonical double-precision floating point NaN value inside an asm.js module.
- canonicalF64NanValueOutsideAsmModule: specifies the bit pattern of the canonical double-precision floating point NaN value in regular handwritten JavaScript code.
- typedArrayEndianness: Either 'little endian' or 'big endian', depending on the endianness of the target hardware. Most likely (x86, Android & iOS ARM) this is 'little endian'.
- GL_VENDOR: passes WebGL GL_VENDOR string from the highest supported version of the WebGL context.
- GL_RENDERER: passes WebGL GL_RENDERER string from the highest supported version of the WebGL context.
- GL_VERSION: passes WebGL GL_VERSION string from the highest supported version of the WebGL context.
- GL_SHADING_LANGUAGE_VERSION: passes WebGL GL_SHADING_LANGUAGE_VERSION string from the highest supported version of the WebGL context.
- GL_UNMASKED_VENDOR_WEBGL: passes WebGL GL_UNMASKED_VENDOR_WEBGL string from the highest supported version of the WebGL context. This requires the WebGL extension WEBGL_debug_renderer_info to be supported.
- GL_UNMASKED_RENDERER_WEBGL: passes WebGL GL_UNMASKED_RENDERER_WEBGL string from the highest supported version of the WebGL context. This requires the WebGL extension WEBGL_debug_renderer_info to be supported.
- supportedWebGLExtensions: lists the different WebGL extensions that are available in the highest supported version of the WebGL context.
Usage
To incorporate the feature tests to your own code, copy over featuretest.js from this repository and call the browserFeatureTest function as shown in the code snippet below. See the page source of this .html file for a complete example.
<html>
<body>
<script src="featuretest.js"></script>
<script>
function onFeatureTestComplete(results) {
// Example: how to test for the presence of a certain API
if (results.supportedApis.indexOf('IndexedDB') != -1) console.log('IndexedDB is supported!');
// Example: how to find if WebGL comes without a performance caveat.
if (results.webGLSupport.webgl1.supported && !results.webGLSupport.webgl1.performanceCaveat) console.log('Hardware-accelerated WebGL is supported!');
// Example: dump all results as a whitespace-readable JSON string.
console.log(JSON.stringify(results, null, 2));
}
browserFeatureTest(onFeatureTestComplete);
</script>
</body>
</html>


Preparation time
less than 30 mins
Cooking time
30 mins to 1 hour
Serves
Serves 6-8
Dietary
This super easy chocolate marble cake recipe has a mocha twist, adding a rich flavour. A perfect teatime treat.
Pre-heat the oven to 180C/350F/Gas 4.
Grease and line a small loaf tin or 20cm/8in round tin.
Cream the butter and sugar with an electric whisk in a large mixing bowl until very pale and fluffy.
Add the beaten egg, a little at a time, whisking well after each addition. Then whisk in the vanilla extract.
Sift the flour and salt into a large bowl, then fold it gently into the butter and egg mixture.
Divide the cake batter into two equal portions (about 350g each).
Add the milk to one portion of the mixture, stirring in gently until well combined.
Mix the cocoa powder and the coffee together in a mug to form a smooth paste. Stir this paste into the other portion of the cake batter until thoroughly combined.
Spoon large blobs of each cake mixture into the prepared tin, alternating the flavours to give a marble effect. Bake for 50-60 minutes until the cake is springy to the touch and a wooden skewer inserted into the centre of the cake comes out clean.
Allow the cake to cool in the tin for ten minutes, then turn out onto a wire rack and cool completely before slicing.


You may opt-out of receiving communications at any time. For further information please see our Privacy Policy.


Draco 3D Data Compression
Draco is an open-source library for compressing and decompressing 3D geometric meshes and point clouds. It is intended to improve the storage and transmission of 3D graphics.
| Website | GitHub |
Contents
This folder contains three utilities:
draco_decoder.js
— Emscripten-compiled decoder, compatible with any modern browser.draco_decoder.wasm
— WebAssembly decoder, compatible with newer browsers and devices.draco_wasm_wrapper.js
— JavaScript wrapper for the WASM decoder.
Each file is provided in two variations:
- Default: Latest stable builds, tracking the project’s master branch.
- glTF: Builds targeted by the glTF mesh compression extension, tracking the corresponding Draco branch.
Either variation may be used with THREE.DRACOLoader
:
var dracoLoader = new THREE.DRACOLoader();
dracoLoader.setDecoderPath('path/to/decoders/');
dracoLoader.setDecoderConfig({type: 'js'}); // (Optional) Override detection of WASM support.
Further documentation on GitHub.


Hover over the elements to see the tooltip
Notice that JQuery code is used here - it is a must for tooltip


#include <GrSkin.h>
Public Member Functions | |
| GrSkin (UReader &reader) | |
| class header. | |
| GrSkin (const tstring &name, URef< GrMesh > bindMesh, const SVec3 *vertexWeights, const unsigned int *vertexBoneIds, const tstring *boneNames, const MMat4x4 *invBindMatrices, unsigned int boneCount) | |
| ~GrSkin () | |
| const tstring & | GetName () const |
| GrSkin * | Clone (const tstring &name) |
| clones the skin in it's entirety. | |
| GrSkin * | CloneRange (const tstring &name, URef< GrMesh > bindMesh, unsigned int vertexStart, unsigned int vertexCount) |
| unsigned int | GetBoneCount () const |
| bone id/names. | |
| unsigned int | GetBoneId (const char *name) const |
| const tstring & | GetBoneName (unsigned int id) const |
| const MMat4x4 & | GetInvBindMatrix (unsigned int id) const |
| URef< GrMesh > | GetBindMesh () const |
| const SVec3 * | GetVertexWeights () const |
| const unsigned int * | GetVertexBoneIds () const |
| void | ReplaceVertexSkinData (SVec3 *newWeights, unsigned int *newBoneIds) |
| void | RemapVertexSkinData (unsigned short *remapping, unsigned int newCount, unsigned int prevCount) |
| remaps vertex skinning data using the remapping passed in. | |
| void | Save (UWriter &writer) const |
| saving and loading. | |
| void | Load (UReader &reader) |
Definition at line 26 of file GrSkin.h.
| GrSkin::GrSkin | ( | UReader & | reader | ) |
class header.
File: GrSkin.cpp Author: Kevin Bray Created: 06-21-06 Copyright © 2004 Bootstrap Studios. All rights reserved. project includes. class GrSkin ctor & dtor
Definition at line 29 of file GrSkin.cpp.
| GrSkin::GrSkin | ( | const tstring & | name, | |
| URef< GrMesh > | bindMesh, | |||
| const SVec3 * | vertexWeights, | |||
| const unsigned int * | vertexBoneIds, | |||
| const tstring * | boneNames, | |||
| const MMat4x4 * | invBindMatrices, | |||
| unsigned int | boneCount | |||
| ) |
the mesh passed in must not contain skinning data.
copy bone names and inverse bind matrices.
Definition at line 42 of file GrSkin.cpp.
| GrSkin::~GrSkin | ( | ) |
Definition at line 66 of file GrSkin.cpp.
clones the skin in it's entirety.
public methods
return a new skin.
Definition at line 81 of file GrSkin.cpp.
| GrSkin * GrSkin::CloneRange | ( | const tstring & | name, | |
| URef< GrMesh > | bindMesh, | |||
| unsigned int | vertexStart, | |||
| unsigned int | vertexCount | |||
| ) |
clones a range of the skin. This should be used when a range of a mesh is cloned.
ensure that the range passed in is valid.
there should be one skin element for every vertex in the mesh passed in.
return a new skin.
Definition at line 89 of file GrSkin.cpp.
Definition at line 137 of file GrSkin.cpp.
| unsigned int GrSkin::GetBoneCount | ( | ) | const [inline] |
| unsigned int GrSkin::GetBoneId | ( | const char * | name | ) | const |
| const tstring & GrSkin::GetBoneName | ( | unsigned int | id | ) | const |
Definition at line 121 of file GrSkin.cpp.
| const MMat4x4 & GrSkin::GetInvBindMatrix | ( | unsigned int | id | ) | const |
Definition at line 129 of file GrSkin.cpp.
| const unsigned int* GrSkin::GetVertexBoneIds | ( | ) | const [inline] |
| void GrSkin::Load | ( | UReader & | reader | ) |
cleanup any existing data.
read in the scrubber.
read in the name.
read in the bone data.
read in the bind mesh.
read in the vertex data.
Definition at line 206 of file GrSkin.cpp.
| void GrSkin::RemapVertexSkinData | ( | unsigned short * | remapping, | |
| unsigned int | newCount, | |||
| unsigned int | prevCount | |||
| ) |
remaps vertex skinning data using the remapping passed in.
remap the vertices.
Definition at line 154 of file GrSkin.cpp.
| void GrSkin::ReplaceVertexSkinData | ( | SVec3 * | newWeights, | |
| unsigned int * | newBoneIds | |||
| ) |
replaces the vertex skinning data. There must be one entry for every vertex in the mesh we're skinning.
Definition at line 144 of file GrSkin.cpp.
| void GrSkin::Save | ( | UWriter & | writer | ) | const |
saving and loading.
write out the scrubber.
write out the name.
write out the bone data.
save out the bind mesh.
write out the vertex data.
Definition at line 174 of file GrSkin.cpp.