Panda3D

Loading...
Searching...
No Matches
Public Member Functions | Public Attributes | Static Public Attributes | Properties | List of all members
MetaInterval Class Reference
Inheritance diagram for MetaInterval:

## Public Member Functions
| __init__ (self, *ivals, **kw)
| __add__ (self, other)
| __delitem__ (self, index)
| __delslice__ (self, i, j)
| __getitem__ (self, index)
| __getslice__ (self, i, j)
| __iadd__ (self, other)
| __len__ (self)
| __repr__ (self, *args, **kw)
| __setitem__ (self, index, value)
| __setslice__ (self, i, j, s)
| __str__ (self, *args, **kw)
| addInterval (self, ival, relTime, relTo)
| addParallel (self, list, name, relTime, relTo, duration)
| addParallelEndTogether (self, list, name, relTime, relTo, duration)
| addSequence (self, list, name, relTime, relTo, duration)
| addTrack (self, trackList, name, relTime, relTo, duration)
| append (self, ival)
| applyIvals (self, meta, relTime, relTo)
| clearIntervals (self)
| clearToInitial (self)
| count (self, ival)
| extend (self, ivals)
| finish (self)
| getDuration (self)
| getIntervalStartTime (self, *args, **kw)
| getManager (self)
| index (self, ival)
| insert (self, index, ival)
| loop (self, startT=0.0, endT=-1.0, playRate=1.0)
| pause (self)
| pop (self, index=None)
| privDoEvent (self, t, event)
| privPostEvent (self)
| remove (self, ival)
| resume (self, startT=None)
| resumeUntil (self, endT)
| reverse (self)
| setIntervalStartTime (self, *args, **kw)
| setManager (self, manager)
| setPlayRate (self, playRate)
| setT (self, t)
| sort (self, cmpfunc=None)
| start (self, startT=0.0, endT=-1.0, playRate=1.0)
| timeline (self, out=None)
| validateComponent (self, component)
| validateComponents (self, components)

## Public Attributes
int | inPython = 0
| ivals = ivals
int | phonyDuration = -1
| pname = name.split('-', 1)[0]
| pstats = None
list | pythonIvals = []

## Static Public Attributes
| add_interval = addInterval
| add_parallel = addParallel
| add_parallel_end_together = addParallelEndTogether
| add_sequence = addSequence
| add_track = addTrack
| clear_intervals = clearIntervals
| clear_to_initial = clearToInitial
| get_duration = getDuration
| get_interval_start_time = getIntervalStartTime
| get_manager = getManager
| notify = directNotify.newCategory("MetaInterval")
| priv_do_event = privDoEvent
| priv_post_event = privPostEvent
| resume_until = resumeUntil
int | SequenceNum = 1
| set_interval_start_time = setIntervalStartTime
| set_manager = setManager
| set_play_rate = setPlayRate
| set_t = setT

## Properties
| duration = property(getDuration)
| manager = property(getManager, setManager)
| play_rate = property(CMetaInterval.getPlayRate, setPlayRate)
| t = property(CMetaInterval.getT, setT)

## Constructor & Destructor Documentation

## ◆ __init__()

__init__ | ( |  | self,
|  | * | ivals,
|  | ** | kw )

## Member Function Documentation

## ◆ __add__()

__add__ | ( |  | self,
|  |  | other )

## ◆ __delitem__()

__delitem__ | ( |  | self,
|  |  | index )

## ◆ __delslice__()

__delslice__ | ( |  | self,
|  |  | i,
|  |  | j )

## ◆ __getitem__()

__getitem__ | ( |  | self,
|  |  | index )

## ◆ __getslice__()

__getslice__ | ( |  | self,
|  |  | i,
|  |  | j )

## ◆ __iadd__()

__iadd__ | ( |  | self,
|  |  | other )

## ◆ __len__()

__len__ | ( |  | self | ) |

## ◆ __repr__()

__repr__ | ( |  | self,
|  | * | args,
|  | ** | kw )

## ◆ __setitem__()

__setitem__ | ( |  | self,
|  |  | index,
|  |  | value )

## ◆ __setslice__()

__setslice__ | ( |  | self,
|  |  | i,
|  |  | j,
|  |  | s )

## ◆ __str__()

__str__ | ( |  | self,
|  | * | args,
|  | ** | kw )

## ◆ addInterval()

addInterval | ( |  | self,
|  |  | ival,
|  |  | relTime,
|  |  | relTo )

## ◆ addParallel()

addParallel | ( |  | self,
|  |  | list,
|  |  | name,
|  |  | relTime,
|  |  | relTo,
|  |  | duration )

## ◆ addParallelEndTogether()

addParallelEndTogether | ( |  | self,
|  |  | list,
|  |  | name,
|  |  | relTime,
|  |  | relTo,
|  |  | duration )

## ◆ addSequence()

addSequence | ( |  | self,
|  |  | list,
|  |  | name,
|  |  | relTime,
|  |  | relTo,
|  |  | duration )

## ◆ addTrack()

addTrack | ( |  | self,
|  |  | trackList,
|  |  | name,
|  |  | relTime,
|  |  | relTo,
|  |  | duration )

## ◆ append()

append | ( |  | self,
|  |  | ival )

## ◆ applyIvals()

applyIvals | ( |  | self,
|  |  | meta,
|  |  | relTime,
|  |  | relTo )

Reimplemented in Parallel, ParallelEndTogether, Sequence, and Track.

## ◆ clearIntervals()

clearIntervals | ( |  | self | ) |

## ◆ clearToInitial()

clearToInitial | ( |  | self | ) |

## ◆ count()

count | ( |  | self,
|  |  | ival )

## ◆ extend()

extend | ( |  | self,
|  |  | ivals )

## ◆ finish()

finish | ( |  | self | ) |

## ◆ getDuration()

getDuration | ( |  | self | ) |

## ◆ getIntervalStartTime()

getIntervalStartTime | ( |  | self,
|  | * | args,
|  | ** | kw )

## ◆ getManager()

getManager | ( |  | self | ) |

## ◆ index()

index | ( |  | self,
|  |  | ival )

## ◆ insert()

insert | ( |  | self,
|  |  | index,
|  |  | ival )

## ◆ loop()

loop | ( |  | self,
|  |  | startT = 0.0,
|  |  | endT = -1.0,
|  |  | playRate = 1.0 )

## ◆ pause()

pause | ( |  | self | ) |

## ◆ pop()

pop | ( |  | self,
|  |  | index = None )

## ◆ privDoEvent()

privDoEvent | ( |  | self,
|  |  | t,
|  |  | event )

## ◆ privPostEvent()

privPostEvent | ( |  | self | ) |

## ◆ remove()

remove | ( |  | self,
|  |  | ival )

## ◆ resume()

resume | ( |  | self,
|  |  | startT = None )

## ◆ resumeUntil()

resumeUntil | ( |  | self,
|  |  | endT )

## ◆ reverse()

reverse | ( |  | self | ) |

## ◆ setIntervalStartTime()

setIntervalStartTime | ( |  | self,
|  | * | args,
|  | ** | kw )

## ◆ setManager()

setManager | ( |  | self,
|  |  | manager )

## ◆ setPlayRate()

setPlayRate | ( |  | self,
|  |  | playRate )

     Changes the play rate of the interval.  If the interval is
    already started, this changes its speed on-the-fly.  Note that
    since playRate is a parameter to start() and loop(), the next
    call to start() or loop() will reset this parameter.

## ◆ setT()

setT | ( |  | self,
|  |  | t )

## ◆ sort()

sort | ( |  | self,
|  |  | cmpfunc = None )

## ◆ start()

start | ( |  | self,
|  |  | startT = 0.0,
|  |  | endT = -1.0,
|  |  | playRate = 1.0 )

## ◆ timeline()

timeline | ( |  | self,
|  |  | out = None )

## ◆ validateComponent()

validateComponent | ( |  | self,
|  |  | component )

Reimplemented in Track.

## ◆ validateComponents()

validateComponents | ( |  | self,
|  |  | components )

## Member Data Documentation

## ◆ add_interval

add_interval = addInterval
| static

## ◆ add_parallel

add_parallel = addParallel
| static

## ◆ add_parallel_end_together

add_parallel_end_together = addParallelEndTogether
| static

## ◆ add_sequence

add_sequence = addSequence
| static

## ◆ add_track

add_track = addTrack
| static

## ◆ clear_intervals

clear_intervals = clearIntervals
| static

## ◆ clear_to_initial

clear_to_initial = clearToInitial
| static

## ◆ get_duration

get_duration = getDuration
| static

## ◆ get_interval_start_time

get_interval_start_time = getIntervalStartTime
| static

## ◆ get_manager

get_manager = getManager
| static

## ◆ inPython

int inPython = 0

## ◆ ivals

ivals = ivals

## ◆ notify

notify = directNotify.newCategory("MetaInterval")
| static

## ◆ phonyDuration

int phonyDuration = -1

## ◆ pname

pname = name.split('-', 1)[0]

## ◆ priv_do_event

priv_do_event = privDoEvent
| static

## ◆ priv_post_event

priv_post_event = privPostEvent
| static

## ◆ pstats

pstats = None

## ◆ pythonIvals

list pythonIvals = []

## ◆ resume_until

resume_until = resumeUntil
| static

## ◆ SequenceNum

int SequenceNum = 1
| static

## ◆ set_interval_start_time

set_interval_start_time = setIntervalStartTime
| static

## ◆ set_manager

set_manager = setManager
| static

## ◆ set_play_rate

set_play_rate = setPlayRate
| static

## ◆ set_t

set_t = setT
| static

## Property Documentation

## ◆ duration

duration = property(getDuration)
| static

## ◆ manager

manager = property(getManager, setManager)
| static

## ◆ play_rate

play_rate = property(CMetaInterval.getPlayRate, setPlayRate)
| static

## ◆ t

t = property(CMetaInterval.getT, setT)
| static