sierpinski | makes a sierpinski triangle of a user-specified height | Canvas library

Class with virtual methods has implicit field - pointer to VMT (virtual method table). You can check it by printing sizeof(Vx) with and without virtual methods. Internal representation of classes and structs is not specified by the C++ standards and varies between compilers, so you should not pass classes with virtual methods to functions like glBufferData.

There seems to be a couple of bugs in your code:

1. n-- does not return n-1, but rather n. You should replace it with n-1.
2. There are few issues with filledTriangle. The (x,y) pairings you create are: (x-x, y), (x, y), and (x/2, height). The (x,y) pairing is a correct point, but the other two are not. Instead you should use (x-length/2,y+height) and (x-length, y) for the top and left points on the triangle.
3. When you call sierpinski recursively, you should pass it x instead of x+x/2. This is because, in this program, you are using the bottom right triangle vertex as the primary vertex. When drawing the right side of the sierpinski triangle, this vertex stays the same.

...and then calls itself three times with the value n-1... means you just need to duplicate calls to sierpinski((n-1)) one after the other 3 times as below:

The "midpoint triangle" inside another triangle is defined by a triangle who's co-ordinates are the mid-points of the sides of the surrounding triangle:

So for each line/side of your triangle, calculate the midpoint:

One can use Python's builtin number parsing to speed up CoordinatesOfString, which is the bottleneck. The key is that each number can be split into a separate number for each digit, which can be individually translated and merged via addition.

For example, the number 110A0A1 can be decomposed to the sum of

• the 0-digits 0000000 or 0,
• the 1-digits 1100001 or 1100001,
• the A-digits 000A0A0 or A * 0001010.

We can use str.replace to transform the initial literal to the 1-digit and A-digit literals. Using int(..., 2) allows to parse these as binary literals.

I also have to do this for the course i'm doing at Massey Uni. The function I used was:

When you want to change the color of your vertices over time, you probably want to modify it frame by frame as in the example at the following link:

https://godbolt.org/z/Y1brGx

I have set up a simple way of making those structures change their values during the rendering loop; you can get [more] creative with that once you got the idea. What is important is that you update the data in your structures and you load the new data in the vertex buffer object at each frame, so that the vertex shader and the fragment shader can read the new values.

Note that you can make the colors change during each frame in different ways; another idea could be using random numbers to set the colors' components.

As a side note, you should be able to pass vertices.data() to glBufferData as a pointer to your vertex data, and avoid declaring an array of Points for it.

Any modification on the GUI only yields visual results after it returns. In the meantime JavaFX cannot handle any events and freezes, until your operation is done.

You can use a Timeline to execute the operation one step at a time though: Use a stack the data for one drawing execution; this allows you to do one drawing operation at a time in addition to modifying the stack for every frame of the Timeline.

The problem was that you were duplicating the Point-based code in the midpt() method in your plotPoints() method, but for tuples instead of Points. Since the triangle is handed to us as a list of tuples, we convert that to a list of Points, and modify our plot() method to accept a Point, and run the whole plotPoints() method in terms of Points: