opengl not drawing some triangles [closed] - c++

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 1 year ago.
Improve this question
In opengl, I was attempting to write a program that would be able to draw multiple rectangles across the screen using triangles. Instead of writing down all of the vertices by hand, I wrote a nested for loop to generate the vertices. However, instead of drawing all the triangles, this program only outputs the last two triangles as a rectangle(see the pictures below). I'm sure that this way of generating triangles is hilariously bad and inefficient but that's not my main gripe with the output of this code.
Below is the nested for loop that adds the vertices to the array(be warned this code is absolutely disgusting)
float initTri1[] = { -1.5f, 0.5f, 0.0f, -1.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f };
float initTri2[] = { -1.5f, 0.5f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.5f, 0.0f };
float vertices[18*4];
float increment =0.0f;
// draws an amount of rectangles equal to the number after 18 in vertices
for (int j = 0; j < sizeof(vertices)/sizeof(vertices[0])/18; j++)
{
increment += 0.5f;
// draws triangle with hypotenuse on right side
for (int i = 0; i < 9; i++)
{
// shifts the value of the initial triangles x verticies by 0.5
if ((i + 1) % 3 != 1)
{
vertices[i+j*9] = initTri1[i];
}
// keeps the y and z values the same as the initial triangle.
else
{
vertices[i+j*9] = initTri1[i] + increment;
}
}
// sometimes draws the triangle with the hypotenuse on the left side
for (int i = 9; i < 18; i++)
{
// shifts the value of the initial triangles x verticies by 0.5
if ((i + 1) % 3 != 1)
{
vertices[i+j*9] = initTri2[i - 9];
}
// keeps the y and z values the same as the initial triangle.
else
{
vertices[i+j*9] = initTri2[i - 9] + increment;
}
}
}
Below are images of the outcome of generating: 2 triangles, 4 triangles, and 8 triangles respectively.

Answer 1

I didn't feel able to follow the index computations of OP. It was easier to try it out. The result looks wrong:
vertices[0]: -1, 0.5, 0
vertices[3]: -1, 0, 0
vertices[6]: -0.5, 0, 0
vertices[9]: -0.5, 0.5, 0
vertices[12]: -0.5, 0, 0
vertices[15]: 0, 0, 0
vertices[18]: 0, 0.5, 0
vertices[21]: 0, 0, 0
vertices[24]: 0.5, 0, 0
vertices[27]: 0.5, 0.5, 0
vertices[30]: 0.5, 0, 0
vertices[33]: 1, 0, 0
vertices[36]: 0.5, 0.5, 0
vertices[39]: 1, 0, 0
vertices[42]: 1, 0.5, 0
vertices[45]: 0, 8.40779e-45, 0
vertices[48]: 8.82286e-39, 0, 8.82332e-39
vertices[51]: 0, 5.87998e-39, 0
vertices[54]: 5.87998e-39, 0, 8.82286e-39
vertices[57]: 0, -4.13785e+09, 4.58841e-41
vertices[60]: 1.4013e-45, 0, 2.8026e-45
vertices[63]: 0, 8.82195e-39, 0
vertices[66]: 5.88135e-39, 0, 0
vertices[69]: 0, 0, 0
Demo on coliru
So, I just rewrote the loops instead of tediously debugging it. (That appeared the lesser evil to me.)
#include <iostream>
int main()
{
float initTri1[] = { -1.5f, 0.5f, 0.0f, -1.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f };
const size_t nTri1 = std::size(initTri1);
float initTri2[] = { -1.5f, 0.5f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.5f, 0.0f };
const size_t nTri2 = std::size(initTri2);
const size_t nRect = 4;
const size_t nVtcs = (nTri1 + nTri2) * nRect;
float vertices[nVtcs];
float increment = 0.0f;
for (size_t j = 0, k = 0; j < nRect; ++j) {
for (size_t i = 2; i < nTri1; i += 3) {
vertices[k++] = initTri1[i - 2] + increment;
vertices[k++] = initTri1[i - 1];
vertices[k++] = initTri1[i - 0];
}
for (size_t i = 2; i < nTri2; i += 3) {
vertices[k++] = initTri2[i - 2] + increment;
vertices[k++] = initTri2[i - 1];
vertices[k++] = initTri2[i - 0];
}
increment += 0.5f;
}
for (size_t k = 0; k < nVtcs; ++k) {
if (k % (nTri1 + nTri2) == 0) std::cout << '\n';
if (k % 3 == 0) {
std::cout << "vertices[" << k << "]: ";
}
std::cout << vertices[k];
std::cout << (k % 3 < 2 ? ", " : "\n");
}
}
Output:
vertices[0]: -1.5, 0.5, 0
vertices[3]: -1.5, 0, 0
vertices[6]: -1, 0, 0
vertices[9]: -1.5, 0.5, 0
vertices[12]: -1, 0, 0
vertices[15]: -1, 0.5, 0
vertices[18]: -1, 0.5, 0
vertices[21]: -1, 0, 0
vertices[24]: -0.5, 0, 0
vertices[27]: -1, 0.5, 0
vertices[30]: -0.5, 0, 0
vertices[33]: -0.5, 0.5, 0
vertices[36]: -0.5, 0.5, 0
vertices[39]: -0.5, 0, 0
vertices[42]: 0, 0, 0
vertices[45]: -0.5, 0.5, 0
vertices[48]: 0, 0, 0
vertices[51]: 0, 0.5, 0
vertices[54]: 0, 0.5, 0
vertices[57]: 0, 0, 0
vertices[60]: 0.5, 0, 0
vertices[63]: 0, 0.5, 0
vertices[66]: 0.5, 0, 0
vertices[69]: 0.5, 0.5, 0
Demo on coliru
The moral of the story:
Simpler code is faster to write.
Simpler code is running sooner.
Simpler code is maintenance friendly.
Profiling it, you might be surprised that simpler code might be even faster.