Minecraft Coding Tutorial: Creating Voxel Structures in Unity

The beginner coder aims to simplify Minecraft coding tutorials for those who struggle to understand complex concepts.

### Creating Minecraft Voxel Code: A Beginner's Tutorial
* 👋 Welcome to my first coding tutorial video focused on Minecraft, where I aim to **share my learning journey** and help others **follow along easily**.
* 💻 While I don't claim to be an expert, my goal is to present the coding process in a **straightforward manner**, as I understand what it's like to be a **beginner**.
* 🔲 Instead of using Unity's built-in cubes, which can be **resource-intensive**, we will draw "chunks" to **optimize performance** and **manage game object limitations** effectively.
* 📏 A voxel consists of **eight corners**, and by creating a **lookup table for these vertices**, we can simplify the process of generating our voxel data.
* 🔗 We will set up a static class to store our voxel vertices and triangles, ensuring that the data remains **consistent throughout the game**.
* 🛠 The tutorial will guide you through creating a mesh in Unity, linking it with a **MeshFilter and MeshRenderer**, and ensuring the **correct rendering of triangles based on vertex order**.
* 🎨 Additionally, we'll implement basic texturing by assigning **UV coordinates** to our voxels, allowing for a **visually appealing representation** of our Minecraft blocks.
* 🚀 This foundational work sets us up for future tutorials, where we will **expand on creating full chunks of voxels** and **enhancing the game's graphical elements**.

hello and welcome to my first attempt at making a code in tutorial video. Just to be original, I'm doing a coding tutorial video on Minecraft. Now, I am by no means an expert. I pretty much learn everything I've learned from these kinds of videos that I'm hoping to make here. I'm not going to claim that my code is any more elegant or more efficient or better in any way than any of the more talented people out there. While I'm hoping to do is make the code in such a way that is as easy as possible to follow along if you don't quite understand what's going on to begin with. Because that part I do understand. Because that was me and still is me in a lot of cases. But in this particular subject, I think I've managed to get to a point where I can at least help some people. So, I'm not gonna waste any time explaining what Minecraft is. If you hear, I'm assuming you know what Minecraft is. So, you may be wondering why it's such a big deal to

make something like Minecraft. You could just use the built-in Unity primitive thing. There we have a cube. We could quite easily duplicate that cube, move it side, move it next. It would help if the first cubes in zero position, move them next to each other, and then programmatically put them all over the place. And we've got lots of cubes now. The reason for that is there's two reasons. One, it is very expensive because in terms of resources, because each of these cubes isn't its own game object, which has its own collide areas, cube mesh, you know, so mesh renderers, transform. It's very expensive to put all these objects on screen. And then the other problem is that you need to have an actual limitation. It can only draw so many game objects. I can only have so many game objects in existence at once. It's a high number. It can get quite a lot of game objects on the screen, but you're gonna hit that in a game like Minecraft because there are a lot of cubes. So we're not going to do that. The easier

way is to actually draw what we call chunks. I imagine most people who know Minecraft leaders know what chunks are, and instead of drawing each individual cube, you just draw the actual mesh of the outside of the chunk. So, if you have ten cubes all along in a flat surface like a floor, you don't need to draw anything under that floor because you can't see it until you start digging. We'll get to that part. So, I've made a little reference to just help us understand. This is a voxel, or the Minecraft voxel, and as you can see, we have eight corners. These are the eight corners of the cube. This is essentially the only location data that we need, is to know where these four eight corners are. So, what we're going to do, I've got back into Unity, and we'll make ourselves a nice little scripts folder because we want to keep everything nice and neat. Almost spell scripts right because that's always a good start. And what we're going to do is we're going to make a lookup table that stores

all of this information while it where these eight where these eight vertices are. You can do this programmatically. You can do it in four loops. You can use math to work out where everything needs to be. I'm not saying this is in any way more efficient. It might actually be more efficient. I'm not sure. It's definitely not more elegant. But like I said, I'm trying to do this in a way that's easier to follow rather than any particular spectacular way of doing it. So the way we're going to do this is we're going to create a self a static class. We'll call this fox all data. I'll open up this and we want it to be a static class because the whole point of this if it ever actually opens. The whole point of this class is that it's just going to start data that we need. It's not going to do anything else. So it's not going to be attached to anything. It's not gonna be edited. It's just gonna star data. So we get rid of mana behavior because

