pandatest

Introduction to Panda3D
Panda3D Basics
Panda3D is not a Beginner’s Tool or a Toy
Panda3D’s Software License
Who is Working on Panda3D
The Introductory Chapter
Installing Panda3D in Windows
Installing Panda3D in Linux
The Installation Process - Linux
General Preparation
Learning Python
Running your Program
Using Command Prompt to Run your Program
A Panda3D Hello World Tutorial
Starting Panda3D
Creating a New Panda3D Application
- showbase
- DirectStart
Running the Program
Loading the Grassy Scenery
- the-scene-graph
- The Program
  - Update the Code
  - Run the Program
Controlling the Camera
- Default Camera Control System
- tasks
  - Update the Code
  - Run the Program
Loading and Animating the Panda Model
- Actors
  - Run the Program
The Program
- Update the Code
Using Intervals to move the Panda
- Intervals and Sequences
  - intervals
- The Program
  - Update the Code
  - Run the Program
Tutorial End
User Contributed Tutorials and Examples
Video Tutorials
- Video lessons by Disney
Programming with Panda3D
ShowBase
Overview
Global Variables with __builtin__
The Scene Graph
Scene Graph Manipulations
The default scene graphs
Loading models
Reparenting nodes and models
Common State Changes
Summary
State Change Cheat Sheet
Manipulating a Piece of a Model
Animated (skeleton animation) models
Unanimated (environment) models
Searching the Scene Graph
Instancing
Advanced Instancing
Instancing: an Important Caveat
The NodePath: a Pointer to a Node plus a Unique Instance ID
The Configuration File
Configuring Panda3D
List of All Config Variables
Accessing Config Vars in a Program
Models and Actors
Geometry Basics
Panda’s Primary File Format
Panda’s Other File Format
Loading Models
The Basics
Inserting the Model into the Scene Graph
Panda Filename Syntax
Loading Actors and Animations
Actor Basics
Using Actors
Panda Filename Syntax
Actor Animations
Basic animation playing
AnimControl
Play rate
Blending
Half-body animation
Interpolation
Actor Intervals
The Task manager
Multi-Part Actors
Animation
Attaching an Object to a Joint
Controlling a Joint Procedurally
Cautions and limitations
Level of Detail
Render Attributes
Render Attributes Basics
Propagation of Attributes
Render Attribute Priorities
Incomplete Section
List of All Attributes
- List of All Attributes
- Undocumented
Incomplete Section
Lighting
Materials
Depth Test and Depth Write
Enabling or Disabling the Depth Buffer
Altering the Depth Buffer
Depth Sorting
Transparency
Fog
- Basic Fog
- Fog Modes
  - Linear Fog
  - Exponential Fog
Alpha Testing
- Alpha Testing
Incomplete Section
Color Write Masks
- Color Write Masks
- Turning on the Color Mask
Antialiasing
Antialiasing
Clip Planes
General Warning about Clip Planes
Incomplete Section
Tinting and Recoloring
Backface Culling and Frontface Culling
Occlusion Culling
Polygon Occluder Culling
Polygon Occluders
Portal Culling
Portal Culling
- What is Portal Culling?
- How are Cells and Portals handled in Panda3D?
Incomplete Section
Light Ramps
Auxiliary Bitplane Control
- Auxiliary Bitplane Control
Values That Can be Requested
Texturing
Simple Texturing
Choosing a Texture Size
Texture Wrap Modes
Texture Filter Types
FTNearest
FTLinear
Mipmaps
Anisotropic Filtering
Simple Texture Replacement
Multitexture Introduction
Texture Modes
The Basics
Modulate mode
Add mode
Replace mode
Decal mode
Blend mode
Normal Map Mode
Height / Parallax Map Mode
Gloss Map Mode
Glow Map Mode
Texture Order
Texture Combine Modes
RGB modes
Alpha modes
Source values
Operands
Texture Transforms
Multiple Texture Coordinate Sets
Automatic Texture Coordinates
Projected Textures
Interval-animated texture transforms
Projected Textures
Simple Environment Mapping
Cube Maps
Environment Mapping with Cube Maps
Automatic Texture Animation
Playing MPG and AVI files
Usage
For powers-of-two limited graphics hardware
Issues
Transparency and Blending
Texture Management
Texture Compression
Shaders
Shader Basics
List of Possible Cg Shader Inputs
- Using Custom Shader Inputs
List of GLSL Shader Inputs
- Vertex shader attributes
  - A special note about vertex colors
