Part of the Khronos Group
OpenGL.org

The Industry's Foundation for High Performance Graphics

from games to virtual reality, mobile phones to supercomputers

Results 1 to 8 of 8

Thread: model textures being redirected to font textures

  1. #1
    Junior Member Newbie Tcll5850's Avatar
    Join Date
    Feb 2014
    Posts
    23

    model textures being redirected to font textures

    ok, so here's something I've been trying to wrap my mind around for a few days now...
    google seems to not have what I'm looking for...
    (prbly because I don't know what I'm looking for)

    anyways... the issue is with the model drawn on display...
    my GUI's font is redirecting the model's first texture to the texture of the last letter drawn on screen:


    but as soon as fonts are not displayed, it draws normally again:


    think you might be able to reference me any possible causes for this??

    I don't feel like sharing my code because there's quite alot that goes into it...
    but the basic principle is the entire model is a single display list drawn using the old FFP.
    and of course, the floor is another display list... :P
    but after that, each character of the font is it's own display list drawn under a separate system.

    once the model is imported, the first frame displays properly, but upon the 2nd frame, that's when the switch happens...
    (that's how I know the first texture is replaced with the last texture... even though the primary material has it's own texture)

    I don't have a material set for the font-lists... could this be the problem??

    or perhapse maybe it's something I don't know I have enabled at the wrong times... >_>
    I'm literally lost here... D:

  2. #2
    Senior Member OpenGL Pro
    Join Date
    Jan 2012
    Location
    Australia
    Posts
    1,117
    Look at the order of texture bindings - it sound like you are binding the texture for drawing before the gui display.

  3. #3
    Junior Member Newbie Tcll5850's Avatar
    Join Date
    Feb 2014
    Posts
    23
    well... the model is drawn first, so the order of the model's texture images are created when the model is imported,
    and bound when drawn via the display list, then the depth is cleared and the GUI is drawn,
    fonts are created upon GUI init, and bound when referenced.

    as far as creation times, the font textures are created first,
    however the system uses SDL so the GL context is redone upon window resize,
    so the order changes here, but that doesn't seem to affect anything...

    note: the GUI is actually an addable module, so everything for the GUI is separate.

    not sure if that clarifies things much though... >.>

  4. #4
    Senior Member OpenGL Pro
    Join Date
    Jan 2012
    Location
    Australia
    Posts
    1,117
    I would check your code carefully from what you describe you are not binding the texture inside the display list so the image is rendered with the last bound texture which by the time you get your second frame is the font texture.

  5. #5
    Junior Member Newbie Tcll5850's Avatar
    Join Date
    Feb 2014
    Posts
    23
    oh... I mis-stated myself then... or forgot to state something... >.>

    no, initially, the fonts are created first:
    Code :
            __GL.glEnable(__GL.GL_TEXTURE_2D)
     
            texture = __GL.glGenTextures(1)
     
            __GL.glBindTexture(__GL.GL_TEXTURE_2D, texture)
            __GL.glTexParameteri(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_MAG_FILTER, __GL.GL_LINEAR)
            __GL.glTexParameteri(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_MIN_FILTER, __GL.GL_LINEAR)
            __GL.glTexImage2D(
                __GL.GL_TEXTURE_2D, # target texture type
                0, # number of mipmaps
                __GL.GL_RGBA, # texture format
                data_w, data_h,
                0, #border
                __GL.GL_RGBA, # input pixel format
                __GL.GL_UNSIGNED_BYTE, # input data format
                data) # pixel data
     
            __GL.glDisable(__GL.GL_TEXTURE_2D)
    along with the display lists that draw the textured quads:
    Code :
            list = __GL.glGenLists(1)
            __GL.glNewList( list, __GL.GL_COMPILE )
     
            __GL.glBindTexture(__GL.GL_TEXTURE_2D, texture)
            __GL.glBegin(__GL.GL_QUADS)
            __GL.glTexCoord2f(0.0, 0.0); __GL.glVertex2f(0.0, 0.0)
            __GL.glTexCoord2f(0.0, 1.0); __GL.glVertex2f(0.0, data_h)
            __GL.glTexCoord2f(1.0, 1.0); __GL.glVertex2f(data_w, data_h)
            __GL.glTexCoord2f(1.0, 0.0); __GL.glVertex2f(data_w, 0.0)
            __GL.glEnd()
     
     
            __GL.glEndList()
    this is what gets drawn after the models which currently don't exist...

    once the models are imported, everything is initialized once (following the same method above)
    textures created:
    Code :
        __GL.glEnable(__GL.GL_TEXTURE_2D)
     
        __GL.glDeleteTextures(__GL_TEX.values()) #clear the last model's textures
        __GL_TEX.clear() #remove the reference IDs
     
        #(re)define textures here
        __GL.glPixelStorei(__GL.GL_UNPACK_ALIGNMENT,1)
     
        for ImageName,ImageW,ImageH,ImagePixels,ImageColors in Libs[7]:
            image = bytearray()
            if len(ImageColors)==0:
                ImageFormat = len(ImagePixels[0])-1 #I, IA, RGB, or RGBA format
                for IRAGBA in ImagePixels: image += bytearray(IRAGBA)
            else:
                ImageFormat = len(ImageColors[0])-1 #I, IA, RGB, or RGBA format
                for I in ImagePixels: image += bytearray(ImageColors[I])
     
            __GL_TEX[ImageName] = __GL.glGenTextures(1)
            __GL.glBindTexture(__GL.GL_TEXTURE_2D, __GL_TEX[ImageName] )
     
            __GL.glTexParameteri(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_MAG_FILTER, __GL.GL_LINEAR)
            __GL.glTexParameteri(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_MIN_FILTER, __GL.GL_LINEAR)
            _IFMT = [__GL.GL_RGB, __GL.GL_RGBA, __GL.GL_RGB, __GL.GL_RGBA][ImageFormat]
            _PXFMT = [__GL.GL_LUMINANCE,__GL.GL_LUMINANCE_ALPHA,__GL.GL_RGB,__GL.GL_RGBA][ImageFormat]
            __GL.glTexImage2D(__GL.GL_TEXTURE_2D, 0, _IFMT, ImageW, ImageH, 0, _PXFMT, __GL.GL_UNSIGNED_BYTE, str(image))
     
        __GL.glDisable(__GL.GL_TEXTURE_2D)
    and then the dislay list for the entire model:
    Code :
     
        #generate Model Display-List here
        __MODEL_DATA = __GL.glGenLists(1)
        __GL.glNewList(__MODEL_DATA, __GL.GL_COMPILE)
     
        __GL.glColor3f(1.0,1.0,1.0)
        for SceneName,SceneObjects in Libs[2]:
            for ObjectID in SceneObjects:
                ObjectName,ObjectViewport,ObjectLRS,ObjectSubData,ObjectParentID=Libs[3][ObjectID]
                SubDataType,SubDataName,SubDataData1,SubDataData2=ObjectSubData
     
                if SubDataType=="_Mesh":
                    __GL.glLineWidth(1.0)
     
                    MaterialName,MaterialTEVs,MaterialColors,MaterialTextures,R1,R2 = Libs[4][SubDataData1] if type(SubDataData1)==int else [
                        "UMC_Def_Mat", '', [[1.0,1.0,1.0,1.0],[1.0,1.0,1.0,1.0],[0.5,0.5,0.5,1.0],[0.0,0.0,0.0,0.0],25.0], [], [], []
                        ]
     
                    MAR,MAG,MAB,MAA = MaterialColors[0] #Ambient
                    MDR,MDG,MDB,MDA = MaterialColors[1] #Diffuse
                    MSR,MSG,MSB,MSA = MaterialColors[2] #Specular
                    MER,MEG,MEB,MEA = MaterialColors[3] #Emmisive
                    MSV = MaterialColors[4] #Shininess
     
                    C0R,C0G,C0B,C0A= (MAR+MDR)/2,(MAG+MDG)/2,(MAB+MDB)/2,(MAA+MDA)/2
     
                    MeshVerts,MeshNormals,MeshColors,MeshUVs,MeshWeights,MeshPrimitives=SubDataData2
     
                    #call from pre-defined textures here
                    for TextureID in MaterialTextures:
                        TextureName,TextureParams,TextureEnvParams,TextureR1,TextureImageName,TextureR2 = Libs[6][TextureID]
     
                        # Apply Texture(s)
                        __GL.glBindTexture(__GL.GL_TEXTURE_2D, __GL_TEX[TextureImageName] )
     
                        '''
                        __GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                        __GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_T, __GL.GL_CLAMP)
                        '''
                        __GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_REPEAT)
                        __GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_T, __GL.GL_REPEAT)
                        #'''
                        #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_MAG_FILTER, __GL.GL_LINEAR)
                        #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_MIN_FILTER, __GL.GL_LINEAR)
     
                        break #only use the first for now
     
                    #notes:
                    #__GL.glTexEnvf(__GL.GL_TEXTURE_ENV, __GL.GL_TEXTURE_ENV_MODE, __GL.GL_MODULATE)
     
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_DEPTH_STENCIL_TEXTURE_MODE, 
                    #                       [__GL.GL_DEPTH_COMPONENT, __GL.GL_STENCIL_COMPONENT][T0])
     
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_BASE_LEVEL, int(T1))
     
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_BORDER_COLOR, [R,G,B,A])
     
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_COMPARE_FUNC,
                    #                       [__GL.GL_CLAMP][T3])
     
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
                    #__GL.glTexParameterf(__GL.GL_TEXTURE_2D, __GL.GL_TEXTURE_WRAP_S, __GL.GL_CLAMP)
     
                    '''
                    glTexParameterf(
                        GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_1D_ARRAY,
                        GL_TEXTURE_2D_ARRAY, GL_TEXTURE_RECTANGLE, GL_TEXTURE_CUBE_MAP
                        ,
                        GL_DEPTH_STENCIL_TEXTURE_MODE, GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_BORDER_COLOR, 
                        GL_TEXTURE_COMPARE_FUNC, GL_TEXTURE_COMPARE_MODE, GL_TEXTURE_LOD_BIAS, 
                        GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_LOD, 
                        GL_TEXTURE_MAX_LOD, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_SWIZZLE_R, 
                        GL_TEXTURE_SWIZZLE_G, GL_TEXTURE_SWIZZLE_B, GL_TEXTURE_SWIZZLE_A, 
                        GL_TEXTURE_SWIZZLE_RGBA, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_TEXTURE_WRAP_R
                        ,
                        GL_DEPTH_STENCIL_TEXTURE_MODE: GL_DEPTH_COMPONENT, GL_STENCIL_COMPONENT
                        GL_TEXTURE_BASE_LEVEL: int(MipMap)
                        GL_TEXTURE_BORDER_COLOR: [R,G,B,A]
                        GL_TEXTURE_COMPARE_FUNC: GL_LEQUAL, GL_GEQUAL, GL_LESS, GL_GREATER,
                            GL_EQUAL, GL_NOTEQUAL, GL_ALWAYS, GL_NEVER
                            #NOTE: GL_TEXTURE_COMPARE_MODE = GL_COMPARE_REF_TO_TEXTURE
                        GL_TEXTURE_COMPARE_MODE: GL_COMPARE_REF_TO_TEXTURE, GL_NONE 
                        GL_TEXTURE_LOD_BIAS: float(Bias)
                        GL_TEXTURE_MIN_FILTER: GL_NEAREST, GL_LINEAR, GL_NEAREST_MIPMAP_NEAREST
                            GL_LINEAR_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_LINEAR
                        GL_TEXTURE_MAG_FILTER: GL_NEAREST, GL_LINEAR
                        GL_TEXTURE_MIN_LOD: -1000
                        GL_TEXTURE_MAX_LOD: 1000
                        GL_TEXTURE_MAX_LEVEL: 1000
                        GL_TEXTURE_SWIZZLE_R: GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_ZERO, GL_ONE
                        GL_TEXTURE_SWIZZLE_G: GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_ZERO, GL_ONE
                        GL_TEXTURE_SWIZZLE_B: GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_ZERO, GL_ONE
                        GL_TEXTURE_SWIZZLE_A: GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_ZERO, GL_ONE
                        GL_TEXTURE_SWIZZLE_RGBA: GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_ZERO, GL_ONE
                        GL_TEXTURE_WRAP_S: GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER, GL_MIRRORED_REPEAT,
                            GL_REPEAT, GL_MIRROR_CLAMP_TO_EDGE
                        GL_TEXTURE_WRAP_T: GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER, GL_MIRRORED_REPEAT,
                            GL_REPEAT, GL_MIRROR_CLAMP_TO_EDGE
                        GL_TEXTURE_WRAP_R: GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER, GL_MIRRORED_REPEAT,
                            GL_REPEAT, GL_MIRROR_CLAMP_TO_EDGE
                        )
     
                    glTexEnvf(
                        GL_TEXTURE_ENV, GL_POINT_SPRITE_OES
                        , 
                        GL_TEXTURE_ENV_MODE, GL_COMBINE_RGB, GL_COMBINE_ALPHA, 
                        GL_SRC0_RGB, GL_SRC1_RGB, GL_SRC2_RGB, 
                        GL_SRC0_ALPHA, GL_SRC1_ALPHA, GL_SRC2_ALPHA, 
                        GL_OPERAND0_RGB, GL_OPERAND1_RGB, GL_OPERAND2_RGB, 
                        GL_OPERAND0_ALPHA, GL_OPERAND1_ALPHA, GL_OPERAND2_ALPHA, 
                        GL_RGB_SCALE, GL_ALPHA_SCALE, GL_COORD_REPLACE_OES
                        ,
                        GL_ADD, GL_ADD_SIGNED, GL_DOT3_RGB, GL_DOT3_RGBA, 
                        GL_INTERPOLATE, GL_MODULATE, GL_DECAL, GL_BLEND, 
                        GL_REPLACE, GL_SUBTRACT, GL_COMBINE, GL_TEXTURE, 
                        GL_CONSTANT, GL_PRIMARY_COLOR, GL_PREVIOUS, GL_SRC_COLOR, 
                        GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
                        (a single boolean value for the point sprite texture coordinate replacement, 
                            or 1.0, 2.0, or 4.0 when specifying the GL_RGB_SCALE or GL_ALPHA_SCALE)
                        )
                    '''
     
                    LC0,LC1=[0,0,0,0],[0,0,0,0] #Remember last used colors (starts at transparent black)
                    for Primitive,Facepoints in MeshPrimitives:
                        __GL.glBegin(__UMCGLPRIMITIVES[Primitive])
                        for V,N,(C0,C1),(U0,U1,U2,U3,U4,U5,U6,U7) in Facepoints:
                            try:
                                if U0!='': __GL.glMultiTexCoord2f(__GL.GL_TEXTURE0,MeshUVs[0][U0][0],MeshUVs[0][U0][1])
                                #if U1!='': glMultiTexCoord2f(GL_TEXTURE1,Fl(UVs[1][U1][0]),Fl(UVs[1][U1][1]))
                                #if U2!='': glMultiTexCoord2f(GL_TEXTURE2,Fl(UVs[2][U2][0]),Fl(UVs[2][U2][1]))
                                #if U3!='': glMultiTexCoord2f(GL_TEXTURE3,Fl(UVs[3][U3][0]),Fl(UVs[3][U3][1]))
                                #if U4!='': glMultiTexCoord2f(GL_TEXTURE4,Fl(UVs[4][U4][0]),Fl(UVs[4][U4][1]))
                                #if U5!='': glMultiTexCoord2f(GL_TEXTURE5,Fl(UVs[5][U5][0]),Fl(UVs[5][U5][1]))
                                #if U6!='': glMultiTexCoord2f(GL_TEXTURE6,Fl(UVs[6][U6][0]),Fl(UVs[6][U6][1]))
                                #if U7!='': glMultiTexCoord2f(GL_TEXTURE7,Fl(UVs[7][U7][0]),Fl(UVs[7][U7][1]))
                                #max texture is 31
                            except: #TODO: note UV display error
                                pass
     
                            if C0!='': #IRAGBA format
                                C0L=len(MeshColors[0][C0])
                                C0R,C0G,C0B,C0A=[__if2f(MeshColors[0][C0][0]),
                                                 __if2f(MeshColors[0][C0][1]) if C0L>2 else __if2f(MeshColors[0][C0][0]),
                                                 __if2f(MeshColors[0][C0][2]) if C0L>2 else __if2f(MeshColors[0][C0][0]),
                                                 __if2f(MeshColors[0][C0][3]) if C0L==4 else (__if2f(MeshColors[0][C0][1]) if C0L==2 else 1.0)]
                                __GL.glColor4f((MAR+MDR+C0R)/3,(MAG+MDG+C0G)/3,(MAB+MDB+C0B)/3,(MAA+MDA+C0A)/3)
     
                            if C1!='': #IRAGBA format
                                C1L=len(MeshColors[1][C1])
                                C1R,C1G,C1B,C1A=[__if2f(MeshColors[1][C1][0]),
                                                 __if2f(MeshColors[1][C1][1]) if C1L>2 else __if2f(MeshColors[1][C1][0]),
                                                 __if2f(MeshColors[1][C1][2]) if C1L>2 else __if2f(MeshColors[1][C1][0]),
                                                 __if2f(MeshColors[1][C1][3]) if C1L==4 else (__if2f(MeshColors[1][C1][1]) if C1L==2 else 1.0)]
                                __GL.glSecondaryColor3f(C1R,C1G,C1B)
     
                                #Alpha is supported but not registered here (glSecondaryColor4f is not a registered function)
     
                            UpdateMat=0
                            if LC0!=[C0R,C0G,C0B,C0A]: UpdateMat=1; LC0=[C0R,C0G,C0B,C0A]
                            #if LC1!=[C1R,C1G,C1B,C1A]: UpdateMat=1; LC1=[C1R,C1G,C1B,C1A]
                            if UpdateMat:
                                __GL.glMaterialfv(__GL.GL_FRONT_AND_BACK, __GL.GL_AMBIENT, [(MAR+C0R)/2,(MAG+C0G)/2,(MAB+C0B)/2,(MAA+C0A)/2])
                                __GL.glMaterialfv(__GL.GL_FRONT_AND_BACK, __GL.GL_DIFFUSE, [(MDR+C0R)/2,(MDG+C0G)/2,(MDB+C0B)/2,(MDA+C0A)/2])
                                __GL.glMaterialfv(__GL.GL_FRONT_AND_BACK, __GL.GL_SPECULAR, [(MSR+C0R)/2,(MSG+C0G)/2,(MSB+C0B)/2,(MSA+C0A)/2])
                                #__GL.glMaterialfv(__GL.GL_FRONT_AND_BACK, __GL.GL_SPECULAR, [0,0,0,1])
                                __GL.glMaterialfv(__GL.GL_FRONT_AND_BACK, __GL.GL_EMISSION, [MER,MEG,MEB,MEA])
                                __GL.glMaterialf(__GL.GL_FRONT_AND_BACK, __GL.GL_SHININESS, MSV)
     
                            if N!='': __GL.glNormal3f(MeshNormals[N][0],MeshNormals[N][1],MeshNormals[N][2])
     
                            VL=len(MeshVerts[V])
                            VX,VY,VZ=MeshVerts[V]+([0.0] if VL==2 else [])
                            __GL.glVertex3f(VX,VY,VZ)
     
                        __GL.glEnd()
     
        __GL.glEndList()
    ^ yes, I know... dev4x sucks... :P
    (dev5 is being completely rebuilt to take the more-modern approach using shaders and such)

    however, that doesn't mean I have to scrap the old method entirely, on a program that's meant to be able to run on anything from a Pentium II, up
    (I know someone who has a P-II running PJ64 at near-perfect frame-rate)

  6. #6
    Senior Member OpenGL Pro
    Join Date
    Jan 2012
    Location
    Australia
    Posts
    1,117
    OK - I would look at the texture array __GL_TEX and make sure the texture id for the font is not in that array. Also clear the bound texture at the end of the font display list and see if you get a black texture on the second frame.

  7. #7
    Junior Member Newbie Tcll5850's Avatar
    Join Date
    Feb 2014
    Posts
    23
    figured I'd hit this up while setting up WinXP on 3 compys... heh
    (I'm supposed to be on break from this to decrypt some net-code for another project I won't be able to tackle in 2 months)

    but anyways... I tried it at the end of the display list AND at the end of when the display lists were called...
    same result unfortunately, and the object appears to have no texture at all (only a silver material from the vertex color (0x808080FF) mixed with the material color (0xFFFFFFFF))

    I don't even see the texture appear on the first frame, but that may be due to 3 disk recovery programs I have running... heh
    (my development (500GB) HDD went RAW yesterday, and I lost alot of important files)

    and it's only this particular model as well >_>
    the rigged model imports just fine, along with one of the other trophies...
    the data checks out completely, including a file comparison in HxD with an original export fresh from the game,
    so I know it's not the model, or the wii would put up a fuss... that aside, it works perfectly it my less-efficient GUI and doesn't bind the eye texture to the primary model...
    (unless, in that GUI, it's the tail that's the last object rendered, binding THAT texture to the primary object, which uses the same texture...)
    ^ in the other models (except for the volt-tackle trophy which throws a weight-binding index error) the tail is part of the body instead of a separate object

    so the old GUI just might have the same issue, but I don't have fonts rendering in that GUI to be able to tell... :P

    I'm prbly gonna have to do a debug to log the info when the model is imported to see if it binds that primary texture properly... >_>

  8. #8
    Junior Member Newbie Tcll5850's Avatar
    Join Date
    Feb 2014
    Posts
    23
    hello to an old topic, I found the issue, and I can't even...

    idk what happened, but internally: (my formatting functions)

    object - material
    0 - None
    1 - 0
    2 - 1
    3 - 1
    4 - 2

    I don't understand how this was even working to begin with :P

    found it by scrapping my last formatting functions and updating the system to my new interface.

    so now we can finally put this issue to rest
    that has to be my second hardest resolution yet (aside from the custom sized floating point values completely screwing up)

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •