Introduction on Developing Activity Implementor
The following steps are needed to define an activity implementor:
- Create an implementor Java class
- Using Designer, add the implementor to the tool panel
Create Implementor Class
The main requirement for an activity implementor class that extends
com.centurylink.mdw.workflow.activity.DefaultActivityImpl
,
or one of its subclasses, built-in or user defined. It is more common to extend
a built-in implementor class, and for adapter, task, event wait, timer wait,
synchronization activities, it is almost impossible not to start from the built-in
activities. The rest of this document covers how to implement activity
implementor from the base activity and common tasks for new implementors,
please refer to corresponding documentation when extending from a built-in activity
implementor.
There is really only one method that must be implemented by an activity
implementor:
- public Object execute(ActivityRuntimeContext runtimeContext) throws ActivityException
- The code logic to execute this activity. The default implementation does
nothing.
Additionally, you can implement the following trace annotation
- @Tracked(LogLevel.TRACE)
- You can apply this annotation to your implementor class to automatically track timings for activity lifecycle stages.
With the annotation applied, timings will be logged as follows if logging is turned on at the specified level for your implementation class.
[(t)20100105.13:40:05.232 p12370.63065 a12416.14985] ScriptExecuterActivity Get Activity Impl Instance: 0.02 ms
[(t)20100105.13:40:05.232 p12370.63065 a12416.14985] ScriptExecuterActivity Prepare Activity: 0.0040 ms
[(t)20100105.13:40:07.045 p12370.63065 a12416.14985] ScriptExecuterActivity Execute Activity: 1789.761 ms
[(t)20100105.13:40:07.123 p12370.63065 a12416.14985] ScriptExecuterActivity Finish Activity: 77.64 ms
If the implementor needs a constructor, it must have one taking no argument,
and it should always invoke the base constructor first.
In a later section, we summarize all methods that are defined in the base
class and can be used in your implementor. You should only use these methods,
and Eclipse IDE makes it easy to find out what methods are available.
Additional notes:
- Do not reference to variables by their names directly, use attributes to get their names instead.
In this way, your implementor can easily be reused in a different place, as
variable names can be configured at design time.
- Use getAttributeValue, so that attribute value
can resolve binding expressions with dynamic runtime values in addition to static text.
- If you extend some subclasses, you may need to override some of the specific methods used by base implementation of execute(), instead. For activities implementing SuspendibleActivity,
you will need to implement resume(), or override it from an existing implementor implementing the activity interface.
- Use setReturnCode() to set return code (default null). You can also set it to
ABORT:
,
CORRECT:
, DELAY:
, ABORT:mycode
, etc.
Do not set it to ERROR:
throw exception instead.
Attribute Descriptor
The Attribute Definition Tab for an activity implementor
in the designer needs to be customized to allow defining attributes
specific to the implementor. The customization is achieved through an attribute
descriptor, which is
an XML string stored as an attribute of the implementor.
As an example, the descriptor for ScriptEvaluator
activity implementor looks like:
<PAGELET>
<RULE NAME='Expression'/>
<HYPERLINK URL='../doc/index.html'>
Click here for script language document</HYPERLINK>
</PAGELET>
The XML descriptors follow a simple syntax:
- The root element is always
PAGELET
- Each first level child element defines a widget in the dialog,
most typically representing an attribute required by the implementor.
- Each first level child element has a set of attributes
for common things like the size and location of the widget
The following table lists all supported XML attributes of widgets.
| XML Attribute | Description |
| NAME | Name of the activity attribute. This is required
if the widget describes an activity attribute. |
| LABEL | Label shown on the dialog. If this is missing,
then NAME is used as the label |
| LX | X coordinate of the label. If this is not present,
the location will be automatically computed. |
| LY | Y coordinate of the label. If this is not present,
the location will be automatically computed. |
| LW | Width of the label. The default
is 160 (pixels) if this is not present |
| VX | X coordinate of the value area. If this is not present,
the location will be automatically computed. |
| VY | Y coordinate of the value area. If this is not present,
the location will be automatically computed. |
| VW | Width of the value area. If this is not present,
the width of the input area takes a default value specific
to each widget type. |
| VH | Height of the value area. If this is not present,
the height of the input area takes a default value specific
to each widget type. |
In the following we list all supported widgets.
- TEXT
- A general text input field. There is no nested element. An
additional attribute SIZE is used to specify the maximum
number of characters allowed in the text input field
- RULE
- A text input area for scripting languages. There is no nested element.
- LIST
- This widget allows to set attribute is a list of values, separated
by "#". The attribute DELIMITER can be used to change
the delimiter.
- SELECT
- This displays a group of radio buttons
for the user to select from one value
out of a list. The list of candidate values are specified
by child elements OPTION, one for each option.
- NOTE
- This simply generates some static text, typically for
instructions. The actual text to display is included
as the contents of the tag.
- HYPERLINK
- This generates a hyper link to a URL. The URL is specified
in the attribute "URL" and the content of the tag
will be displayed as a hyper link.
- MAPPING
- This is used to specify parameter mappings for process
invocation activities. It displays a table of formal parameters
needed by the subprocess and allows user to specify actual
parameters. No nested elements and no additional attributes
are supported by this widget.
- TABLE
- to be completed
Configure the Implementor in Designer
Your implementors must be configured in the designer to be used.
The following information needs to be provided during configuration.
- Activity Implementor Class. This is the class name of your implementor.
When the designer is running in on-line mode (through server), it will validate the
accessibility of the class in the server during save, so you need
to ensure the class is deployed prior to configuring the implementor.
The designer does not validate the class when it is not running in server mode.
- Activity Implementor Label. This is the label displayed
besides the icon in the implementor tool pane. See getLabel() method above
for additional information.
- Activity Type. This is a drop down list of base activity implementor class names.
This information is used by the designer to provide activity type specific
features and there is no runtime implication. The following describes
the function of each type.
- Activity. This is the basic type and there is no special functionality
provided by the designer.
- EventWaitActivity. The run time information will display external messages.
- StartActivity.
- FinishActivity.
- SynchronizationActivity. Allows to configure synchronization in designer
- InvokeProcessActivity. Allows to configure parameter passing,
and subprocess names, etc.
- TaskActivity. A manual task activity.
- ScriptActivity. This allows the designer running inside Eclipse
to pop up editor panel.
- Icon name. See description for getIconName() method above for additional information.
A drop down list with all available icon names is shown for selection.
- Attribute descriptor. This has been described above.
In MDW Designer, you only need to provide the implementor class name,
and the rest of the information can be automatically loaded by pressing the button
"Load from Class" while the server is running and the class is already accessible.
API For Implementing Implementor
The base class DefaultActivityImpl
contains methods (API) for
assisting your implementations. Please refer to its java doc (following
above hyperlink, or through Eclipse IDE) for detailed description of the methods.
Implementing Adapter Activity Implementers
Although the framework is packaged with quite a few
customizable adapter activities, it cannot be possible to cover all
needs and hence you will likely need to define an adapter activity
yourself. There are two primary ways to do this.
The first is to extend a built-in adapter. Refer to the documentation
of that adapter for how to do that.
The second is to extend the base adapter activity class,
AdapterActivityBase
, which is an abstract class.
Follow this link for the detailed documentation for the usage of this class.


