A Day at the Races (1937)
Grade: 65
"A Day at the Races" was the Marx Brothers seventh film, and the follow-up to their most successful film, "A Night at the Opera". Much of the cast from "Opera" returns. The formula of mixing comedy skits with a few musical numbers and a romance is repeated.
Margaret Dumont again plays a wealthy woman cynically romanced by Groucho. Dumont is the star patient at a struggling hospital. Groucho Marx is a horse doctor who has conned his way into being chief of staff. The hospital is owned by lovely Maureen O'Sullivan (not to be confused with Maureen O'Hara or Margaret Sullivan), who is romanced by tenor Allan Jones, who owns a race horse named Hi Hat, whose jocky is Harpo Marx.
Sig Ruman, the comic foil from "Opera", shows up as a pompous doctor. He is the subject of one of Groucho's best one-liners, "Don't point that beard at me, it might go off!"
The skits are inconsistent in quality. Groucho buys a stack of books from Chico, and it isn't that funny. When Groucho fakes a long distance phone call from Leonard Ceeley to Florida, it is funny. When the Marx Brothers turn a medical examination into chaos, it is very funny.
As in "Opera", there are some unnecessary musical numbers. Jones may be a fine tenor, but his songs are empty. The big production number featuring dancer Vivien Fay is out of place. Chico and Harpo take turns on a piano, with Chico showing greater skill. Harpo plays the harp, but it isn't funny and never will be. One musical sequence is almost surreal: Harpo plays Pied Piper for about fifty blacks, who dance and sing with much greater energy than their white counterparts.
<EMAIL_ADDRESS>http://members.tripod.com/~Brian_Koller/movies.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


Creating a New Module
How to create a new module using a manual process for undertaking custom module upload. Important. Recommended for experienced DNN module programmers only.
- Navigate to Host > Extensions.
- Click the Create New Module button. This opens the Edit Module Definition page.
- At Create Module From, select New.
- At Owner Folder, click the Add Folder link to create a unique folder inside DesktopModules for your development files.
- In the Folder Name text box, enter a name for the folder.
- Click the Create Folder link. The new folder is selected.
- At Module Folder, select an existing folder or add a new folder for the module by clicking the Add Folder link using the method above.
- At Language, select either C# (C Sharp) or Visual Basic as the language used for this module.
- In the File Name text box, enter the name for the new module.
- In the Module Name text box, enter the name of this module.
- Optional. In the Description text box, enter the module description.
- At Add Test Page?, select from these options:
- Mark the check box to add a test page for the new module. If selected, you will be taken to the test page once the module is created.
- Unmark the check box for no test page.
- Click the Create Module link.


A module for converting CSV to ArcGIS JS API Graphics.
- Source:
Methods
-
<static> csvToGraphicsLayer(csv, delimiter, xName, yName, spatialReference, zName, mName, graphicsLayerOptions) → {external:esri/layers/GraphicsLayer}
-
Converts a CSV string into a GraphicsLayer.
Parameters:
Name Type Argument Default Description csv
string A CSV table. delimiter
string The delimiter that separates the CSV fields. xName
string <optional>
<nullable>
The field name that provides the X values. This can be omitted as long as the X field is named "X", "Long" or "Longitude" (case-insensitive). yName
string <optional>
<nullable>
The field name that provides the Y values.This can be omitted as long as the Y field is named "Y", "Lat" or "Latitude" (case-insensitive). spatialReference
external:SpatialReference <optional>
<nullable>
{"wkid":4326} zName
string <optional>
<nullable>
mName
string <optional>
<nullable>
graphicsLayerOptions
Object <optional>
<nullable>
Options to pass to the GraphicsLayer constructor. - Source:
Returns:
-
<static> csvToPointGraphics(csv, delimiter, xName, yName, spatialReference, zName, mName, perObjectFunction) → {Array.<external:Feature>}
-
Converts a CSV string into an array of point feature objects.
Parameters:
Name Type Argument Default Description csv
string A CSV table. delimiter
string The delimiter that separates the CSV fields. xName
string <optional>
<nullable>
The field name that provides the X values. This can be omitted as long as the X field is named "X", "Long" or "Longitude" (case-insensitive). yName
string <optional>
<nullable>
The field name that provides the Y values.This can be omitted as long as the Y field is named "Y", "Lat" or "Latitude" (case-insensitive). spatialReference
external:SpatialReference <optional>
<nullable>
{"wkid":4326} zName
string <optional>
<nullable>
The field name mName
string <optional>
<nullable>
perObjectFunction
Function <optional>
<nullable>
A function that is called for each object. This function should take a single parameter: the object parsed from a row of CSV data. - Source:
Returns:
- Type
- Array.<external:Feature>


Return back-home
We highly value your Feedback!
Name:
Email:
Comments:
Kindly! Let us know any of your comments ...


Ohio State vs. Penn State Game Time, Spread, Channel, Announcers
by Andrew McCartyArguably the biggest game of the college football weekend will kick off from Columbus on Saturday afternoon.
No. 2 Ohio State hosts No. 8 Penn State in the biggest game of the Big Ten season thus far. The Buckeyes have a clear path to the College Football Playoff, if they can take down the Nittany Lions tomorrow. However, Penn State can insert itself back into the playoff conversation with a huge upset win over Ohio State as well.
Ryan Day and company are the No. 2 team in the nation, but rank first in offense and defense. They can finally prove they’re the top team in the country by demolishing a very capable Penn State team.
Here’s everything you need to know about the Big Ten clash:
Game Time: 12:00 p.m. ET
Channel: FOX
Spread: Ohio State -18.5
Over/Under: 57.5
Announcers: Gus Johnson, Joel Klatt, Jenny Taft
Ohio State enters as a heavy favorite. However, if the last three games between these two teams are any indication, it should be closer than the experts think.
The Buckeyes have won each of the past two games by a total of two points. Penn State took down Ohio State in 2016, by just three points.
Can the Nittany Lions keep this one close?


