def drawTrack(self, visibility, song, pos): if not song: return if not song.readyToGo: return if self.staticStrings: track_tex = self.board_tex_static else: track_tex = self.board_tex glEnable(GL_TEXTURE_2D) #MFH - logic to briefly display oFlash if self.overdriveFlashCount < self.overdriveFlashCounts and self.oFlash: self.oFlash.texture.bind() elif self.instrument.starPowerActive and self.oCenterLines: self.oCenterLines.texture.bind() else: if self.centerLines: self.centerLines.texture.bind() cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.track_vtx, colors=self.board_col, texcoords=track_tex) glDisable(GL_TEXTURE_2D)
def renderNeckMethod(self, visibility, offset, neck, alpha = False): #blazingamer: New neck rendering method v = visibility glEnable(GL_TEXTURE_2D) if offset == 0: board_tex = self.board_tex_static else: board_tex = self.board_tex if self.failcount == v: board_col = self.board_col_flash else: board_col = self.board_col if alpha == True: glBlendFunc(GL_ONE, GL_ONE) if neck: neck.texture.bind() cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.board_vtx, colors=board_col, texcoords=board_tex) if alpha == True: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) glDisable(GL_TEXTURE_2D)
def drawBPM(self, visibility, song, pos): if not song: return if not song.readyToGo: return track = song.track[self.player] glEnable(GL_TEXTURE_2D) for time, event in track.getEvents(pos - self.currentPeriod * 2, pos + self.currentPeriod * self.beatsPerBoard): if not isinstance(event, Bars): continue glPushMatrix() z = ((time - pos) / self.currentPeriod) / self.beatsPerUnit sw = 0.1 #width self.bpm_vtx[0][2] = self.bpm_vtx[2][2] = z + sw self.bpm_vtx[1][2] = self.bpm_vtx[3][2] = z - sw if event.barType == 0: #half-beat self.bpm_halfbeat.texture.bind() elif event.barType == 1: #beat self.bpm_beat.texture.bind() elif event.barType == 2: #measure self.bpm_measure.texture.bind() cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.bpm_vtx, colors=self.bpm_col, texcoords=self.bpm_tex) glPopMatrix() glDisable(GL_TEXTURE_2D)
def drawBPM(self, visibility, song, pos): if not song: return if not song.readyToGo: return v = visibility w = self.boardWidth track = song.track[self.player] glEnable(GL_TEXTURE_2D) for time, event in track.getEvents(pos - self.currentPeriod * 2, pos + self.currentPeriod * self.beatsPerBoard): if not isinstance(event, Bars): continue glPushMatrix() z = ((time - pos) / self.currentPeriod) / self.beatsPerUnit z2 = ((time + event.length - pos) / self.currentPeriod) / self.beatsPerUnit if z > self.boardLength: f = (self.boardLength - z) / (self.boardLength * .2) elif z < 0: f = min(1, max(0, 1 + z2)) else: f = 1.0 if event.barType == 0: #half-beat sw = 0.1 #width self.bpm_halfbeat.texture.bind() elif event.barType == 1: #beat sw = 0.1 #width self.bpm_beat.texture.bind() elif event.barType == 2: #measure sw = 0.1 #width self.bpm_measure.texture.bind() bpm_vtx = np.array([[-(w / 2), 0, z + sw], [-(w / 2), 0, z - sw], [(w / 2), 0, z + sw], [(w / 2), 0, z - sw]], dtype=np.float32) bpm_tex = np.array([[0.0, 1.0], [0.0, 0.0], [1.0, 1.0], [1.0, 0.0]], dtype=np.float32) bpm_col = np.array([[1, 1, 1, v], [1, 1, 1, v], [1, 1, 1, v], [1, 1, 1, v]], dtype=np.float32) cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=bpm_vtx, colors=bpm_col, texcoords=bpm_tex) glPopMatrix() glDisable(GL_TEXTURE_2D)
def drawSquare(w, h, tw, th): self.square_prim[1, 0] = self.square_prim[3, 0] = w self.square_prim[2, 1] = self.square_prim[3, 1] = h self.square_tex[0, 1] = self.square_tex[1, 1] = th self.square_tex[1, 0] = self.square_tex[3, 0] = tw cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.square_prim, texcoords=self.square_tex)
def drawSideBars(self, visibility, song, pos): if not song: return if not song.readyToGo: return def project(beat): return 0.125 * beat / self.beatsPerUnit # glorandwarf: was 0.12 v = visibility w = self.boardWidth + 0.15 l = self.boardLength offset = (pos - self.lastBpmChange) / self.currentPeriod + self.baseBeat c = (1,1,1) board_tex = np.array([[0.0, project(offset - 2 * self.beatsPerUnit)], [1.0, project(offset - 2 * self.beatsPerUnit)], [0.0, project(offset - 1 * self.beatsPerUnit)], [1.0, project(offset - 1 * self.beatsPerUnit)], [0.0, project(offset + l * self.beatsPerUnit * .7)], [1.0, project(offset + l * self.beatsPerUnit * .7)], [0.0, project(offset + l * self.beatsPerUnit)], [1.0, project(offset + l * self.beatsPerUnit)]], dtype=np.float32) glEnable(GL_TEXTURE_2D) if self.theme == 2 and self.instrument.starPowerActive and self.oSideBars: self.oSideBars.texture.bind() else: self.sideBars.texture.bind() cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.sidebars_vtx, colors=self.board_col, texcoords=board_tex) glDisable(GL_TEXTURE_2D) if self.theme == 1: if shaders.enable("sololight"): shaders.modVar("color",shaders.var["solocolor"]) shaders.setVar("offset",(-3.5,-w/2)) glBegin(GL_TRIANGLE_STRIP) glVertex3f(w / 2-1.0, 0.4, -2) glVertex3f(w / 2+1.0, 0.4, -2) glVertex3f(w / 2-1.0, 0.4, l) glVertex3f(w / 2+1.0, 0.4, l) glEnd() shaders.setVar("offset",(-3.5,w/2)) shaders.setVar("time",shaders.time()+0.5) glBegin(GL_TRIANGLE_STRIP) glVertex3f(-w / 2+1.0, 0.4, -2) glVertex3f(-w / 2-1.0, 0.4, -2) glVertex3f(-w / 2+1.0, 0.4, l) glVertex3f(-w / 2-1.0, 0.4, l) glEnd() shaders.disable()
def renderNeckMethod(self, visibility, offset, neck, alpha = False): #blazingamer: New neck rendering method def project(beat): return 0.125 * beat / self.beatsPerUnit # glorandwarf: was 0.12 if self.instrument.starPowerActive and self.theme == 0:#8bit color = self.engine.theme.spNoteColor #self.spColor #(.3,.7,.9) elif self.instrument.starPowerActive and self.theme == 1: color = self.engine.theme.spNoteColor #self.spColor #(.3,.7,.9) else: color = (1,1,1) v = visibility l = self.boardLength glEnable(GL_TEXTURE_2D) board_tex = np.array([[0.0, project(offset - 2 * self.beatsPerUnit)], [1.0, project(offset - 2 * self.beatsPerUnit)], [0.0, project(offset - 1 * self.beatsPerUnit)], [1.0, project(offset - 1 * self.beatsPerUnit)], [0.0, project(offset + l * self.beatsPerUnit * .7)], [1.0, project(offset + l * self.beatsPerUnit * .7)], [0.0, project(offset + l * self.beatsPerUnit)], [1.0, project(offset + l * self.beatsPerUnit)]], dtype=np.float32) #must be separate for neck flashing. board_col = np.array([[color[0],color[1],color[2], 0], [color[0],color[1],color[2], 0], [color[0],color[1],color[2], v], [color[0],color[1],color[2], v], [color[0],color[1],color[2], v], [color[0],color[1],color[2], v], [color[0],color[1],color[2], 0], [color[0],color[1],color[2], 0]], dtype=np.float32) if alpha == True: glBlendFunc(GL_ONE, GL_ONE) if neck: neck.texture.bind() cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.board_vtx, colors=board_col, texcoords=board_tex) if alpha == True: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) glDisable(GL_TEXTURE_2D)
def drawNoteLane(self, colors, xStartPos, xEndPos, yStartPos, yEndPos): colorArray = np.array([colors[i] for i in (4, 5, 6, 6, 0, 1, 1, 0, 2, 3, 3, 2, 6, 6, 5, 4)], dtype=np.float32) vertexArray = np.array([[xStartPos, yStartPos-self.vocalLaneSize, 0], [xEndPos, yEndPos -self.vocalLaneSize, 0], [xEndPos, yEndPos -self.vocalGlowSize, 0], [xStartPos, yStartPos-self.vocalGlowSize, 0], [xStartPos-self.vocalLaneSize, yStartPos, 0], [xEndPos +self.vocalLaneSize, yEndPos, 0], [xEndPos, yEndPos -self.vocalLaneSize, 0], [xStartPos, yStartPos-self.vocalLaneSize, 0], [xStartPos, yStartPos+self.vocalLaneSize, 0], [xEndPos, yEndPos +self.vocalLaneSize, 0], [xEndPos +self.vocalLaneSize, yEndPos, 0], [xStartPos-self.vocalLaneSize, yStartPos, 0], [xStartPos, yStartPos+self.vocalGlowSize, 0], [xEndPos, yEndPos +self.vocalGlowSize, 0], [xEndPos, yEndPos +self.vocalLaneSize, 0], [xStartPos, yStartPos+self.vocalLaneSize, 0]], dtype=np.float32) cmgl.drawArrays(GL_QUADS, vertices=vertexArray, colors=colorArray)
def draw(self): with cmgl.PushedSpecificMatrix(GL_TEXTURE): with cmgl.PushedSpecificMatrix(GL_PROJECTION): with cmgl.MatrixMode(GL_PROJECTION): self.context.setProjection() with cmgl.PushedMatrix(): glLoadIdentity() glTranslate(self.position[0], self.position[1], 0.0) glRotatef(-self.angle, 0, 0, 1) glScalef(self.scale[0], self.scale[1], 1.0) glScalef(self.pixelSize[0], self.pixelSize[1], 1) glTranslatef(self.shift, self.vshift, 0) glColor4f(*self.color) glEnable(GL_TEXTURE_2D) self.texture.bind() cmgl.drawArrays(GL_QUADS, vertices=ImgDrawing.VTX_ARRAY, texcoords=self.texArray) glDisable(GL_TEXTURE_2D)
def drawTrack(self, visibility, song, pos): if not song: return if not song.readyToGo: return l = self.boardLength if self.staticStrings: offset = 0 else: offset = (pos - self.lastBpmChange) / self.currentPeriod + self.baseBeat track_tex = np.array([[0.0, self.project(offset - 2 * self.beatsPerUnit)], [1.0, self.project(offset - 2 * self.beatsPerUnit)], [0.0, self.project(offset - 1 * self.beatsPerUnit)], [1.0, self.project(offset - 1 * self.beatsPerUnit)], [0.0, self.project(offset + l * self.beatsPerUnit * .7)], [1.0, self.project(offset + l * self.beatsPerUnit * .7)], [0.0, self.project(offset + l * self.beatsPerUnit)], [1.0, self.project(offset + l * self.beatsPerUnit)]], dtype=np.float32) glEnable(GL_TEXTURE_2D) #MFH - logic to briefly display oFlash if self.overdriveFlashCount < self.overdriveFlashCounts and self.oFlash: self.oFlash.texture.bind() elif self.instrument.starPowerActive and self.oCenterLines: self.oCenterLines.texture.bind() else: if self.centerLines: self.centerLines.texture.bind() if self.staticStrings: #MFH cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.track_vtx, colors=self.board_col, texcoords=track_tex) else: #MFH: original moving strings cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.track_vtx, colors=self.board_col, texcoords=track_tex) glDisable(GL_TEXTURE_2D)
def renderIncomingNeck(self, visibility, song, pos, time, neckTexture): #MFH - attempt to "scroll" an incoming guitar solo neck towards the player if not song: return if not song.readyToGo: return l = self.boardLength z = ((time - pos) / self.currentPeriod) / self.beatsPerUnit glEnable(GL_TEXTURE_2D) self.board_scroll_vtx[0][2] = self.board_scroll_vtx[1][2] = z self.board_scroll_vtx[2][2] = self.board_scroll_vtx[3][2] = z + 1 self.board_scroll_vtx[4][2] = self.board_scroll_vtx[5][2] = z + 2 + l * .7 self.board_scroll_vtx[6][2] = self.board_scroll_vtx[7][2] = z + 2 + l if neckTexture: neckTexture.texture.bind() cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.board_scroll_vtx, colors=self.board_col, texcoords=self.board_tex_static) glDisable(GL_TEXTURE_2D)
def renderIncomingSideBars(self, song, pos, time, sideBarImg): if not song: return if not song.readyToGo: return l = self.boardLength z = ((time - pos) / self.currentPeriod) / self.beatsPerUnit glEnable(GL_TEXTURE_2D) self.sidebars_scroll_vtx[0][2] = self.sidebars_scroll_vtx[1][2] = z self.sidebars_scroll_vtx[2][2] = self.sidebars_scroll_vtx[3][2] = z + 1 self.sidebars_scroll_vtx[4][2] = self.sidebars_scroll_vtx[5][2] = z + 2 + l * .7 self.sidebars_scroll_vtx[6][2] = self.sidebars_scroll_vtx[7][2] = z + 2 + l if sideBarImg: sideBarImg.texture.bind() cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.sidebars_scroll_vtx, colors=self.board_col, texcoords=self.board_tex_static) glDisable(GL_TEXTURE_2D)
def renderNeckMethod(self, visibility, offset, neck, alpha = False): #blazingamer: New neck rendering method color = (1,1,1) v = visibility l = self.boardLength glEnable(GL_TEXTURE_2D) board_tex = np.array([[0.0, self.project(offset - 2 * self.beatsPerUnit)], [1.0, self.project(offset - 2 * self.beatsPerUnit)], [0.0, self.project(offset - 1 * self.beatsPerUnit)], [1.0, self.project(offset - 1 * self.beatsPerUnit)], [0.0, self.project(offset + l * self.beatsPerUnit * .7)], [1.0, self.project(offset + l * self.beatsPerUnit * .7)], [0.0, self.project(offset + l * self.beatsPerUnit)], [1.0, self.project(offset + l * self.beatsPerUnit)]], dtype=np.float32) #must be separate for neck flashing. board_col = np.array([[color[0],color[1],color[2], 0], [color[0],color[1],color[2], 0], [color[0],color[1],color[2], v], [color[0],color[1],color[2], v], [color[0],color[1],color[2], v], [color[0],color[1],color[2], v], [color[0],color[1],color[2], 0], [color[0],color[1],color[2], 0]], dtype=np.float32) if alpha == True: glBlendFunc(GL_ONE, GL_ONE) if neck: neck.texture.bind() cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.board_vtx, colors=board_col, texcoords=board_tex) if alpha == True: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) glDisable(GL_TEXTURE_2D)
def renderIncomingNeck(self, visibility, song, pos, time, neckTexture): #MFH - attempt to "scroll" an incoming guitar solo neck towards the player if not song: return if not song.readyToGo: return w = self.boardWidth l = self.boardLength z = ((time - pos) / self.currentPeriod) / self.beatsPerUnit glEnable(GL_TEXTURE_2D) board_vtx = np.array([[-w / 2, 0, z], [w / 2, 0, z], [-w/ 2, 0, z + 1], [w / 2, 0, z + 1], [-w / 2, 0, z + 2 + l * .7], [w / 2, 0, z + 2 + l * .7], [-w / 2, 0, z + 2 + l], [w / 2, 0, z + 2 + l]], dtype=np.float32) board_tex = np.array([[0.0, self.project(-2 * self.beatsPerUnit)], [1.0, self.project(-2 * self.beatsPerUnit)], [0.0, self.project(-1 * self.beatsPerUnit)], [1.0, self.project(-1 * self.beatsPerUnit)], [0.0, self.project(l * self.beatsPerUnit * .7)], [1.0, self.project(l * self.beatsPerUnit * .7)], [0.0, self.project(l * self.beatsPerUnit)], [1.0, self.project(l * self.beatsPerUnit)]], dtype=np.float32) if neckTexture: neckTexture.texture.bind() cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=board_vtx, colors=self.board_col, texcoords=board_tex) glDisable(GL_TEXTURE_2D)
def drawSideBars(self, visibility, song, pos): if not song: return if not song.readyToGo: return color = (1,1,1) v = visibility w = self.boardWidth + 0.15 l = self.boardLength offset = (pos - self.lastBpmChange) / self.currentPeriod + self.baseBeat board_tex = np.array([[0.0, self.project(offset - 2 * self.beatsPerUnit)], [1.0, self.project(offset - 2 * self.beatsPerUnit)], [0.0, self.project(offset - 1 * self.beatsPerUnit)], [1.0, self.project(offset - 1 * self.beatsPerUnit)], [0.0, self.project(offset + l * self.beatsPerUnit * .7)], [1.0, self.project(offset + l * self.beatsPerUnit * .7)], [0.0, self.project(offset + l * self.beatsPerUnit)], [1.0, self.project(offset + l * self.beatsPerUnit)]], dtype=np.float32) #must be separate for sidebar flashing. board_col = np.array([[color[0],color[1],color[2], 0], [color[0],color[1],color[2], 0], [color[0],color[1],color[2], v], [color[0],color[1],color[2], v], [color[0],color[1],color[2], v], [color[0],color[1],color[2], v], [color[0],color[1],color[2], 0], [color[0],color[1],color[2], 0]], dtype=np.float32) glEnable(GL_TEXTURE_2D) if self.instrument.starPowerActive and self.oSideBars: self.oSideBars.texture.bind() else: self.sideBars.texture.bind() if self.isFailing and self.failSideBars and v == self.failcount: self.failSideBars.texture.bind() else: self.sideBars.texture.bind() cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.sidebars_vtx, colors=board_col, texcoords=board_tex) glDisable(GL_TEXTURE_2D) if shaders.enable("sololight"): shaders.modVar("color",shaders.var["solocolor"]) shaders.setVar("offset",(-3.5,-w/2)) cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.soloLightVtx1) shaders.setVar("offset",(-3.5,w/2)) shaders.setVar("time",shaders.time()+0.5) cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.soloLightVtx2) shaders.disable()
def drawSideBars(self, visibility, song, pos): if not song: return if not song.readyToGo: return color = (1,1,1) v = visibility w = self.boardWidth + 0.15 if self.failcount == v: board_col = self.board_col_flash else: board_col = self.board_col glEnable(GL_TEXTURE_2D) if self.instrument.starPowerActive and self.oSideBars and not (self.guitarSolo or self.soloSideBars): self.oSideBars.texture.bind() elif self.instrument.starPowerActive and self.oSoloSideBars and self.oSidebars and self.guitarSolo: self.oSoloSideBars.texture.bind() elif self.guitarSolo and self.soloSideBars: self.soloSideBars.texture.bind() elif self.sideBars: self.sideBars.texture.bind() if self.isFailing and self.failSideBars and v == self.failcount: self.failSideBars.texture.bind() cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.sidebars_vtx, colors=board_col, texcoords=self.board_tex) glDisable(GL_TEXTURE_2D) if shaders.enable("sololight"): shaders.modVar("color",shaders.var["solocolor"]) shaders.setVar("offset",(-3.5,-w/2)) cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.soloLightVtx1) shaders.setVar("offset",(-3.5,w/2)) shaders.setVar("time",shaders.time()+0.5) cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.soloLightVtx2) shaders.disable()
def drawSideBars(self, visibility, song, pos): if not song: return if not song.readyToGo: return v = visibility w = self.boardWidth + 0.15 if self.failcount == v: board_col = self.board_col_flash else: board_col = self.board_col glEnable(GL_TEXTURE_2D) if self.instrument.starPowerActive and self.oSideBars and not (self.guitarSolo or self.soloSideBars): self.oSideBars.texture.bind() elif self.instrument.starPowerActive and self.oSoloSideBars and self.oSidebars and self.guitarSolo: self.oSoloSideBars.texture.bind() elif self.guitarSolo and self.soloSideBars: self.soloSideBars.texture.bind() elif self.sideBars: self.sideBars.texture.bind() if self.isFailing and self.failSideBars and v == self.failcount: self.failSideBars.texture.bind() cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.sidebars_vtx, colors=board_col, texcoords=self.board_tex) glDisable(GL_TEXTURE_2D) if shaders.enable("sololight"): shaders.modVar("color",shaders.var["solocolor"]) shaders.setVar("offset",(-3.5,-w/2)) cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.soloLightVtx1) shaders.setVar("offset",(-3.5,w/2)) shaders.setVar("time",shaders.time()+0.5) cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.soloLightVtx2) shaders.disable()
def drawTrack(self, visibility, song, pos): if not song: return if not song.readyToGo: return def project(beat): return 0.125 * beat / self.beatsPerUnit # glorandwarf: was 0.12 if self.theme == 0 or self.theme == 1: size = 2 else: size = 0 v = visibility w = self.boardWidth l = self.boardLength if self.staticStrings: offset = 0 else: offset = (pos - self.lastBpmChange) / self.currentPeriod + self.baseBeat track_tex = np.array([[0.0, project(offset - 2 * self.beatsPerUnit)], [1.0, project(offset - 2 * self.beatsPerUnit)], [0.0, project(offset - 1 * self.beatsPerUnit)], [1.0, project(offset - 1 * self.beatsPerUnit)], [0.0, project(offset + l * self.beatsPerUnit * .7)], [1.0, project(offset + l * self.beatsPerUnit * .7)], [0.0, project(offset + l * self.beatsPerUnit)], [1.0, project(offset + l * self.beatsPerUnit)]], dtype=np.float32) glEnable(GL_TEXTURE_2D) #MFH - logic to briefly display oFlash if self.theme == 2 and self.overdriveFlashCount < self.overdriveFlashCounts and self.oFlash: self.oFlash.texture.bind() elif self.theme == 2 and self.instrument.starPowerActive and self.oCenterLines: self.oCenterLines.texture.bind() else: self.centerLines.texture.bind() track_vtx = np.array([[-w / 2, 0, -2+size], [w / 2, 0, -2+size], [-w / 2, 0, -1+size], [w / 2, 0, -1+size], [-w / 2, 0, l * .7], [w / 2, 0, l * .7], [-w / 2, 0, l], [w / 2, 0, l]], dtype=np.float32) if self.staticStrings: #MFH color = (1,1,1) track_col = np.array([[color[0],color[1],color[2], v], [color[0],color[1],color[2], v], [color[0],color[1],color[2], v], [color[0],color[1],color[2], v], [color[0],color[1],color[2], v], [color[0],color[1],color[2], v], [color[0],color[1],color[2], 0], [color[0],color[1],color[2], 0]], dtype=np.float32) cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=track_vtx, colors=track_col, texcoords=track_tex) else: #MFH: original moving strings cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=track_vtx, colors=self.board_col, texcoords=track_tex) glDisable(GL_TEXTURE_2D)
def draw3Dtex(self, image, vertex, texcoord, coord = None, scale = None, rot = None, color = (1,1,1), multiples = False, alpha = False, depth = False, vertscale = 0): ''' Simplifies tex rendering @param image: self.xxx - tells the system which image/resource should be mapped to the plane @param vertex: (Left, Top, Right, Bottom) - sets the points that define where the plane will be drawn @param texcoord: (Left, Top, Right, Bottom) - sets where the texture should be drawn on the plane @param coord: (x,y,z) - where on the screen the plane will be rendered within the 3d field @param scale: (x,y,z) - scales an glplane how far in each direction @param rot: (degrees, x-axis, y-axis, z-axis) a digit in the axis is how many times you want to rotate degrees around that axis @param color: (r,g,b) - sets the color of the image when rendered 0 = No Color, 1 = Full color @param multiples: True/False defines whether or not there should be multiples of the plane drawn at the same time only really used with the rendering of the notes, keys, and flames @param alpha: True/False - defines whether or not the image should have black turned into transparent only really used with hitglows and flames @param depth: True/False - sets the depth by which the object is rendered only really used by keys and notes @param vertscale: # - changes the yscale when setting vertex points only really used by notes ''' if not isinstance(image, ImgDrawing): return if alpha == True: glBlendFunc(GL_SRC_ALPHA, GL_ONE) if len(color) == 4: col_array = np.array([[color[0],color[1],color[2], color[3]], [color[0],color[1],color[2], color[3]], [color[0],color[1],color[2], color[3]], [color[0],color[1],color[2], color[3]]], dtype=np.float32) else: col_array = np.array([[color[0],color[1],color[2], 1], [color[0],color[1],color[2], 1], [color[0],color[1],color[2], 1], [color[0],color[1],color[2], 1]], dtype=np.float32) glEnable(GL_TEXTURE_2D) image.texture.bind() if multiples == True: glPushMatrix() if coord != None: glTranslate(coord[0], coord[1], coord[2]) if rot != None: glRotate(rot[0], rot[1], rot[2], rot[3]) if scale != None: glScalef(scale[0], scale[1], scale[2]) if depth == True: glDepthMask(1) if not isinstance(vertex, np.ndarray): vertex = np.array( [[ vertex[0], vertscale, vertex[1]], [ vertex[2], vertscale, vertex[1]], [ vertex[0], -vertscale, vertex[3]], [ vertex[2], -vertscale, vertex[3]]], dtype=np.float32) if not isinstance(texcoord, np.ndarray): texcoord = np.array( [[texcoord[0], texcoord[1]], [texcoord[2], texcoord[1]], [texcoord[0], texcoord[3]], [texcoord[2], texcoord[3]]], dtype=np.float32) cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=vertex, colors=col_array, texcoords=texcoord) if depth == True: glDepthMask(0) if multiples == True: glPopMatrix() glDisable(GL_TEXTURE_2D) if alpha == True: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def drawCmgl(): cmgl.drawArrays(GL_TRIANGLES, vertices=triangVtx, colors=triangCol) cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=spiralVtx, colors=spiralCol)
def renderNeck(self, visibility, song, pos): if not song: return if not song.readyToGo: return v = visibility offset = (pos - self.lastBpmChange) / self.currentPeriod + self.baseBeat #myfingershurt: every theme can have oNeck: if self.guitarSolo and self.soloNeck and self.guitarSoloNeckMode == 1: neck = self.soloNeck elif self.scoreMultiplier > 4 and self.bassGrooveNeck and self.bassGrooveNeckMode == 1: neck = self.bassGrooveNeck elif self.fourxNeckMode == 1 and self.fourMultiNeck and self.scoreMultiplier == 4: neck = self.fourMultiNeck elif self.instrument.starPowerActive and not (self.spcount2 != 0 and self.spcount < 1.2) and self.oNeck and self.scoreMultiplier <= 4 and not self.ovrneckoverlay: neck = self.oNeck else: neck = self.neckDrawing self.renderNeckMethod(v*self.neckAlpha[1], offset, neck) if self.guitarSolo and self.soloNeck and self.guitarSoloNeckMode == 2: #static overlay self.renderNeckMethod(v*self.neckAlpha[2], 0, self.soloNeck) if self.bgcount > 0 and self.bassGrooveNeck and self.bassGrooveNeckMode == 2: #static bass groove overlay self.renderNeckMethod(v*self.bgcount*self.neckAlpha[3], 0, self.bassGrooveNeck) if self.fourXcount > 0 and self.fourMultiNeck and self.fourxNeckMode == 2: #4x multi overlay neck self.renderNeckMethod(v*self.fourXcount*self.neckAlpha[6], offset, self.fourMultiNeck) if self.spcount2 != 0 and self.spcount < 1.2 and self.oNeck: #static overlay if self.oNeckovr and (self.scoreMultiplier > 4 or self.guitarSolo or self.ovrneckoverlay): neck = self.oNeckovr alpha = False else: neck = self.oNeck alpha = True self.renderNeckMethod(v*self.spcount*self.neckAlpha[4], offset, neck, alpha) if self.instrument.starPowerActive and not (self.spcount2 != 0 and self.spcount < 1.2) and self.oNeck and (self.scoreMultiplier > 4 or self.guitarSolo or self.ovrneckoverlay): #static overlay if self.oNeckovr: neck = self.oNeckovr alpha = False else: neck = self.oNeck alpha = True self.renderNeckMethod(v*self.neckAlpha[4], offset, neck, alpha) if shaders.enabled: shaders.globals["basspos"] = shaders.var["fret"][self.player][0] shaders.globals["notepos"] = shaders.var["fret"][self.player][1:] shaders.globals["bpm"] = self.instrument.currentBpm shaders.globals["songpos"] = pos shaders.globals["spEnabled"] = self.instrument.starPowerActive shaders.globals["isFailing"] = self.isFailing shaders.globals["isMultChanged"] = (shaders.var["scoreMult"][self.player] != self.scoreMultiplier) if shaders.globals["isMultChanged"]: shaders.var["multChangePos"][self.player] = pos shaders.globals["scoreMult"] = self.scoreMultiplier shaders.var["scoreMult"][self.player] = self.scoreMultiplier shaders.globals["isDrum"] = self.isDrum shaders.globals["soloActive"] = self.guitarSolo posx = shaders.time() neckcol = (0,0,0) notecolors = list(self.engine.theme.noteColors) if self.isDrum: notecolors[4] = notecolors[0] notecolors[0] = self.engine.theme.noteColors[5] for i in range(5): blend = max(shaders.var["fret"][self.player][i] - posx + 1.5,0.01) neckcol = mixColors(neckcol, notecolors[i], blend) shaders.var["color"][self.player]=neckcol if shaders.enable("neck"): shaders.setVar("fretcol",neckcol) shaders.update() cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=self.shader_neck_vtx) shaders.disable() else: if self.isFailing: self.renderNeckMethod(self.failcount, 0, self.failNeck) if (self.guitarSolo or self.instrument.starPowerActive) and self.theme == 1: shaders.var["solocolor"]=self.shaderSolocolor else: shaders.var["solocolor"]=(0.0,)*4
def draw3Dtex(self, image, vertex, texcoord, coord=None, scale=None, rot=None, color=(1, 1, 1), multiples=False, alpha=False, depth=False, vertscale=0): ''' Simplifies tex rendering @param image: self.xxx - tells the system which image/resource should be mapped to the plane @param vertex: (Left, Top, Right, Bottom) - sets the points that define where the plane will be drawn @param texcoord: (Left, Top, Right, Bottom) - sets where the texture should be drawn on the plane @param coord: (x,y,z) - where on the screen the plane will be rendered within the 3d field @param scale: (x,y,z) - scales an glplane how far in each direction @param rot: (degrees, x-axis, y-axis, z-axis) a digit in the axis is how many times you want to rotate degrees around that axis @param color: (r,g,b) - sets the color of the image when rendered 0 = No Color, 1 = Full color @param multiples: True/False defines whether or not there should be multiples of the plane drawn at the same time only really used with the rendering of the notes, keys, and flames @param alpha: True/False - defines whether or not the image should have black turned into transparent only really used with hitglows and flames @param depth: True/False - sets the depth by which the object is rendered only really used by keys and notes @param vertscale: # - changes the yscale when setting vertex points only really used by notes ''' if not isinstance(image, ImgDrawing): return if alpha == True: glBlendFunc(GL_SRC_ALPHA, GL_ONE) if len(color) == 4: col_array = np.array([[color[0], color[1], color[2], color[3]], [color[0], color[1], color[2], color[3]], [color[0], color[1], color[2], color[3]], [color[0], color[1], color[2], color[3]]], dtype=np.float32) else: col_array = np.array([[color[0], color[1], color[2], 1], [color[0], color[1], color[2], 1], [color[0], color[1], color[2], 1], [color[0], color[1], color[2], 1]], dtype=np.float32) glEnable(GL_TEXTURE_2D) image.texture.bind() if multiples == True: glPushMatrix() if coord != None: glTranslate(coord[0], coord[1], coord[2]) if rot != None: glRotate(rot[0], rot[1], rot[2], rot[3]) if scale != None: glScalef(scale[0], scale[1], scale[2]) if depth == True: glDepthMask(1) if not isinstance(vertex, np.ndarray): vertex = np.array([[vertex[0], vertscale, vertex[1]], [vertex[2], vertscale, vertex[1]], [vertex[0], -vertscale, vertex[3]], [vertex[2], -vertscale, vertex[3]]], dtype=np.float32) if not isinstance(texcoord, np.ndarray): texcoord = np.array( [[texcoord[0], texcoord[1]], [texcoord[2], texcoord[1]], [texcoord[0], texcoord[3]], [texcoord[2], texcoord[3]]], dtype=np.float32) cmgl.drawArrays(GL_TRIANGLE_STRIP, vertices=vertex, colors=col_array, texcoords=texcoord) if depth == True: glDepthMask(0) if multiples == True: glPopMatrix() glDisable(GL_TEXTURE_2D) if alpha == True: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)