we're not putting on anything public, obviously static, so we can access it from anywhere. And then inside, we're going to make a static array. So this wants to be public static. We're gonna make it read-only because we don't want to get in edit is halfway through the game because that will cause all sorts of problems if the cube start changing size and things in the middle of a game when the because in theory Minecraft the world is constantly being generated unless you have a set you generate everything at once the worldís constant will be generated. So if you start changing the fundamental values of a voxel or a chunk or anything partway through the game, you're gonna get all kinds of weird stuff happening. So we're gonna call this voxel verts. Really matter what you call it as Fosbury, so it helps to call it something that makes a bit of sense. Now we know just go back here, we know how many verts there are. Each one of these red dots, red spheres represents a verts. So we know that there are eight verts. There's

always gonna be a verts on a cube. Now, as we get later on and we start drawing things like stairs, for example, that's gonna change, but we'll worry about that layer for now. We know that all of our blocks have got a vert, so we don't need to worry about what the size is because we can set it. And so, we're going to set it to 8 because papers, that's where it is. And then, inside of here, we're going to put 8 vector threes, and these represent the locations of those verts. So, our first vector 3 is 0, 0, 0. Luckily, I've added a little feature to this so I can show this. So, we'll go back to the front or the back, not quite sure which way to orient it. So, we have 0, 0, 0 here, and then 0 next to it, next to the actual coordinate is the index there. It's going to be in this array. So, here, this is the first one in the index in the array. So, that is index 0, as you can

see 1 0 0 is got index 1, so that's going to be the next one in the array. And then 3 0 1 0 2 1 1 0. This order that you put these in isn't necessarily important. It's not important that you do it the same way that I've done it, but it is important for later on. Be orderman 0 0 1, and then finally 0 1 1. So there we have all of our vertices in an array for all of these coordinates. So each one of these represents one of these. Now the way Unity or any 3D thing draws a 3D object is by triangles. So each one of these vertices, three of them together, can make up a triangle. So if I click this one, this one, and this one, we see we get a triangle between these. This is how it's all polygonal 3D meshes are made. It's just a collection of these triangles, and obviously, the more of these red dots you have, the more detail.

you can have. We're just drawing a block, so we don't really need to worry about that sort of thing. But obviously, to draw the block, we have this to draw a face of a block for it. Sorry, we would have this triangle, and then we would have this triangle, and together that would make the face of a block. And I've only coded this so that control wouldn't throw in a lot of time, so I can't show you the whole face, but you get the idea. Now, the important thing about this is that the direction that the triangle is drawn in. So right now, I'm going 1, 2, 3, is very important because clockwise means forward, or if you do it clockwise the way your face is as you're looking at it, that's where it will draw the face. If I spin round to the back here, you'll see it disappears because the backside of a triangle is not rendered. You would have to do some fancy stuff to make it render both sides of a triangle. So if I were to draw that triangle backwards, we

can't see it, but if I spin round here, there it is. So, all the triangles, you have to add them in a clockwise order to the direction that you want them to actually face. So, if I go up here and I do it backwards, you can't see anything. But if I go the same three dots that way, we get a triangle. So, the way that Unity knows which triangles to add is we have two arrays. We have a vertices array, which just stores these values here, stores the location data of the vertices. And then, it has a triangle array. And the triangle array is just an int array. And what the int array does is it references in the knot this array. This is our just a lookup table. But in the actual vertices array that we're going to put these values into, it references the index that a particular vertex will be in. So, if we put this, if this vertex here ends up in, I don't know, number 24 in the vertex array, then we need to reference number 24 in the triangle array when we want to call that.

vertices. So, the way we're going to do it, we're going to use another lookup table. We'll go public static read-only again because, again, we don't want this to change. This is just for reference. It's not actually going to do anything in the game. We'll call this one box or tries new int. And again, we know the values, Gus. If you look in here, we know that each face is made up of 1, 2, 3, and then 1, 2, 3, all just on the backwards, a bigger idea. We know that each face is made up of six triangles, one six triangle references. Sorry, 1, 2, 3, 1, 2, 3. So, we know that each one of these faces is going to need six triangles. And we know that there are six faces: the top, bottom, back, left, right, followed all that solving. So, we want it to be 6 by 6 as we've got one for each face and six triangles on each face. However, from now, we're just going

