src/main/java/eu/svjatoslav/sixth/e3d/gui/ViewPanel.java

   1 /*
   2  * Sixth 3D engine. Author: Svjatoslav Agejenko.
   3  * This project is released under Creative Commons Zero (CC0) license.
   4  *
   5 *
   6  */
   7
   8 package eu.svjatoslav.sixth.e3d.gui;
   9
  10 import eu.svjatoslav.sixth.e3d.gui.humaninput.HIDInputTracker;
  11 import eu.svjatoslav.sixth.e3d.gui.humaninput.KeyboardFocusStack;
  12 import eu.svjatoslav.sixth.e3d.renderer.raster.ShapeCollection;
  13
  14 import javax.swing.*;
  15 import java.awt.*;
  16 import java.awt.event.ComponentEvent;
  17 import java.awt.event.ComponentListener;
  18 import java.util.Set;
  19 import java.util.Timer;
  20 import java.util.concurrent.ConcurrentHashMap;
  21
  22 /**
  23  * Java Swing GUI panel that contains canvas for 3D rendering.
  24  */
  25 public class ViewPanel extends JPanel implements ComponentListener {
  26     private static final long serialVersionUID = 1683277888885045387L;
  27     public Color backgroundColor = Color.BLACK;
  28     private final HIDInputTracker HIDInputTracker = new HIDInputTracker(this);
  29     private final KeyboardFocusStack keyboardFocusStack;
  30     private final Avatar avatar = new Avatar();
  31     private final ShapeCollection rootShapeCollection = new ShapeCollection();
  32     private final Set<ViewRenderListener> viewRenderListeners = ConcurrentHashMap.newKeySet();
  33     /**
  34      * Last time this view was updated.
  35      */
  36     private long lastUpdateMillis = 0;
  37     private Timer canvasUpdateTimer;
  38     private ViewUpdateTimerTask canvasUpdateTimerTask;
  39     private RenderingContext renderingContext = null;
  40     /**
  41      * Currently target FPS for this view. It can be changed at runtime. Also when nothing
  42      * changes in the view, then frames are not really repainted.
  43      */
  44     private int targetFPS = 30;
  45     /**
  46      * Set to true if it is known than next frame reeds to be painted. Flag is cleared
  47      * immediately after frame got updated.
  48      */
  49     private boolean viewRepaintNeeded = true;
  50
  51     public ViewPanel() {
  52         viewRenderListeners.add(avatar);
  53         viewRenderListeners.add(HIDInputTracker);
  54
  55         keyboardFocusStack = new KeyboardFocusStack(this);
  56
  57         initializePanelLayout();
  58
  59         setFrameRate(targetFPS);
  60
  61         addComponentListener(this);
  62     }
  63
  64     public Avatar getAvatar() {
  65         return avatar;
  66     }
  67
  68     public KeyboardFocusStack getKeyboardFocusStack() {
  69         return keyboardFocusStack;
  70     }
  71
  72     public ShapeCollection getRootShapeCollection() {
  73         return rootShapeCollection;
  74     }
  75
  76     public HIDInputTracker getHIDInputTracker() {
  77         return HIDInputTracker;
  78     }
  79
  80     public void addViewUpdateListener(final ViewRenderListener listener) {
  81         viewRenderListeners.add(listener);
  82     }
  83
  84     @Override
  85     public void componentHidden(final ComponentEvent e) {
  86
  87     }
  88
  89     @Override
  90     public void componentMoved(final ComponentEvent e) {
  91
  92     }
  93
  94     @Override
  95     public void componentResized(final ComponentEvent e) {
  96         viewRepaintNeeded = true;
  97     }
  98
  99     @Override
 100     public void componentShown(final ComponentEvent e) {
 101         viewRepaintNeeded = true;
 102     }
 103
 104     @Override
 105     public Dimension getMaximumSize() {
 106         return getPreferredSize();
 107     }
 108
 109     @Override
 110     public Dimension getMinimumSize() {
 111         return getPreferredSize();
 112     }
 113
 114     @Override
 115     public java.awt.Dimension getPreferredSize() {
 116         return new java.awt.Dimension(640, 480);
 117     }
 118
 119     public RenderingContext getRenderingContext() {
 120         return renderingContext;
 121     }
 122
 123     private void initializePanelLayout() {
 124         setFocusCycleRoot(true);
 125         setOpaque(true);
 126         setFocusable(true);
 127         setDoubleBuffered(false);
 128         setVisible(true);
 129         requestFocusInWindow();
 130     }
 131
 132     private void renderFrame() {
 133         // paint root geometry collection to the offscreen render buffer
 134         clearCanvas();
 135         rootShapeCollection.paint(this, renderingContext);
 136
 137         // draw rendered offscreen buffer to visible screen
 138         final Graphics graphics = getGraphics();
 139         if (graphics != null)
 140             graphics.drawImage(renderingContext.bufferedImage, 0, 0, null);
 141     }
 142
 143     private void clearCanvas() {
 144         renderingContext.graphics.setColor(backgroundColor);
 145         renderingContext.graphics.fillRect(0, 0, getWidth(), getHeight());
 146     }
 147
 148     /**
 149      * Calling this methods tells 3D engine that current 3D view needs to be
 150      * repainted on first opportunity.
 151      */
 152     public void repaintDuringNextViewUpdate() {
 153         viewRepaintNeeded = true;
 154     }
 155
 156     public void setFrameRate(final int frameRate) {
 157         if (canvasUpdateTimerTask != null) {
 158             canvasUpdateTimerTask.cancel();
 159             canvasUpdateTimerTask = null;
 160
 161             canvasUpdateTimer.cancel();
 162             canvasUpdateTimer = null;
 163         }
 164
 165         targetFPS = frameRate;
 166
 167         if (frameRate > 0) {
 168             canvasUpdateTimer = new Timer();
 169             canvasUpdateTimerTask = new ViewUpdateTimerTask(this);
 170
 171             canvasUpdateTimer.schedule(canvasUpdateTimerTask, 0,
 172                     1000 / frameRate);
 173         }
 174     }
 175
 176     public void stop() {
 177         if (canvasUpdateTimerTask != null) {
 178             canvasUpdateTimerTask.cancel();
 179             canvasUpdateTimerTask = null;
 180         }
 181
 182         if (canvasUpdateTimer != null) {
 183             canvasUpdateTimer.cancel();
 184             canvasUpdateTimer = null;
 185         }
 186     }
 187
 188     /**
 189      * This method is executed by periodic timer task, in frequency according to
 190      * defined frame rate.
 191      * <p>
 192      * It tells view to update itself. View can decide if actual re-rendering of
 193      * graphics is needed.
 194      */
 195     void updateView() {
 196         maintainRenderingContext();
 197
 198         final int millisecondsPassedSinceLastUpdate = getMillisecondsPassedSinceLastUpdate();
 199
 200         boolean renderFrame = notifyViewRenderListeners(millisecondsPassedSinceLastUpdate);
 201
 202         if (viewRepaintNeeded) {
 203             viewRepaintNeeded = false;
 204             renderFrame = true;
 205         }
 206
 207         // abort rendering if window size is invalid
 208         if ((getWidth() > 0) && (getHeight() > 0) && renderFrame) {
 209             renderFrame();
 210             viewRepaintNeeded = renderingContext.handleDetectedComponentMouseEvents();
 211         }
 212
 213     }
 214
 215     private void maintainRenderingContext() {
 216         int panelWidth = getWidth();
 217         int panelHeight = getHeight();
 218
 219         if (panelWidth <= 0 || panelHeight <=0){
 220             renderingContext = null;
 221             return;
 222         }
 223
 224         if ((renderingContext == null)
 225                 || (renderingContext.width != panelWidth)
 226                 || (renderingContext.height != panelHeight)) {
 227             renderingContext = new RenderingContext(panelWidth, panelHeight);
 228         }
 229
 230         renderingContext.prepareForNewFrameRendering();
 231     }
 232
 233     private boolean notifyViewRenderListeners(int millisecondsPassedSinceLastUpdate) {
 234         boolean reRenderFrame = false;
 235         for (final ViewRenderListener listener : viewRenderListeners)
 236             if (listener.beforeRender(this, millisecondsPassedSinceLastUpdate))
 237                 reRenderFrame = true;
 238         return reRenderFrame;
 239     }
 240
 241     private int getMillisecondsPassedSinceLastUpdate() {
 242         final long currentTime = System.currentTimeMillis();
 243
 244         if (lastUpdateMillis == 0)
 245             lastUpdateMillis = currentTime;
 246
 247         final int millisecondsPassedSinceLastUpdate = (int) (currentTime - lastUpdateMillis);
 248         lastUpdateMillis = currentTime;
 249         return millisecondsPassedSinceLastUpdate;
 250     }
 251
 252     public void addViewRenderListener(ViewRenderListener viewRenderListener) {
 253         viewRenderListeners.add(viewRenderListener);
 254     }
 255
 256     public void removeViewRenderListener(ViewRenderListener viewRenderListener) {
 257         viewRenderListeners.remove(viewRenderListener);
 258     }
 259
 260 }