- Uniform shader inputs
Shaders and Coordinate Spaces
Known Shader Bugs and Limitations
The Shader Generator
The Shader Generator
Sample Programs
Per-Pixel Lighting
Known Limitations
How the Shader Generator Works
Caching and the Shader Generator
Combining Automatic Shaders with Manual Shaders
Creating your own Shader Generator
Cg Shader Tutorial
Cg Shader Tutorials
Pre-requisites
Tutorials
Incomplete Section
Cg Tutorial Part 1
Cg Tutorial Part 1: The Baseline Panda App
3D Models, Shaders and Hardware
Modifying the Script
Cg Tutorial Part 2
Cg Tutorial Part 2: The Simplest Shader
The Shader
The Python Script
Modifying the Shader
Compute Shaders
Camera Control
The Default Camera Driver
Lenses and Field of View
Interplay of lens properties
Orthographic Lenses
Sound
Loading and Playing Sounds and Music
- Architecture
- Basics
Extra Note
Manipulating Sounds
Looping a Sound
Notes on Looping Sounds Seamlessly
Cueing Time
Changing Playback Speed
Audio Managers
DSP Effects
The FilterProperties Object
Multi-Channel
Summary
Incomplete Section
Intervals
Using Intervals
Lerp Intervals
An overview of the NodePath-based LerpIntervals
The rest of the NodePath-based LerpIntervals
Other types of LerpInterval
Function Intervals
Actor Intervals
Sound Intervals
Motion Path and Particle Intervals
MopathInterval
ParticleInterval
Sequences and Parallels
Position, Rotation and Scale Intervals
Projectile Intervals
Tasks and Event Handling
Tasks
The Task Function
Task Return Values
The Do-Later Task
The Task Object
The Task Manager
Task timing
Examples
Task Chains
- Defining task chains
- Using task chains
Event Handlers
Defining a class that can Handle Events
Event Handling Functions
Sending Custom Events
A Note on Object Management
Main Loop
Text and Image Rendering
International character sets
Text Fonts
Text Node
Font
Small Caps
Slant
Shadow
Wordwrap
Alignment
Frame
Card
Picking a Text Node
OnscreenText
OnscreenImage
Embedded Text Properties
Defining your text properties
Registering the new TextProperties objects
Referencing the TextProperties in text strings
DirectGUI
DirectButton
Example
DirectCheckButton
Example
A note on programatically changing the indicatorValue
A note on boxImage and other box* keywords
DirectRadioButton
Example
DirectDialog
YesNo Dialog Example
DirectEntry
Example
DirectFrame
DirectLabel
DirectOptionMenu
Example
Dynamic Updating of a Menu
DirectScrolledList
DirectWaitBar
Example
DirectSlider
Example
DirectScrollBar
DirectScrolledFrame
Render Effects
List of All Render Effects:
Compass Effects
Billboard Effects
Finite State Machines
FSM Introduction
Simple FSM Usage
Arguments to enterStateName methods
Allowed and disallowed state transitions
FSM with input
The defaultFilter method
Advanced FSM Tidbits
request vs. demand
FSM.AlreadyInTransition
forceTransition()
Filtering the optional arguments
Terrain
The Heightfield Tesselator
Incomplete Section
Geometrical MipMapping
Basic Usage
Dynamic Terrains
Advanced Control
Notes
Advanced operations with Panda3D’s internal structures
How Panda3D Stores Vertices and Geometry
GeomVertexData
GeomVertexFormat
GeomPrimitive
GeomTriangles
GeomTristrips
GeomTrifans
GeomLines
GeomLinestrips
GeomPoints
Geom
GeomNode
BoundingVolume
Procedurally Generating 3D Models
Defining your own GeomVertexFormat
Pre-defined vertex formats
Creating and filling a GeomVertexData
Creating the GeomPrimitive objects
Putting your new geometry in the scene graph
Other Vertex and Model Manipulation
Reading existing geometry data
Modifying existing geometry data
MeshDrawer
More about GeomVertexReader, GeomVertexWriter, and GeomVertexRewriter
GeomVertexRewriter
Creating New Textures from Scratch
The PNMImage Class
Getting the Image of a Texture
Loading a PNMImage Into a Texture
Writing 3D Models out to Disk
- BAM Files
The Bam Interface
The Egg Interface
Render-to-Texture and Image Postprocessing
Render-to-Texture Basics
The Low-Level API and the High-Level Utilities
Common Image Filters
Common Image Filters
Basic Setup
What if the Video Card can’t handle it?
The Bloom Filter
The Cartoon Inking Filter
The Volumetric Lighting Filter
The Inverted Filter
The Blur / Sharpen Filter
The Ambient Occlusion Filter
Generalized Image Filters
The Filter Manager
The Simplest Filter
Extracting More Information from the Scene
Using Intermediate Stages
Resolution Management
Cleaning Up
Dynamic Cube Maps
A word of caution
Low-Level Render to Texture
Incomplete Section
Panda3D Rendering Process
Multithreaded Render Pipeline
- Enabling the Multithreaded Render Pipeline
Introducing Graphics Classes
The Graphics Pipe
Creating Windows and Buffers
Display Regions
Example code
Creating New MouseWatchers for Display Regions
Clearing Display Regions
- Sorting
The 2D Display Region
- DirectGui in your new window
Stereo Display Regions
- Using a StereoDisplayRegion
Multi-Pass Rendering
Multi-Pass Rendering
How to Control Render Order
Panda3D Utility Functions
Particle Effects
Using the Particle Panel
Incomplete Section
Loading Particle Systems
Particle Effect Basic Parameters
Particle Factories
Particle Emitters
BoxEmitter
DiscEmitter
PointEmitter
RectangleEmitter
RingEmitter
SphereSurfaceEmitter
SphereVolumeEmitter
TangentRingEmitter
Particle Renderers
PointParticleRenderer
LineParticleRenderer
SparkleParticleRenderer
SpriteParticleRenderer
GeomParticleRenderer
Collision Detection
Collision Solids
CollisionSphere
CollisionTube
CollisionInvSphere
CollisionPlane
CollisionPolygon
CollisionRay
CollisionLine
CollisionSegment
CollisionParabola
CollisionBox
Collision System Chart
Collision Handlers
CollisionHandlerQueue
CollisionHandlerEvent
CollisionHandlerPusher
PhysicsCollisionHandler
CollisionHandlerFloor
Collision Entries
Collision Traversers
Collision Bitmasks
Rapidly-Moving Objects
Visualizing the previous transform
Caveats
Pusher Example
Event Example
Bitmask Example
Clicking on 3D Objects
Garbage Collection
Removing Custom Class Instances
Hardware support
Keyboard Support
Mouse Support
Joystick Support
VR Helmets and Trackers
Math Engine
Incomplete Section
Matrix Representation
Physics
Panda3D Physics Engine
Enabling physics on a node
Applying physics to a node
Example 1: Gravity
Example 2: Rotary Thruster
Types of forces
- LinearVectorForce
- AngularVectorForce
Notes and caveats
Using ODE with Panda3D
Table of Contents
More information
Worlds, Bodies and Masses
Worlds
Bodies and masses
Simulating the Physics World
Simulating the physics scene
Incomplete Section
Attaching Bodies using Joints
Joints
OdeBallJoint example
Incomplete Section
Collision Detection with ODE
Collision Detection
Spaces
Geometry
Surfaces
Collision Events
Example
Using Bullet with Panda3D
Table of Contents
Bullet Hello World
Bullet Debug Renderer
Bullet Collision Shapes
Bullet Collision Filtering
Bullet Continuous Collision Detection
Bullet Queries
Bullet Ghosts
Bullet Character Controller
- Setup
- Moving
- Jumping
- Crouching
Bullet Constraints
Bullet Vehicles
Bullet Softbodies
Bullet Softbody Rope
Bullet Softbody Patch
- Setup
- Visualisation
Bullet Softbody Triangles
- Setup
- Visualisation
Bullet Softbody Tetrahedron
- Setup
- Visualisation
Bullet Softbody Config
- btSoftBody::Material vs. BulletSoftBodyMaterial:
- btSoftBody::Config vs. BulletSoftBodyConfig
Bullet Config Options
Bullet FAQ
- Bullet and Scale
Bullet Samples
- Stack of cubes falling on top of each other:
Motion Paths
Timing
The Global Clock
Incomplete Section
Networking
Datagram Protocol
Client-Server Connection
Preparing the server for connection
Connecting with a client
Transmitting Data
Sending a message
Receiving a message
Downloading a File
Distributed Networking
Multifiles
Creating Multifiles
The multify program
Read Assets
Multifile objects
Subfiles
Stream-Based
Encryption
Patching
Loading resources from nonstandard sources
File Reading
Thread-safe file I/O
Incomplete Section
Threading
Asynchronous Operations
Model loading
Model flattening
Texture uploading
Animation loading
Threading
File I/O
Compiling Panda3D with threading support
Subclassing
Table of features supported per graphic renderer
Artificial Intelligence (PANDAI)
Getting Started
Steering Behaviors
Seek
Flee
Pursue
Evade
Wander
Flock
Obstacle Avoidance
Path Follow
Pathfinding
Mesh Generation
Static Obstacles
Dynamic Obstacles
Uneven Terrain
Source Codes
Distributing Panda3D Applications
Introduction to p3d files
Using packp3d
Referencing packages
Running p3d files
Distributing via the web
Embedding with an object element
Embedding with RunPanda3D
About certificates
Public key, private key
Self-signed certificates
HTTPS (Apache) certificates
Email certificates
Signing your p3d files
P3D file config settings
Distributing as a self-contained installer
Generating an installer
Example
Generating a standalone executable
The runtime Panda3D directory
The package system
Standard packages
Installing packages
More about referencing packages
Building and hosting your own packages
Using ppackage
The pdef syntax
Creating multiple packages
Hosting packages
SSL hosting
Building multiplatform packages
Building patches
Advanced scripting techniques
DetectPanda3D.js
Advanced object tags
Splash window tags
Plugin notify callbacks
- Additional notes
AppRunner
The appRunner.main object
The appRunner.dom object
Reading the HTML tokens
Other appRunner members
P3D origin security
- script_origin
- run_origin
PackageInstaller
Sample Programs in the Distribution
Sample Programs: Asteroids
Sample Programs: Ball in Maze
Sample Programs: Boxing Robots
Sample Programs: Carousel
Sample Programs: Cartoon Shader
Sample Programs: Chessboard
Sample Programs: Disco Lights
Sample Programs: Distortion
Sample Programs: Fireflies
Sample Programs: Fractal Plants
Sample Programs: Glow Filter
Sample Programs: Infinite Tunnel
Sample Programs: Looking and Gripping
Sample Programs: Media Player
Sample Programs: Motion Trails
Sample Programs: Mouse Modes
Sample Programs: Music Box
Sample Programs: Normal Mapping
Sample Programs: Particles
Sample Programs: Procedural Cube
Sample Programs: Roaming Ralph
Sample Programs: Shadows
Sample Programs: Solar System
Sample Programs: Teapot on TV
Sample Programs: Texture Swapping
Debugging
Log Messages
- Generating your own Log Messages
- Redirecting Log Messages to a File
The Python Debugger
Using python -i mode
pdb
Running Panda3D under the CXX Debugger
Before you Begin
Performance Tuning
Modern Performance Tuning Introduction
Most Common Problem: Silly Little Bugs
How Fast Should it Run?
List of Common Performance Issues
Incomplete Section
Basic Performance Diagnostics
Introductory Performance Diagnostics
The Frame-Rate Meter
The Scene Analyzer
Measuring Performance with PStats
QUICK INTRODUCTION
Caveats
THE PSTATS SERVER (The user interface)
Time-based Strip Charts
Value-based Strip Charts
Piano Roll Charts
Additional threads
Color and Other Optional Collector Properties
HOW TO DEFINE YOUR OWN COLLECTORS
HOW IT WORKS (What’s actually happening)
The PStats Client
The PStats Server
The Rigid Body Combiner
- The Rigid Body Combiner
Performance Issue: Too Many Meshes
Performance Issue: Too Many State Changes
Incomplete Section
Performance Issue: Too Many Text Updates
Performance Issue: Too Many Shader Instructions
Too Many Vertex Shader Instructions
Too Many Fragment/Pixel Shader Instructions
Performance Issue: Excessive Fill
Transparency
Incomplete Section
Performance Issue: Memory Full
Incomplete Section
Performance Issue: Python Calculation
Performance Issue: Python Calculation
Performance Issue: Failure to Garbage Collect
Incomplete Section
Performance Issue: Collision System Misuse
Incomplete Section
Performance Issue: Motherboard Integrated Video
Incomplete Section
Performance Issue: Too Many Polygons
Performance Issue: Too Many Polygons
Performance Issue: Miscellaneous
Incomplete Section
Using CXX
How to compile a CXX Panda3D program
How to build a CXX Panda3D game using Microsoft Visual Studio 2008
How to compile a CXX Panda3D program on Linux
How to compile a CXX Panda3D program on Mac OS X
The Window Framework
Texturing in CXX
Reference Counting
Panda3D Tools
The Scene Graph Browser
Enhanced Mouse Navigation
Interrogate
Interrogate
How to use it
Calling Interrogate
Wrapper functions
More Information
Python Editors
SPE
Installing SPE for use with Panda3D
Importing DirectStart
Pipeline Tips
How artists can help programmers with the pipeline:
Things that don’t matter as much, but will give programmers warm-fuzzies:
Model Export
Converting from 3D Studio Max
Using the Exporter
Materials
Max egger changes and additions(To be available in Panda3D 1.7.1 or later)
Known Issues
Converting from Maya
Converting from Blender
Option 1: The Egg export Plugins for Blender
Option 2: The “X” File format
Converting from SoftImage
Converting from Milkshape 3D
More Detailed explanations for MS3D users
Bugs in the Process
Converting from GMax
Installation
Using
Bugs in the Process
Converting from other Formats
Converting Egg to Bam
Parsing and Generating Egg Files
Transforms and Vertices
Custom .egg Readers/Writers
Egg Syntax
Previewing 3D Models in Pview
Building an installer using packpanda
The Scene Editor
Scene Editor Lectures
Building Panda3D from Source
Troubleshooting ppremake on Windows
ppremake doesn’t run (access violation 0xc0000005)
invalid link option /DEBUG, when running make
Building using Microsoft Visual C++ Toolkit 2003
Troubleshooting ppremake on Linux
Undeclared ‘vector_string’
Troubleshooting makepanda on Windows
- Build takes long
Troubleshooting makepanda on Linux
Undefined reference to `__isoc99_sscanf’
Tutorial: Compiling the Panda3D Source on Windows
Compiling Panda3D on Windows
Cheat Sheets
List of Panda3D Executables
Getting Started on OSX
Running the Sample Programs
Troubleshooting Common Issues
More Panda3D Resources
Third-party dependencies and license info
- License Info
- Disclaimer
- Building Panda3D
- Recommended Libraries
- Python
  - ZLib
  - libjpeg
  - libpng
  - OpenSSL
  - libvorbis
  - Freetype
  - GTK2
  - OpenAL Soft
  - Cg Toolkit
  - Eigen
  - libsquish
  - libtiff
  - DirectX (Windows only)
  - X libraries (Linux/FreeBSD only)
  - MFC (Windows only)
  - NPAPI
- Optional
  - FFMPEG
  - FMOD Ex
  - Bullet Physics
  - PhysX
  - Open Dynamics Engine (ODE)
  - OpenGL ES
  - 3ds Max SDK
  - Maya SDK
  - speedtree
  - libRocket
  - OpenCV
  - FCollada
  - FFTW
  - ARToolKit
  - VRPN
  - awesomium
- Build Tools (for compilation only)
  - Bison
  - Flex
- Patent Restriction Issues
The IRC Channel
FAQ

pandatest

Docs »
Panda’s Built-in Physics Engine
View page source

Panda’s Built-in Physics Engine¶

REDIRECT Panda3D Physics Engine

Built with Sphinx using a theme provided by Read the Docs.