
Advertisement
Search the Community
Showing results for tags '2D'.
Found 1000 results

Howdy! I've been making a tower defense game in Game Maker Studio,  still got some programming updates to do. I have been using Kenney assets to serve as placeholders kinda thing as I am not really one that is skilled with the arts and crafts stuff. I am looking to see if anyone would be interested in joining in the creation of this game. https://gamejolt.com/games/3ndl3zzbasedefense/325756 this is like a 'beta' of it. A setback for me right now is to be able to make a new type of tower.. I'd need an image that works that way. I know the code, could you draw the image? I don't really know what to write in these things but yeah if anyone is interested do get in touch!

After a break of several years the 3D book project is back on. A few short words now on what this blog is about. I have to deliver my wife to the bus station in a few minutes, then a week alone so may have the time then to explain things. But the 3D book is something I started in 014 and put several years into, then the break, now on again. A win32 app with a text window and an ogl window. I just remembered I had something written on this so here it is I write to see if anyone in this community of game developers, programmers, enthusiasts, may be interested in a project I have been developing[off and on] for several years now. So follows a short description of this project, which I call the 3DBook project. The 3DFormat Reader: A new format of media. Imagine opening a book, the left page is conventional formatted text  on the right page a 3D animation of the subject of the text on the left hand page. The text page with user input from mouse and keyboard, the 3D page with user input from a game pad. An anatomy text for a future surgeon, with the a beating heart in 3D animation. A children's story adventure book with a 3D fantasy world to enter on the right page. ... Currently 3DFormat Reader consists of a C++ Windows program: Two "child" windows in a main window frame. Two windows: a text2D rendering window and a 3Drendering window. The text2D window, as its' name implies, displays text and 2D graphics; it is programmed using Microsoft's DirectWrite text formatting API and Microsoft's Direct2D API for 2D graphics. The 3Drendering window uses the OpenGL API. A 3DEBook page is formatted in one of two possible modes: DW_MODE or GL_MODE. In GL_MODE both windows are shown; the text2D rendering window is on the left and the 3D OpenGL window is on the right. In DW_MODE, only the text2D rendering window is shown, the OpenGL window is hidden (Logically it is still there, it has just been given zero width). The 3DFormat Reader reads text files, which consists of the text of the book, control character for the formatting of text, (bold, underline, ...), display of tables, loading of images(.jpg .png ...), and control of 2D and 3D routines. 3DReader programming is based on a ModelViewController (MVC) architecture. The MVC design is modular: The Controller component handles user input from the operating system , the Model component processes the input, and the View component sends output back to the user on the display. Typical ParentChild windows programs have multiple "call back" window procedures(winProcs): One for the parent window and one for child window. The MVC model, simplifies message routing by using a callback window procedure which receives Windows messages for the main window, the text2D window and the OGL window. A sample MVC program by Song Ho Ahn was used as a template for the 3DEReader. Rushed for time now, so a hasty sign off and thanks for reading.  8  21 18 I spent the last few days working on procedural mesh generation. First looking to find a bit of code to do what I had in mind. Which begs the question: What did I have in mind? I just wanted a cube mesh generator such that... Requirements Input: An integer n = units from origin to cube face. Output: The vertices for a unit cube centered on the origin. 8n² triangles per cube face. 3 times 8n² verts in clockwise winding order (from the outside of the cube) ready for the rendering pipeline. Screenshot of some cubes generated with the procedural cube mesh generator. That was about it for the output requirements. I did not want to hand code even a single vertex and did not want to load a mesh file. I was sure the code was out there somewhere, but was not finding it. So, a bit reluctantly at first, I started coding the mesh generator. I started enjoying creating this thing and stopped searching for the "outtheresomewhere" code; although still curious how others did this. Analysis First question: How do we number the verts? It would be great to conceive of some concise algorithm to put out the cube face verts all in clockwise order for the outside faces of the cube directly. That seemed beyond me so I plodded along step by step. I decided to just use a simple nested loop to generate the cube face verts and number them in the order they were produced. The hope(and the presumption) was: The loop code was in some order, running thru the x y and z coordinates in order, from n to +n, therefore the output would be a recognizable pattern. The simple nested loop vert generator did not let us down: It gave us a recognizable pattern, at least for this face. It turned out (as expected now) that all six faces have similar recognizable patterns. Plotting the first row or two of verts you can easily see how to run the rest of the pattern. Plot of the first(of six) cube faces verts output by the vert generator: Input of n: There are (2n+1)² verts per cube face, or 25 verts for n = 2. This is looking at the x = n face from the outside of the cube. To simplify the math it helps to define s = 2n. Then there are (s + 1)² verts, or 25 for s = 4 s² cells on the face, or 16 for 4 = 2. We are going divide each cell into 2 triangles, so there are 2s² triangles per face, or 32 for s = 4. Second question: What pattern for the triangles? How to number the 2s² = 32 triangles? What we want in the end is a bit of code such that... for triangles T[0] thru T[2s²1] or T[0] thru T[31]( for n = 4), we have T[N] = f0(N), f1(N), f2(N). Where f0(N) gives the first vertex of T[N] as a function of N. and f1 and f2 give the second and third verts, all in CW winding order looking into the cube of course. Here the choice is a bit arbitrary, but it would seem to make things easier if we can manage to have the order of triangles follow the order of verts to a degree. Numbering the triangles. And now the problem becomes: Look at the triangle vert list, T0  T8...T31 in the image, and try to discern some pattern leading us to the sought after functions f0(N), f1(N), f2(N) where N is the number of the triangle, 0 thru 2s²1. This really is the holy grail of this whole effort; then we have T[N] = f0(N), f1(N), f2(N) and that list of verts can be sent directly to the rendering pipeline. Of course we want these functions to work for all six faces and all 12s² triangles to cover the cube. But first let's see if we can just do this one face, 0 thru 2s²1.. Thru a bit of trial and error the 32 triangles(T0  T31) were ordered as shown. Now we have an ordered list of the triangles and the verts from our loop. T0 = 0 5 6 T1 = 6 1 0 T2 = 1 6 7 T3 = 7 2 1 T4 = 2 7 8 T5 = 8 3 2 T6 = 3 8 9 T7 = 9 4 3 T8 = 5 10 11 ... T30 T31. If we can find a pattern in the verts on the right side of this list; we can implement it in an algorithm and the rest is just coding. Pattern recognition: It appears T2 = T0 with 1 added to each component T3 = T1 with 1 added to each component In general T[N+2] = T[N] with 1 added to each component, until we come to T8 at least. Also it is hard to recognize a relation between the even and odd triangles,To see what is happening here it helps to look at an image of the generalized case where n can take on any integer value n > 0. Looking for patterns in this generalized(for any n) vert plot we see... We have defined s = 2n. The 4 corner coordinates(+n,+n) of the x =  n cube face, one at each corner (+n,+n). There are (s+1)² verts/face numbered (0 thru (s+1)² 1). There are 2s² triangles/face numbered (0 thru 2s² 1). They are indicated in red. It's not as bad as it looks iff you break it down. Let's look at the even triangles only and just the 0th vert of these triangles. For any row we see the number of that first vert of the even triangles just increases by one going down the row. We can even try a relation such as T[N].0 = N/2. Here T[N].0 denotes the 0th vert of th Nth triangle. Which works until we have to jump to the next row. Every time we jump a row we T[N+1].0 = T[N].0 + 2 for the first triangle in the higher row. So we need a corrective term to the T[N].0 = N/2 relation that adds 1 every time we jump a row. We can use computer integer division to generate such a term and N/2s is such a term. It only changes value when we jump rows and we get our first function ... f0(N) = N/2 + N/2s. (even triangles) Remember the integer division will discard any remainder from the terms and check this works for the entire cube face, but only for the even triangles. What about the odd triangles? Going back to the triangle vs vert list for the specific case n = 2, s = 4 for the first row; we see for the odd triangles T[N].0 = T[N1].0 + s + 2. And adding this term, s + 2 to the formula for the even triangle 0th vert we get f0[N] for the odd triangles. f0(N) = N/2 + N/2s + s + 2. (odd triangles) Continuing this somewhat tedious analysis for the remaining functions f1(N), f2(N) we eventually have these relations for the x = n cube face triangles. for N = 0 thru N = 2s²  1. defining m = N/2 + N/2s. T[N] = m, m + s + 1, m + s + 2 T[N] = f0(N), f1(N), f2(N). (even N) T[N] = m + s + 2, m + 1, m T[N] = f0'(N), f1'(N), f2'(N) (odd N) So it turns out we have two sets of functions for the verts, fn(N) for the even triangles and fn'(N) for the odd. To recap here; we now have formulae for all the T[N] verts as functions of N and the input parameter n: Input: An integer n = units from origin to cube face. But this is only for the first face x = n, we have five more faces to determine. So the question is: Do these formulae work for the other faces? And the answer is no they do not, but going through a similar analysis for the remaining face gives similar T[N] = f0(N), f1(N), f2(N) for them. There is still the choice of how to number the remaining triangles and verts on the remaining five faces, and the f0(N), f1(N), f2(N) will depend on the somewhat arbitrary choice of how we do the numbering. For the particular choice of a numbering scheme I ended up making, it became clear how to determine the f0(N), f1(N), f2(N) for the remaining faces. It required making generalized vert plots for the remaining five face similar to the previous image. Then these relation emerged... For face x = n T[N] N(0 thru 2²1) we have the f0(N), f1(N), f2(N), even and odd For face x = n T[N] N(2s² thru 4s²1) add (s+1)² to the x=n face components and reverse the winding order For face y = n T[N] N(4s² thru 6s²1) add 2(s+1)² to the x=n face components and reverse the winding order For face y = n T[N] N(6s² thru 8s²1) add 3(s+1)² to the x=n face components For face z = n T[N] N(8s²0 thru 10s²1) add 4(s+1)² to the x=n face components For face z = n T[N] N(10s²0 thru 12s²1) add 5(s+1)² to the x=n face components and reverse the winding order And these are enough to allow us to write explicit expressions for all 12n² triangles for all 6 faces T[N] and what remains to be done is to implement these expression in code. Which turned out to be a much simpler task than finding the f0(N), f1(N), f2(N) and resulted in a surprisingly short bit of code. Implementation I have attempted to make this C++ snippet of code as generic as possible and have removed any devplatform specific #includes and the like. GLM, a C++ mathematics library for graphics developed by Christophe Riccio is used. It is a header only library. https://github.com/gtruc/glm/releases/download/0.9.9.0/glm0.9.9.0.zip That is the only outside dependency. // Procedural cube face verticies generator #include <vector> #include <glm/gtc/matrix_transform.hpp> struct Triangle { glm::vec3 vert[3]; // the three verts of the triangle }; /* std::vector<Triangle> cube_Faces(int n) Input: integer 'n'; the units from origin to cube face. Output: vector<Triangle> glTriangle; container for the 12*(2*n)² triangles covering the 6 cube faces. */ std::vector<Triangle> cube_Faces(int n){ size_t number_of_triangles(12*(2*n )*(2*n)); size_t number_of_face_verts(6*(2*n +1 )*(2*n+1)); std::vector<glm::vec3> face_verts(number_of_face_verts); std::vector<Triangle> glTriangle(number_of_triangles); // Generate the 6*(2n +1 )² face verts  int l(0); for(int i = 0; i < 6; i++){ for(int j = n; j <= n; j++){ for(int k = n; k <= n; k++){ // Below "ifS" strip out all interior cube verts. if( i == 0){ // do yz faces face_verts[l].x = (float)(n); //x face_verts[l].y = (float)j; //y face_verts[l].z = (float)k;}//z if( i == 1){ // do yz faces face_verts[l].x = (float)(n); //x face_verts[l].y = (float)j; //y face_verts[l].z = (float)k;}//z if( i == 2){ // do zx faces face_verts[l].x = (float)j; //x face_verts[l].y = (float)(n); //y face_verts[l].z = (float)k;}//z if( i == 3){ // do zx faces face_verts[l].x = (float)j; //x face_verts[l].y = (float)(n); //y face_verts[l].z = (float)k;}//z if( i == 4){ // do xy faces face_verts[l].x = (float)j; //x face_verts[l].y = (float)k; //y face_verts[l].z = (float)(n);}//z if( i == 5){ // do xy faces face_verts[l].x = (float)j; //x face_verts[l].y = (float)k; //y face_verts[l].z = (float)(n);}//z l++; } } } // Generate the 12*(2*n)² triangles from the face verts  int s = 2*n; int q = 2*s*s; int a = (s+1)*(s+1); int f(0); int r(0); int h(0); for( int N=0; N < number_of_triangles; ){ // triangles already in CW winding if( N < q  N < 5*q && N > 3*q  1 ){ // do the even indicies f= q*(N/q); r = a*(N/q); h = (Nf)/2 + (Nf)/(2*s) + r; glTriangle[N].vert[0] = face_verts[h]; glTriangle[N].vert[1] = face_verts[s + 1 + h]; glTriangle[N].vert[2] = face_verts[s + 2 + h]; N++; f= q*(N/q); r = a*(N/q); h = (Nf)/2 + (Nf)/(2*s) + r; // do the odd indicies glTriangle[N].vert[0] = face_verts[s + 2 + h]; glTriangle[N].vert[1] = face_verts[ 1 + h]; glTriangle[N].vert[2] = face_verts[h]; N++; f= q*(N/q); r = a*(N/q); h = (Nf)/2 + (Nf)/(2*s) + r; } // triangles needing reverse order for CW winding if( N > 5*q  1  N < 3*q && N > q  1 ){ // do the even indicies glTriangle[N].vert[0] = face_verts[s + 2 + h]; glTriangle[N].vert[1] = face_verts[s + 1 + h]; glTriangle[N].vert[2] = face_verts[h]; N++; f= q*(N/q); r = a*(N/q); h = (Nf)/2 + (Nf)/(2*s) + r; // do the odd indicies glTriangle[N].vert[0] = face_verts[h]; glTriangle[N].vert[1] = face_verts[1 + h]; glTriangle[N].vert[2] = face_verts[s + 2 + h]; N++; f= q*(N/q); r = a*(N/q); h = (Nf)/2 + (Nf)/(2*s) + r; } } // Normalize the cube to side = 1  for(int i = 0; i < number_of_triangles; i++){ glTriangle[i].vert[0].x = glTriangle[i].vert[0].x/(2.0*(float)n); glTriangle[i].vert[0].y = glTriangle[i].vert[0].y/(2.0*(float)n); glTriangle[i].vert[0].z = glTriangle[i].vert[0].z/(2.0*(float)n); glTriangle[i].vert[1].x = glTriangle[i].vert[1].x/(2.0*(float)n); glTriangle[i].vert[1].y = glTriangle[i].vert[1].y/(2.0*(float)n); glTriangle[i].vert[1].z = glTriangle[i].vert[1].z/(2.0*(float)n); glTriangle[i].vert[2].x = glTriangle[i].vert[2].x/(2.0*(float)n); glTriangle[i].vert[2].y = glTriangle[i].vert[2].y/(2.0*(float)n); glTriangle[i].vert[2].z = glTriangle[i].vert[2].z/(2.0*(float)n); }; return glTriangle; } The rendering was done using OpenGl. // OGL render call to the cube mesh generator  PSUEDOCODE int n(2); int cube_triangle_Count = (12*(2*n)*(2*n)); std::vector<Triangle> cube_Triangles(cube_triangle_Count); cube_Triangles = cube_Faces(n); glBindBuffer(GL_ARRAY_BUFFER, uiVBO[0]); glBufferData(GL_ARRAY_BUFFER, cube_Triangles.size()*sizeof(Triangle), &cube_Triangles[0], GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(float), 0); glEnableVertexAttribArray(0); glDrawArray(GL_TRIANGLES,0,3*cube_triangle_Count); This just gets the position attribute of the cube face triangle verts; for the color and other attributes there are a couple of options: Use separate GL_ARRAY_BUFFERS for the color and other attributes. Or add attributes to the Triangle struct... struct Triangle { glm::vec3 vert[3]; // the three verts of the triangle attribute1; attribute2; ... }; Screenshot of the spherified cube. What's next? Now that we have the cube mesh what we can do with with it practically unlimited. The first thing I did was turn it into a sphere. Playing with tesselating the cube or sphere or stellating it with different patterns; might do. Ended up trying a few matrix transformations on the cube mesh. These are shown in the image below. These shapes are result short bits of code like the code for the column shape below. //Column for(int i = 0; i < number_of_triangles; i++){ for(int j = 0; j < 3; j++){ if( glTriangle[i].vert[j].y < 0.5f && glTriangle[i].vert[j].y > 0.5f ){ float length_of_v = sqrt((glTriangle[i].vert[j].x * glTriangle[i].vert[j].x) + (glTriangle[i].vert[j].z * glTriangle[i].vert[j].z)); glTriangle[i].vert[j].x = 0.5f*glTriangle[i].vert[j].x/length_of_v; glTriangle[i].vert[j].z = 0.5f*glTriangle[i].vert[j].z/length_of_v; } } } Doing this; the blacksmith at his forge analogy soon presents. The mesh is the ingot, hammer matrices stretch, round and bend it against the fixed geometry of the anvil  coordinate system. I am the smith. Tetrahedron The tetrahedron is the platonic solid with the least number of faces(4), edges(6), and verts(4). In antiquity it was associated with the element of fire due to its' sharp vertices. The algorithm for the tetrahedron mesh was developed in a similar way to the cube, but here it seemed simpler to get a routine for just one face  an equilateral triangle  and use matrix translations and rotations to form the complete tetrahedron. So more like origami or tinsmithing than blacksmithing. Procedural tetrahedron screenshot. The n = 4 and the general case To get an routine for the general case, n an integer > 0, a bit of what I think is known as mathematical induction was used. PSUEDOCODE Algorithm to generate equilateral triangle face with unit side composed of n² "subtriangle" in the xy plane. std::vector<Triangle> equilateral(int n){ std::vector<Triangle> tri_Angle(n²); // Create the seed triangle in xy plane . // This is triangle "0" in the image above. // This is in the xy(z=0) plane so all the // tri_Angle.vert[0 thrue n 1 ].z = 0. // We just work with the x and y verts. tri_Angle[all].vert[all].z = 0; // The seed triangle tri_Angle[0].vert[0].x = 0; tri_Angle[0].vert[0].y = 0; tri_Angle[0].vert[1].x = 1/2n; tri_Angle[0].vert[1].y = sin(π/3)/n; tri_Angle[0].vert[2].x = 1/n; tri_Angle[0].vert[2].y = 0; // Build the equilateral triangle face. int count(0); for(int row = 0; row < n; row++){ count = 0; Spin = glmRotateMatrix( π/3, zaxis ); // The magic happens here! for(int i = 2*n*row  row*row; i < 2*n*row  row*row + 2*n  2*row  1; i++) { if (count % 2 == 0 ) // Triangle is even in the row  just translate { // more magic. x_Lat = glm_Matrix((count + row)/2n, row*sin(π/3)/n, 0.0f); tri_Angle[i].vert[0] = x_Lat* tri_Angle[0].vert[0]; tri_Angle[i].vert[1] = x_Lat* tri_Angle[0].vert[1]; } else // Triangle is odd in the row  rotate then translate { //and more magic. x_Lat = glm_Matrix((count + row + 1)/2n, row*sin(π/3)/n, 0.0f); tri_Angle[i].vert[0] = x_Lat*Spin*tri_Angle[0].vert[0]; tri_Angle[i].vert[1] = x_Lat*Spin*tri_Angle[0].vert[1]; } } count++; } return tri_Angle; } This is the psuedocode version of the routine which generates the verts for the n² triangles in a face. Getting this algorithm was a bit of a brain drain but looking for patterns in the image of the face allowed it to happen. We use a "seed" triangle, which is triangle 0 on the lower left of the figure. The verts of this one triangle are input; the rest of the n² triangles verts are generated by translating and rotating this seed triangle. Notice: There are n rows, every row has 2 less triangles than the row below. If we number the triangles from 0 to 2n  2*row  2, where the rows run 0 to n; the even triangles just need to be translated ... in the x direction by (count + row)/2n where count = their position in the row 0 to 2n  2*row  2. in the y direction by row*height. height = height of seed triangle. The odd triangles need to be rotated pi/3 = 60 degrees around the z axis then translated ... in the x direction by (count + row + 1)/2n where count = their position in the row 0 to 2n  2*row  2. in the y direction by row*height. height = height of seed triangle. Now we have a single face for the tetrahedron, to join the four faces together we need the angle between the faces called the dihedral angle. Dihedral Angle Each of the five platonic solids has a characteristic called the dihedral angle. This is the angle between the faces. For the cube it is 90 degrees or pi/2 radians. For the tetrahedron it is 70.528779° = arccos(1/3) = atan(2*sqrt(2)); The tetrahedron, with just four faces, is the simplest of the platonic solids. The simplest way I can think of to build it: Start with the four face stacked one on another, edges aligned. Imagine the top three faces each hinged to the bottom face along one edge. Then rotate each face around then hinged edge by arccos(1/3), the dihedral angle. That is the method of the bit of code shown below. vector<Triangle> tetrahedron(int N){ std::vector<Triangle> tetra(4n²); tetra[all].vert[all].z = 0; // The seed triangle tetra[0].vert[0].x = 0; tetra[0].vert[0].y = 0; tetra[0].vert[1].x = 1/2n; tetra[0].vert[1].y = sin(π/3)/n; tetra[0].vert[2].x = 1/n; tetra[0].vert[2].y = 0; //  The first face  // generate the first equilateral triangle face with unit side // composed of n² "subtriangle" in the xy(z=0) plane. int count(0); for(int row = 0; row < n; row++) { count = 0; Spin = glmRotateMatrix( π/3, zaxis ); for(int i = 2*n*row  row*row; i < 2*n*row  row*row + 2*n  2*row  1; i++) { if (count % 2 == 0 ) // Triangle is even in the row  just translate { x_Lat = glm_Matrix((count + row)/2n, row*sin(π/3)/n, 0.0f); tetra[i].vert[0] = x_Lat* tetra[0].vert[0]; tetra[i].vert[1] = x_Lat* tetra[0].vert[1]; } else // Triangle is odd in the row  rotate then translate { x_Lat = glm_Matrix((count + row + 1)/2n, row*sin(π/3)/n, 0.0f); tetra[i].vert[0] = x_Lat*Spin*tetra[0].vert[0]; tetra[i].vert[1] = x_Lat*Spin*tetra[0].vert[1]; } } count++; } //  The second face  // generate the second equilateral face from the first // by rotating around the X axis by the dihedral angle. float tetra_Dihedral = atan(2*sqrt(2)); Spin = glmRotateMatrix( tetra_Dihedral, xaxis ); //just rotate for(int i = 0; i < n²; i++) { for(int j = 0; j < 3; j++) { tetra[n² + i].vert[j] = Spin*tetra[i].vert[j]; } } //The rotation gives CCW verts so need need to make them CW again for(int i = n²; i < 2n²; i++) { swap(tetra[i].vert[0]  with  tetra[i].vert[2]; } //  The third face  // For the second face we rotated the first triangle around its' // base on the X  axis. For the third face we rotate the first // triangle around its' edge along the vector ( 0.5, 0.866025, 0.0 ). Spin = glmRotateMatrix( tetra_Dihedral ,glm::vec3(0.5f,0.866025f,0.0f)); for(int i = 0; i < n²; i++) { for(int j = 0; j < 3; j++) { tetra[2n² + i].vert[j] = Spin*tetra[i].vert[j]; } } //need to make it CW again for(int i = 2n²; i < 3n²; i++) { swap(tetra[i].vert[0]  with  tetra[i].vert[2]; } //  The forth face  // For the forth face we first translate the original face along the // X axis so it right edge vector (0.5f, 0.866025f, 0.0f) passes thru the origin. // Then we rotate the first triangle around the that vector by the dihedral angle. x_Lat = glm::translate( glm::vec3(1.0f, 0.0f, 0.0f)); Spin = glmRotateMatrix( tetra_Dihedral, glm::vec3(0.5f,0.866025f,0.0f)); for(int i = 0; i < n²; i++) { for(int j = 0; j < 3; j++) { tetra[3n² + i].vert[j] = Spin*x_Lat*tetra[i].vert[j]; } } //need to make it CW again for(int i = 3n²; i < 4n²; i++) { swap(tetra[i].vert[0]  with  tetra[i].vert[2]; } // We now have the complete tetrahedron, tetra(4n²), but its' base // is not horizontal so let's make is so. // put the base in the xz plane // rotate 90  dihedral angle around X axis. Spin = glm::rotate( tetra_Dihedral  half_PI, xaxis); for(int i = 0; i < 4n²; i++) { for(int j = 0; j < 3; j++) { tetra[i].vert[j] = Spin*tetra[i].vert[j]; } } // We now have the complete tetrahedron, tetra(4n²), sitting with its' // base on the xz(y=0) plane, let's put its' center at the origin. // For this we need another Platonic Solid attribute: The radius of // the tetrahedrons circumscribed sphere which is sqrt(3/8). So the // center of the tet is this vertical distance down from its' apex. // To put the center at the origin we need to translate down this // distance along the Y axis. We need also to xlat along the Z axis // by 1/2(sqrt(3)) = 0.28867; the distance from the center of a face // to the center of a side. // Finally we need to center along the X axis( xlat .5) x_Lat = glm::translate( glm::vec3(0.5f, sqrt(3/8), sqrt(3)/2); for(int i = 0; i < 4n²; i++) { for(int j = 0; j < 3; j++) { tetra[i].vert[j] = x_Lat*tetra[i].vert[j]; } } return tetra; } Notes: Oops: Left out std::vector<Triangle> tri_Angles(4*n*n); Should be the first line of the function body! Corrections to the corrections: First line of function definition vector<Triangle> tetrahedron(int N){ should be vector<Triangle> tetrahedron(int n){ Those last two for loops could and probably should be combined to do a translate*rotate*triangle in one statement, but I have not tried it. All distances are for a tetrahedron with unit side. The sign of the dihedral angle in the rotations was usually determined by trial and error. I.e.; I tried one sign, compiled the code and rendered the tet. If it was wrong I just reversed the sign. The end result is a tetrahedron with its' center at the origin, its' base in the xz plane, and one edge parallel to the X axis. Of the five platonic solids; three (tetrahedron, octahedron, icosahedron) are composed of equilateral triangle faces. One of square faces (cube). And one of pentagon faces (dodecahedron). Two tetrahedrons fit nicely in a cube. 111618: Corrections to code blocks for equilateral triangle and tetrahedron. 111818: More corrections. Icosahedron Two faces = Icosahedron Petal Five petals in this flower = 10 faces = half of the icosahedron 12518 Understanding the icosahedron's 3d form via 2d images is difficult; we need to make a small, palm sized, 3d model. It takes nineteen paper triangles and some tape. The vertices of five equilateral triangles must come together at each vertex of the icosahedron. The icosahedron has 20 faces and 12 verts, but leaving one face off the model allows us to look in side. Besides; when where done we'll have a neat little icosahedron basket. You don't really need to make a model to code the icosahedron; but it helped me to see some properties which simplified its' construction. Symmetries are important to the mathematician and perhaps even more so to the physicist. They say something has a certain symmetry if you perform a certain operation on it and the world remains unchanged. Unchanged in the sense that you can not even detect something has been done to it. Example: Rotate a square 90 degrees around its center in the plane; the square has that type of rotational symmetry. The square also has an inversion symmetry; if you take every point on the square and invert it through the origin you end up with the same square you started with. Inversion is simply negating all the coordinates. The center must be at the origin of course. This is true for the cube, but not for the tetrahedron. Symmetries simplify the construction (coding) of an object. Going back to the cube; it might have been easier to do three faces and then just invert them thru the origin to get the other three. For the tetrahedron simple inversion is not a symmetry, but I am pretty sure inversion together with a rotation is. If so; we could do two faces and then perform an inversion  rotation on them in one step. And inversion in Cartesian coordinates just means to negate all the verts  easy! Toying with our icosahedron model; holding it gently with our thumb on one vertex and our middle finger on the opposite vertex, lazily twirling it around an imaginary axis through those two vertices; we are struck with a thought: We are toying with our icosahedron model twirling it around an axis through  Eureka!  two opposite vertices: The icosahedron has inversion symmetry. This is great  our work has just been cut in half. We can code half of the icosahedron's verts and just invert(negate) to get the rest. Thank you inversion symmetry. But let's not stop now, we are on a roll (no pun intended); lets see if we can find more symmetries to make our work easier. Looking intently; holding our model as before, but still, not rotating. Then slowly rotating about the axis we see another symmetry. After one fifth of a revolution(2π/5 radians) the universe is the looks the same as when we started rotating it. The icosahedron has a 2π/5 rotational symmetry. Can we use this to cut our work load? You bet we can. First we need to clear up a few points about something central to our construction efforts: The axis of symmetry. (Sorry, the puns just keep coming.) An axis of symmetry is a line passing thru two opposite vertices and the center of the icosahedron. The icosahedron has six of them: We only need one. We will use the Z axis. Dihedral angle: To be precise, it is the angle between the normals of two adjacent faces. The images: Looking at the images we see a flower shape with five "petals". A petals is just two faces joined along a side. The angle between the two petal faces is the icosa's dihedral angle; arccos( √5/3) radians. Five petals make a "flower" , which is ten faces, so it is half of the icosahedron. Once we have five petals joined to make this flower, we just copy/invert all its' verts to get the other half: We have our icosahedron. The Plan: Refer to the figures 1.) Make a petal. 2.) Attach one tip of the petal the axis of symmetry. (Oriented properly of course.) 3.) Copy/rotate the petal around the axis of symmetry by 2π/5 radians four times to get five petals = a flower. We are using the 2π/5 radians rotational symmetry here. 4.) Copy/invert( r > r ) our fivepetaltenface flower to get our 20 face icosahedron. Using inversion symmetry here. So just four steps; sounds simple enough. Each step has its own steps of course, but they are mostly intuitive common sense things we must do to get the result. Constants: Before we get to the code we need four constants. 1.) The dihedral angle between two faces, the dihedral_angle. dihedral_angle. = arccos( √5/3) = 46.06322 radians = 138.18969°. 2.) The angle between the Z axis and the normal of a face of a petal at the vertex. 0.652351 radians 3.) The radius of a circumscribed sphere(A sphere that touches all 12 verts). In other words the distance from the icosahedron center to a vertex. Also called the circumradius. R = sin(2π/5). 4.) The rotational symmetry: 2π/5 radians Let's not do a blow by blow, or should say, a bend by bend, description of the code. If a picture is worth a thousand words, it seems safe to assume an animated 3D image is worth even more. I suggest we compile the code and render to the display step by step. In fact this is how the code was developed; with a projection matrix and a rotation around the Z axis. Compile  Render the first face: F0. " " the first petal: P0 from F0 and F1. " " the second petal P1. " " the third petal P2. " " the fourth petal P3. " " the fifth petal P4. We now have the flower. Compile  Render the inversion of the flower. Done. The icosahedron pseudocode. struct Triangle { glm::vec3 vert[3]; // the three verts of the triangle }; //PSUEDOCODE ICOSAHEDRON /* input: integer n  number of triangles along icosahedron edge. output: std::vector<Triangle> icosahedron  mesh with 20n² triangles. */ std::vector<Triangle> icosahedron( int n ){ const float dihedral_Angle = acos((sqrt(5.0f)/3.0f)); const float dihedral_Comp = π  dihedral_Angle; std::vector<Triangle> T_icosahedron(20n²); // Create the seed triangle T. Triangle T; T.vert[0].x = 0; T.vert[0].y = 0; T.vert[0].z = 0; T.vert[1].x = 1/2n; T.vert[1].y = sin(π/3); T.vert[1].z = 0; T.vert[2].x = 1/n; T.vert[2].y = 0; T.vert[2].z = 0; //  F0  // Create the first face; "F0" in the xy(z=0) plane // from the seed triangle T. int count(0); for(int row = 0; row < n; row++){ count = 0; for(int i = 2*n*row  row*row; i < 2*n*row  row*row + 2*n  2*row  1; i++){ if (count % 2 == 0 ){ // Triangle is even in the row  just translate . x_Lat = glm::translate(count+row)/2n, row*sin(π/3), 0); for(int j = 0; j < 3; j++){ T_icosahedron[i].vert[j] = x_Lat*T.vert[j]; } } else{ // Triangle is odd in the row  rotate then translate. x_Lat = glm::translate( glm::vec3((count+1+row)/2n, row*sin(π/3), 0)); Spin = glm::rotate( π/3, zaxis ); for(int j = 0; j < 3; j++){ T_icosahedron[i].vert[j] = x_Lat*Spin*T.vert[j]; } } count++; } } // At this point comment out the rest of the code, // return T_icosahedron; // Compile and render F0 to the display. //  P0  // Create the first petal "P0" in the xy(z=0) plane. glm::vec3 axis(0.5f, sin(π/3), 0.0f); Spin = glm::rotate( π/3, zaxis ); //just rotate Spin2 = glm::rotate( dihedral_Comp, axis ); for(int i = 0; i < n²; i++){ for(int j = 0; j < 3; j++){ T_icosahedron[n² + i].vert[i] = Spin2*Spin*T_icosahedron[i].vert[j]; } } // xlate P0 by 1.0 along x and bend down by epsilon from the xy plane // epsilon is the angle we want between the Z axis and the normal of F0. // epsilon = 0.6523581f; x_Lat = glm::translate( glm::vec3(1.0f, 0.0f, 0.0f)); Spin2 = glm::rotate( glm::mat4(1.0), π/3, zaxis ); Spin = glm::rotate( glm::mat4(1.0), epsilon, xaxis ); //just rotate for(int i = 0; i < 2n²; i++){ for(int j = 0; j < 3; j++){ T_icosahedron[i].vert[j] = Spin*Spin2**x_Lat*T_icosahedron[i].vert[j]; } } // At this point comment out the rest of the code, // return T_icosahedron; // Compile and render P0 to the display. // Create P1 from the P0 verts, rotate 2π/5 around z then Spin = glm::rotate( 2π/5, zaxis ); //just rotate for(int i = 0; i < 2n²; i++){ for(int j = 0; j < 3; j++){ T_icosahedron[i+2n²].vert[j] = Spin*T_icosahedron[i].vert[j]; } } // At this point comment out the rest of the code, // return T_icosahedron; // Compile and render P0  P1 to the display. // Create P2 thru P4 from P0 verts: rotate around z: // 2*2π/5 for P2, 3*2π/5 for P3 and finally 4*2π/5 for P4 // P2 Spin = glm::rotate( 2*2π/5, zaxis ); //just rotate for(int i = 0; i < 2n²; i++){ for(int j = 0; j < 3; j++){ T_icosahedron[i+4n²].vert[j] = Spin*T_icosahedron[i].vert[j]; } } // P3 Spin = glm::rotate( 3*2π/5, zaxis ); //just rotate for(int i = 0; i < 2n²; i++){ for(int j = 0; j < 3; j++){ T_icosahedron[i+6n²].vert[j] = tSpin*T_icosahedron[i].vert[j]; } } // P4 Spin = glm::rotate( 4*2π/5, zaxis ); //just rotate for(int i = 0; i < 2n²; i++){ for(int j = 0; j < 3; j++){ T_icosahedron[i+8n²].vert[j] = Spin*T_icosahedron[i].vert[j]; } } // At this point we should have the full flower. // Comment out the rest of the code, // return T_icosahedron; // Compile and render P0 thru P4 to the display. // Move everthing up along z to put the icosahedron center at the origin. // radius of circumscribed sphere = sin(2π/5), for face side = 1. x_Lat = glm::translate( glm::vec3(0, 0, sin(2π/5)); for(int i = 0; i < 10n²; i++){ for(int j = 0; j < 3; j++){ T_icosahedron[i].vert[j] = x_Lat*T_icosahedron[i].vert[j]; } } // invert all the verts and reverse for cw winding // this creates the other half of the icosahedron from the first 10 triangles for(int i = 0; i < 10n²; i++){ for(int j = 0; j < 3; j++){ // invert T_icosahedron[i+10n²].vert[j].x = T_icosahedron[i].vert[j].x; T_icosahedron[i+10n²].vert[j].y = T_icosahedron[i].vert[j].y; T_icosahedron[i+10n²].vert[j].z = T_icosahedron[i].vert[j].z; } // Swap verts 0 and 2 to get back to CW winding. hold = T_icosahedron[i+10n²].vert[0];// reverse T_icosahedron[i+10n²].vert[0] = T_icosahedron[i+10*n²].vert[2]; T_icosahedron[i+10n²].vert[2] = hold; } return T_icosahedron; // Spherify  uncomment the code below to spherify the icosahedron /* for(int i = 0; i < 20n²; i++){ for(int j = 0; j < 3; j++){ float length_of_v = sqrt( (T_icosahedron[i].vert[j].x * T_icosahedron[i].vert[j].x) + (T_icosahedron[i].vert[j].y * T_icosahedron[i].vert[j].y) + (T_icosahedron[i].vert[j].z * T_icosahedron[i].vert[j].z)); T_icosahedron[i].vert[j].x = T_icosahedron[i].vert[j].x/length_of_v; T_icosahedron[i].vert[j].y = T_icosahedron[i].vert[j].y/length_of_v; T_icosahedron[i].vert[j].z = T_icosahedron[i].vert[j].z/length_of_v; } } */ return T_icosahedron; } Screenshots: First petal P0 and five petal icosahedron flower.