This contains methods for setting up an
[link:https://developer.mozilla.org/en-US/docs/Web/API/AudioContext AudioContext].
Used internally by the [page:AudioListener AudioListener] and
[page:AudioLoader AudioLoader] classes.
This uses the
[link:https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API Web Audio API].
Return the value of the variable `context` in the outer scope, if defined, otherwise set it to a new [link:https://developer.mozilla.org/en-US/docs/Web/API/AudioContext AudioContext].
Set the variable `context` in the outer scope to `value`.
[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]


Ravelin.encrypt
Name on Card:
Card Number:
Month:
January
February
March
April
May
June
July
August
September
October
November
December
Year:
Encrypt
Output
Output Error


Jonathan Doe Webdesign, Inspiration 19 Comments
We have a number of different teams within our agency that specialise in different areas of business so you can be sure that you won't receive a generic service and although we can't boast years and years of service we can ensure you that is a good thing in this industry. Our teams are up to date with the latest technologies.
Sub page
Before you choose us to take on your project you will probably want to know a bit more about us, so meet the team:
Ross has over 10 years experience in the industry. He is our Creative Director, digital designer, web designer and front-end developer. He is also pretty good with a sketchbook. Before starting the company Ross worked as a designer and studio manager for a design house who boasted a number of big name clients. Ross has brought his vast experience from this role to the work he does now.
Monica is Ross' sister, our Art Director and specialises in graphic and print design. She has also worked with some big names and her designs have won her a number of industry awards.
Sub page
Rachel and Chandler are our Junior Designers. Rachel is a web designer with knowledge of HTML and CSS and supports Ross on projects. Chandler has just finished his Graphic Design degree and enjoys continuing to learn from Monica and building his experience.
Joey and Phoebe focus on bringing new business to the company. They have won a number of big clients recently and both also have qualifications in project management to ensure that the projects run smoothly from start to finish.
Comments
Whether you need to create a brand from scratch, including marketing materials and a beautiful and functional website or whether you are looking for a design.
Joey and Phoebe focus on bringing new business to the company. They have won a number of big clients recently.
Our teams are up to date with the latest technologies, media trends and are keen to prove themselves in this industry.
Our teams are up to date with the latest technologies, media trends and are keen to prove themselves in this industry.
Post your comment
Fill out all required fields to send a message. You have to login to your wordpress account to post any comment. Please don't spam, thank you!


General Elements
-
Sales $127,171
-
Traffic 45%
-
Orders 2447
Raw denim you probably haven't heard of them jean shorts Austin.
Food truck fixie locavore, accusamus mcsweeney's marfa nulla single-origin coffee squid.
Etsy mixtape wayfarers, ethical wes anderson tofu before they sold out mcsweeney's organic lomo retro fanny pack lo-fi farm-to-table readymade.
 Fanny pack portland seitan DIY, art party locavore wolf cliche high life echo park Austin.
Raw denim you probably haven't heard of them jean shorts Austin.
Food truck fixie locavore, accusamus mcsweeney's marfa nulla single-origin coffee squid.
Etsy mixtape wayfarers, ethical wes anderson tofu before they sold out mcsweeney's organic lomo retro fanny pack lo-fi farm-to-table readymade.
Raw denim you probably haven't heard of them jean shorts Austin.
Raw denim you probably haven't heard of them jean shorts Austin.
Raw denim you probably haven't heard of them jean shorts Austin.
Food truck fixie locavore, accusamus mcsweeney's marfa nulla single-origin coffee squid.
Raw denim you probably haven't heard of them jean shorts Austin.
Etsy mixtape wayfarers, ethical wes anderson tofu before they sold out mcsweeney's organic lomo retro fanny pack lo-fi farm-to-table readymade.
Raw denim you probably haven't heard of them jean shorts Austin.
Raw denim you probably haven't heard of them jean shorts Austin.
Food truck fixie locavore, accusamus mcsweeney's marfa nulla single-origin coffee squid.
Etsy mixtape wayfarers, ethical wes anderson tofu before they sold out mcsweeney's organic lomo retro fanny pack lo-fi farm-to-table readymade.
Accordion
Progress Bar
Alerts
Well done! You successfully read this important alert message.
Gritter Notifications
Click to see
Bootstrap Modals (Bootbox.js)


When you have two-factor authentication enabled, Basic Authentication for most endpoints in the REST API v3 requires that you use a personal access token or OAuth token instead of your username and password.
You can generate a new personal access token or use the "Create a new authorization" endpoint in the OAuth Authorizations API to generate a new OAuth token. For more information, see "Creating a personal access token for the command line" in the GitHub Help documentation. Then you would use these tokens to authenticate using OAuth token with the GitHub API. The only time you need to authenticate with your username and password is when you create your OAuth token or use the OAuth Authorizations API.
When you make calls to the OAuth Authorizations API, Basic Authentication
requires that you use a one-time password (OTP) and your username and password
instead of tokens. When you attempt to authenticate with the OAuth
Authorizations API, the server will respond with a
401 Unauthorized
and one of these headers to let you know that
you need a two-factor authentication code:
X-GitHub-OTP: required; SMS
or
X-GitHub-OTP: required; app
.
This header tells you how your account receives its two-factor authentication codes. Depending how you set up your account, you will either receive your OTP codes via SMS or you will use an application like Google Authenticator or 1Password. For more information, see "Configuring two-factor authentication."


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object com.threed.jpct.Mesh
In a Mesh, jPCT stores the actual vertex and triangle information for an object. Mesh can't be instantiated directly. Meshes are shareable between objects. This means that more than one object may use the same instance of Mesh. This saves memory and is more cache-friendly. Meshes are also used for implementing keyframe animation.
Object3D
,
Object3D.getMesh()
,
Object3D.cloneObject()
,
Animation
,
Serialized Form| Field Summary | |
static boolean |
COMPRESS
The mesh will be compressed |
static boolean |
DONT_COMPRESS
The mesh won't be compressed |
static int |
SERIALIZE_ALL
normal serialization (default) |
static int |
SERIALIZE_LOW_PRECISION
float data will be saved as 16 bit precision. on the average ~0.3 percent of precision will be lost |
static int |
SERIALIZE_VERTICES_ONLY
Normals will not be serialized and will have to be recalculated during deserialization. |
| Method Summary | |
void |
addVertexAttributes(VertexAttributes attrs)
Adds some vertex attributes to this mesh. |
void |
applyVertexController()
Executes the apply() method of the assigned VertexController and updates the mesh's vertex data with the new values generated by the controller. |
Mesh |
cloneMesh(boolean compressed)
Returns a copy of this mesh. |
void |
compress()
Compresses the mesh by removing unused information from it. |
float[] |
getBoundingBox()
Returns the bounding box in object space of this mesh in a float array. |
int |
getTriangleCount()
The number of triangles for this mesh. |
int |
getUniqueVertexCount()
Returns the number of unique vertices. |
VertexAttributes[] |
getVertexAttributes()
Returns an array with all the currently assigned vertex attributes. |
int |
getVertexCount()
Returns the number of vertices this mesh consists of |
boolean |
isLocked()
Returns if this mesh has been locked or not! |
void |
removeVertexController()
Removes the VertexController from this mesh. |
void |
setLocked(boolean locked)
Locks an object. |
void |
setSerializeMethod(int method)
Sets the serialization method. |
boolean |
setVertexController(IVertexController controller,
boolean modify)
Sets the VertexController for this Mesh. |
void |
strip()
Removes triangle information from this mesh. |
| Methods inherited from class java.lang.Object |
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
public static final boolean COMPRESS
public static final boolean DONT_COMPRESS
public static final int SERIALIZE_ALL
public static final int SERIALIZE_VERTICES_ONLY
public static final int SERIALIZE_LOW_PRECISION
| Method Detail |
public boolean setVertexController(IVertexController controller, boolean modify)
controller
- the controllermodify
- the mode, i.e. if the modifications are cumulative or not
IVertexController.ALTER_SOURCE_MESH
,
IVertexController.PRESERVE_SOURCE_MESH
,
IVertexController
,
GenericVertexController
public void applyVertexController()
public void removeVertexController()
public void strip()
public void compress()
Loader.loadMD2(java.lang.String, float)
,
getVertexCount()
,
getUniqueVertexCount()
public Mesh cloneMesh(boolean compressed)
compressed
- indicates if compress() should by called after cloning the
mesh or not
COMPRESS
,
DONT_COMPRESS
,
compress()
public int getVertexCount()
public int getUniqueVertexCount()
public int getTriangleCount()
public float[] getBoundingBox()
public void setLocked(boolean locked)
locked
- should it be locked?public boolean isLocked()
public void addVertexAttributes(VertexAttributes attrs)
attrs
- the new attributespublic VertexAttributes[] getVertexAttributes()
public void setSerializeMethod(int method)
method
- Either SERIALIZE_ALL, DONT_SERIALIZE_NORMALS or
SERIALIZE_LOW_PRECISION. Methods can be combined by using the
or-operator.
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


Jamie is a psychology PhD student based at the University of Sussex.
Tests are written with Jest.
To run the tests, install Node and npm. Run npm install
in the root jsPsych directory. Then run npm test
.
To add tests, follow examples contained in this folder.


HIGH FIDELITY (2000) / *** 1/2
Directed by Stephen Frears. Screenplay by D.V. DeVincentis, Steve Pink, John Cusack and Scott Rosenberg, based on the novel by Nick Hornby. Starring Cusack, Todd Louiso, Jack Black. Running time: 113 minutes. Rated AA for offensive language (MFCB). Reviewed on April 12th, 2000.
By SHANNON PATRICK SULLIVAN
Here they are, my all-time Top Five Things To Know About "High Fidelity":
1. The synopsis (well, every review's got to have a synopsis, right?).
Relationships and music, music and relationships -- that's pretty much what "High Fidelity" is all about. John Cusack plays Rob Gordon, a thirtysomething record store owner whose longtime girlfriend Laura (Iben Hjejle) has just left him. Watching her drive away, Rob makes up a list of his top five worst break-ups, and is delighted that Laura hasn't made the cut. At a crossroads in his life, Rob decides to revisit each of these five former lovers (including half the cast of "The Haunting"). He hopes that in so doing, he will finally figure out why all of his romantic entanglements turn out disastrously. Meantime, he's also got to decide if he's happy spending his days running a record store, or if he wants to get something more out of life.
2. The star.
There can be little doubt that this movie turns on John Cusack's everyman qualities. Cusack has always had a broad appeal, even when he's portrayed such unusual characters as a professional assassin ("Grosse Pointe Blank") and a puppeteer with a mystical connection to John Malkovich ("Being John Malkovich"). In "High Fidelity", for once he's playing a character who isn't larger-than-life. Rob Gordon is a pretty regular guy, with a regular job and regular problems; it's hard not to relate, so the movie is accessible on a very fundamental level. His overriding passion is music, and his life is replete with its trappings, but not to the point where we feel alienated from him. For example, to help himself get over Laura, he reorganizes his record collection. "Chronologically?" he's asked. "Autobiographically," he replies, and our gut reaction is no different than if he were eating cookie dough ice cream. Rob is a well-crafted character, and Cusack's portrayal of him is spot on -- if its main character weren't someone the audience could relate to, "High Fidelity" would have been a flop.
The toughest aspect of Cusack's performance is the fact that he makes frequent asides to the audience; indeed, in several cases these asides become full-blown soliloquies. But Cusack knows how to deliver a monologue; he keeps them lively and interesting, without exaggerating for effect. Indeed, these are some of "High Fidelity"'s most enjoyable scenes, which is an accomplishment, given that this kind of filmmaking device often comes across as stagy and dull.
3. The supporting cast.
Cusack might be the high point of "High Fidelity", but it doesn't hurt that he's been placed in pretty talented company. Of particular note are Todd Louiso and Jack Black as Dick and Barry, Rob's employees at the record store, die-hard music buffs who were hired as part-time help years ago and haven't stopped showing up since. Barry is the loud and boisterous one, while Dick is reserved and polite. Together, they form one of the best comic double acts in quite some time. Also very good is Iben Hjejle as Laura. Hjejle's is the film's most complex role: for much of the movie, she has to be convincingly at odds with the protagonist, but at the same time not come across as "the villain", nor forget that Laura and Rob did once care about each other -- and, perhaps, still do. The relationship between Rob and Laura is meant to be realistic, and even though we're seeing everything from Rob's biased perspective, this sense of realism would have been shattered had Hjejle's performance not been so moderate and considered.
4. The cameos.
In addition to the movie's main cast, a number of popular actors have extended cameos in "High Fidelity". These are a lot of fun, especially since several of the actors are playing either exaggerated versions of their public image, or else totally against type. For example, Tim Robbins is cast as Ray, an irritating, ponytailed faux-intellectual who is Laura's new love interest. One of the movie's funniest scenes depicts Rob fantasizing about all the things he'd like to do Ray when the latter confronts him over Laura. Needless to say, the fantasies are neither pretty nor anything approximating reality. Catherine Zeta-Jones, meanwhile, plays Rob's ex-girlfriend Charlie, a sensuous high-society type who may not be everything Rob remembers.
5. The script.
Based on the 1995 novel by Nick Hornby, "High Fidelity" is a hilarious and eclectic look at love, but one which will likely ring true to many viewers. Particularly interesting is the way the movie's version of events is subordinate to Rob's views on his life. Our introduction to various characters and situations is colored by his opinions and memories, and so even though it might feel like we're getting the whole story, there are times when we're really only getting a Rob-biased perspective on things. As Rob uncovers the misunderstandings and misconceptions which have dominated his love life, so too do we.
Probably the only real downside to "High Fidelity" is a subplot about Rob's desire to be a record producer. Although it does arise naturally from the film's subject material, it nonetheless feels artificially appended to the movie, there mostly to give the events a typical Hollywood ending. But "High Fidelity" doesn't really need this; its proper climax comes fifteen minutes before the credits roll, and the extra material ultimately feels like padding. Funny padding, yes, but padding nonetheless.
But this is a minor flaw. "High Fidelity" is a fun, lightweight movie which derives its laughs not from scripted routines but from experiences most anyone who's ever been in a relationship (or even just wanted to be in a relationship) will be familiar with. It is a film which draws its audience in slowly, and plays out gradually, and this may lose people looking for a more high-octane ride. But in its totality, "High Fidelity" is an experience which is not just entertaining, but also very true.
Copyright © 2000 Shannon Patrick Sullivan. Archived at The Popcorn Gallery, http://www.physics.mun.ca/~sps/movies/HighFidelity.html
-- _______________________________________________________________________ / Shannon Patrick Sullivan | "We are all in the gutter, but some of us \ |<EMAIL_ADDRESS>| are looking at the stars." - Oscar Wilde | \___________________________|__________________________________________/ | Popcorn Gallery Movie Reviews www.physics.mun.ca/~sps/movies.html | | Doctor Who: A Brief History of Time (Travel) /drwho.html |
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


How to use the Feathers VideoPlayer
component
The VideoPlayer
class provides video playback capabilities using a flash.net.NetStream
object. Video files may be loaded from a URL and displayed as a Starling texture. Media player controls may be added as children to display information such as the current time or to control playback by seeking or pausing the audio. VideoPlayer
is a subclass of LayoutGroup
, so its children may be positioned and sized using layouts.
The Basics
First, let's create a VideoPlayer
component, set its dimensions, and add it to the display list:
var player:VideoPlayer = new VideoPlayer();
player.setSize( 320, 300 );
this.addChild( player );
To play a video file, pass the URL to the videoSource
property:
player.videoSource = "http://example.com/video.m4v";
To display the video, we need to add an ImageLoader
as a child of the VideoPlayer
:
var loader:ImageLoader = new ImageLoader();
player.addChild( loader );
Notice that we have not set the source
property of the ImageLoader
yet. A video texture requires a moment to initialize on the GPU before it may be rendered by Starling. The VideoPlayer
will dispatch Event.READY
once we can pass the texture to the ImageLoader
:
function videoPlayer_readyHandler( event:Event ):void
{
loader.source = player.texture;
}
player.addEventListener( Event.READY, videoPlayer_readyHandler );
The video texture may be accessed throught the texture
property. Until Event.READY
is dispatched, the texture
property of the VideoPlayer
will be null
.
Adding Controls
Let's give the VideoPlayer
some controls. First, let's create a LayoutGroup
to use as a toolbar for our controls:
var controls:LayoutGroup = new LayoutGroup();
controls.styleNameList.add( LayoutGroup.ALTERNATE_STYLE_NAME_TOOLBAR );
player.addChild(controls);
With the toolbar in place, let's add a PlayPauseToggleButton
and a SeekSlider
. It's as simple as adding them as children of the tool bar:
var button:PlayPauseToggleButton = new PlayPauseToggleButton();
controls.addChild( button );
var slider:SeekSlider = new SeekSlider();
controls.addChild( slider );
There's no need to add event listeners for these controls. You simply need to add them as children of the VideoPlayer
(or a container that has been added as a child of the VideoPlayer
), and everything will be set up automatically.
In the next section, we'll position everything with some layouts.
Layout
First, let's create a layout for the toolbar with our controls. We'll pass a HorizontalLayout
to the layout
property:
var layout:HorizontalLayout = new HorizontalLayout();
layout.gap = 10;
controls.layout = layout;
Here, we've set the gap
property, but HorizontalLayout
provides many more useful features, including padding and alignment. See How to use HorizontalLayout
with Feathers containers for complete details.
If we want our SeekSlider
to stretch to fill as much space as possible within the VideoPlayer
, we can pass in HorizontalLayoutData
:
var sliderLayoutData:HorizontalLayoutData = new HorizontalLayoutData();
sliderLayoutData.percentWidth = 100;
slider.layoutData = sliderLayoutData;
Now, because we set the percentWidth
property, when the width of the toolbar changes, the width of the SeekSlider
will change too.
Next, we want to position the toolbar and the ImageLoader
. Let's use a VerticalLayout
for that.
player.layout = new VerticalLayout();
We want the ImageLoader
to fill as much space as possible.
var loaderLayoutData:VerticalLayoutData = new VerticalLayoutData();
loaderLayoutData.percentWidth = 100;
loaderLayoutData.percentHeight = 100;
loader.layoutData = loaderLayoutData;
Then, we want the toolbar to fill the entire width of the VideoPlayer
:
var controlsLayoutData:VerticalLayoutData();
controlsLayoutData.percentWidth = 100;
controls.layoutData = controlsLayoutData;
Controlling playback programmatically
By default, the VideoPlayer
will automatically start playing its videoSource
. We can use the autoPlay
property to change this behavior:
player.autoPlay = false;
If autoPlay
is set to false
, we can call play()
to begin playback manually:
player.play();
To pause, we can call pause()
to pause playback at the current position:
player.pause();
The togglePlayPause()
method may be called to toggle between the play and pause states:
player.togglePlayPause();
To stop playback and return the video to the beginning, we may call stop()
:
player.stop();
The seek()
function may be called to change the current time:
player.seek( 5.0 );
The time is measured in seconds.
To change the volume, we can pass a flash.media.SoundTransform
object to the soundTransform
property:
player.soundTransform = new SoundTransform( 0.5 );
The toggleFullScreen()
function will toggle between normal and full screen modes:
player.toggleFullScreen();
When the VideoPlayer
is displayed in full screen mode, it will be added as a modal pop-up above all Starling content.
Skinning a VideoPlayer
As mentioned above, VideoPlayer
is a subclass of LayoutGroup
. For more detailed information about the skinning options available to VideoPlayer
, see How to use the Feathers LayoutGroup
component.
Targeting a VideoPlayer
in a theme
If you are creating a theme, you can set a function for the default styles like this:
getStyleProviderForClass( VideoPlayer ).defaultStyleFunction = setVideoPlayerStyles;
If you want to customize a specific video player to look different than the default, you may use a custom style name to call a different function:
player.styleNameList.add( "custom-video-player" );
You can set the function for the custom style name like this:
getStyleProviderForClass( VideoPlayer )
.setFunctionForStyleName( "custom-video-player", setCustomVideoPlayerStyles );
Trying to change the video player's styles and skins outside of the theme may result in the theme overriding the properties, if you set them before the video player was added to the stage and initialized. Learn to extend an existing theme to add custom skins.
If you aren't using a theme, then you may set any of the video player's properties directly.


British broadcasters join up for new BritBox streaming service
by Paul SandleLONDON (Reuters) - A streaming service created by British broadcasters ITV and the BBC and went live on Thursday, entering a market dominated by Netflix and Amazon with a 5.99 pound ($7.70) a month offer focused on domestic content.
Period drama “Downton Abbey”, comedy “Only Fools and Horses” and detective show “Miss Marple”, will be some of the programs on the service, along with all 627 available episodes of “Doctor Who” originally broadcast between 1963 and 1989.
BritBox said Channel Four, a publicly owned and ad-funded broadcaster, would also supply content from next year, to give the service the suite of Britain’s main free-to-air broadcasters which also includes Channel 5.
ITV Chief Executive Carolyn McCall has said BritBox is not designed to replace big-budget U.S. rivals but should be seen an add-on service offering viewers British-focused content.
The broadcaster is investing up to 25 million pounds this year and around 40 million pounds in 2020 in BritBox, a figure dwarfed by the roughly $15 billion Netflix paid for content in 2019 and the $2 billion Apple has spent on original programming for its new video streaming service.
BritBox is offering the exclusive drama “Lambs of God” at launch and ITV’s director of subscription video on demand (SVOD) Reemah Sakaan said more original content would be available next year.
She said BritBox was not making any subscription forecasts, but ITV had ambitious plans to create a profitable scale business.
British viewers would immediately feel at home on the platform, she said, with navigation guided by types of program or content starring favorite actors.
“Quite often streaming services are dominated by U.S. shows and U.S. talent, but UK audiences can feel a bit lost,” she said.
“You will immediately be in a world populated by people and faces that you know, and talent is a really important part of that.”
Content will typically move to BritBox after it has appeared on the broadcasters’ existing catch-up services, such as ITV’s Hub and BBC’s iPlayer, she said.


|
Math library
|
GLFW is an Open Source, multi-platform library for OpenGL, OpenGL ES and Vulkan application development. It provides a simple, platform-independent API for creating windows, contexts and surfaces, reading input, handling events, etc.
GLFW is licensed under the zlib/libpng license.
This is version 3.2.1, which adds support for statically linking the Vulkan loader and fixes for a number of bugs that together affect all supported platforms.
See the downloads page for details and files, or fetch the latest
branch, which always points to the latest stable release. Each release starting with 3.0 also has a corresponding annotated tag with source and binary archives.
If you are new to GLFW, you may find the tutorial for GLFW 3 useful. If you have used GLFW 2 in the past, there is a transition guide for moving to the GLFW 3 API.
GLFW itself requires only the headers and libraries for your window system. It does not need the headers for any context creation API (WGL, GLX, EGL, NSGL) or rendering API (OpenGL, OpenGL ES, Vulkan) to enable support for them.
GLFW supports compilation on Windows with Visual C++ 2010 and later, MinGW and MinGW-w64, on OS X with Clang and on Linux and other Unix-like systems with GCC and Clang. It will likely compile in other environments as well, but this is not regularly tested.
There are also pre-compiled Windows binaries available for all compilers supported on that platform.
See the compilation guide in the documentation for more information.
See the building application guide guide in the documentation for more information.
GLFW supports Windows XP and later, OS X 10.7 Lion and later, and Linux and other Unix-like systems with the X Window System. Experimental implementations for the Wayland protocol and the Mir display server are available but not yet officially supported.
See the compatibility guide in the documentation for more information.
GLFW itself depends only on the headers and libraries for your window system.
The examples and test programs depend on a number of tiny libraries. These are located in the deps/
directory.
The Vulkan example additionally requires the Vulkan SDK to be installed, or it will not be included in the build.
The documentation is generated with Doxygen. If CMake does not find Doxygen, the documentation will not be generated when you build.
Bugs are reported to our issue tracker. Please check the contribution guide for information on what to include when reporting a bug.
_GLFW_VULKAN_STATIC
build macro to make the library use the Vulkan loader linked statically into the application (#820)glfwSetCursorPos
used the wrong minimum (#773)GLFW_INCLUDE_VULKAN
when compiling the library did not fail with the expected error message (#823)CMAKE_MODULE_PATH
was clobbered (#822)glfwSetClipboardString
created an unnecessary intermediate copy of the stringlinmath.h
(#785)GLFW_MAXIMIZED
hint when the process was provided a STARTUPINFO
(#780)GLFW_DONT_CARE
(#805)BadMatch
on some non-reparenting WMs (#789,#798)glfwGetWindowPos
and glfwSetWindowPos
operated on the window frame instead of the client area (#800)WGL_ARB_create_context
extensionlib
prefix matching between EGL and OpenGL ES library binariesOn glfw.org you can find the latest version of GLFW, as well as news, documentation and other information about the project.
If you have questions related to the use of GLFW, we have a forum, and the #glfw
IRC channel on Freenode.
If you have a bug to report, a patch to submit or a feature you'd like to request, please file it in the issue tracker on GitHub.
Finally, if you're interested in helping out with the development of GLFW or porting it to your favorite platform, join us on the forum, GitHub or IRC.
GLFW exists because people around the world donated their time and lent their skills.


{% extends "base.html" %} {% block content %}
| Name | {{ dataanalyse.title }} |
|---|---|
| Type | {{ dataanalyse.type }} |
| Description | {{ dataanalyse.description }} |
| Owner | {{ dataanalyse.created_by }} |
| Project | {{ dataanalyse.project }} |
Table containing numeric gene counts, with samples on columns and gene symbols on rows
Raw FASTQ sample sequencing files generated from an RNA-seq profiling study
Table containing numeric gene counts, with samples on columns and gene symbols on rows
Raw Cell generated from an microarray profiling study


Like many older institutions, Rochester Institute of Technology (RIT) has a rich history. Unknown to many of its current students, however, is the fact that this well-established university in the suburbs of Rochester, New York, was once located in the heart of the city itself. Until 1969, the significantly smaller RIT campus was a staple of downtown Rochester, but its move to the suburbs led to the demolition and sale of many of its former buildings. 50 years after the move, little remains of the school’s original downtown campus.
This interactive, 3D map shows the history of RIT's campus. Maps allow us to see where we have been, so in viewing this map we are placed into the history of RIT and see how far we've come.


@(error: Throwable) @import conf.Configuration._ @page("Error"){ @menu.menubar{ } }{
I love you, but something has gone terribly wrong and I just don't feel at all well.


Instructor: Bill Maxwell (@CloudNautique) is DevOps Manager at Rancher Labs, and previously worked at GoDaddy and Qualcomm. He loves automating and watching systems build from scratch to production, hands-free.
Abstract
In this hands-on workshop, Bill Maxwell, DevOps manager from Rancher Labs, will walk you through the basics of containers and using Docker. We’ll cover how deploying containers, basic Docker commands, working with registries, building images, and continuous delivery with Docker Swarm before briefly discussing different options for delivering a containerized application.
Workshop Requires:
TBA


Adam Zyglis: Smoking gun 21 Nov 2019, 17:49 by https://www.facebook.com/zyglis Click here to see more of Pulitzer Prize-winner Adam Zyglis' political cartoons.


::What Is It::
- Chrome 2 Kindle Chrome2Kindle is a chrome extension that converts the web page you are viewing into a kindle compatible file and sends it direct to your device for later viewing.
::Architecture::
- It utilizes a Google App Engine proxy to do the conversion so, for the moment. Please add<EMAIL_ADDRESS>into your allowed sources in your kindle device management page @ amazon.com


Food and Beverage section offers a quick way to see recent coverage of how onsite operators are adapting culinary and menu trends for their specific customer bases. You’ll also find information on special nutritional and diet needs as well as a section on food humor.
Read MoreThe Kitchen goes on a road trip across the Philippines with a Fried Clam Roll from Vivian, a heartland flavor-packed Midwestern Potato Salad from Jin, and burgers inspired by their home state ingredients from dnrae, leslee and vonage. Plus, a showcase of unique flavors of barbecue sauce from state to state, and barbecue champion and pit master Melissa reveals her secret to award-winning sauce for ribs. Then, Jp joins for a toast to the 49th state with zackry Alaska milkshake.
Read MoreThe Dessert Kitchen produces innovative, healthy, and high quality desserts based on the “light dessert” principle by introducing sweet treats that are both delicious and tasty, but having no added additives, low in fat and sugar.
Read More


NRPN 80,0 on the Editor input channel reads back the current {_program} in the Main {_instrument} as a {MIDI_Program_Set} NRPN 16,0. The Bank MSB and Data MSB values are ignored, but the latter must still be sent to trigger the operation.


Please verify: Any previous installs have been removed & vmimport role has been removed from AWS GovCloud (US).
 Admin API Keys are needed for
AWS and AWS GovCloud (US). The script will output a URL for app UI. Please read through all documentation
prior to installation.
Uninstall
Please verify: Any objects that are left in S3 AWS GovCloud (US) and AWS Buckets are removed. Once verified,
proceed to the install/remove page. You need Admin API Keys for AWS and AWS GovCloud (US). All is removed but
the CloudWatch logs.
Caveats:
1. Install fails if vmimport role exists or leftovers from previous install.
2. Uninstall fails if S3 bucket objects exist.
3. Window images loose .pem login functionality (not Linux in tests). Make sure creds set.
4. No images over 100GiB (tested up to this size).
5. S3 Import is meant for 1TiB or less.
6. S3 Import fails without giving specific S3 Bucket permissions to AWS role or AWS GovCloud (US) user.
Programmatic Interface (API):
While this is not a full API, it will allow you to make gov-cloud-import available to your applications.
Below are sample AWS SDK Javascript calls that show how to initiate an import.
We have a CloudFormation for AWS and AWS GovCloud (US). The installation script deploys these formations
Below should help reference what is being built by the templates.
For AWS:
For AWS GovCloud (US):
After deployed, you then have the ability to transfer AMI/Snapshots via the import images and S3 buckets via Import S3.
Solution: gov-cloud-import-image
This gov-cloud-import-image tool supports importing Snapshots/AMIs owned by your AWS account.
1. User inputs Source OS, AMI/Snapshot ID, and Region
2. Lambda starts Step Functions and passes input
3. Step Functions starts/launches EC2 Worker
4. Lambda copies the Source Image to region adjacent to AWS GovCloud (US)
5. Makes Volume from copied Image and attach to EC2
6. Step Functions issues an EC2 Activity
7. EC2 Worker copies RAW image to AWS GovCloud (US) S3 Bucket
There is no script specific to SSM. The unencrypted values are sent from the AWS CloudFormation. CloudFormation
doesn't support storing encrypted outputs nor sending encrypted parameters to SSM. Since we have AWS GovCloud (US) API Keys, its
important to mention this tool uses specific lambda functions store them encrypted. The other key stored securely is the KeyPair
for the EC2 Worker. This is so if we need to troubleshoot, we have access (you'll also have to change Security Group).
All values are deleted upon uninstall.
The Step Functions drives the workflow of gov-cloud-import. Kicked off via initStepFunction Lambda,
Step Functions is passed the parameters from the browser. Each step is either a Lambda Function,
an EC2 Worker, or a wait event pending a status. This script is encoded inside the AWS CloudFormation
Template.
Lambda performs tasks on the infrastructure necessary for the EC2 worker's copy. It follows up with an API call
to AWS GovCloud (US) for issuing an EC2 ImportImage call and watches the import status. Upon completion, the last Lambda
removes the RAW image from AWS GovCloud (US) S3.
EC2 is used as its the only service that can attach a volume. Nothing is stored on the EC2 but the scripts themselves.
The EC2 runInstance/startInstance is managed by Lambda. It does a createKeyPair and stores the private key in SSM.
This will allow you to get into the instance if needed. It deploys it into the VPC with an Egress only Security Group.
Lambda checks its status again before issuing an Activity in StepFunctions. The shell script bootstraps the image.
Once running, it polls the StepFunction Activity. An activity will have the volumeId (along with other params)
It attaches the drive, copies to AWS GovCloud (US) S3 and sends heartbeats to StepFunction. It can copy as many drives
as EC2 allows attached. An instance size of m5.4xlarge is used. 2 hour after the last copy finishes, the EC2
will stop itself until lambda starts it again. When stopping, it detaches and deletes any orphaned volumes from
failed attempts.
Component: AWS GovCloud (US) VM Import/Export
Code:
Overview
VM Import is used on the RAW image transferred from the EC2 worker into AWS GovCloud (US) S3. The requires a
an S3 Bucket and a role with proper permissions. If successful, the RAW image transformed into AMI.
Solution: gov-cloud-import-s3
This gov-cloud-import-image tool supports importing Snapshots/AMIs owned by your AWS account.
1. User inputs AWS Source Bucket and AWS GovCloud (US) Destination Bucket
2. Lambda starts Step Functions and passes input
3. Step Functions starts/launches EC2 Worker
4. EC2 mounts Source Bucket via S3FS
5. NodeJS compares difference from Source to Destination.
6. NodeJS copies new/changed files to destination and removes files not found in source
Lambda performs tasks on the infrastructure necessary for the EC2 worker's copy. It follows up with an API call
to AWS GovCloud (US) for issuing an EC2 ImportImage call and watches the import status. Upon completion, the last Lambda
removes the RAW image from AWS GovCloud (US) S3.
This is the same EC2 worker as gov-cloud-import-image. The asynchronous nature allows it handle multiple copies well.
File Synchronization allows you to only copy the files you that have changed rather copying all files. To do this
we build a table prior to copying that allows us to know what to update. gov-cloud-import-s3 will run a MD5 hash
on the files in AWS and compare them to the eTag of the Object(s) in AWS GovCloud (US). Commercial is mounted via
s3fs and access via the NodeJS fs. AWS Logs produces CloudWatch sync log showing when each file is started and
finished copying along with file paths. The bucket is unmounted and mountpoint deleted upon completion.
Troubleshooting:
Logging for Lambda and EC2 Worker exist all in CloudWatch. You can reach it easily from StepFunctions


Migrating From PhysX SDK 3.2 to 3.3¶
- This guide highlights all significant parts of the API that have changed in the last dot release. An application with a working integration of the older version of PhysX should be able to easily migrate to the newer version by following these pointers.
Math Classes¶
The static createIdentity() and createZero() methods are now deprecated, and will be removed in a future release. The preferred method is to use the constructors PxMat33(PxIdentity), PxMat44(PxIdentity), PxQuat(PxIdentity), PxTransform(PxIdentity) for identity transforms, and PxMat33(PxZero) and PxMat44(PxZero) for zero matrices.
Scene Query API¶
- The Scene Query API underwent significant changes. The highlights are:
- Former raycastAny, raycastMultiple, raycastSingle API calls are now folded into a single PxScene::raycast call
Same for overlaps and sweeps
Same for PxBatchQuery and PxVolumeCache
- For PxScene queries a deprecated backwards compatibility mapping was added to aid the transition
- This mapping will be removed in the next dot release
- There are now dedicated callback and buffer classes for receiving query results, replacing PxRaycastHit array and count parameters.
- Same for sweeps and overlaps
- See PxRaycastBuffer, PxSweepBuffer, PxOverlapBuffer, PxRaycastCallback, PxSweepCallback, PxOverlapCallback
The way results are returned is now more robust and it is possible to transparently handle unbounded number of results without dynamic allocations.
Header PxSceneQueryFiltering.h was renamed to PxQueryFiltering.h, PxSceneQueryReport.h to PxQueryReport.h
PxHitFlag::eIMPACT changed to PxHitFlag::ePOSITION
PxRaycastHit.impact renamed to PxRaycastHit.position (same for PxSweepHit.impact)
PxQueryFlag::eNO_BLOCK and PxQueryFlag::eANY_HIT flags were added
- The following classes were renamed
- PxSceneQueryHit -> PxQueryHit
- PxSceneQueryFlags -> PxHitFlags
- PxSceneQueryHitType -> PxQueryHitType
- PxSceneQueryFilterData -> PxQueryFilterData
- PxSceneQueryFilterCallback -> PxQueryFilterCallback
- PxSceneQueryFilterFlags -> PxQueryFlags
- PxSceneQueryCache -> PxQueryCache
- PxCCTNonWalkableMode -> PxControllerNonWalkableMode
- PxControllerFlags -> PxControllerCollisionFlags
- PxCCTHit -> PxControllerHit
- PxConstraintDominance -> PxDominanceGroupPair
- PxActorTypeSelectionFlags -> PxActorTypeFlags
- PxFindOverlapTriangleMeshUtil -> PxMeshOverlapUtil
- Old versions are #defined to new versions to simplify transition. These #defines are deprecated and will be phased out.
- queryClient parameter was removed from raycast/sweep/overlap parameter list and added to PxQueryFilterData
- The fix is to simply pass the same value via PxQueryFilterData::clientId
- PxBatchQueryDesc now requires 3 parameters at construction time, PxU32 maxRaycastsPerExecute, PxU32 maxSweepsPerExecute, PxU32 maxOverlapsPerExecute
- Each of these numbers is an upper bound on the number of PxBatchQuery::raycast(), sweep() and overlap() calls before a call to execute()
- Previously there was no way to check for results buffer overflow in batch query code since sizes of these buffers were not specified.
- The fix is to specify the batch query result (different from hit) buffer sizes at construction.
- PxBatchQueryDesc no longer directly holds pointers to memory for queries, in 3.3 these are moved to PxBatchQueryMemory.
- It is now possible to set a new batch query memory descriptor before each execute
- userRaycastHitBuffer has been renamed to userRaycastTouchBuffer
- raycastHitBufferSize has been renamed to raycastTouchBufferSize
- same for overlaps and sweeps (userSweepHitBuffer, sweepHitBufferSize, userOverlapHitBuffer, overlapHitBufferSize)
- A code snippet below illustrates the migration for these code changes
- PxQueryFilterData constructors are now explicit. This means that previously it was possible to write
- scene->raycast(..., PxQueryFlag::eDYNAMIC | PxQueryFlag::eSTATIC, ...), causing PxQueryFilterData to be implicitly constructed by the compiler
- now it is required to explicitly write: scene->raycast(...,PxQueryFilterData(PxQueryFlag::eDYNAMIC | PxQueryFlag::eSTATIC), ...)
- This change was made to improve type safety and reduce confusion while reading the code employing implicit constructors
- PxRaycastBufferN, PxOverlapBufferN and PxSweepBufferN were added for convenience
- A buffer object with space for 10 touching hits and one blocking hit can now be conveniently declared as PxRaycastBufferN<10> hits;
PxRaycastHit and PxSweepHit now inherit from PxLocationHit (formerly from PxSceneQueryImpactHit)
bool PxLocationHit::hadInitialOverlap() function was added to determine if a swept shape was overlapping at sweep distance=0 or if a raycast hit a shape at distance=0.
Functionality of PxSceneQueryFlag::eINITIAL_OVERLAP and PxSceneQueryFlag::eINITIAL_OVERLAP_KEEP was replaced with PxHitFlag::eASSUME_NO_INITIAL_OVERLAP and PxLocationHit::hadInitialOverlap().
- Overlap scene queries with preFilter or postFilter returning multiple eBLOCK hits would previously return multiple results as touching hits.
- eBLOCK should not be returned from user filters for overlap(). Doing so will result in undefined behavior, and a warning will be issued.
- If the PxQueryFlag::eNO_BLOCK flag is set, the eBLOCK will instead be automatically converted to an eTOUCH and the warning suppressed.
Sweeps in 3.3 execute using a new faster code path, in some cases with reduced precision. If you encounter precision issues not previously experienced in earlier versions of PhysX, use ePRECISE_SWEEP flag to enable the backwards compatible more accurate sweep code.
Snippets demonstrating API migration:
Former raycastSingle call:
PxRaycastHit hit;
bool hadHit = scene->raycastSingle(..., hit, ...);
if (hadHit) doStuff(hit);
Is now:
PxRaycastBuffer buf;
Bool hadHit = scene->raycast(..., buf, ...);
if (hadHit) doStuff(buf.block);
Former raycastAny call:
PxSceneQueryHit hit;
bool hadHit = scene->raycastAny(hit);
if (hadHit) doStuff(hit);
Is now:
PxRaycastBuffer buf; // declare a hit buffer with room for a single blocking hit
PxFilterData fdAny; fdAny.flags |= PxQueryFlag::eANY_HIT;
bool hadHit = scene->raycast(buf, PxHitFlags(), fdAny);
if (hadHit) doStuff(buf.block);
Former Multiple call:
PxRaycastHit buffer[N];
bool hasBlock;
PxI32 result = Scene->raycastMultiple(buffer, N, hasBlock);
if (result == -1)
handleOverflow();
else
{
if (hasBlock)
{
doBlocking(buffer[result-1]);
doTouches(buffer, result-1);
}
else
{
doTouches(buffer, result);
}
}
Is now:
PxRaycastBufferN<N> buf;
scene->raycast(buf);
if (buf.hasBlock)
doBlocking(buf.block);
doTouches(buf.touches, buf.nbTouches);
or:
for (PxU32 i = 0; i < buf.getNbAnyHits(); i++) // "any" in this context refers to blocking or
// touching hits
doAnyHit(buf.getAnyHit(i));
Former batch query memory setup code in 3.2:
const PxU32 maxRaycastHits = 16, maxRaycastQueries = 8;
PxRaycastQueryResult* resultBuffer = new PxRaycastQueryResult[maxRaycastQueries];
PxRaycastHitBuffer* hitBuffer = new PxRaycastHit[maxRaycastHits];
PxBatchQueryDesc desc; // required no arguments, there was no safety check for maximum number
// of queries per batch (not hits per query)
desc.userRaycastResultBuffer = resultBuffer;
desc.userRaycastHitBuffer = hitBuffer;
desc.raycastHitBufferSize = maxRaycastHits;
PxBatchQuery* bq = PxCreateBatchQuery(desc);
for (PxU32 iQuery = 0; iQuery < maxRaycastQueries; iQuery++)
bq->raycastSingle(...); // up to 8 raycast queries are allowed per PxBatchQuery::execute()
// call but there was no overflow check in 3.2
bq->execute();
for (PxU32 iResult = 0; iResult < nQueries; iResult++)
{
for (PxU32 iHit = 0; iHit < resultBuffer[i].nbHits; iHit++)
{
bool isBlocking = (iHit == resultBuffer[i].nbHits &&
(resultBuffer[iResult].hits[iHit].flags & PxSceneQueryFlag::eBLOCKING_HIT));
processHit(resultBuffer[iResult].hits[iHit], isBlocking);
}
}
Batch query setup code in 3.3:
const PxU32 maxRaycastHits = 16, maxRaycastQueries = 8;
PxBatchQueryDesc desc(maxQueries, 0, 0); // note the new required maximum of queries per batch
// (this is different from maximum hits)
PxBatchQuery* bq = scene->createBatchQuery(desc);
PxRaycastQueryResult* resultBuffer = new PxRaycastQueryResult[maxRaycastQueries];
PxRaycastHitBuffer hitBuffer = new PxRaycastHit[maxRaycastHits];
PxBatchQueryMemory mem(maxQueries, 0, 0); // maximum number of queries for each type
// (raycasts, overlaps, sweeps)
mem.userRaycastResultBuffer = resultBuffer;
mem.userRaycastTouchBuffer = hitBuffer;
mem.raycastTouchBufferSize = maxHits;
PxBatchQuery* bq = PxCreateBatchQuery(desc);
bq->setUserMemory(mem);
for (PxU32 iQuery = 0; iQuery < maxRaycastQueries; iQuery++)
bq->raycastSingle(...); // up to 8 raycast queries are allowed per PxBatchQuery::execute()
// with query count overflow check as of 3.3
bq->execute();
for (PxU32 iResult = 0; iResult < nQueries; iResult++)
{
// note that the blocking hit is now reported in resultBuffer[i].block and touching hits in
// resultBuffer[i].touches
for (PxU32 iHit = 0; iHit < resultBuffer[i].nbTouches; iHit++)
processTouchingHit(resultBuffer[iResult].touches[iHit]);
processBlockingHit(resultBuffer[iResult].block);
}
SPU batch queries¶
In 3.2 the number of SPUs to be used per batch query was controlled by a global setting via setSceneParamInt call:
PxPS3Config::setSceneParamInt(getScene(), PxPS3ConfigParam::eSPU_RAYCAST, 3);
In 3.3 PxBatchQuery no longer automatically executes on multiple SPUs but requires a separate PPU thread, this design allows higher flexibility, such as executing batches on multiple SPU and PPU threads simultaneously, better control of parallel execution and allows the user to fine tune thread load balancing. Here's one possible way to run batch queries on multiple SPUs in 3.3:
struct BQThread : shdfnd::Thread
{
Ps::Sync mBatchReady;
Ps::Sync mBatchCompleted;
PxBatchQuery* mBatch;
PX_FORCE_INLINE BQThread() { mBatch = NULL; }
PX_FORCE_INLINE void submitBatch(PxBatchQuery* batch) { mBatch = batch; }
virtual void execute()
{
// execute submitted batches until quit is signalled
for(;;)
{
mBatchReady.wait();
mBatchReady.reset();
if (quitIsSignalled())
break;
mBatch->execute();
mBatch = NULL;
mBatchCompleted.set();
} // for (;;)
quit(); // shutdown thread
}
};
// main thread code:
// pre-create and launch batch execute threads
for (PxU32 iThread = 0; iThread < nThreads; iThread++)
{
BQThread* t = PX_NEW(BQThread);
t->start();
mThreads.pushBack(t);
}
// submit batches
for (PxU32 iThread = 0; iThread < nThreads; iThread++)
{
// create batches
PxBatchQuery* threadBatch = createBatch(...);
threadBatch->setRunOnSpu(true);
mThreads[iThread]->submitBatch(threadBatch);
mThreads[iThread]->mBatchReady.set();
}
// execute another batch on PPU in the meantime.
PxBatchQuery* threadBatch = createBatch(...);
threadBatch->setRunOnSpu(false);
threadBatch->execute();
// do other PPU work...
// wait for SPU batches to complete:
for (PxU32 i=0; i<mThreads.size(); ++i)
{
mThreads[i]->mBatchCompleted.wait();
mThreads[i]->mBatchCompleted.reset();
releaseBatch(mThreads[i]->mBatch);
}
// terminate batch threads
for (PxU32 i=0; i<mThreads.size(); ++i)
{
mThreads[i]->signalQuit();
mThreads[i]->mBatchReady.set();
mThreads[i]->waitForQuit();
PX_DELETE(mThreads[i]);
}
Whether the batch is executed on SPU or PPU is determined by either bool PxBatchQueryDesc::runOnSpu or PxBatchQuery::setRunOnSpu(bool), by default batch query is executed on SPU:
PxBatchQueryDesc desc;
...
desc.runOnSpu = true;
...
Core PhysX¶
The following methods require that the corresponding objects have been added to a scene. Calling these methods for objects which are not in a scene will result in undefined behavior. In the CHECKED build configuration an error message will get sent.
- addForce/addTorque/clearForce/clearTorque() on a PxRigidBody
- isSleeping/wakeUp/putToSleep() on a PxRigidDynamic, PxArticulation or PxCloth
- PxScene::resetFiltering() and the deprecated counterparts on PxShape and PxParticleBase
The sleep behavior of dynamic rigid bodies has changed significantly. Among the changes are:
- The wakeUp() method of PxRigidDynamic and PxArticulation has lost the wake counter parameter. Use the newly introduced method setWakeCounter() instead to set a specific value.
- Putting a dynamic rigid actor to sleep will clear any pending force updates.
- Switching a dynamic actor to kinematic will put the actor to sleep immediately.
- Switching a kinematic actor back to dynamic will not affect the sleep state (previously the actor was woken up).
- Calling wakeUp/putToSleep() on a kinematically controlled dynamic actor is not valid any longer. The sleep state of a kinematic actor is solely defined based on whether a target pose has been set (see API documentation of isSleeping() for details).
- A call to PxRigidBody::setCMassLocalPose() does not wake up the actor anymore. Add a call to PxRigidBody::wakeUp() to get the old behavior back. Note: this also affects related methods in PhysXExtensions like PxRigidBodyExt::updateMassAndInertia() etc.
- Adding or removing a PxConstraint to/from the scene does not wake the connected actors up automatically anymore (note: this applies to PxJoint in PhysX Extensions as well).
- If a non-zero velocity or force is set through PxRigidBody::setLinearVelocity(), ::setAngularVelocity(), ::addForce() or ::addTorque(), the actor will get woken up automatically even if the autowake parameter is false.
- PxRigidBody::clearForce() and ::clearTorque() do not have the autowake parameter, to optionally wake the actor up, anymore. These methods will not change the sleep state any longer. Call ::wakeUp() subsequently to get the old default behavior.
Shapes may now be shared between actors. This change has several ramifications:
- PxShape::getActor() now returns a pointer rather than a reference. If the shape is shareable, the pointer is NULL.
- The following methods of PxShape have been removed: getGlobalPose(), raycast(), sweep(), overlap(), getWorldBounds(). Replacements can be found in PxShapeExt.
- PxShape now has the same reference counting semantics as meshes and materials, so that release() releases the user reference, and when the last reference is released, the shape is destroyed.
- Shapes created through PxRigidActor::createShape() are still destroyed automatically when the actor is released. However, after serializing and deserializing such a shape, the regular reference counting semantics apply.
- return results from scene queries which previously specified a shape now specify an actor also.
Shape local transforms cannot be specified on shape creation anymore. Instead set the local transform after creation with PxShape::setLocalPose().
The PxObserver/PxObservable system has been replaced by the PxDeletionListener API. The supported object types have been extended from PxActor to all core objects inheriting from PxBase. Furthermore, two kinds of deletion events are now distinguished: user release and memory release. The following snippet shows pseudocode for the transition from the previous to the new API:
old API:
class MyObserver : public PxObserver
{
public:
virtual void onRelease(const PxObservable& observable);
}
MyObserver myObs;
PxRigidDynamic* d = create...;
d->registerObserver(myObs);
new API:
class MyDelListener : public PxDeletionListener
{
public:
virtual void onRelease(const PxBase* observable, void* userData,
PxDeletionEventFlag::Enum deletionEvent);
}
MyDelListener myDelListener;
PxPhysics* physics = create...;
PxRigidDynamic* d = create...;
physics->registerDeletionListener(myDelListener, PxDeletionEventFlag::eUSER_RELEASE, true);
PxBase* b = d;
physics->registerDeletionListenerObjects(myDelListener, &b, 1);
The contactStream in PxContactPair is now stored in a variable-size compressed contact stream. This is used to save memory. As such, you can no longer simply cast it to a PxContactPoint* and access the data. Instead, you must either use PxContactPair::extractContacts or us a PxContactStreamIterator to interpret the data. Please see the callbacks section of the user guide for further information.
The friction API and behavior for dynamic rigid bodies has changed slightly:
- Friction mode flags eENABLE_ONE_DIRECTIONAL_FRICTION and eENABLE_TWO_DIRECTIONAL_FRICTION have been replaced by PxFrictionType::Enum PxSceneDesc::frictionType.
- PxSceneDesc::contactCorrelationDistance has been deprecated, and it no longer has an influence on how many friction anchors are created in a single frame, only on when they are removed in later frames. This may cause a very minor change in friction behavior.
PxShape::resetFiltering() and PxParticleBase::resetFiltering() have been deprecated. Please use one of the new overloaded methods PxScene::resetFiltering() instead.
PxClientBehaviorBit and PxActorClientBehaviorBit have been renamed to PxClientBehaviorFlag and PxActorClientBehaviorFlag respectively.
PxActorTypeSelectionFlag and PxActorTypeSelectionFlags have been renamed to PxActorTypeFlag and PxActorTypeFlags respectively.
PxConstraintDominance has been renamed to PxDominanceGroupPair
The parameter 'spring' on articulation joints has been renamed 'stiffness'.
The parameter 'tangentialSpring' on articulation joints has been renamed 'tangentialStiffness'.
PxConstraintFlag::Type has been renamed to PxConstraintFlag::Enum
Discrete contact reports are no longer produced for pairs without PxPairFlag::eDETECT_DISCRETE_CONTACT raised in the filter shader. Previously, discrete contact generation would always have been performed regardless of the presence of the PxPairFlag::eDETECT_DISCRETE_CONTACT flag. This change potentially improves performance when using specific shapes for CCD-only collision, which would have previously generated discrete contacts and then ignored them in the solver.
Trigger reports are no longer produced for pairs without PxPairFlag::eDETECT_DISCRETE_CONTACT raised in the filter shader. PxPairFlag::eTRIGGER_DEFAULT has been modified to include the PxPairFlag::eDETECT_DISCRETE_CONTACT flag.
PhysX Extensions¶
- Joint limits have been more carefully separated into PxJointLinearLimit, PxJointAngularLimitPair, PxJointLinearLimitPair.
- PxJoint::getType() is deprecated. Joints now inherit from PxBase, and getConcreteType() replaces getType(). Alternatively, to dynamically cast to a particular joint type, use e.g. joint->is<PxD6Joint>() which will return a pointer to a D6 joint if the type matches, otherwise NULL.
- The parameter 'spring' in joint limits and drives has been renamed 'stiffness'.
- Dominance settings no longer apply to joints. To achieve this effect, use setInvMassScale. For example if actor0 in the joint is to affect actor1 but not conversely, use setInvMassScale0(0.0f), setInverseInertiaScale0(0.0f).
PhysX Character Controller¶
- When creating a PxControllerManager, a reference to a PxScene has to be provided. As a consequence, creating a controller from a PxControllerManager now only requires the controller descriptor as an argument.
- On PxControllerManager::release(), all associated PxObstacleContext instances will get deleted automatically. Make sure to not access PxObstacleContext instances after the corresponding manager has been released.
PhysX Vehicles¶
A new struct has been introduced to hold the enumerated list that began with PxVehicleDrive4W::eFRONT_LEFT_WHEEL. The changes are
- PxVehicleDrive4W::eFRONT_LEFT_WHEEL -> PxVehicleDrive4WWheelOrder::eFRONT_LEFT
- PxVehicleDrive4W::eFRONT_RIGHT_WHEEL -> PxVehicleDrive4WWheelOrder::eFRONT_RIGHT
- PxVehicleDrive4W::eREAR_LEFT_WHEEL -> PxVehicleDrive4WWheelOrder::eREAR_LEFT
- PxVehicleDrive4W::eREAR_RIGHT_WHEEL -> PxVehicleDrive4WWheelOrder::eREAR_RIGHT
A new struct has been introduced to hold the enumerated list that began with PxVehicleDrive4WControl::eANALOG_INPUT_ACCEL. The changes are
- PxVehicleDrive4W::eANALOG_INPUT_ACCEL -> PxVehicleDrive4WControl::eANALOG_INPUT_ACCEL
- PxVehicleDrive4W::eANALOG_INPUT_BRAKE -> PxVehicleDrive4WControl::eANALOG_INPUT_BRAKE
- PxVehicleDrive4W::eANALOG_INPUT_HANDBRAKE -> PxVehicleDrive4WControl::eANALOG_INPUT_HANDBRAKE
- PxVehicleDrive4W::eANALOG_INPUT_STEER_LEFT -> PxVehicleDrive4WControl::eANALOG_INPUT_STEER_LEFT
- PxVehicleDrive4W::eANALOG_INPUT_STEER_RIGHT -> PxVehicleDrive4WControl::eANALOG_INPUT_STEER_RIGHT
- PxVehicleDrive4W::eMAX_NUM_DRIVE4W_ANALOG_INPUTS -> PxVehicleDrive4WControl::eMAX_NB_DRIVE4W_ANALOG_INPUTS
A new struct has been introduced to hold the enumerated list that began with PxVehicleDrive4W::eFRONT_LEFT_WHEEL. The changes are
- PxVehicleDriveTank::eTANK_WHEEL_FRONT_LEFT -> PxVehicleDriveTankWheelOrder::eFRONT_LEFT
- PxVehicleDriveTank::eTANK_WHEEL_FRONT_RIGHT -> PxVehicleDriveTankWheelOrder::eFRONT_RIGHT,
- PxVehicleDriveTank::eTANK_WHEEL_1ST_FROM_FRONT_LEFT -> PxVehicleDriveTankWheelOrder::e1ST_FROM_FRONT_LEFT,
- PxVehicleDriveTank::eTANK_WHEEL_1ST_FROM_FRONT_RIGHT -> PxVehicleDriveTankWheelOrder::e1ST_FROM_FRONT_RIGHT
- PxVehicleDriveTank::eTANK_WHEEL_2ND_FROM_FRONT_LEFT -> PxVehicleDriveTankWheelOrder::e2ND_FROM_FRONT_LEFT
- PxVehicleDriveTank::eTANK_WHEEL_2ND_FROM_FRONT_RIGHT -> PxVehicleDriveTankWheelOrder::e2ND_FROM_FRONT_RIGHT
- PxVehicleDriveTank::eTANK_WHEEL_3RD_FROM_FRONT_LEFT -> PxVehicleDriveTankWheelOrder::e3RD_FROM_FRONT_LEFT
- PxVehicleDriveTank::eTANK_WHEEL_3RD_FROM_FRONT_RIGHT -> PxVehicleDriveTankWheelOrder:: e3RD_FROM_FRONT_RIGHT
- PxVehicleDriveTank::eTANK_WHEEL_4TH_FROM_FRONT_LEFT -> PxVehicleDriveTankWheelOrder::e4TH_FROM_FRONT_LEFT
- PxVehicleDriveTank::eTANK_WHEEL_4TH_FROM_FRONT_RIGHT -> PxVehicleDriveTankWheelOrder::e4TH_FROM_FRONT_RIGHT
- PxVehicleDriveTank::eTANK_WHEEL_5TH_FROM_FRONT_LEFT -> PxVehicleDriveTankWheelOrder::e5TH_FROM_FRONT_LEFT
- PxVehicleDriveTank::eTANK_WHEEL_5TH_FROM_FRONT_RIGHT -> PxVehicleDriveTankWheelOrder::e5TH_FROM_FRONT_RIGHT
- PxVehicleDriveTank::eTANK_WHEEL_6TH_FROM_FRONT_LEFT -> PxVehicleDriveTankWheelOrder::e6TH_FROM_FRONT_LEFT
- PxVehicleDriveTank::eTANK_WHEEL_6TH_FROM_FRONT_RIGHT -> PxVehicleDriveTankWheelOrder::e6TH_FROM_FRONT_RIGHT
- PxVehicleDriveTank::eTANK_WHEEL_7TH_FROM_FRONT_LEFT -> PxVehicleDriveTankWheelOrder::e7TH_FROM_FRONT_LEFT
- PxVehicleDriveTank::eTANK_WHEEL_7TH_FROM_FRONT_RIGHT -> PxVehicleDriveTankWheelOrder::e7TH_FROM_FRONT_RIGHT
- PxVehicleDriveTank::eTANK_WHEEL_8TH_FROM_FRONT_LEFT -> PxVehicleDriveTankWheelOrder::e8TH_FROM_FRONT_LEFT
- PxVehicleDriveTank::eTANK_WHEEL_8TH_FROM_FRONT_RIGHT -> PxVehicleDriveTankWheelOrder::e8TH_FROM_FRONT_RIGHT
- PxVehicleDriveTank::eTANK_WHEEL_9TH_FROM_FRONT_LEFT -> PxVehicleDriveTankWheelOrder::e9TH_FROM_FRONT_LEFT
- PxVehicleDriveTank::eTANK_WHEEL_9TH_FROM_FRONT_RIGHT -> PxVehicleDriveTankWheelOrder::e9TH_FROM_FRONT_RIGHT
- PxVehicleDriveTank::eTANK_WHEEL_9TH_FROM_FRONT_RIGHT -> PxVehicleDriveTankWheelOrder::e9TH_FROM_FRONT_RIGHT
A new struct has been introduced to hold the enumerated list that began with PxVehicleDriveTank::eANALOG_INPUT_ACCEL. The changes are
- PxVehicleDriveTank::eANALOG_INPUT_ACCEL -> PxVehicleDriveTankControl::eANALOG_INPUT_ACCEL
- PxVehicleDriveTank::eANALOG_INPUT_BRAKE_LEFT -> PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_LEFT
- PxVehicleDriveTank::eANALOG_INPUT_BRAKE_RIGHT -> PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_RIGHT
- PxVehicleDriveTank::eANALOG_INPUT_THRUST_LEFT -> PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_LEFT
- PxVehicleDriveTank::eANALOG_INPUT_THRUST_RIGHT -> PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_RIGHT
- PxVehicleDriveTank::eMAX_NUM_DRIVETANK_ANALOG_INPUTS -> PxVehicleDriveTankControl::eMAX_NB_DRIVETANK_ANALOG_INPUTS
A new struct has been introduced to hold the enumerated list that began with PxVehicleDriveTank::eDRIVE_MODEL_STANDARD. The changes are
- PxVehicleDriveTank::eDRIVE_MODEL_STANDARD -> PxVehicleDriveTankControlModel::eSTANDARD
- PxVehicleDriveTank::eDRIVE_MODEL_SPECIAL -> PxVehicleDriveTankControlModel::eSPECIAL
A new struct has been introduced to hold the enumerated list that began with eVEHICLE_TYPE_DRIVE4W. The changes are
- eVEHICLE_TYPE_DRIVE4W -> PxVehicleTypes::eDRIVE4W
- eVEHICLE_TYPE_DRIVETANK -> PxVehicleTypes::eDRIVETANK
- eVEHICLE_TYPE_NODRIVE -> PxVehicleTypes::eNODRIVE
- eMAX_NUM_VEHICLE_TYPES -> PxVehicleTypes::eMAX_NB_VEHICLE_TYPES
A new struct has been introduced to hold the enumerated list that began with PxVehicleGraph::eCHANNEL_JOUNCE. The changes are
- PxVehicleGraph::eCHANNEL_JOUNCE -> PxVehicleWheelGraphChannel::eJOUNCE
- PxVehicleGraph::eCHANNEL_SUSPFORCE -> PxVehicleWheelGraphChannel::eSUSPFORCE
- PxVehicleGraph::eCHANNEL_TIRELOAD -> PxVehicleWheelGraphChannel::eTIRELOAD
- PxVehicleGraph::eCHANNEL_NORMALIZED_TIRELOAD -> PxVehicleWheelGraphChannel::eNORMALIZED_TIRELOAD
- PxVehicleGraph::eCHANNEL_WHEEL_OMEGA -> PxVehicleWheelGraphChannel::eWHEEL_OMEGA
- PxVehicleGraph::eCHANNEL_TIRE_FRICTION -> PxVehicleWheelGraphChannel::eTIRE_FRICTION
- PxVehicleGraph::eCHANNEL_TIRE_LONG_SLIP -> PxVehicleWheelGraphChannel::eTIRE_LONG_SLIP
- PxVehicleGraph::eCHANNEL_NORM_TIRE_LONG_FORCE -> PxVehicleWheelGraphChannel::eNORM_TIRE_LONG_FORCE
- PxVehicleGraph::eCHANNEL_TIRE_LAT_SLIP -> PxVehicleWheelGraphChannel::eTIRE_LAT_SLIP
- PxVehicleGraph::eCHANNEL_NORM_TIRE_LAT_FORCE -> PxVehicleWheelGraphChannel::eNORM_TIRE_LAT_FORCE
- PxVehicleGraph::eCHANNEL_NORM_TIRE_ALIGNING_MOMENT -> PxVehicleWheelGraphChannel::eNORM_TIRE_ALIGNING_MOMENT
- PxVehicleGraph::eMAX_NUM_WHEEL_CHANNELS -> PxVehicleWheelGraphChannel::eMAX_NB_WHEEL_CHANNELS
A new struct has been introduced to hold the enumerated list that began with PxVehicleGraph::eCHANNEL_ENGINE_REVS. The changes are
- PxVehicleGraph::eCHANNEL_ENGINE_REVS -> PxVehicleDriveGraphChannel::eENGINE_REVS
- PxVehicleGraph::eCHANNEL_ENGINE_DRIVE_TORQUE -> PxVehicleDriveGraphChannel::eENGINE_DRIVE_TORQUE
- PxVehicleGraph::eCHANNEL_CLUTCH_SLIP -> PxVehicleDriveGraphChannel::eCLUTCH_SLIP
- PxVehicleGraph::eCHANNEL_ACCEL_CONTROL -> PxVehicleDriveGraphChannel::eACCEL_CONTROL
- PxVehicleGraph::eCHANNEL_BRAKE_CONTROL -> PxVehicleDriveGraphChannel::eBRAKE_CONTROL
- PxVehicleGraph::eCHANNEL_HANDBRAKE_CONTROL -> PxVehicleDriveGraphChannel::eHANDBRAKE_CONTROL
- PxVehicleGraph::eCHANNEL_STEER_LEFT_CONTROL -> PxVehicleDriveGraphChannel::eSTEER_LEFT_CONTROL
- PxVehicleGraph::eCHANNEL_STEER_RIGHT_CONTROL -> PxVehicleDriveGraphChannel::eSTEER_RIGHT_CONTROL
- PxVehicleGraph::eCHANNEL_GEAR_RATIO -> PxVehicleDriveGraphChannel::eGEAR_RATIO
- PxVehicleGraph::eMAX_NUM_ENGINE_CHANNELS -> PxVehicleDriveGraphChannel::eMAX_NB_DRIVE_CHANNELS
A new struct has been introduced to hold the enumerated list that began with PxVehicleGraph::eGRAPH_TYPE_WHEEL. The changes are
- PxVehicleGraph::eGRAPH_TYPE_WHEEL -> PxVehicleGraphType::eWHEEL
- PxVehicleGraph::eGRAPH_TYPE_ENGINE -> PxVehicleGraphType::eDRIVE
Non-persistent data is no longer stored in the vehicle. Instead of storing this data in each vehicle it is stored in an array and passed to PxVehicleUpdates as an extra function argument. A simple example of how to construct, use, and read this data is given below. This example code updates an array of vehicles and tests if they are in the air. If the vehicles are not in the air then the actor under each wheel is recorded and stored in an array:
void updateVehicles(const PxF32 timestep, const PxVec3& gravity, const PxVehicleDrivableSurfaceToTireFrictionPairs& fricPairs, PxVehicleWheels** vehicles, PxU32 numVehicles, std::vector<PxActor*>& hitActors) { //Count the total number of wheels. unsigned int numWheels = 0; for(unsigned int i = 0; i < numVehicles; i++) { numWheels += vehicles[i]->mWheelsSimData.getNbWheels(); } //Allocate buffers to store results for each vehicle and each wheel. PxVehicleWheelQueryResult* vehicleWheelQueryResults = new PxVehicleWheelQueryResult[numVehicles]; PxWheelQueryResult* wheelQueryResults = new PxWheelQueryResult[numWheels]; PxU32 wheelCount = 0; for(PxU32 i = 0; i < numVehicles; i++) { vehicleWheelQueryResults[i].nbWheelQueryResults = vehicles[i]->mWheelsSimData.getNbWheels(); vehicleWheelQueryResults[i].wheelQueryResults = &wheelQueryResults[wheelCount]; wheelCount += vehicles[i]->mWheelsSimData.getNbWheels(); } //Update the array of vehicles. PxVehicleUpdates(timestep, gravity, fricPairs, numVehicles, vehicles, vehicleWheelQueryResults); //Test if each vehicle is in the air. for(PxU32 i = 0; i < numVehicles; i++) { if(!PxVehicleIsInAir(vehicleWheelQueryResults[i])) { for(PxU32 j = 0; j < vehicleWheelQueryResults[i].nbWheelQueryResults; j++) { if(vehicleWheelQueryResults[i].wheelQueryResults[j].tireContactActor) { hitActors.push_back (vehicleWheelQueryResults[i].wheelQueryResults[j].tireContactActor); } } } } delete[] vehicleWheelQueryResults; delete[] wheelQueryResults; }
The following accessors to non-persistent data associated with each wheel have been replaced as follows
- PxVehicleWheelsDynData::getSuspLineStart -> PxWheelQueryResult::suspLineStart
- PxVehicleWheelsDynData::getSuspLineDir -> PxWheelQueryResult::suspLineDir
- PxVehicleWheels::getSuspRaycast -> PxWheelQueryResult::suspLineStart, PxWheelQueryResult::suspLineDir, PxWheelQueryResult::suspLineLength
- PxVehicleWheelsDynData::getTireDrivableSurfaceShape -> PxWheelQueryResult::tireContactShape
- PxVehicleWheelsDynData::getTireDrivableSurfaceMaterial -> PxWheelQueryResult::tireSurfaceMaterial
- PxVehicleWheelsDynData::getTireDrivableSurfaceType -> PxWheelQueryResult::tireSurfaceType
- PxVehicleWheelsDynData::getTireDrivableSurfaceContactPoint -> PxWheelQueryResult::tireContactPoint
- PxVehicleWheelsDynData::getTireDrivableSurfaceContactNormal -> PxWheelQueryResult::tireContactNormal
- PxVehicleWheelsDynData::getTireFriction -> PxWheelQueryResult::tireFriction
- PxVehicleWheelsDynData::getSuspJounce -> PxWheelQueryResult::suspJounce
- PxVehicleWheelsDynData::getSuspensionForce -> PxWheelQueryResult::suspSpringForce
- PxVehicleWheelsDynData::getTireLongitudinalDir -> PxWheelQueryResult::tireLongitudinalDir
- PxVehicleWheelsDynData::getTireLateralDir -> PxWheelQueryResult::tireLateralDir
- PxVehicleWheelsDynData::getTireLongSlip -> PxWheelQueryResult::longitudinalSlip
- PxVehicleWheelsDynData::getTireLatSlip ->PxWheelQueryResult::lateralSlip
- PxVehicleWheelsDynData::getSteer -> PxWheelQueryResult::steerAngle
- PxVehicleWheels::isInAir -> PxWheelQueryResult::isInAir
PxVehicleWheels::setWheelShapeMapping and PxVehicleWheels::getWheelShapeMapping have been moved to PxVehicleWheelsSimData::setWheelShapeMapping and PxVehicleWheelsSimData::getWheelShapeMapping
PxVehicleWheels::setSceneQueryFilterData and PxVehicleWheels::getSceneQueryFilterData have been moved to PxVehicleWheelsSimData::setSceneQueryFilterData and PxVehicleWheelsSimData::getSceneQueryFilterData
PxVehicle4WEnable3WTadpoleMode and PxVehicle4WEnable3WDeltaMode now take an extra function argument: a non-const reference to a PxVehicleWheelsDynData
PxVehicleWheels::isInAir() has been replaced with PxVehicleIsInAir(const PxVehicleWheelQueryResult& vehWheelQueryResults)
PxVehicleDrive4WSmoothAnalogRawInputsAndSetAnalogInputs now takes an extra function argument "const bool isVehicleInAir". This can be calculated using the function PxVehicleIsInAir
To improve api consistency PxVehicleTelemetryData::getNumWheelGraphs is now PxVehicleTelemetryData::getNbWheelGraphs
To improve api consistency PX_MAX_NUM_WHEELS is now PX_MAX_NB_WHEELS
To improve api consistency PxVehicleGraph::eMAX_NUM_TITLE_CHARS is now PxVehicleGraph::eMAX_NB_TITLE_CHARS
PxVehicleTireData::mCamberStiffness has been replaced with PxVehicleTireData::mCamberStiffnessPerUnitGravity. PxVehicleTireData::mCamberStiffnessPerUnitGravity should be set so that it is equivalent to the old value of PxVehicleTireData::mCamberStiffness divided by the magnitude of gravitational acceleration (PxScene::getGravity().magnitude()). The advantage of using PxVehicleTireData::mCamberStiffnessPerUnitGravity is that it independent of length scale.
PxVehicleComputeTireForceDefault has been removed from the public vehicle api. Custom tire shaders that call PxVehicleComputeTireForceDefault are best implemented by taking a copy of PxVehicleComputeTireForceDefault and calling the copy instead.
CCD¶
The mechanism to activate CCD per shape has changed in 3.3. The PxShapeFlag::eUSE_SWEPT_BOUNDS that was used in 3.2 to active swept bounds per shape has been removed. In its place is a new flag PxRigidBodyFlag::eENABLE_CCD that is set per rigid actor. Setting this flag for an actor in 3.3 has approximately the same effect as setting PxShapeFlag::eUSE_SWEPT_BOUNDS on all the actor's shapes in 3.2.
PxPairFlag::eSWEPT_INTEGRATION_LINEAR has been replaced with PxPairFlag::eCCD_LINEAR in PhysX 3.3.
PxSceneFlag::eENABLE_SWEPT_INTEGRATION flag in 3.2 has been replaced with PxSceneFlag::eENABLE_CCD in PhysX 3.3.
A simple example of how to enable CCD on a specific shape is given below. This demonstrates creating a body consisting of a large box and a smaller sphere, where the box is only used in discrete collision detection and the sphere is only used in CCD. The simulation filter shader shown here requires that the filter data of both shapes be flagged with eCCD_RESPONSE to generate a CCD response (PxPairFlag::eCCD_LINEAR). Likewise, the filter shader shown here is configured so that the filter data of both shapes need to be flagged with eDISCRETE_RESPONSE in order to generate a collision response (PxPairFlag::eRESOLVE_CONTACTS). A final remark is that the following shader requires that shapes of static actors have filter data with flags eDISCRETE_RESPONSE | eCCD_RESPONSE in order to ensure ccd and collision response from pairs that involve a static actor and a CCD-enabled dynamic actor:
struct CCDFilterTest { enum FilterFlags { eDISCRETE_RESPONSE = 1 << 0 eCCD_RESPONSE = 1 << 1 }; static PxFilterFlags filterShader( PxFilterObjectAttributes attributes0, PxFilterData filterData0, PxFilterObjectAttributes attributes1, PxFilterData filterData1, PxPairFlags& pairFlags, const void* constantBlock, PxU32 constantBlockSize) { pairFlags = PxPairFlags(0); PxU32 combo = filterData0.word0 & filterData1.word0; if(combo & eDISCRETE_RESPONSE) { pairFlags |= PxPairFlag::eRESOLVE_CONTACTS; } if(combo & eCCD_RESPONSE) { pairFlags |= PxPairFlag::eCCD_LINEAR; } return PxFilterFlags(); } }; .... PxRigidDynamic* dyn = getPhysics().createRigidDynamic(PxTransform(PxVec3(-4, -3.5, 0))); PxBoxGeometry box; box.halfExtents = PxVec3(1.f, 1.f, 1.f); PxSphereGeometry sphere; sphere.radius = 0.75f; PxShape* boxShape = dyn->createShape(box, getDefaultMaterial()); PxShape* sphereShape = dyn->createShape(sphere, getDefaultMaterial()); PxFilterData data = boxShape->getSimulationFilterData(); data.word0 |= CCDFilterTest::eDISCRETE_RESPONSE; boxShape->setSimulationFilterData(data); data = sphereShape->getSimulationFilterData(); data.word0 |= CCDFilterTest::eCCD_RESPONSE; sphereShape->setSimulationFilterData(data); dyn->setRigidBodyFlag(PxRigidBodyFlag::eENABLE_CCD, true); getActiveScene().addActor(*dyn);
PhysX Visual Debugger¶
- A new flag has been introduced to configure the visualizing of constraints:
PxVisualDebuggerFlag::eTRANSMIT_CONSTRAINTS;
- A new function has been introduced to configure PxVisualDebugger flags:
PxVisualDebugger::setVisualDebuggerFlags( PxVisualDebuggerFlags flags);
- A new funtion has been introduced to send error stream to PVD:
PxVisualDebugger::sendErrorMessage((PxErrorCode::Enum code, const char* message, const char* file, PxU32 line);
- The following functions were renamed:
PxVisualDebugger::getPvdConnectionFactory() -> PxVisualDebugger::getPvdConnection(); PxVisualDebugger::getPvdConnection() -> PxVisualDebugger::getPvdDataStream();
- The PVD connect function changed to the same method as previously 3.2 version:
PxVisualDebuggerExt::connect -> PxVisualDebuggerExt::createConnection;
The constraint, contacts and scene queries visualizing can all be configed with PxVisualDebuggerFlag in 3.3. Here is an example for how to enable pvd visualizing the contacts :
mPhysics->getVisualDebugger()->setVisualDebuggerFlags(PxVisualDebuggerFlag::eTRANSMIT_CONTACTS | PxVisualDebuggerFlag::eTRANSMIT_CONSTRAINTS);
PhysX Cloth¶
There have been substantial changes to the PhysX 3.3 cloth solver that improve performance and behavior. This has resulted in a reorganization of how constraints are stored and processed in the cloth fabric. Prior to PhysX 3.3 the cloth solver used fibers to organize edge constraints into independent groups. In PhysX 3.3 it is no longer necessary to decompose constraints into fibers, instead edge constraints now exist individually and are solved in larger, independent sets. Interface changes are detailed below:
Previously there were multiple solver types to choose from for each group of constraints such as eFAST, eSTIFF, eBENDING, etc (previously PxClothPhaseSolverConfig::SolverType). There is now one type of solver for all edge constraints, this is a flexible distance constraint with controls to adjust stiffness within certain ranges of compression and stretch (see PxClothStretchConfig). Behaviors such as bending are now achieved by the way distance constraints are arranged geometrically, rather than through a specialized bending solver.
To reduce stretching a new constraint type has been added called "tether" constraints. These constraints do not act along edges of the mesh, but act as long range attachments between particles that enforce a maximum distance between two points. See PxClothFabric::getTetherAnchors().
Cloth cooking which was previously part of the PxCooking library has been moved to the extension library, see PxClothFabricCooker:
// PhysX 3.2.x cooking->cookClothFabric(meshDesc, gravity, outputStream); // PhysX 3.3 PxClothFabricCooker cooker(meshDesc, gravity, useGeodesicTethers); cooker.save(outputStream, false);
The PxClothCollisionData parameter has been removed from PxPhysx::createCloth(). The collision shapes can now be added after cloth creation using PxCloth::addCollisionSphere and PxCloth::addCollisionCapsule.
PxCloth::wakeUp() does not have a parameter anymore. Use the newly introduced method setWakeCounter() instead to set a specific value.
PxCloth::setDampingCoefficient now takes a PxVec3 instead of a PxReal to specify the damping per axis.
PxCloth::setPhaseSolverConfig() has been renamed to PxCloth::setStretchConfig()
PxCloth::lockClothReadData() has been renamed to PxCloth::lockParticleData()
PxClothFabricTypes.h has been removed, this header has been merged with PxClothFabric.h
RepX Serialization¶
Substantial changes were made to the PhysX 3.3 serialization interface. Handling of collections and references between collections have been unified for RepX and binary serialization.
The RepX and RepXUpgrader libraries have been removed. RepX functionality is now provided through PhysXExtensions.
RepXCollection has been replaced with PxCollection, which is the common collection class for both RepX and binary serialization in 3.3. Collections are now instantiated on deserialization with PxSerialization::createCollectionFromXml(). Empty collections can be created with PxCreateCollection(). Serialization into RepX format is achieved through PxSerialization::serializeCollectionToXml().
TRepXId has been replaced with PxSerialObjectId.
RepXIdToRepXObjectMap and RepXObject have been replaced with new functionality in PxCollection, which now maps between serializable objects and PxSerialObjectId values.
RepXExtension was removed. Serialization and deserialization of serializable types is achieved through the PxRepXSerializer interface.
- RepXUtility and PxToolkit functionality has been replaced with various functions in PxSerialization, PxCollection and PxScene.
- A PxCollection with all PxPhysics-level objects such as shapes, meshes or materials (formally referred to as buffers) can be created using PxCollectionExt::createCollection(PxPhysics&).
- Similarly PxCollectionExt::createCollection(PxScene&) can be used to create a collection of PxScene-level objects.
- Dependencies between objects and collections can be handled with PxSerialization::complete().
- The objects of a collection can be added to a scene with PxScene::addCollection().
- Operations on files are generally handled with abstract interfaces: PxOutputStream and PxInputData. Default implementations are available as PxDefaultFileOutputStream and PxDefaultFileInputData.
RepXUpgrader::upgradeCollection was removed. RepX data can be converted to newer PhysX versions by deserializing and re-serializing a collection: PxSerialization::createCollectionFromXml(), PxSerialization::serializeCollectionToXml().
Serialization functionality requires a PxSerializationRegistry instance which can be created with PxSerialization::createSerializationRegistry().
XML serialization can be configured to store the cooked triangle and convex mesh data along with the plain data for faster loading.
PhysXVehicles supports RepX serialization. PxSerializationRegistry needs to be provided to PxInitVehicleSDK() for vehicle serialization, PxCloseVehicleSDK() for cleanup.
Custom class RepX serialization is supported in 3.3, more information please read Serialization.
Binary Serialization¶
The binary serialization interface has been refactored and unified with the RepX serialization interface.
Most serialization functionality requires an instance of the new class PxSerializationRegistry. It is application managed and can be created with PxSerialization::createSerializationRegistry() and released with PxSerializationRegistry::release().
The base class for serializable types has been renamed from PxSerializable to PxBase. Most of the serialization functionality moved to a separate PxSerializer class. A PxSerializer instance per serializable type is registered in the PxSerializationRegistry. All PhysX and PhysXExtension serializables are registered by default.
- PxCollection has been reworked.
- PxCollection::serialize() and PxCollection::deserialize() were replaced with PxSerialization::createCollectionFromBinary() PxSerialization::serializeCollectionToBinary() in PhysXExtensions.
- PxSerializable::collectForExport() has been replaced with PxCollection::add(). PxSerialzation::complete() helps to add required objects for resolving dependencies. PxSerializable::isSerializable() should be used check whether a collection can be successfully serialized.
PxUserReferences was removed: PxCollection instances can now be used directly to resolve dependencies between collections on deserialization. PxSerialization::complete() supports creating collections with external dependencies to other collections.
PxSerialObjectRef has been replaced with PxSerialObjectId.
PxCollectForExportSDK() and PxCollectForExportScene() functions were replaced with PxCollectionExt::createCollection(PxPhysics& physics) and PxCollectionExt::createCollection(PxScene& scene).
PxDumpMetaData() was replaced with PxSerialization::dumpBinaryMetaData().
The PxBinaryConverter moved from PhysXCooking to PhysXExtensions. PxCooking::createBinaryConverter() was replaced with PxSerialization::createBinaryConverter().
PhysXVehicles supports binary serialization. PxSerializationRegistry needs to be provided to PxInitVehicleSDK() for vehicle serialization, PxCloseVehicleSDK() for cleanup.
Custom class binary serialization is supported in 3.3, more information please read Serialization.
PhysX TaskManager¶
- The pxtask namespace has been removed and all its types are now included in the physx namespace with a Px prefix, for example pxtask::LightCpuTask has become physx::PxLightCpuTask


St. Beuno and the Curlew
Boys who go bird-nesting often wonder why it is so hard to find the nest of the curlew. As a matter of fact it is the fault, as they would consider it, of St. Beuno. When he lived at Clynnog he used to go regularly on Sunday to preach at Llanddwyn, off the coast of Anglesey, walking on the sea with the book of sermons which he used to carry about with him. One Sunday, as he was coming back from Llanddwyn to Clynnog, treading the surface of the sea as if it had been dry land, he dropped his precious writings into the water, and failed to recover them. The saint was much worried, because even for saints the task of writing sermons is a troublesome one.
When he reached dry land he was much relieved to find his book on a stone out of the reach of the tide, with a curlew mounting guard over it. The pious bird had picked it up, and brought it to safety. Thereupon the holy man knelt down and prayed for the protection and favour of the Creator for the curlew. His prayer was heard, and ever since it has been extremely difficult to discover where the long-beaked bird lays its eggs.


[gecode-users] Best practice to use a shared_ptr in a gecode solver
Gustavo Gutierrez
gustavo.ggutierrez at gmail.com
Tue Nov 4 03:58:57 CET 2014
Dear Gecode users,
This is probably a naive question and very related to C++. However, it is
quite related to gecode as well. In my use case I have a shared pointer to
an object that contains all the information of a problem instance. As
usual, the constructor is where the CSP is defined and that object is
passed as an argument to it.
In addition, I implemented a brancher that also require some of the
information pointed by the shared pointer. Note that this infromation is
not actually needed to construct the brancher but when computing a choice.
I have tried several ways to make both the brancher and the shared_pointer
happy with their respective requirements. However I have found myself in
the following situation.
When I add the shared_pointer as an attribute to the brancher I get the
shared pointer reference counter messed up. The reason is that the brancher
does not actually have a destructor and hence the shared_pointer counter is
never decremented and the owned pointer is never destructed at the end of
the solver execution. I tried to explicitly call the destructor of the
shared pointer in the dispose method of the brancher. However, it seems
that the brancher gets copied more times than the dispose method is called.
Is there a way to integrate both approaches smoothly?. Probably I am
overlooking something.
Regards,
Gustavo
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.gecode.org/pipermail/users/attachments/20141103/905e52be/attachment.html>
More information about the users
mailing list


Fecha_Creacion: 2017-12-29T16:08:47.694Z
Dimension: Replacement Dimension
Id_Locacion: 43
Nombre: Alphabetrium
Residentes: ['https://rickandmortyapi.com/api/character/161', 'https://rickandmortyapi.com/api/character/162', 'https://rickandmortyapi.com/api/character/212', 'https://rickandmortyapi.com/api/character/213', 'https://rickandmortyapi.com/api/character/253']
Tipo: Planet
URL: https://rickandmortyapi.com/api/location/43


§605-17 Penalties. Any person violating sections 605-14 to 605-16 shall be guilty of a misdemeanor. [L 1955, c 150, §2; RL 1955, §217-15; HRS §605-17; am L 1972, c 184, §1(i); am L 1975, c 45, pt of §2; am L 2001, c 47, §2]
Case Notes
Penalty for first offense is only a violation. 68 H. 226, 708 P.2d 138 (1985).
Where Oregon law firm did not "practice law within the jurisdiction" of Hawaii, it did not violate §605-14 nor this section; thus, plaintiff could recover fees under §607-14 for services rendered by firm. 87 H. 37, 951 P.2d 487 (1998).


|
Riflexions is hiring. Positions open are immediate. We would be glad if you can refer your connects / friend's to join us and be part of the Riflexions team. |
|
|
Role Profile |
No of Openings |
|---|---|
|
Technical Lead - Banking domain ( 5+ Years of experience) |
1 |
|
Senior Java/ J2EE developers ( 2 - 3 Year experience) |
4 |
|
UI /UX Developer ( 2-3 year experience) |
1 |
|
Business Analyst ( 2-3 Year experience) |
4 |


SceneJS - Super sample anti-aliasing
On platforms that don't implement anti-aliasing on the WebGL context, one can use supersampling
to anti-alias by rendering to a larger canvas and then scaling the canvas down using CSS.
Use the up and down arrow keys to increase or decrease supersampling multiplier for the canvas size.
Current multiplier:
2


This is a Mac Excel FRT record. It stores the information for Filemaker queries.
Record Data
|
Offset |
Field Name |
Size |
Contents |
|
4 |
rt |
2 |
Record type; this matches the BIFF rt in the first two bytes of the record; =08c5h |
|
6 |
grbitFrt |
2 |
FRT flags; must be zero |
|
8 |
grbit |
4 |
Flags |
|
12 |
cchName |
2 |
|
|
14 |
rgchName |
var |
|
The grbit field contains the following option flags:
|
Offset |
Bits |
Mask |
Flag Name |
Contents |
|
0 |
0 |
0001h |
fPrompt |
1= |
|
0 |
15-1 |
FFFEh |
(Reserved) |
Reserved; must be zero |
|
1 |
15-0 |
FFFFh |
(Reserved) |
Reserved; must be zero |


Note: There is no glibc wrapper for this system call; see NOTES.
The flags argument is a bit mask that controls the operation of the call. The following values can be specified in flags:
The high-order bits (corresponding to the mask 0xffff0000) of flags contain the architecture of the to-be-executed kernel. Specify (OR) the constant KEXEC_ARCH_DEFAULT to use the current architecture, or one of the following architecture constants KEXEC_ARCH_386, KEXEC_ARCH_68K, KEXEC_ARCH_X86_64, KEXEC_ARCH_PPC, KEXEC_ARCH_PPC64, KEXEC_ARCH_IA_64, KEXEC_ARCH_ARM, KEXEC_ARCH_S390, KEXEC_ARCH_SH, KEXEC_ARCH_MIPS, and KEXEC_ARCH_MIPS_LE. The architecture must be executable on the CPU of the system.
The entry argument is the physical entry address in the kernel image. The nr_segments argument is the number of segments pointed to by the segments pointer; the kernel imposes an (arbitrary) limit of 16 on the number of segments. The segments argument is an array of kexec_segment structures which define the kernel layout:
struct kexec_segment { void *buf; /* Buffer in user space */ size_t bufsz; /* Buffer length in user space */ void *mem; /* Physical address of kernel */ size_t memsz; /* Physical address length */ };
The kernel image defined by segments is copied from the calling process into previously reserved memory.
The required constants are in the Linux kernel source file linux/kexec.h, which is not currently exported to glibc. Therefore, these constants must be defined manually.
This system call is available only if the kernel was configured with CONFIG_KEXEC.


How to install cls on Windows¶
Some Python libraries may need to be compiled.  This is mostly needed for cryptography libraries. You can find them at:
Once you run the installer you need to check on the choices as shown in the next image.
You will also have to add the following path to the PATH variable:
C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.24.28314\bin\Hostx64\x64\
Make sure you adapt your path based on the current version of this program