EntityBase

The base class for custom game entities. More...

Import Statement: import VPlay 2.0
Inherits:

Item

Inherited By:

EntityBaseDraggable and RubeBody.

Properties

Signals

Methods

Detailed Description

The EntityBase component is the base class for all game entities in a V-Play game. It is a container of other components for the game logic, visual representation, physics or audio components. Entities are used together with the EntityManager, which handles creation, removal and receiving of entities.

The EntityBase has 2 major properties: entityType and entityId.

Entity Type

The entityType property is the same for all entities of the same EntityBase, i.e. for all EntityBase instances. In contrast, the entityId is unique for each entity. The entityType property is useful e.g. for collision detection, when you would like to know with which kind of entity you collided with.

If you never need to make any decisions in your game logic based on the entityType, you do not need to set it. However, it is considered good practice to always define an entityType, because the type shows up in the debug outputs and thus makes the application flow easier to follow.

Variation Type

In some cases, the entityType might not be sufficient to distinguish between entities. One such case is when you define an EntityBase and provide properties for the outside that define what kind of entity it is. E.g. a stronger version with more health than the default entity version, but with the exact same code except this property modification. To distinguish between these "variations" of the same entityType without having to copy existing QML code, the variationType property is available.

It serves as the "extended type" of an entity. Consider the following example:

Enemy.qml:

EntityBase {
    entityType: "enemy"
    variationType: "defaultEnemy"

    property int health: 100
}

VariationTypeMain.qml:

Item {
  Enemy {
      x:100
      y: 100
      // the variationType will be defaultEnemy, health is 100
  }

  Enemy {
      x: 200
      y: 100
      // make this enemy stronger - to be able to distinguish them at a collision
      health: 200
      variationType: "strongEnemy"
  }
}

So with the variationType set to strongEnemy, a call of isOfType("strongEnemy") will only return true for the second entity. Whereas isOfType("enemy") returns true for both, the defaultEnemy and strongEnemy variations.

Entity Id

Every entity in a game has a unique entityId, which helps in distinguishing them and finding them from the EntityManager. If you do not set an entityId explicitly, it will automatically be generated from the EntityManager. The auto-generated entityId string is the entityType concatenated with the variationType and the current number of created entities in EntityManager.

The entityId is different than the QML id property in several ways. First, the QML id is only available within the same QML file where it was assigned and in their children components. Thus it does not allow you to access dynamically created entities which is possible with the entityId property. The type of the entityId is a String, compared to the typeless id property.

You can access other entities by their id property like in this example:

Item {
  EntityBase {
      id: player1 // for access within the same QML file
      entityId: "player1" // for dynamic access with entityManager.getEntityId()
  }

  EntityBase {
      id: player2
      entityId: "player2"
  }
}

However, this approach is not sufficient when you create entities dynamically at runtime, because you can only set id for entities declared in QML files. For that purpose, you can use the EntityManager function EntityManager::getEntityById().

The entityId is also useful for collision detection. E.g. if you want to handle collisions between 2 entity types, but only for a specific entityId.

Note: : If you do not need collision detections or game logic based on the entityId, you do not need to set this property and leave the auto-generated version.

Entity Creation And Removal with EntityManager

You can create and destroy entities at runtime with the EntityManager. Here is an example of a simple entity that consists of a simple (non-animated) Image.

import VPlay 2.0
import QtQuick 2.0

GameWindow {

    EntityManager {
        id: entityManager
        entityContainer: scene
    }

    Scene {
        id: scene

        EntityBase {
            id: boxEntity
            entityId: "box1"
            entityType: "box"

            Image {
                source: "../assets/img/box.png"
            }
        }

        MouseArea {
            anchors.fill: parent
            onClicked: {
                // if you click the scene, a new entity is created
                var newEntityProperties = {
                    x: Math.random()*scene.width,
                    y: Math.random()*scene.height,
                    rotation: Math.random()*360
                }

                entityManager.createEntityFromComponentWithProperties(
                            boxEntity,
                            newEntityProperties);
            }
        }
    }
}

In this example, the entity was defined within the same QML file like the GameWindow and Scene. It is good practice, to write entity definitions in an own QML file. That has the advantage that it is logically separated from other code. So instead of having a single file EntityTestMain.qml, we split the previous example into 2 files:

Box.qml:

import VPlay 2.0
import QtQuick 2.0

EntityBase {
    id: boxEntity
    // the entityId will be set from outer components!
    entityType: "box"

    Image {
        source: "../assets/img/box.png"
    }
}

and EntityTestMain.qml:

import VPlay 2.0
import QtQuick 2.0

GameWindow {

    EntityManager {
        id: entityManager
        entityContainer: scene
    }

    Scene {
        id: scene

        Box {
            id: boxEntity
            entityId: "box1"
        }

        MouseArea {
            anchors.fill: parent
            onClicked: {
                // if you click the scene, a new entity is created
                var newEntityProperties = {
                    x: Math.random()*scene.width,
                    y: Math.random()*scene.height,
                    rotation: Math.random()*360
                }

                entityManager.createEntityFromUrlWithProperties(
                            Qt.resolvedUrl("entities/Box.qml"),
                            newEntityProperties);
            }
        }
    }
}

Note: the entity creation from the entityManager is done differently now, as we are creating a new entity from a qml file. Thus we are using EntityManager::createEntityFromUrlWithProperties.

Entity Pooling

You can use entity pooling to increase the performance of your game. Usually, a call of removeEntity() or one of the removal functions in EntityManager like EntityManager::removeEntityById() immediately destroy the entity from memory. This has the advantage that memory consumption is at a minimum. However, creating entities during the game may be a very slow operation, depending how complex your entity is. That means, the more components you have as children of the entity, the longer the creation takes, which can build up to tens of milliseconds. This creation process would then stall the game and produce a perceived slowlyness of your game.

To prevent this performance drain at creating new entities, you can use entity pooling. Entity pooling does not immediately destroy the entity after a call to removeEntity(), but instead just marks it as invisible. When an entity of the same entityType should be created later with EntityManger::createEntityFromUrl() or similar creation functions, the invisible entity is reused. Thus there is no negative performance impact of creation. So with pooling, you trade higher memory consumption for better runtime performance.

To enable entity pooling, both the EntityManager::poolingEnabled and the poolingEnabled property of the entity must be enabled. If you want to prevent some entities from being pooled, you can leave the default setting of poolingEnabled, which is false.

The best strategy to gain maximum performance is to enable entity pooling for all entity types that get removed and created frequently. To make sure there already are pooled entities available when the user first starts the game, you can pre-create pooled entities with EntityManager::createPooledEntitiesFromUrl() or EntityManager::createPooledEntitiesFromComponent().

Entity Pooling Example

See this example how to pre-create 10 entities at game startup, which are then used from the entit pool later in the game:

import VPlay 2.0
import QtQuick 2.0

GameWindow {

  EntityManager {
    id: entityManager
    // creates the entities in the game scene
    entityContainer: scene

    // enables pooling, also set in the Entity that shall be pooled to true
    poolingEnabled: true

    Component.onCompleted: {
      // creates 10 pooled entities at startup, which are then made invisible
      createPooledEntitiesFromComponent(entityComponent, 10)
    }
  }

  Scene {
    id: scene

    Row {
      spacing: 5

      SimpleButton {
        text: "Create Entitiy"
        onClicked: {
          entityManager.createEntityFromComponentWithProperties(entityComponent, {x: utils.generateRandomValueBetween(0, scene.width), y: utils.generateRandomValueBetween(0, scene.height) })
        }
      }
      SimpleButton {
        text: "Remove Last Added Entity"
        onClicked: {
          entityManager.removeLastAddedEntity()
        }
      }
      // toggle pooling - when disabled, a call of Entity.removeEntity() leads to destruction of the entity
      SimpleButton {
        text: "PoolingEnabled: " + entityManager.poolingEnabled
        onClicked: {
          entityManager.poolingEnabled = !entityManager.poolingEnabled
        }
      }
    }
  }

  // in a real game, make an own qml file out of this and use createEntityFromUrl() instead of createEntityFromComponent()
  Component {
    id: entityComponent
    EntityBase {
      id: poolingTestEntity
      entityType: "poolingTest"

      // enable this entity type for pooling (also set EntityManager::poolingEnabled to true)
      // other entity types might not be set for pooling, thus this needs to be enabled per-entity-type
      poolingEnabled: true

      width: 20
      height: 30

      Rectangle {
        color: "green"
        anchors.fill: parent
      }

      MouseArea {
        anchors.fill: parent
        // click on the rectangle to remove it
        onClicked: poolingTestEntity.removeEntity()
      }

      onEntityCreated: console.debug("entity created with id", entityId)
      onEntityDestroyed: console.debug("entity destroyed with id", entityId)

      Component.onCompleted: console.debug("entity constructor with id", entityId)
      // onDestruction is NOT called when removeEntity is called, because poolingEnabled is set to true
      // this speeds up multiple creation/removal of entities
      Component.onDestruction: console.debug("entity destructor with id", entityId)
    }
  }

}

Property Documentation

collidersActive : bool

This property indicates if the entity's colliders are active. The active property of BoxCollider and CircleCollider are connected with the colliderActive property, so you can deactivate an entity from the physics system. Usually you do not need to set this property explicitly, because it is connected with the visible property. So when the entity is set to invisible, the colliders also are inactive. If you want to enable the physics colliders of this entity when it is invisible, you can set it to true.

You can also connect this property with other components, if you do not want to make an entity invisible but just deactivate some of the components.

By default, collidersActive is set to the visible property.


entityId : string

This string property holds the unique identifier of an entity. It can be used for collision detection and distinguishing between single EntityBase instances especially when created dynamically. If the entityId is not set explicitly, the EntityManager generates an entityId for it. The auto-generated name starts with the entityType followed by the variationType if one is specified and ends with an increasing counter value for the current number of available entities. Each of these are separated by a "_".

An example entityId for an entity would be obstacle_toyblock_3. This is the entityId of an entity with entityType obstacle and variationType toyblock, which is the third entity created in the entityManager.

With the entityId you can retrieve a reference to other entities with EntityManager::getEntityById(). You can also remove entities based on it with EntityManager::removeEntityById().

The entityId will automatically be adjusted if you accidentally set the same id twice. In such a case, another "_" is appended at the end of your initially desired entityId. Thus always fetch the entityId of a dynamically created entity, even if you set the entityId as a creation parameter. Consider this example code as best practice to retrieve the entityId from a dynamically created component:

var entityId = entityManager.createEntityFromUrlWithProperties( Qt.resolvedUrl("entities/MyEntity.qml"), { entityId: "myEntityId"})

// do NOT query the entityManager with the id "myEntityId" directly
// because it might have changed the entityId if an entity with the same id already exists to "myEntityId_"
var entity = entityManager.getEntityById(entityId)

See also EntityBase description about entityId and EntityManager.


entityType : string

This property holds the type of the entity which is the same for all instances (i.e. objects) of this type. It can be used e.g. for checking the type of the collided entity at collision detection.

If multiple variations of the same type should be used, consider additionally setting a variationType.

The function isOfType compares if the argument is equal to this defined entityType, or the variationType.

See also variationType, EntityBase description about entityType, and isOfType.


poolingEnabled : bool

Set this property to use this entity for pooling in the EntityManager. By default, it is set to false.

For pooling to work, you also need to set EntityManager::poolingEnabled to true.

If you enable pooling, the entity does not get destroyed from memory when you call removeEntity(), but is set to invisible until the entity type can be reused again. This has the benefit of a better performance when creating entities at runtime.

If you enable pooling for an entity, make sure all Timers, Animations and Sprites are stopped in onMovedToPool and get reset to their intended initial values in onUsedFromPool. You need to do this manually, because auto-storing all properties of an entity and its children proved not being efficient enough.

See also Entity Pooling, EntityManager::poolingEnabled, movedToPool, and usedFromPool.