2d sidescroll action game looking for an artist
seedofpanic posted a topic in Hobby Project Classifieds
Hi everyone, Me and my friend are working on an 2d action shooting game. You can check techno demo of core mechanic here: https://spidamoo.itch.io/bunny So, as you can see, we really need an artist here. (And probably for other projects after) 
Before starting: I'm looking for a Java developer who want to help me improving my game engine and then, create a game that I will describe My goal is to create a "fight arena" multiplayer game similar to xblaster (only how they managed arena, I do not want robot stuff) For people who do not know this game, let me explain how I'm inspired by it You log in the game, you can enter an arena at any time, in the arena, there are 4 portals where you can go and enter another arena, there can be a maximum of 4players in the same arena, they have to fight each other in order to get money to improve their characters. I won't describe it any longer, I've much more ideas about the game. I already done the server architecture, I have a Game Engine (the client side), but there are still things to do on it, that's why I'm looking for another developer to help me if the game also look interesting for you Here the version of the engine: https://github.com/TheMode911/ProneusEngineV2/blob/master/src/main/java/fr/proneus/engine/demo/DemoState.java Discord: TheMode#3487

Current Project Action/Adventure/Puzzle Over the Shoulder/3rd person Steampunk/Medieval aesthetic Coop (2 Player story line) Calling all content creators and programmers of any skill and experience level to join the team. Please be at least 16+ years of age. Artist(s) NEEDED (Unspecific; 3D Models, Concept Art, Animation, Ads, Graphic Design, ...)* *Artist(s), We currently do not have any art styles set. We are looking for an original artist to set the art style for our production. This is a big opportunity. Feel free to ask questions. I am super excited to get started and meet some new people. Comment or message me for Discord server invitation.

