> For the complete documentation index, see [llms.txt](https://kakara.gitbook.io/engine/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://kakara.gitbook.io/engine/getting-started-1/game-items.md).

# Game Items

Now that we have a black screen, it is time for us to add in objects (GameItems).

## Creating a Game Item

Let's make a basic Game Item. To start, let's go to the `MainScene` and construct a new GameItem in the `loadGraphics()` method.

```java
GameItem gameItem = new GameItem();
```

That constructs an empty game item named `gameItem`. If you were to run the game you would see nothing for two reasons:

1. The game item has not been added to the scene.
2. The game item has no mesh.

Let's deal with issue #1 first. When you construct a game item it just sits in memory. In order for us to get that game item to appear in a scene we must add it. The AbstractGameScene includes an `add()` utility method. The `add()` method allows you to add more than just GameItems, which we will cover in the future.

```java
GameItem gameItem = new GameItem();
add(gameItem);
```

Once again if you run the code you see nothing. That is due to reason #2.

## Meshes

A mesh represents a 3D geometric figure. In order for us to see a 3D object we need to use a Mesh. GameItems can be made from one or more meshes. (GameItems can also be empty as seen above.) Meshes can be generated via code or loaded through 3D files (such as .obj files). We will learn about the latter at a later point in time.

Let's have the `gameItem` be a cube. Start off by defining a new mesh variable above our GameItem declaration.

The mesh constructor takes several parameters.

```java
Mesh cubeMesh = new Mesh(positions, textureCoords, normals, indices);
```

#### Positions (Vertices)

The positions value is a float array which contains all of the vertices for the Mesh. The length of the array is the `number of vertices * 3`.

#### Texture Coordinates (UVs)

Texture coordinates (also commonly called uvs) are the texture coordinates for each vertex. Texture coordinates range from 0-1 and are 2D vectors. (0, 0) is the top left while (1, 1) is the bottom right. The length of the array should be the `number of coordinate * 2`. (Note: The order of the vectors matter.)

#### Normal Coordinates

The normal coordinates represent the orthogonal vector for each vertex. Once again it needs to be in the same order as the position vectors.

#### Indices

There is often more than one of a single position vector. To save memory indices are used. Indices represent the true order of vectors. It is an int array with the numbers representing a certain position vertex.

[Check out a more detailed explanation on what these values are.](/engine/getting-started-1/game-items.md)

### A Cube Mesh

The Kakara Engine has predefined definitions for primitive objects, such as a cube. The data for a cube is stored in the `CubeData` class. Using the cube data class you can create your cubic mesh.

```java
Mesh cubeMesh = new Mesh(CubeData.vertex, CubeData.texture, CubeData.normal, 
    CubeData.indices);
```

### Materials

Now that we have our cube mesh, we need a way to texture it or give it color. To do that we assign meshes a material. We start off by constructing a material class.

```java
Material cubeMaterial = new Material();
```

By default that creates a Material with a white color. We will learn about adding textures in the next chapter.

Now that we have our material created, we need to add it to the mesh we created.

```java
cubeMesh.setMaterial(cubeMaterial);
```

### Giving Game Items a Mesh

Now it is time to give our game item a mesh. To do that we just pass a mesh into the constructor.

```java
GameItem gameItem = new GameItem(cubeMesh);
```

## Transformations

If you run the code you will notice that you still don't see anything. That is because the Camera and the Cube are at the same location. We must move the cube farther back on the Z axis in order to see it. We do that by changing the position of the `Transform` component. For now don't worry about what components are, we will learn about them in the next chapter.

We can access the `Transform` component through a public field in the GameItem class. From there we can call the `setPosition()` method.

```java
gameItem.transform.setPosition(0, 0, -10);
```

Now if you run the code we should see a gray square. In the next chapter we will learn about components and how to make our cube rotate.

![The output of the code we just wrote.](/files/-MSuO9bH8xnclCJQUAN5)

## Final Code

{% tabs %}
{% tab title="MainScene.java" %}

```java
import org.kakara.engine.GameHandler;
import org.kakara.engine.engine.CubeData;
import org.kakara.engine.gameitems.GameItem;
import org.kakara.engine.gameitems.Material;
import org.kakara.engine.gameitems.mesh.Mesh;
import org.kakara.engine.scene.AbstractGameScene;

public class MainScene extends AbstractGameScene {
    public MainScene(GameHandler gameHandler) {
        super(gameHandler);
    }

    @Override
    public void work() {

    }

    @Override
    public void loadGraphics(GameHandler gameHandler) throws Exception {
        Mesh cubeMesh = new Mesh(CubeData.vertex, CubeData.texture, 
            CubeData.normal, CubeData.indices);
        Material cubeMaterial = new Material();
        cubeMesh.setMaterial(cubeMaterial);

        GameItem gameItem = new GameItem(cubeMesh);
        gameItem.transform.setPosition(0, 0, -10);
        
        add(gameItem);
    }

    @Override
    public void update(float v) {

    }
}

```

{% endtab %}
{% endtabs %}