preventFromRemovalFromEntityManager : bool

If this property is set, a call of EntityManager::removeAllEntities() wont delete this entity. This property is set to true from BuildEntityButton for the entity created for level dragging, to prevent them getting destroyed. You can also set it to true, if you do not want to remove an entity with EntityManager::removeAllEntities(). Alternatively, if you only want to remove specific entities with defined entityType properties, you could also use EntityManager::removeEntitiesByFilter().

Note: if you set this property, the entity also does not get stored with EntityManager::storeEntitiesAsJson().

The default is false.

See also EntityManager::removeEntitiesByFilter() and EntityManager::removeAllEntities().


toStoreProperties : variant

This property is used in conjunction with the serialization feature and EntityManager::storeEntitiesAsJson().

All properties in this list get stored in that function. By default, the entityId, entityType, variationType, x, y, and rotation are stored.

If you also want to store for example myCustomProperty and myOtherProperty, set it to the following:

EntityBase {
  // these properties are modified at runtime, and should be stored when the level is stored
  property int myCustomProperty
  property string myOtherProperty

  toStoreProperties: ["myCustomProperty", "myOtherProperty"]
}

variationType : string

A variationType is useful for entities that share the same properties and logic (so basically are the same entityType), but have different initial settings of these properties. E.g. two versions of an entity may exist, one variationType "defaultEnemy" and one "strongerEnemy" with a higher initial value of the health property.

The function isOfType compares if the argument is equal to this defined entityType, or the variationType.

See also entityType, EntityBase description about entityType, and isOfType.


Signal Documentation

entityCreated()

This handler is called when the entity got created.

If pooling is disabled, this only happens once and is the same as Component.onCompleted(). However, when pooling is enabled it may happen multiple times, in fact every time the entity gets reused for pooling. The order of pooling calls is the following:

  1. onUsedFromPool
  2. onEntityCreated
  3. onEntityDestroyed
  4. onMovedToPool

See also poolingEnabled and EntityManager::poolingEnabled.


entityDestroyed()

This handler is called when the entity got destroyed.

If you connected a property to this entity, you should reset it to null in this handler.

See also poolingEnabled and EntityManager::poolingEnabled.


movedToPool()

This handler is called when poolingEnabled is set to true and the entity got removed from EntityManager.

Internally, the visible property is set to false when this signal occurs, so you do not need to set it invisible explicitly if pooling is enabled.

You should stop all timers, animations and running SpriteSequences when this handler occurs, so you are not wasting resources while the entity is pooled.

See also usedFromPool and removeEntity().


usedFromPool()

This handler is called when the entity was pooled before and gets reused now by calling EntityManager::createEntityFromUrl() or other creation functions.

Internally, the visible property is set to true when this signal occurs, so you do not need to set it visible explicitly if pooling is enabled.

You should restart all timers, animations and SpriteSequences when this handler occurs, and set all properties to the initial values. You could also do that in onEntityCreated, but it is better in this function because onEntityCreated gets also called when the entity is created the first time, i.e. when Component.onCompleted() is called. The onUsedFromPool handler is only called the second time when an entity is created, when it already removed before.

See also movedToPool and entityCreated.


Method Documentation

getComponent( objectName)

Returns the component with the given objectName or undefined if none is found.

Use this method if you want to access a component of this entity from the outside, without using an alias. To reference it within an entity, the QML id property should be used as it is faster than calling this function. Also an alias to this id is faster, because in getComponent() all children must be iterated, whereas an alias is just a direct reference to the inner component.

Note: Only direct children of EntityBase are searched, so that is the difference to Qt's findChild() method.


isOfType( type)

Returns true if the entityType or variationType matches the type.

Use this function e.g. for collision detection, when you want to know with which entity type you collided.


removeEntity()

Removes the entity from the EntityManager.

Internally this is just a wrapper function for a call of EntityManager::removeEntityById().

If pooling is enabled, the entity does not get removed but set to invisible.

See also poolingEnabled.


Voted #1 for:

  • Easiest to learn
  • Most time saving
  • Best support

