Phyloa

In part 1, all we did was set up a window. In part 2, I want to show how Graphics2D can be used to draw cool stuff.

Note: I won’t show the code for creating the window or looping through the frames. I’ll assume you either have that code or some other piece of code with a game loop and a Graphics2D object.

First I want to show how to use setColor() and drawLine(). There are many other drawing commands, check the Graphics2D Javadoc for the full list. Here is the code:

And here is what it draws: The code is pretty straightforward here. I set the draw color to black, then fill a background. I then move the origin to the center of the screen, and set mag, the radius of the circle, and incAmt, the angle size of each “slice”.

The for block loops from 0 to 2PI. It first chooses a color, using the Color.getHSBColor() method. It then creates a Polygon object, and adds three points, one at the center, one at the edge of the circle, and one at the next edge. Finally it fills the polygon on the screen.

The next example is much simpler. Here is the code:

And here is what it looks like:

Note:  I’m drawing this continually each frame, so I don’t fill a rectangle at the beginning to clear each frame.  Also, I move the origin into the negative by the circles’ radius. This is because drawOval() draws from the top left, not from the center.

Each frame I choose a random color, and then draw it randomly on the screen. That’s It!

In this series of articles I want to show a few fun things that can be done easily in java. Most of these have to do with graphics. Programming became much more fun for me when I could visualize what I was doing on screen. Java makes it very easy to do this. In this first article, I will show how to create a window that can be drawn into using a game loop.

The first thing we are going to need is a window to draw in. Here is the complete code, I will explain it more below.

Here are the fields we use:

The JFrame is the outer window that contains all the components.

The Canvas is the component we will be drawing onto.

The BufferStrategy allows what we draw to be shown smoothly on the screen with no flickering. Go to the BufferStrategy Javadocs to learn more.

The Graphics2D class gives us nice methods for drawing geometry, text, and images.

The program will run while running == true;

In the constructor we set everything up.

The constructor takes two parameters. These are the width and height of the canvas.

We initialize the JFrame, and then set its close operation to stop the program when the window is closed.

We then initialize the canvas, and set it’s preferred size. We add the canvas to the center of the JFrame, and then pack the JFrame. Packing causes the frame to resize itself to allow the interior elements to be at their preferred size.

Then, we tell the canvas to create a BufferStrategy, and then we get a reference to it. Finally, we set the window to visible, so it will show up on the screen.

Our program uses a “game loop”, which means a function is called every frame which lets us draw to the screen. void start() is the function.

Most of the function is within a while loop.

First we get the graphics context, and then call our update function. After we have finished drawing to the screen, we dispose of the Graphics2d object and tell the BufferStrategy to draw to the screen. We then wait for 10 milliseconds.

Note: Waiting for a constant amount of time will not give constant frame rates. A better strategy is to ask how long it’s been since the last frame, and wait until a preset amount of time has passed. I’m doing this just for simplicity.

The update function is where the logic and drawing commands will go.

In this example I draw a rectangle in the center of the screen. Then I set the color to blue and draw some text in the rectangle.

The main method is pretty simple. I new up a BasicWindow, and then call start().

Here is what the finished program looks like when run.

Pretty boring, I know. But now we have a framework upon which we can do a whole lot more.

Source Code