Java-Gaming.org    
Featured games (81)
games approved by the League of Dukes
Games in Showcase (499)
Games in Android Showcase (118)
games submitted by our members
Games in WIP (568)
games currently in development
News: Read the Java Gaming Resources, or peek at the official Java tutorials
 
    Home     Help   Search   Login   Register   
Pages: [1]
  ignore  |  Print  
  Facing issues while trying to load a texture  (Read 298 times)
0 Members and 1 Guest are viewing this topic.
Offline arcadiaq

Junior Newbie





« Posted 2013-07-24 18:37:36 »

I'm trying to setup LWJGL space invaders demo and I'm currently facing following issues: 1) I'm unable to load a texture after a setup 2) The project compiles while having cannot resolve symbol 'gl' in few class files
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
85  
86  
87  
88  
89  
90  
91  
92  
93  
94  
95  
96  
97  
98  
99  
100  
101  
102  
103  
104  
105  
106  
107  
108  
109  
110  
111  
112  
113  
114  
115  
116  
117  
118  
119  
120  
121  
122  
123  
124  
125  
126  
127  
128  
129  
130  
131  
132  
133  
134  
135  
136  
137  
138  
139  
140  
141  
142  
143  
144  
145  
146  
147  
148  
149  
150  
151  
package org.newdawn.spaceinvaders.lwjgl;

import org.lwjgl.opengl.GL11;

/**
 * A texture to be bound within JOGL. This object is responsible for
 * keeping track of a given OpenGL texture and for calculating the
 * texturing mapping coordinates of the full image.
 *
 * Since textures need to be powers of 2 the actual texture may be
 * considerably bigged that the source image and hence the texture
 * mapping coordinates need to be adjusted to matchup drawing the
 * sprite against the texture.
 *
 * @author Kevin Glass
 * @author Brian Matzon
 */
public class Texture {
    /** The GL target type */
    private int target;
    /** The GL texture ID */
    private int textureID;
    /** The height of the image */
    private int height;
    /** The width of the image */
    private int width;
    /** The width of the texture */
    private int texWidth;
    /** The height of the texture */
    private int texHeight;
    /** The ratio of the width of the image to the texture */
    private float widthRatio;
    /** The ratio of the height of the image to the texture */
    private float heightRatio;

    /**
     * Create a new texture
     *
     * @param target The GL target
     * @param textureID The GL texture ID
     */

    public Texture(int target,int textureID) {
        this.target = target;
        this.textureID = textureID;
    }

    /**
     * Bind the specified GL context to a texture
     *
     * @param gl The GL context to bind to
     */

    public void bind() {
        GL11.glBindTexture(target, textureID);
    }

   
    /**
     * Set the height of the image
     *
     * @param height The height of the image
     */

    public void setHeight(int height) {
        this.height = height;
        setHeight();
    }
   
    /**
     * Set the width of the image
     *
     * @param width The width of the image
     */

    public void setWidth(int width) {
        this.width = width;
        setWidth();
    }
   
    /**
     * Get the height of the original image
     *
     * @return The height of the original image
     */

    public int getImageHeight() {
        return height;
    }
   
    /**
     * Get the width of the original image
     *
     * @return The width of the original image
     */

    public int getImageWidth() {
        return width;
    }
   
    /**
     * Get the height of the physical texture
     *
     * @return The height of physical texture
     */

    public float getHeight() {
        return heightRatio;
    }
   
    /**
     * Get the width of the physical texture
     *
     * @return The width of physical texture
     */

    public float getWidth() {
        return widthRatio;
    }
   
    /**
     * Set the height of this texture
     *
     * @param texHeight The height of the texture
     */

    public void setTextureHeight(int texHeight) {
        this.texHeight = texHeight;
        setHeight();
    }
   
    /**
     * Set the width of this texture
     *
     * @param texWidth The width of the texture
     */

    public void setTextureWidth(int texWidth) {
        this.texWidth = texWidth;
        setWidth();
    }
   
    /**
     * Set the height of the texture. This will update the
     * ratio also.
     */

    private void setHeight() {
        if (texHeight != 0) {
            heightRatio = ((float) height)/texHeight;
        }
    }
   
    /**
     * Set the width of the texture. This will update the
     * ratio also.
     */

