---
title: Table
slug: table
description: Learn how to customize tables in vpx with this comprehensive document. It covers variable details such as table dimensions, rotation, scale, and more. Discover options for physics, graphics, sound, and lighting, as well as a specialized callback function 
docTags: 
createdAt: 2019-11-29T05:15:36.000Z
---

## Variables

*Variables are items in vpx you can set, adjust or call.*

| Call                                | Detail                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Example |
| ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- |
| Name(string)                        | table name                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |         |
| FileName(string)                    | file name (without path and extension)                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |         |
| Width(float)                        | Playfield width. default=1000                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |         |
| Height(float)                       | Playfield height. default=2000                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |         |
| GlassHeight(float)                  | Height of Glass above Playfield.  The ball will collide with this if shot upwards.                                                                                                                                                                                                                                                                                                                                                                                                                         |         |
| TableHeight(float)                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| Inclination(float)                  | Angle of Table (used for Display only). default=43                                                                                                                                                                                                                                                                                                                                                                                                                                                         |         |
| Rotation(float)                     | Rotation of Table (used mainly for FS/Cab tables: 270)                                                                                                                                                                                                                                                                                                                                                                                                                                                     |         |
| Scalex(float)                       | X Scale of Table                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |         |
| Scaley(float)                       | Y Scale of Table                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |         |
| Scalez(float)                       | Z Scale of Table                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |         |
| Xlatex(float)                       | X Offset of Table                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |         |
| Xlatey(float)                       | Y Offset of Table                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |         |
| Xlatez(float)                       | Z Offset of Table                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |         |
| Layback(float)                      | Skew of Table (used mainly for FS/Cab tables). default=0                                                                                                                                                                                                                                                                                                                                                                                                                                                   |         |
| FieldOfView(float)                  | Perspective of Table. default=45                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |         |
| BackglassMode(int)                  | Which Backglass mode is active (0=Desktop,1=Fullscreen,2=FullSingleScreen)                                                                                                                                                                                                                                                                                                                                                                                                                                 |         |
| MaxSeparation(float)                | Maximum separation/scale effect for Stereo 3D (ranges from 0..1)                                                                                                                                                                                                                                                                                                                                                                                                                                           |         |
| ZPD(float)                          | Reads the depth where the Stereo 3D should happen (ranges from 0..1)                                                                                                                                                                                                                                                                                                                                                                                                                                       |         |
| Offset(float)                       | Reads the constant offset for the Stereo 3D effect (ranges from 0..1)                                                                                                                                                                                                                                                                                                                                                                                                                                      |         |
| PlayfieldColor(OLE\_COLOR)          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| BackDropColor(OLE\_COLOR)           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| BackdropImage(string)               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| SlopeMax(float)                     | Angle of Playfield within Cabinet (used for Physics only)                                                                                                                                                                                                                                                                                                                                                                                                                                                  |         |
| SlopeMin(float)                     | Angle of Playfield within Cabinet (used for Physics only)                                                                                                                                                                                                                                                                                                                                                                                                                                                  |         |
| GlobalDifficulty(float)             | Mainly chooses/weights between SlopeMax and SlopeMin, but also affects precision of flippers/scattering (0..100)                                                                                                                                                                                                                                                                                                                                                                                           |         |
| Gravity(float)                      | default=0.86543                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| Friction(float)                     | for the Playfield, default=0.0025                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |         |
| Elasticity(float)                   | for the Playfield, default=0.2                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |         |
| ElasticityFalloff(float)            | for the Playfield, default=0                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |         |
| Scatter(float)                      | scatter angle for the Playfield, default=0                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |         |
| DefaultScatter(float)               | default=0, overrides all elements that have scatter angle set to \< 0                                                                                                                                                                                                                                                                                                                                                                                                                                      |         |
| OverridePhysics(int)                | overrides the table physics settings with pre defined settings defined under Preferences -> Physics Options.<br />You can define up to 8 different physics settings for the table and the flippers. Save them to one of the 8 slots and by assigning the slot number to this OverridePhysics it overrides these settings. default=0 (means use table settings)                                                                                                                                             |         |
| PhysicsLoopTime(int)                | the meaning of this has changed starting with 9.2.1: it specifies the maximum number of iterations spent in the physics update.<br /><br />by setting it f.e. to 1, the rendered frame updates will -always- match the physics updates, everything above 1 allows for multiple physics updates per frame<br /><br />(2, 3 or 4 can be good values for this, as it slows down the physics temporarily if the FPS drop below 50, 33 or 25 in these cases). default=-1 (which means infinite updates allowed) |         |
| YieldTime(int)                      |  time in milliseconds to sleep during each frame - can help side threads like vpinmame. default=0                                                                                                                                                                                                                                                                                                                                                                                                          |         |
| BallImage(string)                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| BallFrontDecal(string)              | image of the ball front decal                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |         |
| BallDecalMode(bool)                 | switch between using the ball decal as ball logo or ball 'scratches'                                                                                                                                                                                                                                                                                                                                                                                                                                       |         |
| Image(string)                       | playfield image                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| EnableAntialiasing(bool)            | enables AA for this table if you have set 'Enable AntiAliasing' in the video options. default=false                                                                                                                                                                                                                                                                                                                                                                                                        |         |
| EnableFXAA(bool)                    | enables FXAA for this table if you have set 'Enable FXAA' in the video options. default=false                                                                                                                                                                                                                                                                                                                                                                                                              |         |
| RenderEMReels(bool)                 | default=true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |         |
| RenderDecals(bool)                  | default=true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |         |
| TableAdaptiveVSync(int)             | sets adaptive vsync option for this table (-1=use global setting, 0=off, 1=automatic, any other number is refresh rate in Hz)                                                                                                                                                                                                                                                                                                                                                                              |         |
| BallReflection                      | enable ball reflection on table. depending on the global video setting 'Reflect Ball on Playfield' this is on or off. Or it is defined specific for this table.                                                                                                                                                                                                                                                                                                                                            |         |
| PlayfieldReflectionStrength(int)    | defines the reflection strength of the (dynamic) table elements on the playfield (0-100)                                                                                                                                                                                                                                                                                                                                                                                                                   |         |
| BallPlayfieldReflectionScale(float) | scale/dampen the contribution of the playfield to the ball reflections                                                                                                                                                                                                                                                                                                                                                                                                                                     |         |
| DefaultBulbIntensityScale(float)    | scale/dampen the contribution of the bulbs lights on the ball. This is a default setting for all balls created on the the table. If you need ball specific intensity scaling you can change the intensity by using the BulbIntensityScale value on the ball                                                                                                                                                                                                                                                |         |
| BallTrail                           | enable ball trail/motion blur on table. depending on the global video setting 'Ball Trail/Motion Blur' this is on or off. Or it is defined specific for this table.                                                                                                                                                                                                                                                                                                                                        |         |
| TrailStrength(int)                  | defines the strength of the ball trail (0-100)                                                                                                                                                                                                                                                                                                                                                                                                                                                             |         |
| DetailLevel(int)                    | defines the ramp accuracy for this table and overrides the global setting from the video options (range 0-10).                                                                                                                                                                                                                                                                                                                                                                                             |         |
| PlungerNormalize(int)               | Mech-Plunger component adjustment or weak spring, aging. default=100                                                                                                                                                                                                                                                                                                                                                                                                                                       |         |
| PlungerFilter(bool)                 | default=false                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |         |
| Accelerometer(bool)                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| AccelNormalMount(bool)              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| AccelerometerAngle(float)           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| JoltAmount(int)                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| TiltAmount(int)                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| JoltTriggerTime(int)                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| TiltTriggerTime(int)                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| DeadZone(int)                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| NudgeTime(float)                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| TableSoundVolume(int)               | Scales the global sound volume (in percent). default=100                                                                                                                                                                                                                                                                                                                                                                                                                                                   |         |
| TableMusicVolume(int)               | Scales the global music volume (in percent). default=100                                                                                                                                                                                                                                                                                                                                                                                                                                                   |         |
| LightAmbient(OLE\_COLOR)            | changes the ambient light contribution for each material, please always try to keep this at full Black                                                                                                                                                                                                                                                                                                                                                                                                     |         |
| Light0Emission(OLE\_COLOR)          | changes the light contribution for each material (currently light0 emission is copied to light1, too)                                                                                                                                                                                                                                                                                                                                                                                                      |         |
| LightEmissionScale(float)           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| EnvironmentEmissionScale(float)     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| AOScale(float)                      | scaling factor when blending the ambient occlusion                                                                                                                                                                                                                                                                                                                                                                                                                                                         |         |
| SSRScale(float)                     | scaling factor when blending the screen space reflections                                                                                                                                                                                                                                                                                                                                                                                                                                                  |         |
| BloomStrength(float)                | scaling factor when blurring the clipped framebuffer contribution (leave at 1 for kinda natural glow)                                                                                                                                                                                                                                                                                                                                                                                                      |         |
| LightHeight(float)                  | height of lights                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |         |
| LightRange(float)                   | range of lights                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         |
| ColorGradeImage(String)             | the 256x16 LUT texture used for the color grading post process                                                                                                                                                                                                                                                                                                                                                                                                                                             |         |

## Callback

| Call                                        | Detail                                                                      | Example                        |
| ------------------------------------------- | --------------------------------------------------------------------------- | ------------------------------ |
| OnBallBallCollision(ball1, ball2, velocity) | Called when two balls collide.  ball1 and ball2 are the two ball objects.   | See default table for example. |

## Events

| Event       | Detail | Example |
| ----------- | ------ | ------- |
| \_init      |        |         |
| \_KeyDown   |        |         |
| \_KeyUp     |        |         |
| \_MusicDone |        |         |
| \_Exit      |        |         |
| \_Paused    |        |         |
| UnPaused    |        |         |

```javascript
        methods:
                [id(DISPID_GameEvents_Init)]  void Init();
                [id(DISPID_GameEvents_KeyDown)]  void KeyDown( [in] long keycode);
                [id(DISPID_GameEvents_KeyUp)]  void KeyUp( [in] long keycode);
                [id(DISPID_GameEvents_MusicDone)]  void MusicDone();
                [id(DISPID_GameEvents_Exit)]  void Exit();
                [id(DISPID_GameEvents_Paused)]  void Paused();
                [id(DISPID_GameEvents_UnPaused)]  void UnPaused();

        }
```