to draw sorry in an equal signs in there for now. We're just going to do one face, and so we need to set that to 1, because otherwise it will come up with an error. Occurs, I don't, but the rest of the faces in, and we'll do the top face, so 3, 7, 2, -7, 6. And again, I'm not doing this from memory. I am, I do have this written down on a bit of paper. So, hmm, that is currently the only face in there. Just keep track of that. That's currently the only face in there, so we don't need to worry about what reference. We're just going to be calling index zero. And then what we will do is we will loop through these, each one, and then for each one of these triangles, we will add the corresponding vector three from here into the vertex array. So, the first one is 3, so that's 0, 1, 2. This would be the first one that's been added. And then the next one is 7, so then it

would add 7 and then 2, so then it would add two. Remember, the first item in an index in an array is 0, right? So, we'll save this and back into Unity, not that reference thing. And we need another script. This one will be a regular MonoBehaviour. We're gonna call it Chunk. We'll get more into chunks and what they do later. So, in here, get rid of the update for now. We're not gonna be needing that. We need a reference to a MeshRenderer and a MeshFilter. We just go back into Unity, and I'm going to create a game object, gray empty. We'll just call this Chunk for now. And we're going to add a MeshFilter, MeshRenderer, and then we'll drag our script onto here and then link up the MeshFilter in the MeshRenderer. So, the MeshFilter basically all it does is it stores the data for the actual mesh, the vertex locations, the triangles, all that kind of thing. It's all starting the MeshFilter when there is a mesh there. This

object here will have a mesh in it. I couldn't give it one now, but obviously, we're going to be creating our own. So, we don't want to put that in there, and then the mesh renderers does as it looks like materials, like so, your textures, all that kind of thing, your lighting. None of that's important for now. So, now that we've got that, we'll go back in here. We're going to need to keep track of the current triangle that we're on for a reason. That'll be easy to explain once I've run a bit more code, but let's just get this here. And then what we need is an array of vertices that we're going to store for the mesh. I'm going to use a list. Like I said, this is not the way I'm doing it. It's not necessarily the most efficient. I'm almost certain the list is not the most efficient way to do this, but it will work. I think it's a little bit easier to follow along what's going on. So, we're gonna create a list of

vector threes call this vertices equals new list vector three and then we need another list of triangles sort of in sorry for our triangles. Okay, now we need a four loop, and what we're doing here is we're looping through whichever one of these. The minute there's only one, so there's no question which one we're actually going to be looping through, but whichever one of these we're currently on, we need to loop through each int in that array. So, we know at the minute, obviously, this will get a little bit more complicated further down the line, but at the minute, we know that there are six in there. So, we don't need to worry about how long the array is because we know it's going to be six. So, I is less than six. Now, in here, we're just going to add to the erase it. We're using this nice and simple command vertices dad, and we call our voxel data class. It's static, so we can get it from anywhere. Voxel verte, no, sorry, that's wrong. Voxel no.

So in here, we need to get the current triangle that we're on. So what we'll do is we will make a new int, and we'll call it current triangle. And you know what, I'll call it triangle index, and we'll call this one vertex index because it's probably a bit more accurate, right? So we'll call this one triangle index. Now, this is going to equal, we'll get reference to our voxel data class, voxel tries, and then for now, we've only got one, so we don't need to worry about which of these arrays because right now there is only one array. So we reference zero, and then this one wants to be I, the current iteration of the loop. So now we have that, we just go into the vertices dot add, nice handy command, makes it a lot easier than trying to work out where we are, and then an array because this just adds to the end of that list. Like I say, not particularly efficient, but for what we're doing, it should work. Another reference to the voxel data class, this

time we're going for the Vauxhall verts array, and we're adding whatever the current triangle says. So, what this line here is doing is, well, this one here is pulling a number out of here, and then this is using that number to add one of these vertices, X vertices. So, if the number is seven, then it's gonna add this one. So, this is how we populate our vertices list. Now we need to populate our triangles list. Now, unfortunately, we can't just use any of this data because this day, only these numbers here, only correspond to this. We're creating a new list here, and you were so we need to keep track of what triangle or on. So, the way we're gonna do this is this vertex index that I've created up here that I haven't explained yet. We're just going to improve in Crapper. We're just going to use that to add to the triangles, and all we're gonna do is add whatever the current vertex index is, and then after we've done that, we will increment vertex index. So, every