Develop Cross-Platform Apps and Games 50% Faster!

  • Voted the best supported, most time-saving and easiest to learn cross-platform development tool
  • Based on the Qt framework, with native performance and appearance on all platforms including iOS and Android
  • Offers a variety of plugins to monetize, analyze and engage users
FREE!
create apps
create games
cross platform
native performance
3rd party services
game network
multiplayer
level editor
easiest to learn
biggest time saving
best support
Sign up for Free and start developing right away!
I want to make Games
I want to make Apps
Game Development
Cross-Platform, Any Resolution

Use one IDE to deploy to all supported platforms, including iOS and Android, from a single code base.

Support all screen resolutions, aspect ratios and sizes with auto-adapting UI elements, smart scene scaling and memory efficient asset selection.

Learn More

V-Play ranked #1 at research2guidance cross-platform tool benchmarking 2014 by 2188 developers comparing 40 leading tools.

Multiplayer

V-Play Multiplayer supports both real-time and turn-based gameplay, so you can use it to make many different types of cross-platform multiplayer games. It's perfect for making player-vs-player games like 'Words with Friends' or games for a large amount of players, such as 'Clash of Clans'.

Learn More Video

Highscores & Achievements

The V-Play Game Network is a cross-platform gaming service that allows players around the world to compare game highscores and achievements. Players can also challenge each other across multiple platforms and share their progress on Facebook.

Learn More

QML & JavaScript

Qt Meta Language is a highly intuitive reactive language, which is super easy to learn, yet it's extremely powerful and flexible. Mix it with JavaScript to create awesome stuff, with just a few lines of code.

import QtQuick 2.0
import VPlay 2.0

GameWindow {
  Scene {
    
    SimpleButton {
      anchors.centerIn: parent
      text: "Press Me"
      onClicked: {
        console.debug("Wow you pressed me!")
      }
    }
  }
}

Learn More

Monetize & Analyze

With V-Play, you can use many 3rd party services for ads, in-app purchases, analytics and more, with just a few lines of code. All of these plugins work cross-platform, which allows you to maintain a single code base.

Learn More

Level Editor

The LevelEditor can be used during development to create and modify levels for your game, which you can then bundle in your final publishing build. Additionally, you can also integrate the in-game level editor to your published game and let your gamers create new levels.

Learn More Video

Card Game like UNO, Hearthstone or Poker

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/OneCard/OneCard.pro

Match-3 like Candy Crush Saga

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/JuicySquash/JuicySquash.pro

<Path to V-PlaySDK>/Examples/V-Play/demos/JuicySquashAdvanced/JuicySquashAdvanced.pro

Puzzle like 2048 or Threes!

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/2048/2048.pro

Casino like Big Win Slots

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/FlaskOfRum/FlaskOfRum.pro

Side Scroller like Jetpack Joyride or Flappy Bird

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/FlappyBird/FlappyBird.pro

Tower Defense like Castle Defense or Bloons TD

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/Squaby/Squaby.pro

Falldown & Jump like Doodle Jump or Mega Jump

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/ChickenOutbreak/ChickenOutbreak.pro

<Path to V-PlaySDK>/Examples/V-Play/demos/ChickenOutbreak2/ChickenOutbreak2.pro

<Path to V-PlaySDK>/Examples/V-Play/demos/DoodleJump/DoodleJump.pro

Platformer like Super Mario or Lep's World

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/Platformer/Platformer.pro

<Path to V-PlaySDK>/Examples/V-Play/demos/PlatformerWithLevelEditor/PlatformerWithLevelEditor.pro

Action like Angry Birds, Fruit Ninja, Cut the Rope

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/StackTheBoxWithCommunityEditor/StackTheBoxWithCommunityEditor.pro

<Path to V-PlaySDK>/Examples/V-Play/demos/BalloonPop/BalloonPop.pro

<Path to V-PlaySDK>/Examples/V-Play/demos/CarChallenge/CarChallenge.pro

Arcade like Arkanoid or Space Invaders

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/ZombieBreak/ZombieBreak.pro

Community like Super Mario Maker or Minecraft

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/examples/Squaby/Squaby.pro

<Path to V-PlaySDK>/Examples/V-Play/demos/StackTheBoxWithCommunityEditor/StackTheBoxWithCommunityEditor.pro

<Path to V-PlaySDK>/Examples/V-Play/demos/PlatformerWithLevelEditor/PlatformerWithLevelEditor.pro

Any other Idea? let us know how we can help you

You are looking for another demo?

The V-Play SDK includes many open-source demos for different game genres. You can use their source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

If you do not find your game genre in this list and wonder if V-Play is the right choice, just contact us, we are happy to help!

Contact Us

App Development
Better Apps, Less Effort

Develop feature-rich, cross-platform mobile apps from a single code base.

V-Play apps look, feel and perform exactly like native iOS, Android and Desktop apps. With less code & much faster development time.

Learn More Highlights Video

V-Play ranked #1 at research2guidance cross-platform tool benchmarking 2014 by 2188 developers comparing 40 leading tools.

Save Time, Code & Money

Save up to 90% source code with V-Play, compared to frameworks like Xamarin, Titanium, React Native and others.

Learn More

QML & JavaScript

Qt Meta Language is a highly intuitive reactive language, which is super easy to learn, yet it's extremely powerful and flexible. Mix it with JavaScript to create awesome stuff, with just a few lines of code. QML also allows you to easily create smooth and complex animations.

import QtQuick 2.0
import VPlayApps 2.0

App {
  Page {
    
    AppButton {
      anchors.centerIn: parent
      text: "Press Me"
      onClicked: {
        console.debug("Wow you pressed me!")
      }
    }
  }
}

Learn More

Monetize & Analyze

With V-Play, you can use many 3rd party services for ads, in-app purchases, analytics and more, with just a few lines of code. All of these plugins work cross-platform, which allows you to maintain a single code base.

Learn More

Native Sensors & More

V-Play Apps harness the power of Qt, the leading cross-platform development framework used by over 1,000,000 developers.

This gives your access to native device features like sensors, camera, file system as well as multimedia, networking, localization and much more.

Learn More

Responsive Design

V-Play has built in responsive design capabilities, you can target phones and tablets with the same source code.

Learn More

Highly Extensible

You have existing JavaScript, C++ or native code? You want to add any 3rd party SDK that we do not offer already?

No worries, you can add any JS, C++, Java or Objective-C code to your project.

Learn More

Component Showcase App shows the most important V-Play features and components

We got a demo app for you!

The V-Play SDK includes an open-source demo for this app type. You can use its source code and build your app in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/appdemos/showcase/Showcase.pro

Qt World Summit Conference App a full-featured conference management app made by V-Play

We got a demo app for you!

The V-Play SDK includes an open-source demo for this app type. You can use its source code and build your app in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/appdemos/qtws2016/QtWS2016.pro

Twitter App how to build layouts like in the official Twitter app for iOS and Android

We got a demo app for you!

The V-Play SDK includes an open-source demo for this app type. You can use its source code and build your app in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/appdemos/twitter/Twitter.pro

Maps App displays free bikes or boxes at bike stations for Vienna's bike sharing service Citybike Wien

We got a demo app for you!

The V-Play SDK includes an open-source demo for this app type. You can use its source code and build your app in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/appdemos/maps/Maps.pro

Messaging App demonstrates how to create the UI of a Facebook Messenger like app

We got a demo app for you!

The V-Play SDK includes an open-source demo for this app type. You can use its source code and build your app in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/appdemos/messaging/Messaging.pro

Weather App how to include powerful animations into your user interface

We got a demo app for you!

The V-Play SDK includes an open-source demo for this app type. You can use its source code and build your app in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/appdemos/waether/Weather.pro

Any other Idea? let us know how we can help you

You are looking for another app demo?

The V-Play SDK includes many open-source demos for different app types. You can use their source code and build your app in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play..

If you do not find your app type in this list and wonder if V-Play is the right choice, just contact us, we are happy to help!

Contact Us