コード例 #1
0
 /**
  * Initializes the appropriate D3D offscreen surface based on the value of the type parameter. If
  * the surface creation fails for any reason, an OutOfMemoryError will be thrown.
  */
 protected void initSurface() {
   // any time we create or restore the surface, recreate the raster
   synchronized (this) {
     wrn = null;
   }
   // REMIND: somewhere a puppy died
   class Status {
     boolean success = false;
   };
   final Status status = new Status();
   D3DRenderQueue rq = D3DRenderQueue.getInstance();
   rq.lock();
   try {
     rq.flushAndInvokeNow(
         new Runnable() {
           public void run() {
             status.success = initSurfaceNow();
           }
         });
     if (!status.success) {
       throw new InvalidPipeException("Error creating D3DSurface");
     }
   } finally {
     rq.unlock();
   }
 }
コード例 #2
0
    @Override
    void restoreSurface() {
      if (!peer.isAccelCapable()) {
        throw new InvalidPipeException("Onscreen acceleration " + "disabled for this surface");
      }
      Window fsw = graphicsDevice.getFullScreenWindow();
      if (fsw != null && fsw != peer.getTarget()) {
        throw new InvalidPipeException(
            "Can't restore onscreen surface" + " when in full-screen mode");
      }
      super.restoreSurface();
      // if initialization was unsuccessful, an IPE will be thrown
      // and the surface will remain lost
      setSurfaceLost(false);

      // This is to make sure the render target is reset after this
      // surface is restored. The reason for this is that sometimes this
      // surface can be restored from multiple threads (the screen update
      // manager's thread and app's rendering thread) at the same time,
      // and when that happens the second restoration will create the
      // native resource which will not be set as render target because
      // the BufferedContext's validate method will think that since the
      // surface data object didn't change then the current render target
      // is correct and no rendering will appear on the screen.
      D3DRenderQueue rq = D3DRenderQueue.getInstance();
      rq.lock();
      try {
        getContext().invalidateContext();
      } finally {
        rq.unlock();
      }
    }
コード例 #3
0
 public Rectangle getNativeBounds() {
   D3DRenderQueue rq = D3DRenderQueue.getInstance();
   // need to lock to make sure nativeWidth and Height are consistent
   // since they are set from the render thread from the native
   // level
   rq.lock();
   try {
     // REMIND: use xyoffsets?
     return new Rectangle(nativeWidth, nativeHeight);
   } finally {
     rq.unlock();
   }
 }
コード例 #4
0
    protected void setElem(final int x, final int y, final int pixel, final SurfaceData sData) {
      if (sData.isSurfaceLost()) {
        return;
      }

      D3DRenderQueue rq = D3DRenderQueue.getInstance();
      rq.lock();
      try {
        rq.flushAndInvokeNow(
            new Runnable() {
              public void run() {
                dbSetPixelNative(sData.getNativeOps(), x, y, pixel);
              }
            });
        sData.markDirty();
      } finally {
        rq.unlock();
      }
    }
コード例 #5
0
    protected int getElem(final int x, final int y, final SurfaceData sData) {
      if (sData.isSurfaceLost()) {
        return 0;
      }

      int retPixel;
      D3DRenderQueue rq = D3DRenderQueue.getInstance();
      rq.lock();
      try {
        rq.flushAndInvokeNow(
            new Runnable() {
              public void run() {
                pixel = dbGetPixelNative(sData.getNativeOps(), x, y);
              }
            });
      } finally {
        retPixel = pixel;
        rq.unlock();
      }
      return retPixel;
    }
コード例 #6
0
  /**
   * Disposes the native resources associated with the given D3DSurfaceData (referenced by the pData
   * parameter). This method is invoked from the native Dispose() method from the Disposer thread
   * when the Java-level D3DSurfaceData object is about to go away.
   */
  static void dispose(long pData) {
    D3DRenderQueue rq = D3DRenderQueue.getInstance();
    rq.lock();
    try {
      RenderBuffer buf = rq.getBuffer();
      rq.ensureCapacityAndAlignment(12, 4);
      buf.putInt(DISPOSE_SURFACE);
      buf.putLong(pData);

      // this call is expected to complete synchronously, so flush now
      rq.flushNow();
    } finally {
      rq.unlock();
    }
  }
コード例 #7
0
  @Override
  public void flush() {
    D3DRenderQueue rq = D3DRenderQueue.getInstance();
    rq.lock();
    try {
      RenderBuffer buf = rq.getBuffer();
      rq.ensureCapacityAndAlignment(12, 4);
      buf.putInt(FLUSH_SURFACE);
      buf.putLong(getNativeOps());

      // this call is expected to complete synchronously, so flush now
      rq.flushNow();
    } finally {
      rq.unlock();
    }
  }
コード例 #8
0
 static void swapBuffers(
     D3DSurfaceData sd, final int x1, final int y1, final int x2, final int y2) {
   long pData = sd.getNativeOps();
   D3DRenderQueue rq = D3DRenderQueue.getInstance();
   // swapBuffers can be called from the toolkit thread by swing, we
   // should detect this and prevent the deadlocks
   if (rq.isRenderQueueThread()) {
     if (!rq.tryLock()) {
       // if we could not obtain the lock, repaint the area
       // that was supposed to be swapped, and no-op this swap
       final Component target = (Component) sd.getPeer().getTarget();
       SunToolkit.executeOnEventHandlerThread(
           target,
           new Runnable() {
             public void run() {
               target.repaint(x1, y1, x2, y2);
             }
           });
       return;
     }
   } else {
     rq.lock();
   }
   try {
     RenderBuffer buf = rq.getBuffer();
     rq.ensureCapacityAndAlignment(28, 4);
     buf.putInt(SWAP_BUFFERS);
     buf.putLong(pData);
     buf.putInt(x1);
     buf.putInt(y1);
     buf.putInt(x2);
     buf.putInt(y2);
     rq.flushNow();
   } finally {
     rq.unlock();
   }
 }
コード例 #9
0
  static {
    D3DRenderQueue rq = D3DRenderQueue.getInstance();
    d3dImagePipe = new D3DDrawImage();
    d3dTextPipe = new D3DTextRenderer(rq);
    d3dRenderPipe = new D3DRenderer(rq);
    if (GraphicsPrimitive.tracingEnabled()) {
      d3dTextPipe = d3dTextPipe.traceWrap();
      d3dRenderPipe = d3dRenderPipe.traceWrap();
      // The wrapped d3dRenderPipe will wrap the AA pipe as well...
      // d3dAAPgramPipe = d3dRenderPipe.traceWrap();
    }
    d3dAAPgramPipe = d3dRenderPipe.getAAParallelogramPipe();
    d3dTxRenderPipe =
        new PixelToParallelogramConverter(d3dRenderPipe, d3dRenderPipe, 1.0, 0.25, true);

    D3DBlitLoops.register();
    D3DMaskFill.register();
    D3DMaskBlit.register();
  }