Jump to content
  • Advertisement
    1. Past hour
    2. This is a good question and it something I've been thinking about a lot lately for my own project. However I'm working in 3D on spherical world generated on the fly at run time, and I suspect a solution that will work for you will be very different from what I need. Perhaps you could tell us a little more. Is it truly 2D, or is it more isometric view? What kind of physics/collision will be supported? Do you generate everything in advance or is it done as you go at run time.
    3. Guy Fleegman

      Orange Instinct - My first Web Game

      Got it now. Thanks. I couldn't get past the 4th level, but it's still a cool little game. If you ever make a difficulty setting, you should make it scale through different types of fruit. Like, easy can be a banana or something. 😉 Thanks for sharing your game!
    4. Today
    5. Kirk Lazarus

      I hate dialogue systems

      Well best of luck! Im sure if will turn out great. Im unfamiliar with scripting dialogue systems myself. Can you paste some sample code?
    6. Gnollrunner

      Sick of Javascript bugs, going back to Java

      No problem my friend. I fine with a lively discussion. Seriously, good luck with your project whatever language you decide on. I hope it's successful.
    7. CyberFlash

      Looking for an artist for a Tower Defense

      While the Base Defense game is done, we are working on our next project, and if you would still like to help, we would love to formally introduce ourselves on Discord https://discord.gg/X5bXzT3 and see if you'd be interested in the next one?
    8. Haha, well, I don't want this to be an argument But, if you have an example of a task that you think is inelegant or verbose to implement in JS, it might be interesting to share it here. Maybe I or someone else could provide an example implementation in JS for illustrative or comparative purposes.
    9. I'll mention a couple other things in addition to the above post. - You might double-check the documentation for srand(), as you seem to be misusing it here. - Maybe you're modifying all those arguments for the benefit of the caller somewhere, but keep in mind that if that's not the case, they don't need to be non-constant references (or references at all). - In the 'while' conditional, you have an assignment ('player_control = 2') rather than a comparison. - The return statement probably isn't doing what you expect (look into the C++ comma operator for info on that). Also, for what it's worth it might be a little easier to comment if you just include the code directly into your post rather than via image (that way readers can easily search it, copy-and-paste, and so on).
    10. Look at the while condition to keep it in the loop. It says the condition is that player must still be the second one and down must be less than four. But inside the loop you never change any of these variables so the loop never ends. If the second player must just make one movement then you need to change to control to one before the loop ends. If down means how much times the second player moves then you must change as well.
    11. 3dBookman

      The 3D book

      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 3D-Book project. The 3D-Format 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 3D-Format Reader consists of a C++ Windows program: Two "child" windows in a main window frame. Two windows: a text-2D rendering window and a 3D-rendering window. The text-2D 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 3D-rendering window uses the OpenGL API. A 3DE-Book page is formatted in one of two possible modes: DW_MODE or GL_MODE. In GL_MODE both windows are shown; the text-2D rendering window is on the left and the 3D OpenGL window is on the right. In DW_MODE, only the text-2D rendering window is shown, the OpenGL window is hidden (Logically it is still there, it has just been given zero width). The 3D-Format 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. 3D-Reader programming is based on a Model-View-Controller (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 Parent-Child 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 call-back window procedure which receives Windows messages for the main window, the text-2D window and the OGL window. A sample MVC program by Song Ho Ahn was used as a template for the 3DE-Reader. 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 "out-there-somewhere" 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[N-1].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 dev-platform 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/g-truc/glm/releases/download/0.9.9.0/glm-0.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 = (N-f)/2 + (N-f)/(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 = (N-f)/2 + (N-f)/(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 = (N-f)/2 + (N-f)/(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 = (N-f)/2 + (N-f)/(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 = (N-f)/2 + (N-f)/(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. PSUEDO-CODE Algorithm to generate equilateral triangle face with unit side composed of n² "sub-triangle" 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² "sub-triangle" 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. 11-16-18: Corrections to code blocks for equilateral triangle and tetrahedron. 11-18-18: More corrections. Icosahedron Two faces = Icosahedron Petal Five petals in this flower = 10 faces = half of the icosahedron 12-5-18 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 five-petal-ten-face 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; } Screen-shots: First petal P0 and five petal icosahedron flower.
    12. Yesterday
    13. I am trying to write a function for the CPU to keep calling a play in a do while loop (which I am assuming is correct) with a pause in between and for the menu to be brought up to the user after each selection from the playbook function that contains the playbook menu. I am not an expert with the cin operator, but my playbook function works perfectly when the user is entering the plays but the cursor hangs when it is calling the function_cpu for the cpu to make the selection. I am sure I am missing something in the code here. I put some notes in the code below.
    14. Find a spot on the planet's surface where you want to place the object. Then figure out the size of the base of the object you want to place (say a castle) then "sculpt" the surrounding area to support it. Either raise or lower verticies, or add in more.
    15. BertS

      Question about Shared class behaviour

      I know it's not the exact type, but since these are properties I'm loading from a data file I was hoping I didn't need to use the exact type. IE AngelScript would be smart enough to downcast or get the implemented interfaces to match the function signatures. Looking deeper at the source this doesn't look like it'd be the case unfortunately. But aside from that looking at that comment, I think you're right and what I'm seeing is intended behaviour: All modules need to contain the types. I assumed these types would be shared across modules by default, but no such luck
    16. 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)
    17. Septopus

      My First Game : Tic Tak Toe

      Very cool! This is an excellent first! Nicely done.
    18. Graphicedit

      Looking for an artist for a Tower Defense

      do you need help?
    19. This approach makes sense. Do you have any known games in mind which use this approach? Can't think of any straight away.
    20. A common virtual joystick takes wherever they touch down as the center point, then let them drag in any direction as they would a directional stick. Buttons add complications. For some games it fits well. For some games it fits badly. Ultimately you need to think about the game and make your controls work with the device. The last few rounds of consoles have been convenient because XBox and PlayStation controllers are extremely similar so developers have less effort, but you should consider each system on its own and decide what works and what doesn't. Similarly on mobile, most developers assume a touch screen only, assuming no hardware buttons and no peripherals attached. Only one model, solve the problem once rather than per-device.
    21. MrFloat

      Question about Shared class behaviour

      Is using pType->GetMethodByDecl("void set_Prop(SomeClass@)"); not a mistake? Based on the actual interface one would expect to see pType->GetMethodByDecl("void set_Prop(IInterface@)"); It sounds like you might not be using shared classes correctly, you can read more about them here: https://www.angelcode.com/angelscript/sdk/docs/manual/doc_script_shared.html It's mentioned that "in order to work the scripts in all modules that share the entity must implement the entity the same way", so all modules are expected to contain the shared classes. The thing to be carefull here is that I think when I tested the shared classes were "owned" by the first module that was loaded with them and if that module gets disposed, the shared classes it owned get destroyed even if other modules were using them (not sure if it's a bug or intended). That page also gives the alternative to having duplicate class definitions in a form of "external" keyword.
    22. fleabay

      My First Game : Tic Tak Toe

      Congratulations on completing your first game.
    23. Hello guys, Not sure if this is the right forum, but I'll post it anyway. I have recently started working on a game which I was originally planning for a PC (using unity). The game is an orthographic top-down run and gun and heavily relies on movement controls. Now due to budget limitations I am thinking about going mobile first. However, when I started investigating the development of the on-screen joystick for a mobile game, I found it extremely poor, annoying and limited. I tried several "classic" sega ports and they were extremely difficult and frustrating to control (especially remembering that I played these classics as a kid and never got frustrated). Is this simply a bad example of the joystick? Are there any good games which I can look at as an example? Or is this really as good as it gets for touchscreen devices?
    24. Graphicedit

      Looking for Artist(s)

      Hi is it still active?
    25. In an aggressive move to lure developers, Discord will allow developers to self-publish games with a 90/10 revenue split. The announcement claims developers are creating their own stores and launchers to distribute their games instead of focusing on what's really important. Read more on the Discord blog here. View full story
    26. In an aggressive move to lure developers, Discord will allow developers to self-publish games with a 90/10 revenue split. The announcement claims developers are creating their own stores and launchers to distribute their games instead of focusing on what's really important. Read more on the Discord blog here.
    27. Qunary

      Astroworks Devlog #3

      Devlog #3 - Supercharge! 14th of December 2018 Really A Studio - Follow us on Twitter! - Subscribe to our Youtube channel for upcoming devlog videos! - Join our Discord server! - Consider supporting the team on Patreon! - Interested in contributing to the project? Fill out our application form or contact a Producer on the Discord server! Who are we Really A Studio (RAS) is an independent game development team. RAS was founded on the 30th of October 2018 as a bootstrap startup with the goal of creating innovative, quality video games. Our incredible team consists of passionate designers, artists, 3D technologists, sound engineers, and content producers from all around the globe working together to create great games. Our first and current project is Astroworks, a singleplayer sci-fi action game set to release in 2019Q1. Astroworks Concept Astroworks is a story-driven 3d arcade space combat action game. Fight against a galactic megacorporation turned evil with multiple spaceship choices, heaps of weapons and abilities, featuring tons of explosions! Embark on challenging missions which include fighting against swarms of enemy battle drones, blowing up enemy capital ships, sabotaging factories, spaceship races and more! Today's topics: Abilities part 1 This is only a description of the abilities but gameplay about using them is going to be ready very soon. Please don’t let this turn you off though, because I’m going to boost your morale right after this! On this weekend we are going to release an Astroworks reveal trailer, featuring some gameplay, along with bits taken from a cutscene – conveniently a cutscene right before the mission called „Supercharge!” begins, so be on the lookout! There were never a better time to be subscribed to our YT channel and to get notified about this right when it goes up on Twitter! Abilities are special powers which can be used to overcome enemies. There are 6 abilities throughout the game. In this post only 3 of them are going to be introduced to reduce it’s length. They are going to be unlocked gradually as you progress through the story. At the beginning of each mission, on the briefing screen you are going to be able to choose from 2 abilities to bring on that particular mission. In game you are going to be able to use them by pressing either the Q or the E keys. After usage abilities enter a short cooldown period and while that lasts, they are unusable. Cooldowns are very short though! Decoy The very first ability available to the player from the beginning is Decoy, which creates a hologram that looks identical to the player and keeps doing whatever the player was doing at the moment of its’ creation. When you activate this ability the hologram will fire upon enemies which get in range with the weapon equipped at the time of activating the ability, diverting their attention. The decoy is created at the same place the player occupies, has no collision with other spaceships and doesn’t deal damage. The basic use of the decoy ability is to distract enemy spaceships by confusing them, so they don’t know which spaceship is the real one. Electrify Generates electric current and sends it towards an enemy defensive structure. The structure is disabled for 10 seconds and takes continuous damage. Once the target of this ability has been set, it is impossible for enemy spaceships to obstruct it. The electrify ability is useful when dealing with enemy bases because it allows the player to disable the defensive structures and get close to them without taking damage. Supercharge Activates the boost mode in the thrusters to triple the speed of the spaceship. The thrusters will take some time to recover from the extra effort and this ability will be disabled during this time. The supercharge ability is a short cooldown ability that is most useful for repositioning and for avoiding certain attacks. Previous Devlog: #2 – Call me Bad: Thank you for your attention! Soon we'll have in-game screenshots too! Tune in next time as well and don't forget to follow our activity on these sites: Thank you for your attention! Tune in next time as well and don't forget to follow our activity on these sites: Really A Studio - Follow us on Twitter! - Subscribe to our Youtube channel for upcoming devlog videos! - Join our Discord server! - Consider supporting the team on Patreon! - Interested in contributing to the project? Fill out our application form or contact a Producer on the Discord server!
    28. Hello everyone, it's my first time posting on this forum. I'm very excited to meet you. Anyways, my first question is about procedurally generating a world. I'm seeing how to implement a procedural generated world, and placing objects after that seem to be a big challenge. Let's say I have a big object that doesn't fit inside a chunk or that it is spawned in the frontier of a chunk. How would you go about generating the whole thing using the nearby chunks? With terrain it's pretty easy because the terrain is not hardcoded, so the algorithm is entirely free. But when I want to place hardcoded objects like castles or trees, I can't just cut the castle in half - or can I? What's a way to approach this problem? I'm using LWJGL/OpenGL in Java for a 2D game.
    29. Vivid3DDev

      Artist Looking to Collaborate

      Yeah it's the second name actually. Was called "Vivid3D" - but yeah it's easy enough to change the name. As for the lab, yeah as photo-realistic as possible is my prefered style in mind for the game. I mean once that scene is done and I can show you running in the engine, maybe you would be interested in help making it into a full game, and we'd share the profits if any or kick starter is successful. And however it's done, the gltf export option from sketchfab works great, and the engine has the following texture slots. 1= diffuse color map 2= normal map 3 = specular map 4 = glow map You can email if you like, rather than co-coordinating it here.
    30. Interesting feedback, first time I have an insight that sound like coming from actual game dev. (are you ?) will definetly challenge myself into trying to make a suite with combat theme etc.
    31. Volts Pots

      2D sprite cost - need some advice

      Correct, will do
    32. Rutin

      2D sprite cost - need some advice

      I had a project which had static pose and a few variations which were under 10 frames each, but was around $800 all said and done; Something I needed for a mobile app at the time. I don't pay by frame, I pay for the end result that I want. Once I tell the artist what I need, they tell me their quote and I either negotiate, accept it, or move on. I honestly have no time to nit pick rates per frame, and every little detail. If they choose to break it down on their invoicing then so be it, but I don't even look or care. I would suggest that you post your service request for bids. There is no other way to gage what you'll be charged. Just make sure you consider the portfolios for each bidder. Hypotheticals wont matter because the variance in prices for art is very wide spread.
    33. Kfostergraphics

      Artist Looking to Collaborate

      Thanks!
    34. Oh, sorry I missed that question at first. Calculus is necessary to understand the world, so I recommend taking it in general. I don't know how necessary it is specifically in procedural generation. Perhaps to understand Perlin noise it's a good idea to know some calculus. But you can probably just treat it as a black box, use it to make some pictures and never bother with the fine details. For AI, the only place where you absolutely need it is for computing the gradient of a loss function in machine learning ("backpropagation"). And again, these days there are many libraries that do the dirty work for you, so you can probably get away with very little understanding of the details.
    35. CortexDragon

      Capture constantbuffer in commandlist

      Instead of having one constant buffer that is changed every frame, can you rotate between 2 (or even 3) constant buffers, so you have your alternate frames commandlists be bound to different constant buffers. This allows a constant buffers value once set to remain at that value for a certain number of frames, long enough for the commandlist that uses it to finish executing Basically the same approach that the tutorial dx12 samples use (They use 3 frame objects) Also remember any changes you make to one buffer eventually have to be made to the other frames buffers if you want those other buffers to also have that value. (keeping a single cpu copy of the buffer, making your changes to that, then copying that into the current frames buffer is the easiest way)
    36. blesseddisciple

      Sick of Javascript bugs, going back to Java

      I'm not trying to sound abrasive, just giving my opinions as well.
    37. Gnollrunner

      Artist Looking to Collaborate

      Cool stuff!
    38. Hello, So I've been successfully using AngelScript in my personal project, but I ran into an issue which was unexpected. I have the following setup: [module A] shared interface IInterface { } shared class SBaseClass { } [module B] shared class SClass : SBaseClass { IInterface@ Prop { set { ... } } } [module C] shared class SomeClass : IInterface { } Now in my code I have a handle to an object of type SClass and I request the function ID of the Prop setter like this: const auto pType = hObject->GetObjectType(); if (pType) { const auto pFunc = pType->GetMethodByDecl("void set_Prop(SomeClass@)"); } Now this fails to find the method declaration, because it can't find the SomeClass type. That's because the script engine takes the module of the first method to start looking for the type (module A in this case) and it seems the modules only look in types directly registered with the engine or that were parsed inside the module itself. I would've expected shared types to be checked here too. I can work around this, but was wondering if this was intended behaviour, an oversight or if I'm simply missing something. Thanks for any and all help!
    39. Kfostergraphics

      Artist Looking to Collaborate

      Excellent, Yeah I believe the engine was Multimedia Fusion. I didn't know if they have recently implemented 3D into their workload. Awesome job on getting an engine going though. I don't think I could do something like that, It seems extremely complicated. Also, the name is the easy part, you can always get around that once the dust settles from all that code, lol. As far as the Lab goes, did you want Hand painted style or semi-realistic? Thanks, Kevin
    40. Gnollrunner

      Sick of Javascript bugs, going back to Java

      Lets put it this way.... The OO in JavaScript is not the classic OO you find in Java, C# and C++. If you understand how it works you won't get into trouble. There are features in many different languages that if you don't understand them well, you can get yourself into trouble. That's not unique to JavaScript. The beauty of JavaScript is that at it's core, it's simple. You can choose, or not choose to use it's higher level features, but again you should understand the core of the language and how the higher level stuff is implemented over that core if you are going to use them. Many people do, and use them quite successfully. If it's not for you, fine. I'm really not trying to convince you to use it. I just don't think the problem is with the language itself. If you disagree with that, well Ok. No reason we all have to agree.
    41. Vivid3DDev

      Artist Looking to Collaborate

      Hi. thanks yeah, specific would be better. Fusion is a new engine I've been coding for over a yeah, I recall there being a other engine called Fusion, I think that was for 2D games though. But i'll change my engine's name though, considering that. but that aside, yeah specific help would be great, the game is inspired by desu ex/cyberpunk 2077 etc. Would a test room, like a science lab with tables etc be out of the question? I can't pay for anything, but once it goes on sale(Either engine or game) I can pay for previous an new work. oh and sketchfab exports work in fusion with a single click, including textures etc. via the "Autoconverted glTF" option of download. so that would be easy.
    42. Pff... Is this OOP paradigm you blaming? Bad architectural decisions and someones' inability to write clean code is what you should blame instead.
    43. Here's how I'd figure out the relation between cos(2x) and cos(x) (which I actually don't remember). One of the very few formulas I do remember is: exp(i*x) = cos(x) + i*sin(x) Even for this formula, what I really remember is that exp(i*x) is a point in the unit circle at an angle x, and the rest I can write down from there. Computing the square of that, I get exp(i*2*x) = (cos(x) + i*sin(x))^2 But we also have exp(i*2x) = cos(2x) + i*sin(2x) If I look at the real part of those two expressions, I think I'll get the identity I want: cos(x)^2 - sin(x)^2 = cos(2x) I can get rid of the sin(x)^2 because I know that cos(x)^2+sin(x)^2=1. Again, this is not something I remember, it's just the fact that cos(x) and sin(x) are the coordinates of a point on the unit circle. cos(x)^2 - (1 - cos(x)^2) = cos(2x) 2*cos(x)^2 - 1 = cos(2x) cos(x)^2 = (cos(2x)+1)/2 There you have it. With a little bit of practice, this process doesn't take much time at all. If I have been doing trigonometry problems recently, I might remember the formula for a little while, but in the long term, I know I'll be able to derive it when I need it.
    44. Kfostergraphics

      Artist Looking to Collaborate

      Thanks! I've never messed with Fusion, but I've heard of it. You are welcome to use some of the assets or request, but I wont be able to help you with the back half of the assets. I'd prefer to use UE4 so i could operate most of the prop and mesh asset features. But either way, there are quite a few free to download assets on the page that you are welcome to, or if you need something specific I can definitely help you out with that. Kfostergraphics@gmail.com
    45. blesseddisciple

      Sick of Javascript bugs, going back to Java

      To flesh out our arguments, let's say I present a programming obstacle, nothing too time consuming. You program it JS and again in Java, (or I can in Java but then we introduce different programming styles/approaches), and then we compare which one looks/functions more efficiently and with less trouble. Does that sound fair? You literally just admitted that they threw together some stuff to make it act like something it's not. You may not see that as a bad thing, but you can't blame others for not agreeing with you on that point.
    46. Vivid3DDev

      Artist Looking to Collaborate

      Hi, Your work is very impressive - Atm I am working on Fusion, it is a custom 3d engine/ui/ide to make games with. Here is a video of it running. If you have any interest in making a sci-fi/cyberpunk style game using it, I'd love to talk about it. you can reply to me here or at antonyrobwells@gmail.com - Cheers. https://www.youtube.com/watch?v=5xAzBcdAc_s - you can see more shots etc on my twitter @antwellsmusic
    47. 3D / 2D / Sound Artist looking to collaborate. You can check my work out here. https://sketchfab.com/Lowpolyprincipal https://www.artstation.com/kevinfoster1 https://www.behance.net/kfoster01
    48. Volts Pots

      2D sprite cost - need some advice

      Thanks for the reply! Well, with internet it is not difficult to find an artist out there. Actually, a lot of guys on devinart and artstation are talented beyond limits. Main question would still be the cost Thanks for the reply! So far, I paid around 100$ for a character concept art (not an actual sprite, just the way the character looks, colors, etc). But the character would look different in the actual game and I not every artist understands animation and keyframes from what I know. So, when you say you had paid 350$ for a single sprite - do you mean that if idle animation has around 5 frames, it would 5x the cost?
    49. ggenije

      Properly stretch texture on quad unity

      Ok sorry for bad explanation, I was in hurry... The code for next image is[in unity] void CreateLaserWW(Vector3 beg, Vector3 end, float widthbeg, float widthend) { Vector3 dir = end - beg; Vector3 keydir = dir; keydir = Quaternion.AngleAxis(90.0f, Vector3.up) * keydir; keydir.Normalize(); Vector3 begleft, begright, endleft, endright; begleft.y = beg.y; begleft.x = beg.x + (keydir.x * widthbeg); begleft.z = beg.z + (keydir.z * widthbeg); begright.y = beg.y; begright.x = beg.x - (keydir.x * widthbeg); begright.z = beg.z - (keydir.z * widthbeg); endleft.y = end.y; endleft.x = end.x + (keydir.x * widthend); endleft.z = end.z + (keydir.z * widthend); endright.y = end.y; endright.x = end.x - (keydir.x * widthend); endright.z = end.z - (keydir.z * widthend); keydir = begleft - beg; keydir = Quaternion.AngleAxis(-90.0f, dir.normalized) * keydir; keydir.Normalize(); Vector3 begleft2, begright2, endleft2, endright2; begleft2.y = beg.y + (keydir.y * widthbeg); begleft2.x = beg.x + (keydir.x * widthbeg); begleft2.z = beg.z + (keydir.z * widthbeg); begright2.y = beg.y - (keydir.y * widthbeg); begright2.x = beg.x - (keydir.x * widthbeg); begright2.z = beg.z - (keydir.z * widthbeg); endleft2.y = end.y + (keydir.y * widthend); endleft2.x = end.x + (keydir.x * widthend); endleft2.z = end.z + (keydir.z * widthend); endright2.y = end.y - (keydir.y * widthend); endright2.x = end.x - (keydir.x * widthend); endright2.z = end.z - (keydir.z * widthend); MeshFilter mf = GetComponent<MeshFilter>(); Mesh mesh = new Mesh(); mf.mesh = mesh; Vector3 middle = beg + (dir * 0.5f); Vector3 beghalf = (begleft + begright) * 0.5f; Vector3[] vertices = new Vector3[9] { begleft, endleft, endright, begright, begleft2, endleft2, endright2, begright2, beghalf }; int[] tri = new int[3 * 3]; tri[0] = 0; tri[1] = 1; tri[2] = 8; tri[3] = 1; tri[4] = 2; tri[5] = 8; tri[6] = 2; tri[7] = 3; tri[8] = 8; Vector2[] uv = new Vector2[9]; uv[1] = new Vector2(0, 0); uv[2] = new Vector2(0, 1.0f); uv[3] = new Vector2(1.0f, 1.0f); uv[0] = new Vector2(1.0f, 0); uv[8] = new Vector3(1.0f, 0.5f); mesh.vertices = vertices; mesh.triangles = tri; mesh.uv = uv; } Code does:need width of bases of trapezoid and positions and renders it Point of this code is to render a As you can see this quad mesh is made of 3 triangles ,but texture is not evenly distributed on the quad(trapezoid), with 2 triangles it's even worse, There is similar post about this but in opengl The link But how to make it in unity
    50. It definitely sets a mood! I like it quite a bit. I'd really like to see how you could create a suite of themes to match this world. Some that are less ambient, others that can take the core of the melody here and flip it around to support combat, victory, loss, etc.
  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!