- Learn 3 web technologies: HTML, CSS, and JS
- Develop page to showcase your interests
- Publish your work to the web
- Have fun!
- Developer tools
- "About Me" HTML page
- Add _style_ with CSS
- Make it interactive with JS
- Add some animations
- Save our progress, publish our work
- Create a "Blog" page
- Embed images, videos, music
- Create a navigation menu
- Create a blog post editor
- Connect our "Blog" to a database
- TBD
Ask your neighbor...
- "What’s your name?"
- What do they hope to learn in this workshop?
- What’s a webpage they think is really cool?
- Find out their favorite music, movie, hobby, or place in NYC...
Share something about your neighbor with the class!
You will need a personal email address!
GitHub - where we will save and publish our code
Cloud9 - an online code editor where we will write our code
Connect our editor to our code storage


The Ethyl Wearable Recovery Device
Your Profile
Your Groups
Your Support
Sharan's Profile
Sharan Juangphanich
USA
Acheivements:
2 Months+
Helped 10+ people
Active member of AA
Hi, I'm hoping to be free from the control of alcohol because my family is important to me.


MuW201: Tangible Computing, 2019
by a second year multimedia and product design student
Progress:
Week 1 - Reflection
Week 2 - Introduction to p5js Functions (and suffering)
Week 3 - Understanding For Loops (and feeling the sense of achievement when you finally do)
Week 4 - Playing with mic.Input (and looking cool)
Week 5 - Arrays (and hell)
Week 6 - Ooh 3D and infinite stuff
Week 7 - More 3D stuff but I decided to focus on my final instead
Week 8 - Project One
Week 14 - Project Two


First Paragraph

Second Paragraph with id="mainPara"
Third Paragraph

Fourth Paragraph