time. We've added a vertex. We add the current vertex index. It starts off at 0. We add 1, and then it increments to 1, and then the next one will be 1, and so every single triangle is added in the right order, and this determines the order. We know that it's gonna be in the right order for we know it's gonna be in the right order because that's the way we've done it in that array. So, like I said, the order that we do these numbers is important, and it's also for reasons that will be a bit more apparent when we get to the texturing part. The order that we do them needs to be the same on each face. So, if I start bottom left, go straight up and across there, if that's my first triangle, then when I do the top face, my first triangle again needs to be whatever the bottom left is. Like it, let's just say that I wanted to face this way, needs to go up and across in the exact same way because of the way.

that we're going to do the texturing. Like I said, there might be other ways to do it, just makes it a bit easier to explain, I think. Let me know in the comments if you think I'm wrong. So, if I decide, I have decided to start bottom left, go straight up, and then across. Then I need to do that on every face so that the texturing, the way I'm going to do the text rim, will work out. So, we'll go back in here, we'll go back in here, sorry, save that. Now, this will loop through the current triangle, which is the current face, which is the only face we've got a minute, and it will add the vertical, the necessary vertices, and the triangles to the array. And then what we need to do is create a mesh that we can then put that detail in. So, new mesh like that, no cap, Yolo. And then we need to add our vertices list into the mesh's vertices array. Fortunately, there is a nice little added built-in function on the list to

just create an array, and that's the vertices to array. Same again with the triangles, and then we need to recalculate the normals. I'll explain this a little bit there in a second. So, we do this by recalculating normals. Now, the recalculate normals thing, if you don't already know, each one of these vertices has a direction they're facing. So, this is so that the unis can render the light and other things accurately. You start messing with the normals, you get all sorts of weird artifacts and things not looking quite right, and we're driving a cube, so it's not really important. Every face, like these four vertices here, face straight upwards. These four here face this way, and yes, there are, I know it looks like we only need eight vertices, but there are actually, each face has its own four vertices, so each vertex has actually got three vertices in the same position. This is necessary to draw an actual cube as opposed to drawing a sort of smooth blob, because the unity will attempt to smooth between vertices, so you won't get

this nice hard edge. If you just share all the vertices, even though it feels like it should be more efficient, and it probably is more efficient, but visually, to get this nice crisp edge of your cube, you need to have vertices for every edge. So, this face can't share vertices with this face; otherwise, this edge would be all smoothed over, and I've completely forgotten why I was saying that. All right, for the recalculate normals. So, because we're just drawing straight faces, got the direction of these vertices just gonna be straight up, and for these ones gonna be straight forward. We don't need to do anything complicated, so recalculate normals. The built-in function is perfectly capable of doing this, and then when we finally finished doing that, we call our mesh filter mesh, and we set our new mesh to that. So, now the theory, if I press play, we should get a luminous purple square, which you can't see because of the position of the camera, but there it is. It's luminous purple because there is currently no texture or material data, so

we'll just quickly fix that for now. Temporarily, the way we do this, we need one more list. This is a list of vector tools, and I'll explain this a bit better when we actually do the texturing. But for now, I'm just gonna do something just to get rid of the horrible purple color. So, we're gonna call this one you've ease it cause new list vector too. And then down here, all we're gonna do for the time being is just add vector 2.0. And then down here, mesh dot u V equals UV these dot two array. And try not to press all sorts of random keys with my fat fingers. In theory, that should get rid of the... It should get rid, but it hasn't. Oh, right, sorry, yeah, yes. So, we do actually need to give it a material. So, create a materials folder, materials folder. And then we will create a material that we will just call voxels for now. I'll do and get rid of the smoothness, make it not shiny because that's horrible. And if

we go into our chunk, and we drop down this little menu here. We have a material thing, and just drag this into there theory. That should fix that horrible purple. There we go. So now we have a nice white square. It is drawn a 1 1 by 1 square. Should be one off the ground, and now we have our top face. So if we go back into our cold, and we go back into voxel data, we can now that we know how that works. Let's add the rest of these faces. So again, I've got all this written down, and again, it's important what order you do it. Does make a difference what all do you do it. I'm not saying that you couldn't change this order if for some reason you felt that it would benefit your code, but the order is important. You need to keep track of the order that you're doing the code in. Of course, it would help if you were using the right symbols. So this is the back face, this is the front face, and that is all of our faces. So now that