Developing a Java based library need Java developers and web developers
CodyOrr4 posted a topic in Hobby Project Classifieds
Hey everyone I am looking for JAVA DEVELOPERS & WEB DEVELOPERS! 🤓 Project Summary: Basic Requirements: (you'll be further tested once established) Why do I need a web developer?: CONTACTS: 
RPG Adventure in a visual novel style? (noob)
IGotProblems posted a topic in Hobby Project Classifieds
I am curious, if anyone would be interested in an RPG Adventure in a visual novel art style? I loved Doki Doki and if I could create something in an RPG element, that would be THE BEST. I am a complete noob however, that is the thing. Like I just started adventuring into coding two weeks ago. I love it so far. I think I may be addicted. oof. Which is why I want to create something I have that itch. lol. Basically if anyone who wants to pitch in for free, or not I'd be glad to include them in the credits section. Also, I'd love to get the community involved in this, to create more fun RPGesk things if that makes sense. Where would I go for that? 
I want to create a simple 2D Java game , where I should be able to shoot a ball with a character (with a spritesheet). The problem is, I don't know which classes or which methods i would need. I thought of using a physics engine called "dyn4j", but actually i don't know much about it and my researches about it failed. I just found some examples of some games, where I looked for a shoot program, but I couldn't find anything: https://github.com/dyn4j/dyn4jsamples/tree/master/src/main/java/org/dyn4j/samples. The shot should be realistic as possible and of course collisions should also be handled. I also thought to use a mathematical function that resembles a parabola for the shot, but I think there should be an easier way. Do you think i should use dyn4j or another physics engine? Which classes or methods would help?

2D HLSL  Sample the backbuffer I'm rendering to
CSharpCoder posted a topic in Graphics and GPU Programming
In MonoGame I'm writing a shader for lighting and shadows in a 2D Platformer. A shadow will be drawn for each character for each light that hits said character. Because shadows from different lights can overlap the shadows are drawn to a texture where each pixel is a bitfield where each bit tells you if the pixel was reflected by a given light. In the lighting shader for each light, it only applies light if the bit for that light is not set at the given pixel. In order to not make for example 40 draw calls to draw 40 shadows if 40 lights overlapped a character, I batch shadows together into a VertexBuffer with the data specifying which light created the given shadow. In the shadow shader, it samples the render target I am drawing the shadows to and sets its own bit. My problem is that the changes from the previous shadows in the same batch aren't applied to the render target until after the draw call has completed. This results in the bitfield getting overwritten by shadows from other lights. If I could somehow sample the back buffer this wouldn't be a problem. Is there any way I can fix this without making a draw call for each shadow? 
Toltec and the mysteries of the secret island
Vangelis Stavrogiannis posted a topic in Your Announcements
Hello guys, My name is Vangelis and i am the developer of the game "Toltec and the mysteries of the secret island" The game is a 2d physics based platformer with a lot of elements of 90s games. And a unique mouse control system also suitable for gamers with disabilities. Steam page : https://store.steampowered.com/app/961870 
Profile Mode for Orx demonstrated on Twitch tomorrow
sausagejohnson posted a topic in Your Announcements
All games written with Orx have a profile screen that can be called up to monitor for any inefficiencies or bottlenecks. Iarwain will be demonstrating the Profile Mode for Orx over twitch tomorrow night at: Come along if you're interested to learn about it. There will be an opportunity to cover any topics after the demo. Here's some time zones as a guide to when it's on: Montréal, Canada Tue, 11 Dec 2018 at 1:00 am EST Rome, Italy Tue, 11 Dec 2018 at 7:00 am CET San Francisco, USA Mon, 10 Dec 2018 at 10:00 pm PST Sydney, Australia Tue, 11 Dec 2018 at 5:00 pm AEDT You can check other time zones here: https://www.timeanddate.com/worldclock/converter.html?iso=20181211T060000&p1=165&p2=215&p3=224&p4=240 
Hey Folks!!! We have a great news for you, we just released a Demo that is our last version of the game before the Early Access on Steam! This is Version 0.9d. The game had several modifications, We hope you like it! Download Link: http://playriseofages.com/demo09d/

Hello, my name is Giovanni Bruno and I developed a game in a week that creates a casual experience of reflex and focus on the iOS platform. I'd love to hear your take on the game. Would you have 20 seconds to watch a little gameplay? Gameplay link: https://www.youtube.com/watch?v=A7aGA9yVpEQ Download link: https://itunes.apple.com/us/app/levita/id1445334524?ls=1&mt=8 More about me: I've been an iOS developer since 2017 when I joined Apple Developer Academy Mackenzie in Brazil, I had a great opportunity to be a WWDC 2018 scholarship winner and attend the event. Now I'm venturing into the development of casual games for iOS, I hope to create ever better experiences that enchant people from all over the world. I know that the game is very simple, but I hope that someone play it!

2D [WIPMetroidvania] Slap of GodSingle developer
Aydin Kerimoglu posted a topic in Critique and Feedback
Hi folks,My name is Aydin. For a while, i'm developing a game by myself. My profession is actually illustration and animation. I'm just learning coding. So I have no idea how long the process will take. But I'm sure I can finish it. The main theme is the mysterious events that emerged in the 15th century Ottoman Empire. ( Yeg (Baba Yaga), gulyabani (ghoul), itbarak(werewolf), vampires, zombies and witches emerging in Constantiniye (aka İstanbul) etc.) You can review a 20second preview at the link below. I am aware that there is not enough data to evaluate it yet.But, i'm glad to hear that what you're thinking about the first look and the idea. 
Im say Hello for everybody ,for every guest on this blog ! My name is Oleg (im here https://www.timeanddate.com/worldclock/russia/tolyatti) and im sorry for my bad english skill. So,what im gonna do . Post here my current sketches ( almost everyday ). What i need from developers with expirience (sure if you have time for me) , is critique for any part with any angle , advice , recommendations , your corrections about actual styles and trends and your test works for me if you want(for next "paint day"). And im read all messages, think more and do more, i hope do better and better Im streaming almost everyday you can type on chat (if im online) ( https://www.youtube.com/channel/UCax7W3OAuGdIukLYRUK3VSQ)

Atum engine is a newcomer in a row of game engines. Most game engines focus on render techniques in features list. The main task of Atum is to deliver the best toolset, that’s why, as I hope, Atum will be a good light weighted alternative to Unity for indie games. Atum already has fully workable editor that has an ability to play test edited scene. All system code has simple ideas behind them and focuses on easy to use functionality. That’s why code is minimized as much as possible. All source can be found here  https://github.com/ENgineE777/Atum In case you have questions related to Atum engine do not hesitate to contact me via email enginee777@gmail.com Currently the engine have follow features:  PC, Android and iOS platforms are supported  Scene Editor with ability to play test edited scene  Powerful system for binding properties into the editor  Powerful assets system  Track based editor for creation of animated objects  Sprite Editor  Render system that supports DX11 and OpenGL  UI system bassed on assets  Script system based on angel script  Controls system based on aliases  Font system based on stb_truetype.h  Support of PhysX 3.0, there are samples in repo that's using physics  Network code which allows to create server/clinet; there is some code in repo which allows

As does everyone on this site, I suppose. Allow me to elaborate. You've heard of Undertale. right? That retrographics RPG that put a spin on the whole concept? Yea, of course you do. (I mean, if you don't, here's a Wikipedia link: https://en.wikipedia.org/wiki/Undertale) Then, of course, you know about the various Alternate Universes (AUs) of this game that the community has made, like Underswap or Underfell. Well, I want to make a sort of "fangame" of Undertale. Basically Undertale, except it's an AU: Painted Plummet. Now, I'll give you a basic summary of Painted Plummet. It's basically Undertale, but the characters are replaced with YouTube animators, like Jaiden Animations or TheOdd1sOut. Now, the Au itself belongs to [RP]=Retribution, but I have made my own take on it, called CB!Painted Plummet. Now, let me clarify, takes on AUs aren't uncommon. There's a take on Underswap called TS!Underswap (and that's admittedly the only example that comes to mind.) Now, I'm posting this on here because I'd like for you guys to give feedback on this idea, maybe throw some concepts for game mechanics at me, whatever you feel like giving me. So go ahead! (Oh, and if you want me to tell you the characters, lemme know.)

Hi, At the moment I want to create a team to make a new top down shooter game for Windows and Mobile. Our store page https://play.google.com/store/apps/dev?id=8448896228303860944 I need gamemaker programmers and 2D artists, You can send your cv / works on; contact@massoftgames.com And you can add me on Discord; RuLing62 Thank you, and see you later!

Hello! For more that two years I'm making my 2D sandbox adventure RPG with generated and almost fully destructible world. Recently the project become opensource and detailed description can be found here  https://github.com/mrDIMAS/TheDwarfAdventure Here is gameplay video (very short) with core mechanics: Latest stable build can be found here  https://github.com/mrDIMAS/TheDwarfAdventure/releases I need some feedback and if you found a bug  create an issue  this will help me a lot.

 2D
 Open Source

(and 1 more)
Tagged with:

PROGRESSThought I'd reach out for some feedback on my little project. This is an android twoplayer game for topdown boxing matches. The core mechanics are all that I have accomplished thus far, later I want to add different configurations for your boxer (special effects, increased health or damage, etc) and maybe even a single player AI to practice against.SCREENSHOTS #1 *****************************************************************#2 FEEDBACKRight now the gameplay feedback I'm looking for is on the fundamental mechanics of the game.One area of particular concern is the window of opportunity for a player to block after their opponent has begun a punch. Currently that window is onetenth of a second, otherwise you will be to late to counter their blow. I want it to be difficult to successfully pull off a block and have it be something that requires real attention to accomplish. I'm wondering though if it isn't too difficult right now, which may encourage mindless button mashing, which is certainly not what I want to condone.Another consideration is whether having three main actions (block, attack, charge) provides a good balance. My idea with having three main areas is that your two thumbs will have to leave one section uncovered at all times. This should result in hand movements that telegraph actions to the opponent.Aside from these, any other constructive criticism is very welcome.LINKMy game can be found at the Google Play Store here: https://play.google.com/apps/testing/com.meatandgrain.PunchABunchNOTE There is a known graphics error when performing a special punch. There are no doubt other unknown errors as well. Thank you for your time, I hope you'll be able to find some fun in this little game!

HTML5 Theraxius  HTML5 2D action game + level editor
therax1986 posted a topic in Your Announcements
Hi everyone. For the last few months I’ve been working on a simple HTML5 2D side scrolling action game called Theraxius. It's nothing new and revolutionary, it's more like an evolution of different technology (combination of HTML5, PHP, MySQL). The game also includes a level editor so you can create your own levels. The game and the level editor is written almost completely in JavaScript, no download is required. Just load and play. Here are a few screenshots and the link to the page. In the next weeks I’ll try to post some videos, try to add registration (for newsletter and later for public test). Release date: when it's done theraxius.com 
As I like to say with a deep sadness in my soul, I've been failing at game dev for about three decades. I've been having fun, but I'm ultimately disappointed with my progress. So I've once again changed my goals and strategy and over engineered it. Which brings me to my current project. My new goal is to get better through repetition, but using a strategy for that repetition to make my skill development more efficient. So far, I've completed some clones of the first levels of two games (Ninja Gaiden and Super Mario Bros. for the NES), and am starting out on making the first level of Bionic Commando (also for the NES). I'm redoing the graphics in half the res of the originals for now. So far, this strategy seems to have taught me more in the few months I've been doing it, than the five years it took me to complete my last game. The difference I suppose is that I'm not going to attempt to release most of these games. I might consider polishing and releasing the ones that aren't clones. This big learning project looks like it will take me a few years, in the meantime I'll probably start other projects while still working through it but this is going to be my primary project for a long while. And something that I think I should have done in the first place so many years ago. I'd like to share my progress from time to time and hopefully have some discussions.

2D Artist needed for a browser strategy (hobby project)
andrii_k posted a topic in Hobby Project Classifieds
Hi all! We are a team of two programmers developing a turnbased browser strategy, and we need someone to help with the art. It is a card+board strategy. Every player has a castle, and in their turn can move units and play cards. Current art is partially placeholder, partially original (contributed by some friends), but we'd love to have somebody joining the team and taking care of the visual side. Main tasks are drawing cards, objects on the board and interface elements. A prototype is available here https://lords.world (needs at least two people to play properly, but you can play against a dummy bot to get an idea). Please pm if interested. Best regards, Andrii and Serge 
Gameplay Snow Ash Land Now on steam  Social and PVP multipalyer top down shooter  Join us !
Snow AshLand posted a topic in Your Announcements
Snow Ash Land A 2D multiplayer top down shooter Social  MMoRpg  Pvp  Craft  Build Hello everyone, this is my first post here, I'm happy to present you today my video games "snow ash land " , I worked hard for more than 3 years to get there, but today in the mass of games, it's difficult to get out of the mass, so I would have liked to find a nice person to join our discord and community. The game is already very advanced and will be finished within 6 months maximum ,it is already on steam ,in demo and early access ,we all appreciate constructive feedback ,and hope tohave attracted your curiosity Snow Ash Land is a multiplayer postapocalyptic topdown shooter game with rpg mechanics and survival in a semiopen world. It simulates a reborn society in a postapocalyptic world. Guided by factions with very different ideologies, the player can choose to help rebuild civilization or destroy humanity. There's a lot of interractions between players in multiplayer mode : Guilds, pvp territory wars, resources and information exchanges, language, politics, economy, building... STEAM :https://store.steampowered.com/app/977670/Snow_Ash_Land/ DISCORD : https://discord.gg/3j6e33kWebsite: https://snowashland.webnode.fr/ 
2D TexturePacker(Atlas)  Any visible problems?
Vivid3DDev posted a topic in Graphics and GPU Programming
Hi, I am trying to code a Lightmapper for my 3D engine, and as such I implemented a TexturePacker/Atlas, and although it's working OK, I find it oddly ineffecient. It mostly packs all to the left and leaves a lot of free space to the right. Here is the code, can you spot anything wrong, or suggest another way to do it? Cheers. I have a test win.form app if required, I could upload it. Cheers. using System.Collections.Generic; namespace Vivid3D.Util.Texture { public class TexTree { public static List<TreeLeaf> Leafs = new List<TreeLeaf>(); public TreeLeaf Root { get; set; } public Rect RC; public TexTree ( int w, int h ) { RC = new Rect ( 0, 0, w, h ); //Root = ne //w TreeLeaf (new Rect(0,0,w,h)); } public TreeLeaf Insert ( int w, int h, int id = 1 ) { //return Root.Insert ( w, h ); if ( Root == null ) { Root = new TreeLeaf ( new Rect ( 0, 0, w, h ), id ) { Used = true }; Root.Child [ 0 ] = new TreeLeaf ( new Rect ( 0, h, RC.W, RC.H  h ) ); Root.Child [ 1 ] = new TreeLeaf ( new Rect ( w, 0, RC.W  w, h ) ); } else { return Root.Insert ( w, h ); } return Root; } } public class TreeLeaf { public TreeLeaf[] Child = new TreeLeaf[2]; public Rect RC = new Rect(); public int TexID = 0; public bool Used = false; public TreeLeaf ( Rect s, int id = 1 ) { RC = s; TexID = 1; Child [ 0 ] = Child [ 1 ] = null; TexTree.Leafs.Add ( this ); } public TreeLeaf Insert ( int w, int h ) { if ( Used ) { TreeLeaf rn = Child [ 1 ].Insert ( w, h ); if ( rn != null ) { return rn; } rn = Child [ 0 ].Insert ( w, h ); if ( rn != null ) { return rn; } } else { if ( w < RC.W && h < RC.H ) { Used = true; Child [ 0 ] = new TreeLeaf ( new Rect ( RC.X, RC.Y + h, RC.W, RC.H  h ) ); Child [ 1 ] = new TreeLeaf ( new Rect ( RC.X + w, RC.Y, RC.W  w, h ) ); RC.W = w; RC.H = h; return this; } else { return null; } } return null; } public bool Fits ( int w, int h ) { return w < RC.W && h < RC.H; } } public class Rect { public float X,Y,W,H; public Rect ( ) { X = Y = W = H = 0; } public Rect ( float x, float y, float w, float h ) { X = x; Y = y; W = w; H = h; } } }

Advertisement