Ejemplo n.º 1
0
def genBgFileFromSeed(w, vs, seed, jpeg=0, scale=1):
    """
    Generates a background texture into filename constructed
    from the seed. Seed is some 64bit integer value.
    ThePaperMill must loaded and be set to be global.

    Returns the filename with absolute path of the generated file.
    """
    scalePostfix = ''
    if scale != 1: scalePostfix = '-%sx' % (scale)

    size = vs.getSize()

    # for Java to accept Python Long
    if seed > 0x7FFFFFFFFFFFFFFFL:
        lseed = seed - 0x10000000000000000L
    else:
        lseed = seed

    pap = ThePaperMill().getPaper(lseed,
                                  passmask=passmask,
                                  vecs=[[.5, 0], [0, .5]])
    pq = GLRen.createPaperQuad(pap, -0.5, -0.5, 0.5, 0.5, 0)
    cs = vs.coords.affine(0, 1, 0, 0, 768 * scale, 0, 0, 768 * scale)
    vs.matcher.add(cs, "tex")
    vs.put(SolidBackdropVob(java.awt.Color(0, 0, 0)))
    vs.map.put(pq, cs, 0)
    w.renderStill(vs, 0)

    if (jpeg):
        print 'Saving background texture into %s%s-paper.gen.jpg.' % (
            str(seed), scalePostfix)
        saveanim.saveframe('bgfile.tmp', w, 0, 0, 384 * scale, 384 * scale)
        os.system("convert -quality 95 %s %s" \
                  % ('bgfile.tmp', basedir+str(seed)+'%s-paper.gen.jpg' % (scalePostfix)))
        os.system("rm bgfile.tmp")
        return os.path.abspath(basedir + str(seed) + '%s-paper.gen.jpg' %
                               (scalePostfix))
    else:
        print 'Saving background texture into %s%s-paper.gen.png.' % (
            str(seed), scalePostfix)
        saveanim.saveframe(
            basedir + str(seed) + '%s-paper.gen.png' % (scalePostfix), w, 0, 0,
            384 * scale, 384 * scale)
        return os.path.abspath(basedir + str(seed) + '%s-paper.gen.png' %
                               (scalePostfix))
Ejemplo n.º 2
0
    def getOptimizedPaper(self,
                          seed,
                          passmask=[1, 1, 1, 1, 1, 1, 1],
                          numcolors=8,
                          minlum=80,
                          blend=0):
        pap = self.getPaper(seed, passmask, numcolors, minlum, blend)

        if not GL.hasExtension("GL_SGIS_generate_mipmap"):
            print "Warning: not returning optimized paper because"
            print "GL_SGIS_generate_mipmap extension is required but not available"
            return pap
        if GL.workaroundStupidBuggyAtiDrivers:
            print "Warning: not returning optimized paper because"
            print "copyTexImage2D has problems on ATI drivers"
            return pap

        # Now, we render a region.
        v = pap.repeat._getSTVectors()

        vs = optimizingWindow.createVobScene()
        vs.map.put(vob.vobs.SolidBackdropVob(java.awt.Color.red))

        cs1 = vs.coords.ortho(0, 0, 0, 0, optimizedPaperSize + 1,
                              optimizedPaperSize + 1)
        cs2 = vs.coords.affine(0, 0, 0, 0, v[0][0], v[0][1], v[1][0], v[1][1])
        vs.map.put(GLRen.createPaperQuad(pap, 0, 0, 1, 1, 1), cs1, cs2)
        optimizingWindow.renderStill(vs, 1)

        tex = GL.createTexture()
        texid = tex.getTexId()
        GL.call("""
	    BindTexture TEXTURE_2D %(texid)s
	    TexParameter TEXTURE_2D TEXTURE_MAX_ANISOTROPY_EXT 2
	    TexParameter TEXTURE_2D  GENERATE_MIPMAP_SGIS TRUE
	    TexParameter TEXTURE_2D  TEXTURE_MIN_FILTER LINEAR_MIPMAP_LINEAR
	    TexParameter TEXTURE_2D  TEXTURE_MAG_FILTER LINEAR
	    BindTexture TEXTURE_2D 0
	""" % locals())

        tex.copyTexImage2D(optimizingWindow.getRenderingSurface(), "FRONT",
                           "TEXTURE_2D", 0, "RGB5", 0, 0, optimizedPaperSize,
                           optimizedPaperSize, 0)

        # Apparently, NV drivers 44.96 (maybe others) have some trouble
        # with the 1x1 mipmap getting clobbered.
        # Usually, that wouldn't be a problem, but papers will be viewed
        # 1) at largely different scales
        # 2) blurred for text background
        # so this matters.
        # We shall forbid the use of that mipmap
        tex.setTexParameter("TEXTURE_2D", "TEXTURE_MAX_LEVEL",
                            optimizedPaperMaxLevel)

        if dbg:
            vob.putil.texture.printTex(tex.getTexId())

        npap = PaperHanger()
        npap.setNPasses(1)
        npap.cachedTexture = tex
        npap.addDepend(tex)  # Need this for clones to survive

        ppass = npap.getPass(0)

        ppass.setSetupcode("""
            PushAttrib ENABLE_BIT TEXTURE_BIT DEPTH_BUFFER_BIT COLOR_BUFFER_BIT CURRENT_BIT
            Disable BLEND
	    ActiveTexture TEXTURE1
	    Disable TEXTURE_2D
	    ActiveTexture TEXTURE0
	    Enable DEPTH_TEST
	    DepthFunc LESS
	    BindTexture TEXTURE_2D %(texid)s
	    TexEnv TEXTURE_ENV TEXTURE_ENV_MODE REPLACE
	    Color 0 1 0
	    Enable TEXTURE_2D
	    SecondaryColorEXT 0 0 0
	""" % locals())

        ppass.setNTexGens(1)
        # t = pap.repeat.vecs
        t = v
        if dbg:
            print "T ", t
        ppass.putNormalTexGen(0, [
            t[0][0],
            t[0][1],
            0,
            0,
            -t[1][0],
            -t[1][1],
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
        ])

        ppass.setTeardowncode("""
            PopAttrib
            ActiveTexture TEXTURE0
        """)

        if dbg:
            print "Ret: ", npap.toString(), npap.getPass(0).getNTexGens()

        return npap