we have all of our faces. We should be able to use this data to change our code in here a bit and draw a full cube. So, what we need to do now is we need to create a second loop. So, we'll just do this one as we call it P 4 into P equals Z 0. P is less than, and again we know that this is 6 because when I change this here, I will have set it as 6. So, we don't need to worry about what this specific length of the array is because we set the length. So, we'll say that the six P plus plus, and then and close all that right. So, now we have two loops, and then all we're going to do here is instead of calling the zero index, the first face every time, we're gonna call whatever appears. So, all that means is there, it's going to loop through each one of these, and then for each one of these, it's gonna loop through each one of these, and then it's gonna do what.

we've already established it's doing so. If I go back into Unity, we should have a full cube this time. Yeah, there we go. For each face, it's looping through and it's drawing the triangles to create each face, which put together makes a full cube. And that's basically all the voxel is. Obviously, it's more involved in drawing the full chunk. So, the last thing I want to do for this video is get the texturing working. So, I've got a little picture somewhere. I've lost. There is. So, to understand how textures work, basically, each one of the UV vector twos is a coordinate on the actual texture. So, the textures work. 0, 0 is bottom-left. 0, 1 is top-left. 1, 1 top-right center. And dead center would be 0.5, 0.5. It's a normalized value for the texture. So, regardless of what size the texture is, 0 is the bottom left and 1, 1 is the top right. So, if it was a hundred, then not 0.9. If it was 100 pixels wide.

not 0.9 would be 90 pixels into the texture. The way Unity draws these textures on your actual model is that you assign a match to these vector twos here, which correspond directly to the vector threes in here. So, whatever index one is of this vector 3, index 1 of this vector 2 will correspond to it. And what that means is that if this one has got a UV, or if the matching UV vector for this one is at 0 0, and then the matching UV vector for this one is at 0 1, and then the matching UV vector for the real other side of the triangle is at 1 0, then that triangle will show the bottom half or the other diagonal half of this texture. This texture is the one I'm gonna use for just for setting up, by the way. So, with that in mind, go back into Unity. That's not Unity. Go back into Unity, and we're gonna create a new folder just for textures. Again, just keep everything nice.

and organized. And then I'm going to drag my texture. I'm going to attempt to drag my texture into there. Make sure everything's set right. This texture is only 16 pixels. We want it on clump because when you have it on repeat, you can kind of get a weird little bleed edge. So, it shouldn't be a problem with this texture because it's got a black border. But when you have it on repeat, you can get sort of a bleed-over effect around the edges. And each face that we draw is gonna want it so uncontained texture. So, we don't want anything bleeding over from the edges. And we want point mode just because we're doing Minecraft. So, we don't want everything to be, we don't want Unity attempting to smooth the texture out. So, I'll apply that now in our materials. Unity is running a little bit slow at the minute. In our materials, we've got to voxel. Go to our voxel's material. And we go up to here and we want to set this as

the texture. So now, whatever UV information we use on our mats, on our actual mesh, we'll be referencing this texture. So, let's get started in actually setting that. And the way we're gonna do this is we're gonna use another lookup table. Now, if you remember, I said that I needed to keep the order that the triangles were done for each face the same. So, the way I've been doing is I've been going bottom left, top left, bottom right, and then I think pretty sure I've been going bottom right, top left, top right. Whatever the order is, it's the same on every face. And what that allows me to do is it allows me to just have a lookup table of vector tools, which we're going to set up the exact same way as the other ones. And then I can just call this without having to worry about which position we are in or anything like that, because everything's added in the same order. So, it'll be easy to explain once I've actually done it. So, we'll just set this

up for now voxel you v's goes new vector to six again because we know that there are only six vertices in a try sorry for six triangle indexes in our face and we only need to store information for manface and then we can use it for each different face so the first each of our faces the first vertex that gets added is the bottom left so the bottom left of the actual face wants to be the bottom left of the texture and then the next one so if we go if we look at this one this is a back face we go 0 3 so we're going hero as a first one and then 3 is our second one so this 1 0 0 that's 0 0 down here the next one 0 1 so we want to add 0 1 next we'll just copy that cuz I'm lazy and then zero one and then if we look again the next one is one so one in here is this one so that's the bottom right of our texture which as you can see is one.

zero and so on. Like I said, I've written all this down so I don't forget it. Um, hopefully, that's enough for you to understand what's going on. I'll just add the rest of the numbers, the rest of the vectors. So we've got the first triangle, and then from there, one zero zero, one, and finally one one semicolon on the end of there. So this is a lookup table for voxel UVs, and then what this allows us to do, instead of just adding a vector 2 to 0, we can add voxel data, voxel UVs, and then the current triangle index that we're using, and that should give us a... Oh, let's just see what I've done wrong here. And oh, right, okay. And I'm sorry if anyone's been screaming at the monitor or whatever. Um, Unity things have been trying to... for, you know, vector 3. So try that again when it's finished. Yep, all right. So if I press play now, we should have a textured voxel. There we go. And all that's doing is for each face.

it's referencing our one texture that we've got here. Obviously, things get a little bit more complicated when you want different textures on the voxel because you have to work out the position of each texture within the overall texture. I don't know if you've ever seen the Minecraft texture pack, but it's basically one big picture of lots of little 16 by 16 pictures. You need to work out where in that picture each vertex needs to reference. So, it's easy when it's 0 and 1, 0 and 0, 1 and 1, 1. That's easy enough. The problem comes when you've got 16 of these and you need to divide it up. I mean, it's not that big a problem, but it's more complicated than this. So, that is where I'm gonna end this video. We've got one nice little voxel on the screen. In the next video, we're gonna turn it into a chunk full of voxels, Minecraft voxels, that is, as you can see.

It's drawing it all the way around, and hopefully, we all get a chunk, a nice chunk going next time. Any feedback will be appreciated. Like I said, this is just a bit of an experiment for me, but for now, have fun.

Make Minecraft in Unity 3D Tutorial - 01 - The First Voxel

Game related content!!!!11one

On this channel you will find mostly beginner-to-intermediate level tutorials for working with Unity 3D, typically using C#, with something different (but always video game or game-dev related) occasionally sneaking in. This channel is family friendly in language and themes, however the occasional low-poly bunny rabbit may get squashed in the pursuit of game dev shenanigans.

You have been warned.

b3agz

Coding Tutorial: Creating a Minecraft-like Game

The tutorial aims to help beginners learn coding for a Minecraft-like game, using a straightforward approach.

It emphasizes the importance of drawing chunks instead of individual cubes to optimize resource use and manage game objects.

The tutorial also introduces a static class to store vertex data for the cubes, aiming for an easy-to-follow coding process.

A static, read-only array is created to store the vertices of a cube, with eight Vector3 coordinates representing their locations.

The order of the vertices in the array is important for later operations, as they will be used to form triangles, which are essential for drawing 3D objects.

The direction in which the triangles are drawn determines the visibility of the object's faces, with clockwise drawing rendering the front face and counterclockwise drawing rendering the back face.

In Unity, triangles are added in a clockwise order using two arrays: a vertices array for location data and a triangle array for referencing vertex indices.

A static read-only lookup table is used to define the triangles for each face, with six triangles needed for each of the six faces.

The script then loops through the triangle indices to add the corresponding vertex values to the vertices array, while a MeshFilter and MeshRenderer are used to store and display the mesh data.

Creating a Mesh with Vertices and Triangles

The process involves setting up a mesh by creating a list of vertices and triangles.

A loop is used to iterate through the vertex data, adding each vertex to the list and populating the triangles list based on the current vertex index.

The approach may not be the most efficient, but it simplifies the process of populating the mesh.

The process of adding vertices and triangles for a cube mesh is done in a specific order to ensure consistency across all faces, which is important for texturing.

Each face of the cube has its own set of four vertices, preventing smooth edges and ensuring a crisp appearance.

The normals are recalculated to accurately render light and avoid visual artifacts, and the new mesh is then assigned to the mesh filter.

Fixing the Purple Color and Drawing a Full Cube

A new list for vector tools is created to address the purple color issue, and a material folder is established to create a non-shiny voxel material.

The code is updated to loop through and draw each face of the cube, resulting in a complete cube shape.

The texturing process is explained, with UV coordinates normalized to map the texture correctly, regardless of its size.

Textures in Unity are assigned using vector twos and vector threes to match UV coordinates, determining how the texture is applied to the model.

A new folder is created for organizing textures, with the texture set to clump mode to avoid bleed-over effects.

A lookup table is used to maintain the order of triangle indices for each face, allowing for consistent UV mapping across different faces.

The speaker is creating a lookup table for voxel UVs to add voxel data and the current triangle index, aiming to texture a voxel in Unity.

The process involves referencing a single texture for each face, but it becomes more complicated when using multiple textures, requiring the division of a larger image into smaller sections.

The video ends with the speaker planning to create a chunk full of Minecraft-style voxels in the next tutorial.