{% extends "blog/base_template.html" %} {% import "macros/tag_widget.html" as tag_widget %} {# Displays a post. Expects three arguments: #} {# `post`: the Post to display. #} {# `next_post`: the post that came after this one (may be None). #} {# `prev_post`: the post that came before this one (may be None). #} {% block content %}
Posted on {{ post.publish_date.strftime('%B %d, %Y') }} by {{ post.author.name }}
{{ prev_post.title }}
{{ next_post.title }}


A2DynamicDelegate Class Reference
| Inherits from | NSProxy |
| Declared in | A2DynamicDelegate.h |
Overview
A2DynamicDelegate implements a class’s delegate, data source, or other delegated protocol by associating protocol methods with a block implementation.
- (IBAction) annoyUser
{
// Create an alert view
UIAlertView *alertView = [[UIAlertView alloc]
initWithTitle: @"Hello World!"
message: @"This alert's delegate is implemented using blocks. That's so cool!"
delegate: nil
cancelButtonTitle: @"Meh."

Tasks
Other Methods
-
– initWithProtocol:
The designated initializer for the A2DynamicDelegate proxy.
-
protocol
The protocol delegating the dynamic delegate.
property -
handlers
A dictionary of custom handlers to be used by custom responders in a A2Dynamic(Protocol Name) subclass of A2DynamicDelegate, like
propertyA2DynamicUIAlertViewDelegate
. -
realDelegate
When replacing the delegate using the A2BlockDelegate extensions, the object responding to classical delegate method implementations.
property
Block Instance Method Implementations
-
– blockImplementationForMethod:
The block that is to be fired when the specified selector is called on the reciever.
-
– implementMethod:withBlock:
Assigns the given block to be fired when the specified selector is called on the reciever.
-
– removeBlockImplementationForMethod:
Disassociates any block so that nothing will be fired when the specified selector is called on the reciever.
Block Class Method Implementations
-
– blockImplementationForClassMethod:
The block that is to be fired when the specified selector is called on the delegating object’s class.
-
– implementClassMethod:withBlock:
Assigns the given block to be fired when the specified selector is called on the reciever.
-
– removeBlockImplementationForClassMethod:
Disassociates any blocks so that nothing will be fired when the specified selector is called on the delegating object’s class.
Properties
handlers
A dictionary of custom handlers to be used by custom responders
in a A2Dynamic(Protocol Name) subclass of A2DynamicDelegate, like
A2DynamicUIAlertViewDelegate
.
@property (nonatomic, strong, readonly) NSMutableDictionary *handlers
Declared In
A2DynamicDelegate.h
Instance Methods
blockImplementationForClassMethod:
The block that is to be fired when the specified selector is called on the delegating object’s class.
- (id)blockImplementationForClassMethod:(SEL)selector
Parameters
- selector
An encoded selector. Must not be NULL.
Return Value
A code block, or nil if no block is assigned.
Declared In
A2DynamicDelegate.h
blockImplementationForMethod:
The block that is to be fired when the specified selector is called on the reciever.
- (id)blockImplementationForMethod:(SEL)selector
Parameters
- selector
An encoded selector. Must not be NULL.
Return Value
A code block, or nil if no block is assigned.
Declared In
A2DynamicDelegate.h
implementClassMethod:withBlock:
Assigns the given block to be fired when the specified selector is called on the reciever.
- (void)implementClassMethod:(SEL)selector withBlock:(id)block
Parameters
- selector
An encoded selector. Must not be NULL.
- block
A code block with the same signature as selector.
Discussion
Warning: Starting with A2DynamicDelegate 2.0, a block will not be checked for a matching signature. A block can have less parameters than the original selector and will be ignored, but cannot have more.
Declared In
A2DynamicDelegate.h
implementMethod:withBlock:
Assigns the given block to be fired when the specified selector is called on the reciever.
- (void)implementMethod:(SEL)selector withBlock:(id)block
Parameters
- selector
An encoded selector. Must not be NULL.
- block
A code block with the same signature as selector.
Discussion
[tableView.dynamicDataSource implementMethod:@selector(numberOfSectionsInTableView:)
withBlock:NSInteger^(UITableView *tableView){
return 2;
}];
Warning: Starting with A2DynamicDelegate 2.0, a block will not be checked for a matching signature. A block can have less parameters than the original selector and will be ignored, but cannot have more.
Declared In
A2DynamicDelegate.h
initWithProtocol:
The designated initializer for the A2DynamicDelegate proxy.
- (id)initWithProtocol:(Protocol *)protocol
Parameters
- protocol
A protocol to which the dynamic delegate should conform.
Return Value
An initialized delegate proxy.
Discussion
An instance of A2DynamicDelegate should generally not be created by the user, but instead by calling a method in NSObject(A2DynamicDelegate). Since delegates are usually weak references on the part of the delegating object, a dynamic delegate would be deallocated immediately after its declaring scope ends. NSObject(A2DynamicDelegate) creates a strong reference.
Declared In
A2DynamicDelegate.h
removeBlockImplementationForClassMethod:
Disassociates any blocks so that nothing will be fired when the specified selector is called on the delegating object’s class.
- (void)removeBlockImplementationForClassMethod:(SEL)selector
Parameters
- selector
An encoded selector. Must not be NULL.
Declared In
A2DynamicDelegate.h


Hi, I'm Joshua Beto. I'm a software developer and recent graduate from UC Riverside with a BS in Computer Science. I'm passionate about computer graphics, programming contests, and spreading CS knowledge to others.
Click on the other sections to find out more about me! (Or just click here to expand everything)


Resetting the grid will erase all history. This action cannot be undone.
Are you sure you want to clear this grid?
Resetting the grid will erase defined electrodes and history. This action cannot be undone.
Are you sure you want to delete this grid?
This action cannot be undone.
An unexpected error occurred.
Cancel
OK
Save
Refresh
Continue


--- layout: archive title: Zulip Chat Archive permalink: /stream/113489-new-members/topic/Prime.20Theorem.20Help.html ---
Here is the theorem I am trying to prove:
Let n > 1. If n has no positive prime factor less than or equal to sqrt(n), then n is prime.
Here is a proof from Hungerford's Abstract Algebra:
Suppose n has the given property but assume that n is not prime. Then n has at least two positive prime factors, say p1 and p2, so that n = p1p2k for some positive integer k. By hypothesis, n has no positive prime divisors less than or equal to sqrt(n). Hence p1 > sqrt(n) and p2 > sqrt(n). Hence n = p1p2k >= p1*p2 >n. Contradiction.
I am new to lean, so I am trying to translate proofs in textbooks for practice. Can anyone please tell me how to translate this proof into Lean code?
Here's the statement:
import data.nat.prime open nat example (n : ℕ) (hn : n > 1) (hp : ∀ p : ℕ, prime p ∧ p ∣ n → p > sqrt n) : prime n := begin sorry end
It's time for bed in London though, so you'll have to look through data.nat.prime for hints.
Should I use an absurd statement for contradiction? If not then what?
Sure, why not? You'd prove X
and not X
and then use absurd
. It's defined in core lean as def absurd {a : Prop} {b : Sort v} (h₁ : a) (h₂ : ¬a) : b
The end result is: from contradictory hypotheses you can summon a proof of anything you want
Can you give an example of how an absurd statement works in lean (I see how it works logically)
In tactic mode, exact absurd h1 h2
where h1
is a proof of some proposition a
and h2
is a proof of not a
axiom up_is_down : Prop example : 1 = 2 → up_is_down := λ h, have h_not : 1 ≠ 2 := dec_trivial, absurd h h_not
So based on the theorem statement of Kevin Buzzard and Hungerford's proof, should I be writing:
exact absurd (not prime) hp ? for my first line of code
no
So then what?
If you cannot do basic logic then trying to prove this theorem is biting off far more than you can chew.
You should start with some Lean tutorial, like the natural number game, or reading Theorem Proving in Lean
Why not try and prove stuff like p ∧ q → q ∧ p
or p → ¬ ¬ p
first?
You need to be able to steer basic logic before you can start doing arithmetic
Last updated: Apr 24 2020 at 19:02 UTC


|
0.9.9 API documenation
|
Include <glm/gtc/matrix_transform.hpp> to use the features of this extension. More...
Functions | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | frustum (T left, T right, T bottom, T top, T near, T far) |
| Creates a frustum matrix with default handedness, using the default handedness and default near and far clip planes definition. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | frustumLH (T left, T right, T bottom, T top, T near, T far) |
| Creates a left handed frustum matrix. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | frustumLH_NO (T left, T right, T bottom, T top, T near, T far) |
| Creates a left handed frustum matrix. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | frustumLH_ZO (T left, T right, T bottom, T top, T near, T far) |
| Creates a left handed frustum matrix. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | frustumNO (T left, T right, T bottom, T top, T near, T far) |
| Creates a frustum matrix using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | frustumRH (T left, T right, T bottom, T top, T near, T far) |
| Creates a right handed frustum matrix. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | frustumRH_NO (T left, T right, T bottom, T top, T near, T far) |
| Creates a right handed frustum matrix. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | frustumRH_ZO (T left, T right, T bottom, T top, T near, T far) |
| Creates a right handed frustum matrix. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | frustumZO (T left, T right, T bottom, T top, T near, T far) |
| Creates a frustum matrix using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | infinitePerspective (T fovy, T aspect, T near) |
| Creates a matrix for a symmetric perspective-view frustum with far plane at infinite with default handedness. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | infinitePerspectiveLH (T fovy, T aspect, T near) |
| Creates a matrix for a left handed, symmetric perspective-view frustum with far plane at infinite. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | infinitePerspectiveRH (T fovy, T aspect, T near) |
| Creates a matrix for a right handed, symmetric perspective-view frustum with far plane at infinite. More... | |
| template<typename T , qualifier Q> | |
| GLM_FUNC_DECL mat< 4, 4, T, Q > | lookAt (vec< 3, T, Q > const &eye, vec< 3, T, Q > const ¢er, vec< 3, T, Q > const &up) |
| Build a look at view matrix based on the default handedness. More... | |
| template<typename T , qualifier Q> | |
| GLM_FUNC_DECL mat< 4, 4, T, Q > | lookAtLH (vec< 3, T, Q > const &eye, vec< 3, T, Q > const ¢er, vec< 3, T, Q > const &up) |
| Build a left handed look at view matrix. More... | |
| template<typename T , qualifier Q> | |
| GLM_FUNC_DECL mat< 4, 4, T, Q > | lookAtRH (vec< 3, T, Q > const &eye, vec< 3, T, Q > const ¢er, vec< 3, T, Q > const &up) |
| Build a right handed look at view matrix. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | ortho (T left, T right, T bottom, T top) |
| Creates a matrix for projecting two-dimensional coordinates onto the screen. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | ortho (T left, T right, T bottom, T top, T zNear, T zFar) |
| Creates a matrix for an orthographic parallel viewing volume, using the default handedness and default near and far clip planes definition. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | orthoLH (T left, T right, T bottom, T top, T zNear, T zFar) |
| Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | orthoLH_NO (T left, T right, T bottom, T top, T zNear, T zFar) |
| Creates a matrix for an orthographic parallel viewing volume using right-handed coordinates. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | orthoLH_ZO (T left, T right, T bottom, T top, T zNear, T zFar) |
| Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | orthoNO (T left, T right, T bottom, T top, T zNear, T zFar) |
| Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | orthoRH (T left, T right, T bottom, T top, T zNear, T zFar) |
| Creates a matrix for an orthographic parallel viewing volume, using right-handed coordinates. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | orthoRH_NO (T left, T right, T bottom, T top, T zNear, T zFar) |
| Creates a matrix for an orthographic parallel viewing volume, using right-handed coordinates. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | orthoRH_ZO (T left, T right, T bottom, T top, T zNear, T zFar) |
| Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | orthoZO (T left, T right, T bottom, T top, T zNear, T zFar) |
| Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspective (T fovy, T aspect, T near, T far) |
| Creates a matrix for a symetric perspective-view frustum based on the default handedness and default near and far clip planes definition. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveFov (T fov, T width, T height, T near, T far) |
| Builds a perspective projection matrix based on a field of view and the default handedness and default near and far clip planes definition. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveFovLH (T fov, T width, T height, T near, T far) |
| Builds a left handed perspective projection matrix based on a field of view. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveFovLH_NO (T fov, T width, T height, T near, T far) |
| Builds a perspective projection matrix based on a field of view using left-handed coordinates. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveFovLH_ZO (T fov, T width, T height, T near, T far) |
| Builds a perspective projection matrix based on a field of view using left-handed coordinates. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveFovNO (T fov, T width, T height, T near, T far) |
| Builds a perspective projection matrix based on a field of view using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveFovRH (T fov, T width, T height, T near, T far) |
| Builds a right handed perspective projection matrix based on a field of view. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveFovRH_NO (T fov, T width, T height, T near, T far) |
| Builds a perspective projection matrix based on a field of view using right-handed coordinates. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveFovRH_ZO (T fov, T width, T height, T near, T far) |
| Builds a perspective projection matrix based on a field of view using right-handed coordinates. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveFovZO (T fov, T width, T height, T near, T far) |
| Builds a perspective projection matrix based on a field of view using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveLH (T fovy, T aspect, T near, T far) |
| Creates a matrix for a left handed, symetric perspective-view frustum. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveLH_NO (T fovy, T aspect, T near, T far) |
| Creates a matrix for a left handed, symetric perspective-view frustum. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveLH_ZO (T fovy, T aspect, T near, T far) |
| Creates a matrix for a left handed, symetric perspective-view frustum. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveNO (T fovy, T aspect, T near, T far) |
| Creates a matrix for a symetric perspective-view frustum using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveRH (T fovy, T aspect, T near, T far) |
| Creates a matrix for a right handed, symetric perspective-view frustum. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveRH_NO (T fovy, T aspect, T near, T far) |
| Creates a matrix for a right handed, symetric perspective-view frustum. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveRH_ZO (T fovy, T aspect, T near, T far) |
| Creates a matrix for a right handed, symetric perspective-view frustum. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | perspectiveZO (T fovy, T aspect, T near, T far) |
| Creates a matrix for a symetric perspective-view frustum using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise. More... | |
| template<typename T , qualifier Q, typename U > | |
| GLM_FUNC_DECL mat< 4, 4, T, Q > | pickMatrix (vec< 2, T, Q > const ¢er, vec< 2, T, Q > const &delta, vec< 4, U, Q > const &viewport) |
| Define a picking region. More... | |
| template<typename T , typename U , qualifier Q> | |
| GLM_FUNC_DECL vec< 3, T, Q > | project (vec< 3, T, Q > const &obj, mat< 4, 4, T, Q > const &model, mat< 4, 4, T, Q > const &proj, vec< 4, U, Q > const &viewport) |
| Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates using default near and far clip planes definition. More... | |
| template<typename T , typename U , qualifier Q> | |
| GLM_FUNC_DECL vec< 3, T, Q > | projectNO (vec< 3, T, Q > const &obj, mat< 4, 4, T, Q > const &model, mat< 4, 4, T, Q > const &proj, vec< 4, U, Q > const &viewport) |
| Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates. More... | |
| template<typename T , typename U , qualifier Q> | |
| GLM_FUNC_DECL vec< 3, T, Q > | projectZO (vec< 3, T, Q > const &obj, mat< 4, 4, T, Q > const &model, mat< 4, 4, T, Q > const &proj, vec< 4, U, Q > const &viewport) |
| Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates. More... | |
| template<typename T , qualifier Q> | |
| GLM_FUNC_DECL mat< 4, 4, T, Q > | rotate (mat< 4, 4, T, Q > const &m, T angle, vec< 3, T, Q > const &axis) |
| Builds a rotation 4 * 4 matrix created from an axis vector and an angle. More... | |
| template<typename T , qualifier Q> | |
| GLM_FUNC_DECL mat< 4, 4, T, Q > | scale (mat< 4, 4, T, Q > const &m, vec< 3, T, Q > const &v) |
| Builds a scale 4 * 4 matrix created from 3 scalars. More... | |
| template<typename T , qualifier Q> | |
| GLM_FUNC_DECL mat< 4, 4, T, Q > | translate (mat< 4, 4, T, Q > const &m, vec< 3, T, Q > const &v) |
| Builds a translation 4 * 4 matrix created from a vector of 3 components. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | tweakedInfinitePerspective (T fovy, T aspect, T near) |
| Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping. More... | |
| template<typename T > | |
| GLM_FUNC_DECL mat< 4, 4, T, defaultp > | tweakedInfinitePerspective (T fovy, T aspect, T near, T ep) |
| Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping. More... | |
| template<typename T , typename U , qualifier Q> | |
| GLM_FUNC_DECL vec< 3, T, Q > | unProject (vec< 3, T, Q > const &win, mat< 4, 4, T, Q > const &model, mat< 4, 4, T, Q > const &proj, vec< 4, U, Q > const &viewport) |
| Map the specified window coordinates (win.x, win.y, win.z) into object coordinates using default near and far clip planes definition. More... | |
| template<typename T , typename U , qualifier Q> | |
| GLM_FUNC_DECL vec< 3, T, Q > | unProjectNO (vec< 3, T, Q > const &win, mat< 4, 4, T, Q > const &model, mat< 4, 4, T, Q > const &proj, vec< 4, U, Q > const &viewport) |
| Map the specified window coordinates (win.x, win.y, win.z) into object coordinates. More... | |
| template<typename T , typename U , qualifier Q> | |
| GLM_FUNC_DECL vec< 3, T, Q > | unProjectZO (vec< 3, T, Q > const &win, mat< 4, 4, T, Q > const &model, mat< 4, 4, T, Q > const &proj, vec< 4, U, Q > const &viewport) |
| Map the specified window coordinates (win.x, win.y, win.z) into object coordinates. More... | |
Include <glm/gtc/matrix_transform.hpp> to use the features of this extension.
Defines functions that generate common transformation matrices.
The matrices generated by this extension use standard OpenGL fixed-function conventions. For example, the lookAt function generates a transform from world space into the specific eye space that the projective matrix functions (perspective, ortho, etc) are designed to expect. The OpenGL compatibility specifications defines the particular layout of this eye space.
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::frustum | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a frustum matrix with default handedness, using the default handedness and default near and far clip planes definition.
To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::frustumLH | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a left handed frustum matrix.
If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::frustumLH_NO | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a left handed frustum matrix.
The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::frustumLH_ZO | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a left handed frustum matrix.
The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::frustumNO | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a frustum matrix using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::frustumRH | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a right handed frustum matrix.
If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::frustumRH_NO | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a right handed frustum matrix.
The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::frustumRH_ZO | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a right handed frustum matrix.
The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::frustumZO | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a frustum matrix using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::infinitePerspective | ( | T | fovy, |
| T | aspect, | ||
| T | near | ||
| ) |
Creates a matrix for a symmetric perspective-view frustum with far plane at infinite with default handedness.
| fovy | Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. |
| aspect | Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::infinitePerspectiveLH | ( | T | fovy, |
| T | aspect, | ||
| T | near | ||
| ) |
Creates a matrix for a left handed, symmetric perspective-view frustum with far plane at infinite.
| fovy | Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. |
| aspect | Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::infinitePerspectiveRH | ( | T | fovy, |
| T | aspect, | ||
| T | near | ||
| ) |
Creates a matrix for a right handed, symmetric perspective-view frustum with far plane at infinite.
| fovy | Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. |
| aspect | Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, Q> glm::lookAt | ( | vec< 3, T, Q > const & | eye, |
| vec< 3, T, Q > const & | center, | ||
| vec< 3, T, Q > const & | up | ||
| ) |
Build a look at view matrix based on the default handedness.
| eye | Position of the camera |
| center | Position where the camera is looking at |
| up | Normalized up vector, how the camera is oriented. Typically (0, 0, 1) |
| GLM_FUNC_DECL mat<4, 4, T, Q> glm::lookAtLH | ( | vec< 3, T, Q > const & | eye, |
| vec< 3, T, Q > const & | center, | ||
| vec< 3, T, Q > const & | up | ||
| ) |
Build a left handed look at view matrix.
| eye | Position of the camera |
| center | Position where the camera is looking at |
| up | Normalized up vector, how the camera is oriented. Typically (0, 0, 1) |
| GLM_FUNC_DECL mat<4, 4, T, Q> glm::lookAtRH | ( | vec< 3, T, Q > const & | eye, |
| vec< 3, T, Q > const & | center, | ||
| vec< 3, T, Q > const & | up | ||
| ) |
Build a right handed look at view matrix.
| eye | Position of the camera |
| center | Position where the camera is looking at |
| up | Normalized up vector, how the camera is oriented. Typically (0, 0, 1) |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::ortho | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top | ||
| ) |
Creates a matrix for projecting two-dimensional coordinates onto the screen.
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::ortho | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | zNear, | ||
| T | zFar | ||
| ) |
Creates a matrix for an orthographic parallel viewing volume, using the default handedness and default near and far clip planes definition.
To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::orthoLH | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | zNear, | ||
| T | zFar | ||
| ) |
Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::orthoLH_NO | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | zNear, | ||
| T | zFar | ||
| ) |
Creates a matrix for an orthographic parallel viewing volume using right-handed coordinates.
The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::orthoLH_ZO | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | zNear, | ||
| T | zFar | ||
| ) |
Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::orthoNO | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | zNear, | ||
| T | zFar | ||
| ) |
Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::orthoRH | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | zNear, | ||
| T | zFar | ||
| ) |
Creates a matrix for an orthographic parallel viewing volume, using right-handed coordinates.
If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::orthoRH_NO | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | zNear, | ||
| T | zFar | ||
| ) |
Creates a matrix for an orthographic parallel viewing volume, using right-handed coordinates.
The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::orthoRH_ZO | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | zNear, | ||
| T | zFar | ||
| ) |
Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::orthoZO | ( | T | left, |
| T | right, | ||
| T | bottom, | ||
| T | top, | ||
| T | zNear, | ||
| T | zFar | ||
| ) |
Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspective | ( | T | fovy, |
| T | aspect, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a matrix for a symetric perspective-view frustum based on the default handedness and default near and far clip planes definition.
To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
| fovy | Specifies the field of view angle in the y direction. Expressed in radians. |
| aspect | Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveFov | ( | T | fov, |
| T | width, | ||
| T | height, | ||
| T | near, | ||
| T | far | ||
| ) |
Builds a perspective projection matrix based on a field of view and the default handedness and default near and far clip planes definition.
To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
| fov | Expressed in radians. |
| width | Width of the viewport |
| height | Height of the viewport |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveFovLH | ( | T | fov, |
| T | width, | ||
| T | height, | ||
| T | near, | ||
| T | far | ||
| ) |
Builds a left handed perspective projection matrix based on a field of view.
If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| fov | Expressed in radians. |
| width | Width of the viewport |
| height | Height of the viewport |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveFovLH_NO | ( | T | fov, |
| T | width, | ||
| T | height, | ||
| T | near, | ||
| T | far | ||
| ) |
Builds a perspective projection matrix based on a field of view using left-handed coordinates.
The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| fov | Expressed in radians. |
| width | Width of the viewport |
| height | Height of the viewport |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveFovLH_ZO | ( | T | fov, |
| T | width, | ||
| T | height, | ||
| T | near, | ||
| T | far | ||
| ) |
Builds a perspective projection matrix based on a field of view using left-handed coordinates.
The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
| fov | Expressed in radians. |
| width | Width of the viewport |
| height | Height of the viewport |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveFovNO | ( | T | fov, |
| T | width, | ||
| T | height, | ||
| T | near, | ||
| T | far | ||
| ) |
Builds a perspective projection matrix based on a field of view using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| fov | Expressed in radians. |
| width | Width of the viewport |
| height | Height of the viewport |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveFovRH | ( | T | fov, |
| T | width, | ||
| T | height, | ||
| T | near, | ||
| T | far | ||
| ) |
Builds a right handed perspective projection matrix based on a field of view.
If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| fov | Expressed in radians. |
| width | Width of the viewport |
| height | Height of the viewport |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveFovRH_NO | ( | T | fov, |
| T | width, | ||
| T | height, | ||
| T | near, | ||
| T | far | ||
| ) |
Builds a perspective projection matrix based on a field of view using right-handed coordinates.
The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| fov | Expressed in radians. |
| width | Width of the viewport |
| height | Height of the viewport |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveFovRH_ZO | ( | T | fov, |
| T | width, | ||
| T | height, | ||
| T | near, | ||
| T | far | ||
| ) |
Builds a perspective projection matrix based on a field of view using right-handed coordinates.
The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
| fov | Expressed in radians. |
| width | Width of the viewport |
| height | Height of the viewport |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveFovZO | ( | T | fov, |
| T | width, | ||
| T | height, | ||
| T | near, | ||
| T | far | ||
| ) |
Builds a perspective projection matrix based on a field of view using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
| fov | Expressed in radians. |
| width | Width of the viewport |
| height | Height of the viewport |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveLH | ( | T | fovy, |
| T | aspect, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a matrix for a left handed, symetric perspective-view frustum.
If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| fovy | Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. |
| aspect | Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveLH_NO | ( | T | fovy, |
| T | aspect, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a matrix for a left handed, symetric perspective-view frustum.
The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| fovy | Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. |
| aspect | Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveLH_ZO | ( | T | fovy, |
| T | aspect, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a matrix for a left handed, symetric perspective-view frustum.
The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
| fovy | Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. |
| aspect | Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveNO | ( | T | fovy, |
| T | aspect, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a matrix for a symetric perspective-view frustum using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| fovy | Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. |
| aspect | Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveRH | ( | T | fovy, |
| T | aspect, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a matrix for a right handed, symetric perspective-view frustum.
If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition) Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| fovy | Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. |
| aspect | Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveRH_NO | ( | T | fovy, |
| T | aspect, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a matrix for a right handed, symetric perspective-view frustum.
The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| fovy | Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. |
| aspect | Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveRH_ZO | ( | T | fovy, |
| T | aspect, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a matrix for a right handed, symetric perspective-view frustum.
The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
| fovy | Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. |
| aspect | Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::perspectiveZO | ( | T | fovy, |
| T | aspect, | ||
| T | near, | ||
| T | far | ||
| ) |
Creates a matrix for a symetric perspective-view frustum using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
| fovy | Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. |
| aspect | Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far | Specifies the distance from the viewer to the far clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, Q> glm::pickMatrix | ( | vec< 2, T, Q > const & | center, |
| vec< 2, T, Q > const & | delta, | ||
| vec< 4, U, Q > const & | viewport | ||
| ) |
Define a picking region.
| center | Specify the center of a picking region in window coordinates. |
| delta | Specify the width and height, respectively, of the picking region in window coordinates. |
| viewport | Rendering viewport |
| T | Native type used for the computation. Currently supported: half (not recommended), float or double. |
| U | Currently supported: Floating-point types and integer types. |
| GLM_FUNC_DECL vec<3, T, Q> glm::project | ( | vec< 3, T, Q > const & | obj, |
| mat< 4, 4, T, Q > const & | model, | ||
| mat< 4, 4, T, Q > const & | proj, | ||
| vec< 4, U, Q > const & | viewport | ||
| ) |
Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates using default near and far clip planes definition.
To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
| obj | Specify the object coordinates. |
| model | Specifies the current modelview matrix |
| proj | Specifies the current projection matrix |
| viewport | Specifies the current viewport |
| T | Native type used for the computation. Currently supported: half (not recommended), float or double. |
| U | Currently supported: Floating-point types and integer types. |
| GLM_FUNC_DECL vec<3, T, Q> glm::projectNO | ( | vec< 3, T, Q > const & | obj, |
| mat< 4, 4, T, Q > const & | model, | ||
| mat< 4, 4, T, Q > const & | proj, | ||
| vec< 4, U, Q > const & | viewport | ||
| ) |
Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| obj | Specify the object coordinates. |
| model | Specifies the current modelview matrix |
| proj | Specifies the current projection matrix |
| viewport | Specifies the current viewport |
| T | Native type used for the computation. Currently supported: half (not recommended), float or double. |
| U | Currently supported: Floating-point types and integer types. |
| GLM_FUNC_DECL vec<3, T, Q> glm::projectZO | ( | vec< 3, T, Q > const & | obj, |
| mat< 4, 4, T, Q > const & | model, | ||
| mat< 4, 4, T, Q > const & | proj, | ||
| vec< 4, U, Q > const & | viewport | ||
| ) |
Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
| obj | Specify the object coordinates. |
| model | Specifies the current modelview matrix |
| proj | Specifies the current projection matrix |
| viewport | Specifies the current viewport |
| T | Native type used for the computation. Currently supported: half (not recommended), float or double. |
| U | Currently supported: Floating-point types and integer types. |
| GLM_FUNC_DECL mat<4, 4, T, Q> glm::rotate | ( | mat< 4, 4, T, Q > const & | m, |
| T | angle, | ||
| vec< 3, T, Q > const & | axis | ||
| ) |
Builds a rotation 4 * 4 matrix created from an axis vector and an angle.
| m | Input matrix multiplied by this rotation matrix. |
| angle | Rotation angle expressed in radians. |
| axis | Rotation axis, recommended to be normalized. |
| T | Value type used to build the matrix. Supported: half, float or double. |
| GLM_FUNC_DECL mat<4, 4, T, Q> glm::scale | ( | mat< 4, 4, T, Q > const & | m, |
| vec< 3, T, Q > const & | v | ||
| ) |
Builds a scale 4 * 4 matrix created from 3 scalars.
| m | Input matrix multiplied by this scale matrix. |
| v | Ratio of scaling for each axis. |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, Q> glm::translate | ( | mat< 4, 4, T, Q > const & | m, |
| vec< 3, T, Q > const & | v | ||
| ) |
Builds a translation 4 * 4 matrix created from a vector of 3 components.
| m | Input matrix multiplied by this translation matrix. |
| v | Coordinates of a translation vector. |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. #include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
...
// m[0][0] == 1.0f, m[0][1] == 0.0f, m[0][2] == 0.0f, m[0][3] == 0.0f
// m[1][0] == 0.0f, m[1][1] == 1.0f, m[1][2] == 0.0f, m[1][3] == 0.0f
// m[2][0] == 0.0f, m[2][1] == 0.0f, m[2][2] == 1.0f, m[2][3] == 0.0f
// m[3][0] == 1.0f, m[3][1] == 1.0f, m[3][2] == 1.0f, m[3][3] == 1.0f
|
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::tweakedInfinitePerspective | ( | T | fovy, |
| T | aspect, | ||
| T | near | ||
| ) |
Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
| fovy | Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. |
| aspect | Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL mat<4, 4, T, defaultp> glm::tweakedInfinitePerspective | ( | T | fovy, |
| T | aspect, | ||
| T | near, | ||
| T | ep | ||
| ) |
Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
| fovy | Specifies the field of view angle, in degrees, in the y direction. Expressed in radians. |
| aspect | Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). |
| near | Specifies the distance from the viewer to the near clipping plane (always positive). |
| ep | Epsilon |
| T | Value type used to build the matrix. Currently supported: half (not recommended), float or double. |
| GLM_FUNC_DECL vec<3, T, Q> glm::unProject | ( | vec< 3, T, Q > const & | win, |
| mat< 4, 4, T, Q > const & | model, | ||
| mat< 4, 4, T, Q > const & | proj, | ||
| vec< 4, U, Q > const & | viewport | ||
| ) |
Map the specified window coordinates (win.x, win.y, win.z) into object coordinates using default near and far clip planes definition.
To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
| win | Specify the window coordinates to be mapped. |
| model | Specifies the modelview matrix |
| proj | Specifies the projection matrix |
| viewport | Specifies the viewport |
| T | Native type used for the computation. Currently supported: half (not recommended), float or double. |
| U | Currently supported: Floating-point types and integer types. |
| GLM_FUNC_DECL vec<3, T, Q> glm::unProjectNO | ( | vec< 3, T, Q > const & | win, |
| mat< 4, 4, T, Q > const & | model, | ||
| mat< 4, 4, T, Q > const & | proj, | ||
| vec< 4, U, Q > const & | viewport | ||
| ) |
Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
| win | Specify the window coordinates to be mapped. |
| model | Specifies the modelview matrix |
| proj | Specifies the projection matrix |
| viewport | Specifies the viewport |
| T | Native type used for the computation. Currently supported: half (not recommended), float or double. |
| U | Currently supported: Floating-point types and integer types. |
| GLM_FUNC_DECL vec<3, T, Q> glm::unProjectZO | ( | vec< 3, T, Q > const & | win, |
| mat< 4, 4, T, Q > const & | model, | ||
| mat< 4, 4, T, Q > const & | proj, | ||
| vec< 4, U, Q > const & | viewport | ||
| ) |
Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
| win | Specify the window coordinates to be mapped. |
| model | Specifies the modelview matrix |
| proj | Specifies the projection matrix |
| viewport | Specifies the viewport |
| T | Native type used for the computation. Currently supported: half (not recommended), float or double. |
| U | Currently supported: Floating-point types and integer types. |


Intro
I needed simple responsive backgrounds for more than one project and I haven't found a utility that is flexible enough or fit my needs, so I wrote one.
Features
- AMD support
- Small foot print: 803 bytes (minified)
- Simple usage (srcset style)
- Passes validation
- Modern Browser support only
- Does what it does and nothing more
Excluded by design
- Events (on load and resize): Use your favourite framework, library or vanilla js function or whatever you like for that.
- Throttling events: I'd suggest something like lodash's _.throttle() but it's up to you.
- CSS defaults: Use your own CSS as you need it.
Getting started
Clone Repository, download or install via npm install --save-dev srcsetbg
Markup
<div class="srcsetbg"
data-srcset="img/xs.png 420w, img/s.png 780w, img/m.png 1024w, img/l.png 1400w, img/xl.png 1920w">
Note: the script uses the ℕw param as maximum width with one execption: the largest param is used as minimum width.
JS
Once included the script is included and the markup is ready, just run:
ctrlSrcSetBg();
By default the script looks for elements, that contains the class name srcsetbg.
Of course you can override the class name like so: ctrlSrcSetBg('my-own-selector');
A little bit more advanced but not that much
The script just uses the data-srcset attribtue to extracts and map the values and set one of them as background image. If you use an event listener for the 'resize' event, you may want to throttle the execution, because events can be expensive.
Example
AMD/jQuery/lodash/Coffeescript:
# require libs/modules
_ = require 'lodash'
$ = require 'jquery'
srcsetbg = require 'ctrl-srcsetbg' # set custom CSS selector
# init event listeners
$(window).on('resize', _.throttle(srcsetbg, 50)) # throttle the resize event
$(window).on('ready', srcsetbg) # this one needs no throttling


Inheritance diagram for IITLibraryPlaylist:
A library playlist consists of all the tracks in a user's library.
For convenience, you can retrieve the main library playlist using IiTunes::LibraryPlaylist().
Public Member Functions | |
Methods | |
| HRESULT | AddFile ([in] BSTR filePath,[out, retval] IITOperationStatus **iStatus) |
| Add a file or files inside a folder to the playlist. | |
| HRESULT | AddFiles ([in] VARIANT *filePaths,[out, retval] IITOperationStatus **iStatus) |
| Add an array of files and/or folders to the playlist. | |
| HRESULT | AddURL ([in] BSTR url,[out, retval] IITURLTrack **iURLTrack) |
| Add a streaming audio URL to the playlist. | |
| HRESULT | AddTrack ([in] VARIANT *iTrackToAdd,[out, retval] IITTrack **iAddedTrack) |
| Add an existing track to the playlist. |
|
|
Add a file or files inside a folder to the playlist. You cannot use this method to add a file that requires conversion to be added (e.g. a CD track), use IiTunes::ConvertFile() or IiTunes::ConvertFile2() instead. If you add a folder that contains files that require conversion, they will be skipped.
|
|
|
Add an array of files and/or folders to the playlist. You cannot use this method to add a file that requires conversion to be added (e.g. a CD track), use IiTunes::ConvertFile() or IiTunes::ConvertFile2() instead. If you add a folder that contains files that require conversion, they will be skipped.
|
|
|
Add an existing track to the playlist. You cannot use this method to add a CD track (ITTrackKindCD) to another playlist, use IiTunes::ConvertTrack() instead. or IiTunes::ConvertTrack2() instead. You cannot add a shared library track (ITTrackKindSharedLibrary) to another playlist.
|
|
|
Add a streaming audio URL to the playlist.
|