Examples of org.gbcpainter.loaders.textures.TextureLoader

org.gbcpainter.loaders.textures.TextureLoader
Definition of a texture loaders
A texture loader manages the lifetime of textures. Each texture is identified by a name. Given its name, the loaders searches and loads the best texture. It also manages the accelerated version of the textures. All these processes is implementation dependent
It exposes methods to load and check the status of the textures and unload them. @author Lorenzo Pellegrini

                                    @NotNull final Iterable<String> resources ) throws Exception {
    super( );
    this.textures = resources;
    this.previousPosition = new Point( initialPosition );


    final TextureLoader loader = GraphicsEnv.getInstance().getTextureLoader();


    for (String resource : resources) {
      try {
        loader.loadTexture( resource, true );
      } catch ( Exception e ) {
        throw new TextureNotFoundException( e );
      }
    }

View Full Code Here


    if ( resourceName == null ) {
      return null;
    }


    final TextureLoader loader = GraphicsEnv.getInstance().getTextureLoader();


    final Dimension dimension = loader.getDimension( resourceName );


    return GraphicsEnv.getInstance().gamePointAndTextureToScreen( animationPosition, dimension );
  }

View Full Code Here

    }
    if ( this.explosionTime >= this.animationEndTime ) {
      throw new IllegalArgumentException();
    }


    final TextureLoader loader = GraphicsEnv.getInstance().getTextureLoader();


    for (String countdownTexture : countdownTextures) {
      loader.loadTexture( countdownTexture, true );
    }


    for (String explosionTexture : explosionTextures) {
      loader.loadTexture( explosionTexture, true );
    }


    loader.loadTexture( BEFORE_ACTIVATION_TEXTURE, true );


  }

View Full Code Here


    if ( resourceName == null ) {
      return null;
    }


    final TextureLoader loader = GraphicsEnv.getInstance().getTextureLoader();


    final Dimension dimension = loader.getDimension( resourceName );


    return GraphicsEnv.getInstance().gamePointAndTextureToScreen( animationPosition, dimension );
  }

View Full Code Here

                                  resourceFromDirection;
    this.resourceNameColored = RESOURCE_NAME_PREFIX +
                               RESOURCE_COLORED +
                               resourceFromDirection;


    final TextureLoader loader = GraphicsEnv.getInstance().getTextureLoader();


    loader.loadTexture( this.resourceNameNotColored, true );


    loader.loadTexture( this.resourceNameColored, true );




    for (String halfJunctionResource : halfJunctionsResources) {
      loader.loadTexture( halfJunctionResource, true );
    }
  }

View Full Code Here

   * @param colored true if colored, false if not colored
   */
  @Override
  public synchronized void setColored( final boolean colored ) throws TextureNotFoundException {
    this.colored = colored;
    final TextureLoader loader = GraphicsEnv.getInstance().getTextureLoader();


    final String requestedTexture;


    if ( colored ) {
      requestedTexture = this.resourceNameColored;
    } else {
      requestedTexture = this.resourceNameNotColored;
    }


    Image texture = loader.getTexture( requestedTexture, true );


    if ( texture == null ) {
      try {
        texture = loader.loadTexture( requestedTexture, true );
      } catch ( Exception e ) {
        throw new TextureNotFoundException( "Can't find texture " + requestedTexture, e );
      }
    }

View Full Code Here

      }
    }






    final TextureLoader loader = GraphicsEnv.getInstance().getTextureLoader();
    //final int baseDimension = GraphicsEnv.getInstance().getBasePointDimension();


    if(!this.voidPipe) {
      if ( isVertical( segment ) ) {
        loader.loadTexture( NON_COLORED_PART_VERTICAL, true );
        /*if ( loader.getBaseDimension( NON_COLORED_PART_VERTICAL ).height !=
              baseDimension ) {
          throw new InvalidTextureException( "Pipe texture " + NON_COLORED_PART_VERTICAL + " has an invalid size!" );
        }*/


        loader.loadTexture( COLORED_PART_VERTICAL, true );
        /*if ( loader.getBaseDimension( COLORED_PART_VERTICAL ).height != baseDimension ) {
          throw new InvalidTextureException( "Pipe texture " + COLORED_PART_VERTICAL + " has an invalid size!" );
        }*/


        loader.loadTexture( COLORED_SLICE_VERTICAL, true );
        loader.loadTexture( NON_COLORED_SLICE_VERTICAL, true );
      } else {
        loader.loadTexture( NON_COLORED_PART_HORIZONTAL, true );
        /*if ( loader.getBaseDimension( NON_COLORED_PART_HORIZONTAL ).width !=
              baseDimension ) {
          throw new InvalidTextureException( "Pipe texture " + NON_COLORED_PART_HORIZONTAL + " has an invalid size!" );
        }*/


        loader.loadTexture( COLORED_PART_HORIZONTAL, true );
        /*if ( loader.getBaseDimension( COLORED_PART_HORIZONTAL ).width != baseDimension ) {
          throw new InvalidTextureException( "Pipe texture " + COLORED_PART_HORIZONTAL + " has an invalid size!" );
        }*/


        loader.loadTexture( COLORED_SLICE_HORIZONTAL, true );
        loader.loadTexture( NON_COLORED_SLICE_HORIZONTAL, true );
      }
    }




  }

View Full Code Here

    if(this.isVoidPipe()) {
      return;
    }


    final Iterable<PipePart> parts = new TreeSet<>( this.colorParts );
    final TextureLoader loader = GraphicsEnv.getInstance().getTextureLoader();
    final Segment pipeSegment = this.getSegment();


    final Dimension textureDimension;


    int gamePosition;
    final int upperLimit;


    /*
      Stampa le texure su schermo.


      Game position mantiene la posizione matematica della tubatura (model), e andrà dall'ascissa dell'estremo
      più a sinistra se la tubatura è orizzontale oppure dall'ordinata dell'estremo superiore se verticale.
      Upperlimit è impostato al limite opposto.


      Viene prima dipinta la parte non colorata, poi la parte colorata.


      screenPosition mantiene la posizione che deve avere la texture su schermo.


      screenPosition viene aggiornato a ogni pezzo di texture come un cursore.


      Questa parte riguarda il disegno delle sole parti non modificate in questo step.
     */
    Rectangle screenRect;
    Point screenPosition;
    final Iterator<Map.Entry<Integer, Boolean>> changedIterator = this.changedParts.entrySet()
                                                                               .iterator();
    Map.Entry<Integer, Boolean> nextSkip = changedIterator.hasNext() ? changedIterator.next() : null;


    if ( this.isVertical() ) {
      textureDimension = loader.getDimension( NON_COLORED_PART_VERTICAL );
      gamePosition = pipeSegment.getMinY();
      upperLimit = pipeSegment.getMaxY();


      for (final PipePart part : parts) {


        for (; gamePosition <= upperLimit && gamePosition < part.getStart(); gamePosition++) {
          screenRect = GraphicsEnv.getInstance().gamePointAndTextureToScreen( new Point( pipeSegment.getXA(), gamePosition ), textureDimension );
          screenPosition = new Point( screenRect.x, screenRect.y );
          final String pickTexture;


          if ( nextSkip != null && nextSkip.getKey() == gamePosition ) {
            pickTexture = ( nextSkip.getValue() ) ? COLORED_PART_VERTICAL : NON_COLORED_PART_VERTICAL;
            nextSkip = changedIterator.hasNext() ? changedIterator.next() : null;
          } else {
            pickTexture = NON_COLORED_PART_VERTICAL;
          }


          this.doDraw( g2, pickTexture, screenPosition );
        }


        for (; gamePosition <= part.getEnd(); gamePosition++) {
          screenRect = GraphicsEnv.getInstance().gamePointAndTextureToScreen( new Point( pipeSegment.getXA(), gamePosition ), textureDimension );
          screenPosition = new Point( screenRect.x, screenRect.y );
          final String pickTexture;


          if ( nextSkip != null && nextSkip.getKey() == gamePosition ) {
            pickTexture = ( nextSkip.getValue() ) ? COLORED_PART_VERTICAL : NON_COLORED_PART_VERTICAL;
            nextSkip = changedIterator.hasNext() ? changedIterator.next() : null;
          } else {
            pickTexture = COLORED_PART_VERTICAL;
          }


          this.doDraw( g2, pickTexture, screenPosition );
        }


      }


      for (; gamePosition <= upperLimit; gamePosition++) {
        screenRect = GraphicsEnv.getInstance().gamePointAndTextureToScreen( new Point( pipeSegment.getXA(), gamePosition ), textureDimension );
        screenPosition = new Point( screenRect.x, screenRect.y );
        final String pickTexture;


        if ( nextSkip != null && nextSkip.getKey() == gamePosition ) {
          pickTexture = ( nextSkip.getValue() ) ? COLORED_PART_VERTICAL : NON_COLORED_PART_VERTICAL;
          nextSkip = changedIterator.hasNext() ? changedIterator.next() : null;
        } else {
          pickTexture = NON_COLORED_PART_VERTICAL;
        }


        this.doDraw( g2, pickTexture, screenPosition );
      }


    } else {
      textureDimension = loader.getDimension( NON_COLORED_PART_HORIZONTAL );


      gamePosition = pipeSegment.getMinX();
      upperLimit = pipeSegment.getMaxX();


      for (final PipePart part : parts) {


        for (; gamePosition <= upperLimit && gamePosition < part.getStart(); gamePosition++) {
          screenRect = GraphicsEnv.getInstance().gamePointAndTextureToScreen( new Point( gamePosition, pipeSegment.getYA() ), textureDimension );
          screenPosition = new Point( screenRect.x, screenRect.y );
          final String pickTexture;


          if ( nextSkip != null && nextSkip.getKey() == gamePosition ) {
            pickTexture = ( nextSkip.getValue() ) ? COLORED_PART_HORIZONTAL : NON_COLORED_PART_HORIZONTAL;
            nextSkip = changedIterator.hasNext() ? changedIterator.next() : null;
          } else {
            pickTexture = NON_COLORED_PART_HORIZONTAL;
          }
          this.doDraw( g2, pickTexture, screenPosition );


        }


        for (; gamePosition <= part.getEnd(); gamePosition++) {


          screenRect = GraphicsEnv.getInstance().gamePointAndTextureToScreen( new Point( gamePosition, pipeSegment.getYA() ), textureDimension );
          screenPosition = new Point( screenRect.x, screenRect.y );
          final String pickTexture;


          if ( nextSkip != null && nextSkip.getKey() == gamePosition ) {
            pickTexture = ( nextSkip.getValue() ) ? COLORED_PART_HORIZONTAL : NON_COLORED_PART_HORIZONTAL;
            nextSkip = changedIterator.hasNext() ? changedIterator.next() : null;
          } else {
            pickTexture = COLORED_PART_HORIZONTAL;
          }
          this.doDraw( g2, pickTexture, screenPosition );
        }
      }


      for (; gamePosition <= upperLimit; gamePosition++) {


        screenRect = GraphicsEnv.getInstance().gamePointAndTextureToScreen( new Point( gamePosition, pipeSegment.getYA() ), textureDimension );
        screenPosition = new Point( screenRect.x, screenRect.y );
        final String pickTexture;


        if ( nextSkip != null && nextSkip.getKey() == gamePosition ) {
          pickTexture = ( nextSkip.getValue() ) ? COLORED_PART_HORIZONTAL : NON_COLORED_PART_HORIZONTAL;
          nextSkip = changedIterator.hasNext() ? changedIterator.next() : null;
        } else {
          pickTexture = NON_COLORED_PART_HORIZONTAL;
        }
        this.doDraw( g2, pickTexture, screenPosition );
      }


    }
    assert ! changedIterator.hasNext();


    /*
      Draws the modified parts on screen


      Modified parts are drawn as slices from the lower coordinate (leftmost X coordinate
      is horizontal, upper Y coordinate if vertical) to the upper one of the animation part
     */
    if ( ! this.coloringAnimations.isEmpty() ) {
      boolean remainingAnimations = false;
      if ( this.isVertical() ) {
        for (PipeColoringAnimation animation : this.coloringAnimations) {
          final Line2D donePart = animation.getDonePart();
          if ( donePart == null ) {
            continue;
          }


          final boolean colored = animation.isColoring();
          @NonNls
          final String selectedTexture = colored ? COLORED_SLICE_VERTICAL : NON_COLORED_SLICE_VERTICAL;
          final Dimension sliceDimension = loader.getDimension( selectedTexture );
          final Rectangle screenRealPosition = GraphicsEnv.getInstance().gamePointAndTextureToScreen( donePart.getP1(), sliceDimension );
          final Rectangle screenRealPositionUpper = GraphicsEnv.getInstance().gamePointAndTextureToScreen( donePart.getP2(), sliceDimension );
          final int lowerY = Math.min( screenRealPosition.y, screenRealPositionUpper.y );
          final int upperY = Math.max( screenRealPosition.y, screenRealPositionUpper.y );


          Point cursor = new Point( screenRealPosition.x, lowerY );
          for (; cursor.y < upperY; cursor.y++) {
            this.doDraw( g2, selectedTexture, cursor );
          }


          if ( ! animation.isTerminated() ) {
            remainingAnimations = true;
          }
        }
      } else {


        for (PipeColoringAnimation animation : this.coloringAnimations) {
          final Line2D donePart = animation.getDonePart();
          if ( donePart == null ) {
            continue;
          }


          final boolean colored = animation.isColoring();
          @NonNls
          final String selectedTexture = colored ? COLORED_SLICE_HORIZONTAL : NON_COLORED_SLICE_HORIZONTAL;
          final Dimension sliceDimension = loader.getDimension( selectedTexture );
          final Rectangle screenRealPosition = GraphicsEnv.getInstance().gamePointAndTextureToScreen( donePart.getP1(), sliceDimension );
          final Rectangle screenRealPositionUpper = GraphicsEnv.getInstance().gamePointAndTextureToScreen( donePart.getP2(), sliceDimension );
          final int lowerX = Math.min( screenRealPosition.x, screenRealPositionUpper.x );
          final int upperX = Math.max( screenRealPosition.x, screenRealPositionUpper.x );

View Full Code Here

  }


  private void doDraw( final @NotNull Graphics2D g2, final @NotNull String resourceName, final @NotNull Point where ) throws Exception {
    boolean done = false;
    boolean tryAcceleration = true;
    final TextureLoader loader = GraphicsEnv.getInstance().getTextureLoader();


    do {
      final Image img = loader.loadTexture( resourceName, tryAcceleration );
      g2.drawImage( img, where.x, where.y, null );
      try {
        if ( ! loader.mustReload( resourceName, tryAcceleration ) ) {
          done = true;
        }
      } catch ( NoSuchElementException e ) {
        if ( ! tryAcceleration ) {
          throw new TextureNotFoundException( e );

View Full Code Here

0 1

TOP

Related Classes of org.gbcpainter.loaders.textures.TextureLoader

org.gbcpainter.game.model.grid.JunctionImpl

org.gbcpainter.game.model.grid.PipeImpl

org.gbcpainter.game.model.monsters.BombImpl

org.gbcpainter.game.view.AbstractResourceDrawable

org.gbcpainter.game.view.animations.SingleSlotAnimatedElement

org.gbcpainter.game.view.animations.SlotAnimatedElement

org.gbcpainter.game.view.SlotResourceDrawable

org.gbcpainter.test.TextureLoaderTest

org.gbcpainter.test.TransparencyTextureLoadingTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.