protected D3DSurfaceData(
      WComponentPeer peer,
      D3DGraphicsConfig gc,
      int width,
      int height,
      Image image,
      ColorModel cm,
      int numBackBuffers,
      int swapEffect,
      VSyncType vSyncType,
      int type) {
    super(getCustomSurfaceType(type), cm);
    this.graphicsDevice = gc.getD3DDevice();
    this.peer = peer;
    this.type = type;
    this.width = width;
    this.height = height;
    this.offscreenImage = image;
    this.backBuffersNum = numBackBuffers;
    this.swapEffect = swapEffect;
    this.syncType = vSyncType;

    initOps(graphicsDevice.getScreen(), width, height);
    if (type == WINDOW) {
      // we put the surface into the "lost"
      // state; it will be restored by the D3DScreenUpdateManager
      // prior to rendering to it for the first time. This is done
      // so that vram is not wasted for surfaces never rendered to
      setSurfaceLost(true);
    } else {
      initSurface();
    }
    setBlitProxyKey(gc.getProxyKey());
  }
 @Override
 protected MaskFill getMaskFill(SunGraphics2D sg2d) {
   if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) {
     /*
      * We can only accelerate non-Color MaskFill operations if
      * all of the following conditions hold true:
      *   - there is an implementation for the given paintState
      *   - the current Paint can be accelerated for this destination
      *   - multitexturing is available (since we need to modulate
      *     the alpha mask texture with the paint texture)
      *
      * In all other cases, we return null, in which case the
      * validation code will choose a more general software-based loop.
      */
     if (!D3DPaints.isValid(sg2d) || !graphicsDevice.isCapPresent(CAPS_MULTITEXTURE)) {
       return null;
     }
   }
   return super.getMaskFill(sg2d);
 }
 public GraphicsConfiguration getDeviceConfiguration() {
   return graphicsDevice.getDefaultConfiguration();
 }
  public void validatePipe(SunGraphics2D sg2d) {
    TextPipe textpipe;
    boolean validated = false;

    // REMIND: the D3D pipeline doesn't support XOR!, more
    // fixes will be needed below. For now we disable D3D rendering
    // for the surface which had any XOR rendering done to.
    if (sg2d.compositeState >= sg2d.COMP_XOR) {
      super.validatePipe(sg2d);
      sg2d.imagepipe = d3dImagePipe;
      disableAccelerationForSurface();
      return;
    }

    // D3DTextRenderer handles both AA and non-AA text, but
    // only works with the following modes:
    // (Note: For LCD text we only enter this code path if
    // canRenderLCDText() has already validated that the mode is
    // CompositeType.SrcNoEa (opaque color), which will be subsumed
    // by the CompositeType.SrcNoEa (any color) test below.)

    if (
    /* CompositeType.SrcNoEa (any color) */
    (sg2d.compositeState <= sg2d.COMP_ISCOPY && sg2d.paintState <= sg2d.PAINT_ALPHACOLOR)
        ||

        /* CompositeType.SrcOver (any color) */
        (sg2d.compositeState == sg2d.COMP_ALPHA
            && sg2d.paintState <= sg2d.PAINT_ALPHACOLOR
            && (((AlphaComposite) sg2d.composite).getRule() == AlphaComposite.SRC_OVER))
        ||

        /* CompositeType.Xor (any color) */
        (sg2d.compositeState == sg2d.COMP_XOR && sg2d.paintState <= sg2d.PAINT_ALPHACOLOR)) {
      textpipe = d3dTextPipe;
    } else {
      // do this to initialize textpipe correctly; we will attempt
      // to override the non-text pipes below
      super.validatePipe(sg2d);
      textpipe = sg2d.textpipe;
      validated = true;
    }

    PixelToParallelogramConverter txPipe = null;
    D3DRenderer nonTxPipe = null;

    if (sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON) {
      if (sg2d.paintState <= sg2d.PAINT_ALPHACOLOR) {
        if (sg2d.compositeState <= sg2d.COMP_XOR) {
          txPipe = d3dTxRenderPipe;
          nonTxPipe = d3dRenderPipe;
        }
      } else if (sg2d.compositeState <= sg2d.COMP_ALPHA) {
        if (D3DPaints.isValid(sg2d)) {
          txPipe = d3dTxRenderPipe;
          nonTxPipe = d3dRenderPipe;
        }
        // custom paints handled by super.validatePipe() below
      }
    } else {
      if (sg2d.paintState <= sg2d.PAINT_ALPHACOLOR) {
        if (graphicsDevice.isCapPresent(CAPS_AA_SHADER)
            && (sg2d.imageComp == CompositeType.SrcOverNoEa
                || sg2d.imageComp == CompositeType.SrcOver)) {
          if (!validated) {
            super.validatePipe(sg2d);
            validated = true;
          }
          PixelToParallelogramConverter aaConverter =
              new PixelToParallelogramConverter(
                  sg2d.shapepipe, d3dAAPgramPipe, 1.0 / 8.0, 0.499, false);
          sg2d.drawpipe = aaConverter;
          sg2d.fillpipe = aaConverter;
          sg2d.shapepipe = aaConverter;
        } else if (sg2d.compositeState == sg2d.COMP_XOR) {
          // install the solid pipes when AA and XOR are both enabled
          txPipe = d3dTxRenderPipe;
          nonTxPipe = d3dRenderPipe;
        }
      }
      // other cases handled by super.validatePipe() below
    }

    if (txPipe != null) {
      if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) {
        sg2d.drawpipe = txPipe;
        sg2d.fillpipe = txPipe;
      } else if (sg2d.strokeState != sg2d.STROKE_THIN) {
        sg2d.drawpipe = txPipe;
        sg2d.fillpipe = nonTxPipe;
      } else {
        sg2d.drawpipe = nonTxPipe;
        sg2d.fillpipe = nonTxPipe;
      }
      // Note that we use the transforming pipe here because it
      // will examine the shape and possibly perform an optimized
      // operation if it can be simplified.  The simplifications
      // will be valid for all STROKE and TRANSFORM types.
      sg2d.shapepipe = txPipe;
    } else {
      if (!validated) {
        super.validatePipe(sg2d);
      }
    }

    // install the text pipe based on our earlier decision
    sg2d.textpipe = textpipe;

    // always override the image pipe with the specialized D3D pipe
    sg2d.imagepipe = d3dImagePipe;
  }
 /**
  * For now, we can only render LCD text if: - the pixel shaders are available, and - blending is
  * disabled, and - the source color is opaque - and the destination is opaque
  */
 public boolean canRenderLCDText(SunGraphics2D sg2d) {
   return graphicsDevice.isCapPresent(CAPS_LCD_SHADER)
       && sg2d.compositeState <= SunGraphics2D.COMP_ISCOPY
       && sg2d.paintState <= SunGraphics2D.PAINT_OPAQUECOLOR
       && sg2d.surfaceData.getTransparency() == Transparency.OPAQUE;
 }
 /** Returns the D3DContext for the GraphicsConfig associated with this surface. */
 public final D3DContext getContext() {
   return graphicsDevice.getContext();
 }
 @Override
 public SurfaceDataProxy makeProxyFor(SurfaceData srcData) {
   return D3DSurfaceDataProxy.createProxy(
       srcData, (D3DGraphicsConfig) graphicsDevice.getDefaultConfiguration());
 }