    private void setWidth() {
        if (texWidth != 0) {
            widthRatio = ((float) width)/texWidth;
        }
    }
}


the lines with trouble are
1  
2  
3  
4  
5  
    /**
     * Bind the specified GL context to a texture
     *
     * @param gl The GL context to bind to
     */


here's one of the places in code where I have that issue. I also think the first issue is somehow caused by this "cannot resolve" problem.

I've also tried to Invalidate Caches, didn't help.
Offline gouessej
« Reply #1 - Posted 2013-07-24 18:42:05 »

Hi

What have you tried to do? You claim you use LWJGL but the gl symbol probably comes from JOGL. This class looks like a very old version of our Texture class.

Offline arcadiaq

Junior Newbie





« Reply #2 - Posted 2013-07-24 18:46:46 »

Hi.

I'm basically trying to run a LWJGL very old game demo and it's also using JOGL. You're right, it's a modified version of java-gaming Texture class.

I'd be grateful if you could help me to find out what's wrong with this class, cause it doesn't actually load textures. And also if you could help me to find the newer version of this class.

this is the Texture Loader class I'm also trying to use http://lwjgl.org/wiki/index.php?title=Examples:SpaceInvaders_TextureLoader
Games published by our own members! Check 'em out!
Legends of Yore - The Casual Retro Roguelike
Offline RobinB

JGO Ninja


Medals: 44
Projects: 1
Exp: 3 years


Spacegame in progress


« Reply #3 - Posted 2013-07-24 18:49:20 »

It only holds created textures, the creation is done with the TextureLoader class supplied with the demo.

1  
2  
3  
4  
5  
6  
7  
8  
    /**
     * Bind the specified GL context to a texture
     *
     * @param gl The GL context to bind to
     */

    public void bind() {
        GL11.glBindTexture(target, textureID);
    }


The doc is obviously wrong, because there are no params, best to ignore this line.
Offline arcadiaq

Junior Newbie





« Reply #4 - Posted 2013-07-24 18:54:43 »

Ah well. I see. But what's wrong with the Texture Loader class?

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
85  
86  
87  
88  
89  
90  
91  
92  
93  
94  
95  
96  
97  
98  
99  
100  
101  
102  
103  
104  
105  
106  
107  
108  
109  
110  
111  
112  
113  
114  
115  
116  
117  
118  
119  
120  
121  
122  
123  
124  
125  
126  
127  
128  
129  
130  
131  
132  
133  
134  
135  
136  
137  
138  
139  
140  
141  
142  
143  
144  
145  
146  
147  
148  
149  
150  
151  
152  
153  
154  
155  
156  
157  
158  
159  
160  
161  
162  
163  
164  
165  
166  
167  
168  
169  
170  
171  
172  
173  
174  
175  
176  
177  
178  
179  
180  
181  
182  
183  
184  
185  
186  
187  
188  
189  
190  
191  
192  
193  
194  
195  
196  
197  
198  
199  
200  
201  
202  
203  
204  
205  
206  
207  
208  
209  
210  
211  
212  
213  
214  
215  
216  
217  
218  
219  
220  
221  
222  
223  
224  
225  
226  
227  
228  
229  
230  
231  
public class TextureLoader {
    /** The table of textures that have been loaded in this loader */
    private HashMap table = new HashMap();

    /** The colour model including alpha for the GL image */
    private ColorModel glAlphaColorModel;
   
    /** The colour model for the GL image */
    private ColorModel glColorModel;
   
    /**
     * Create a new texture loader based on the game panel
     *
     * @param gl The GL content in which the textures should be loaded
     */

    public TextureLoader() {
        glAlphaColorModel = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB),
                                            new int[] {8,8,8,8},
                                            true,
                                            false,
                                            ComponentColorModel.TRANSLUCENT,
                                            DataBuffer.TYPE_BYTE);
                                           
        glColorModel = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB),
                                            new int[] {8,8,8,0},
                                            false,
                                            false,
                                            ComponentColorModel.OPAQUE,
                                            DataBuffer.TYPE_BYTE);
    }
   
    /**
     * Create a new texture ID
     *
     * @return A new texture ID
     */

    private int createTextureID()
    {
       IntBuffer tmp = createIntBuffer(1);
       GL11.glGenTextures(tmp);
       return tmp.get(0);
    }
   
    /**
     * Load a texture
     *
     * @param resourceName The location of the resource to load
     * @return The loaded texture
     * @throws IOException Indicates a failure to access the resource
     */

    public Texture getTexture(String resourceName) throws IOException {
        Texture tex = (Texture) table.get(resourceName);
       
        if (tex != null) {
            return tex;
        }
       
        tex = getTexture(resourceName,
                         GL11.GL_TEXTURE_2D, // target
                        GL11.GL_RGBA,     // dst pixel format
                        GL11.GL_LINEAR, // min filter (unused)
                        GL11.GL_LINEAR);
       
        table.put(resourceName,tex);
       
        return tex;
    }
   
    /**
     * Load a texture into OpenGL from a image reference on
     * disk.
     *
     * @param resourceName The location of the resource to load
     * @param target The GL target to load the texture against
     * @param dstPixelFormat The pixel format of the screen
     * @param minFilter The minimising filter
     * @param magFilter The magnification filter
     * @return The loaded texture
     * @throws IOException Indicates a failure to access the resource
     */

    public Texture getTexture(String resourceName,
                              int target,
                              int dstPixelFormat,
                              int minFilter,
                              int magFilter) throws IOException
    {
        int srcPixelFormat = 0;
       
        // create the texture ID for this texture
       int textureID = createTextureID();
        Texture texture = new Texture(target,textureID);
       
        // bind this texture
       GL11.glBindTexture(target, textureID);
 
        BufferedImage bufferedImage = loadImage(resourceName);
        texture.setWidth(bufferedImage.getWidth());
        texture.setHeight(bufferedImage.getHeight());
       
        if (bufferedImage.getColorModel().hasAlpha()) {
            srcPixelFormat = GL11.GL_RGBA;
        } else {
            srcPixelFormat = GL11.GL_RGB;
        }

        // convert that image into a byte buffer of texture data
       ByteBuffer textureBuffer = convertImageData(bufferedImage,texture);
       
        if (target == GL11.GL_TEXTURE_2D)
        {
            GL11.glTexParameteri(target, GL11.GL_TEXTURE_MIN_FILTER, minFilter);
            GL11.glTexParameteri(target, GL11.GL_TEXTURE_MAG_FILTER, magFilter);
        }
 
        // produce a texture from the byte buffer
       GL11.glTexImage2D(target,
                      0,
                      dstPixelFormat,
                      get2Fold(bufferedImage.getWidth()),
                      get2Fold(bufferedImage.getHeight()),
                      0,
                      srcPixelFormat,
                      GL11.GL_UNSIGNED_BYTE,
                      textureBuffer );
       
        return texture;
    }
   
    /**
     * Get the closest greater power of 2 to the fold number
     *
     * @param fold The target number
     * @return The power of 2
     */

    private int get2Fold(int fold) {
        int ret = 2;
        while (ret < fold) {
            ret *= 2;
        }
        return ret;
    }
   
    /**
     * Convert the buffered image to a texture
     *
     * @param bufferedImage The image to convert to a texture
     * @param texture The texture to store the data into
     * @return A buffer containing the data
     */

    private ByteBuffer convertImageData(BufferedImage bufferedImage,Texture texture) {
        ByteBuffer imageBuffer = null;
        WritableRaster raster;
        BufferedImage texImage;
       
        int texWidth = 2;
        int texHeight = 2;
       
        // find the closest power of 2 for the width and height
       // of the produced texture
       while (texWidth < bufferedImage.getWidth()) {
            texWidth *= 2;
        }
        while (texHeight < bufferedImage.getHeight()) {
            texHeight *= 2;
        }
       
        texture.setTextureHeight(texHeight);
        texture.setTextureWidth(texWidth);
       
        // create a raster that can be used by OpenGL as a source
       // for a texture
       if (bufferedImage.getColorModel().hasAlpha()) {
            raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,texWidth,texHeight,4,null);
            texImage = new BufferedImage(glAlphaColorModel,raster,false,new Hashtable());
        } else {
            raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,texWidth,texHeight,3,null);
            texImage = new BufferedImage(glColorModel,raster,false,new Hashtable());
        }
           
        // copy the source image into the produced image
       Graphics g = texImage.getGraphics();
        g.setColor(new Color(0f,0f,0f,0f));
        g.fillRect(0,0,texWidth,texHeight);
        g.drawImage(bufferedImage,0,0,null);
       
        // build a byte buffer from the temporary image
       // that be used by OpenGL to produce a texture.
       byte[] data = ((DataBufferByte) texImage.getRaster().getDataBuffer()).getData();

        imageBuffer = ByteBuffer.allocateDirect(data.length);
        imageBuffer.order(ByteOrder.nativeOrder());
        imageBuffer.put(data, 0, data.length);
        imageBuffer.flip();
       
        return imageBuffer;
    }
   
    /**
     * Load a given resource as a buffered image
     *
     * @param ref The location of the resource to load
     * @return The loaded buffered image
     * @throws IOException Indicates a failure to find a resource
     */

    private BufferedImage loadImage(String ref) throws IOException
    {
        URL url = TextureLoader.class.getClassLoader().getResource(ref);
       
        if (url == null) {
            throw new IOException("Cannot find: "+ref);
        }
       
        BufferedImage bufferedImage = ImageIO.read(new BufferedInputStream(getClass().getClassLoader().getResourceAsStream(ref)));
 
        return bufferedImage;
    }
   
    /**
     * Creates an integer buffer to hold specified ints
     * - strictly a utility method
     *
     * @param size how many int to contain
     * @return created IntBuffer
     */

    protected IntBuffer createIntBuffer(int size) {
      ByteBuffer temp = ByteBuffer.allocateDirect(4 * size);
      temp.order(ByteOrder.nativeOrder());

      return temp.asIntBuffer();
    }    
}


As I'm launching the game I got "Unable to load texture: sprites/gotyou.gif"
Offline RobinB

JGO Ninja


Medals: 44
Projects: 1
Exp: 3 years


Spacegame in progress


« Reply #5 - Posted 2013-07-24 19:38:33 »

Where excactly is this image stored?
Just paste the full folder

Also, im not sure about gifs, why dont you use png's?
Offline davedes
« Reply #6 - Posted 2013-07-24 19:46:19 »

For PNGs you can use Matthias' decoder:
https://github.com/mattdesl/lwjgl-basics/wiki/Textures

Pages: [1]
  ignore  |  Print  
 
 
You cannot reply to this message, because it is very, very old.

 

Add your game by posting it in the WIP section,
or publish it in Showcase.

The first screenshot will be displayed as a thumbnail.

Pippogeek (39 views)
2014-09-24 16:13:29

Pippogeek (30 views)
2014-09-24 16:12:22

Pippogeek (20 views)
2014-09-24 16:12:06

Grunnt (45 views)
2014-09-23 14:38:19

radar3301 (28 views)
2014-09-21 23:33:17

BurntPizza (64 views)
2014-09-21 02:42:18

BurntPizza (33 views)
2014-09-21 01:30:30

moogie (42 views)
2014-09-21 00:26:15

UprightPath (50 views)
2014-09-20 20:14:06

BurntPizza (54 views)
2014-09-19 03:14:18
List of Learning Resources
by Longor1996
2014-08-16 10:40:00

List of Learning Resources
by SilverTiger
2014-08-05 19:33:27

Resources for WIP games
by CogWheelz
2014-08-01 16:20:17

Resources for WIP games
by CogWheelz
2014-08-01 16:19:50

List of Learning Resources
by SilverTiger
2014-07-31 16:29:50

List of Learning Resources
by SilverTiger
2014-07-31 16:26:06

List of Learning Resources
by SilverTiger
2014-07-31 11:54:12

HotSpot Options
by dleskov
2014-07-08 01:59:08
java-gaming.org is not responsible for the content posted by its members, including references to external websites, and other references that may or may not have a relation with our primarily gaming and game production oriented community. inquiries and complaints can be sent via email to the info‑account of the company managing the website of java‑gaming.org
Powered by MySQL Powered by PHP Powered by SMF 1.1.18 | SMF © 2013, Simple Machines | Managed by Enhanced Four Valid XHTML 1.0! Valid CSS!