OpenGLContext 3.0.0a1__py3-none-any.whl

OpenGLContext/audio/settings.py

@@ -0,0 +1,82 @@
+"""What a player gets to decide about sound.
+
+A declared node rather than loose fields on the
+:class:`~OpenGLContext.contextdefinition.ContextDefinition`, for the same reason
+the movement modes are: sound has more than one knob, they belong together, and
+a node gets validation, defaults, serialisation and a generated settings page
+from the field system rather than from a parallel layer.
+
+**Whose volume is whose** is the distinction worth understanding here, because
+getting it wrong makes a volume control appear not to work:
+
+:attr:`AudioSettings.volume`
+    The **player's** volume -- what the slider on the settings screen moves, what
+    a volume key should write, and what is saved with the rest of the player's
+    settings.  The engine reads it every frame, so moving it is heard at once.
+:attr:`~omi_audio.engine.AudioEngine.master_gain`
+    The **application's** mix level -- how loud this scene was authored to be.
+    An application sets it once and the player never sees it.
+
+The two multiply.  Writing one over the other every frame -- which is the
+tempting shortcut -- makes whichever loses last exactly one frame, and the
+symptom is a volume key that prints a new number and changes nothing.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from vrml import field, node
+
+from OpenGLContext import renderoptions
+
+
+class AudioSettings(node.Node):
+    """Sound, as the player controls it."""
+
+    PROTO = 'AudioSettings'
+
+    #: Whether the scene's sounds are played at all.  Off opens no device and
+    #: starts no audio thread, which is what a capture run, a benchmark or a
+    #: machine with no sound card wants.  A scene with nothing audible in it
+    #: costs nothing either way; see :mod:`OpenGLContext.audio.scene`.
+    enabled = field.newField(
+        'enabled', 'SFBool', 1,
+        lambda: renderoptions.env_flag('OPENGLCONTEXT_AUDIO', True))
+    #: The player's volume: 0 silent, 1 as the application intended.  Linear
+    #: rather than decibels because that is what ``KHR_audio_emitter`` gains
+    #: are, and mixing the two units in one chain is how a volume control ends
+    #: up feeling wrong at one end of its travel.
+    volume = field.newField(
+        'volume', 'SFFloat', 1,
+        lambda: renderoptions.env_number('OPENGLCONTEXT_AUDIO_VOLUME', 1.0))
+    #: How many sounds may play at once.  Past the pool's size the least
+    #: important is dropped, so this is a quality setting as much as a budget:
+    #: a busy scene on a small pool loses its quietest sounds first.
+    voices = field.newField('voices', 'SFInt32', 1, 32)
+
+    #: How a generated settings page presents these; see
+    #: :mod:`OpenGLContext.ui.generate`.
+    UI_HINTS = {
+        'enabled': {'label': 'Sound'},
+        'volume': {'label': 'Volume', 'minimum': 0.0, 'maximum': 1.0,
+                   'step': 0.05},
+        'voices': {'label': 'Simultaneous sounds', 'minimum': 4,
+                   'maximum': 128, 'step': 4},
+    }
+
+    #: The order a settings page shows them in.
+    FIELDS = ('enabled', 'volume', 'voices')
+
+
+def settings_for(context: Any) -> AudioSettings:
+    """The audio settings of ``context``, defaulted if it declares none.
+
+    A context need not have a definition at all -- a bare test double often does
+    not -- and a scene with sound in it should still run when it does not.
+    """
+    definition = getattr(context, 'contextDefinition', None)
+    settings = getattr(definition, 'audio', None)
+    if isinstance(settings, AudioSettings):
+        return settings
+    return AudioSettings()

OpenGLContext/bin/choosecontext.py

@@ -0,0 +1,224 @@
+#! /usr/bin/env python
+'''Choose Context class for use as default testing context
+'''
+from OpenGLContext import testingcontext
+BaseContext = testingcontext.getInteractive()
+from OpenGLContext.scenegraph.basenodes import *
+from vrml.vrml97 import nodetypes
+from OpenGLContext.events import mouseevents
+from gettext import gettext as _
+
+class ChoiceContext( BaseContext ):
+    currentChoice = 0
+    def loadChoices( self ):
+        """See which contexts are available"""
+        choices = [
+            e.name for e in self.getContextTypes()
+        ]
+        return list(enumerate(choices))
+    def nameForContextType( self, index ):
+        if index > -1:
+            return self.choices[index][1]
+        return -1,None
+    def setSavedText( self, index ):
+        self.savedChoice = self.currentChoice
+        self.savedText.string = [ _('Current: %s')%(
+            self.nameForContextType( self.savedChoice )
+        )]
+        return self.savedChoice
+    def OnInit( self ):
+        """Setup callbacks and build geometry for rendering"""
+        self.choices = self.loadChoices()
+        print('Available Contexts', self.choices)
+        current = self.getDefaultContextType()
+        for i,name in self.choices:
+            if name == current:
+                self.currentChoice =  self.savedChoice = i
+        fontStyle = FontStyle3D(
+            size = 1,
+            family = "SERIF",
+            justify = "CENTER",
+            renderBack = False,
+            renderSides = False,
+        )
+        navFontStyle = FontStyle3D(
+            size = 2,
+            family = "SANS",
+            justify = "CENTER",
+            renderBack = False,
+            renderSides = False,
+        )
+        backButton = Text(
+            string = _('<'),
+            fontStyle = navFontStyle,
+        )
+        forwardButton = Text(
+            string = _('>'),
+            fontStyle = navFontStyle,
+        )
+        saveButton = Text(
+            string = _('Save'),
+            fontStyle = fontStyle,
+        )
+        self.previousButton = MouseOver(
+            choice = [
+                Shape(
+                    geometry = backButton,
+                    appearance = Appearance(
+                        material = Material( diffuseColor = (0,.5,0) ),
+                    ),
+                ),
+                Shape(
+                    geometry = backButton,
+                    appearance = Appearance(
+                        material = Material( diffuseColor = (0,1,0) ),
+                    ),
+                ),
+            ],
+            whichChoice = 0,
+        )
+        clicker = Shape(
+            DEF = 'CLICKER',
+            geometry = Box( size=(1,1,.001)),
+            appearance = Appearance(
+                material = Material( transparency=0 ),
+            ),
+        )
+        self.nextButton = MouseOver(
+            choice = [
+                Group(
+                    children = [
+                        Shape(
+                            geometry = forwardButton,
+                            appearance = Appearance(
+                                material = Material( diffuseColor = (0,.5,0) ),
+                            ),
+                        ),
+                        clicker,
+                    ],
+                ),
+                Group(
+                    children = [
+                        Shape(
+                            geometry = forwardButton,
+                            appearance = Appearance(
+                                material = Material( diffuseColor = (1,1,0) ),
+                            ),
+                        ),
+                        #clicker,
+                    ],
+                ),
+            ],
+            whichChoice = 0,
+        )
+        self.saveButton = MouseOver(
+            choice = [
+                Shape(
+                    geometry = saveButton,
+                    appearance = Appearance(
+                        material = Material( diffuseColor = (0,.5,0) ),
+                    ),
+                ),
+                Shape(
+                    geometry = saveButton,
+                    appearance = Appearance(
+                        material = Material( diffuseColor = (0,1,0) ),
+                    ),
+                ),
+            ],
+            whichChoice = 0,
+        )
+        self.currentChoiceText = 		Text(
+            string=[self.choices[self.currentChoice][1]],
+            fontStyle = fontStyle,
+        )
+        self.savedText = 		Text(
+            string='',
+            fontStyle = fontStyle,
+        )
+        self.setSavedText( self.currentChoice )
+
+        self.sg = sceneGraph(
+            children = [
+                SimpleBackground( color = (0,0,.25) ),
+                Transform(
+                    translation = (0,2,0),
+                    children = [
+                        Shape(
+                            geometry = self.currentChoiceText,
+                        ),
+                    ],
+                ),
+                Transform(
+                    translation = (-4,-1.5,0),
+                    children = [
+                        self.previousButton,
+                    ],
+                ),
+                Transform(
+                    translation = (4,-1.5,0),
+                    children = [
+                        self.nextButton,
+                    ],
+                ),
+                Transform(
+                    translation= (0,-1,0),
+                    children = [self.saveButton],
+                ),
+                Transform(
+                    translation= (0,-3,0),
+                    children = [
+                        Shape(
+                            geometry = self.savedText,
+                        ),
+                    ],
+                ),
+            ],
+        )
+#        self.addEventHandler(
+#            'mousebutton', 
+#            node=self.previousButton, 
+#            button = 0,
+#            state = 0,
+#            function = self.OnPrevious,
+#        )
+#        self.addEventHandler(
+#            'mousebutton', 
+#            node=self.nextButton, 
+#            button = 0,
+#            state = 0,
+#            function = self.OnNext,
+#        )
+#        self.addEventHandler(
+#            'mousebutton', 
+#            node=self.saveButton, 
+#            button = 0,
+#            state = 0,
+#            function = self.OnSave,
+#        )
+            
+    def OnNext( self, event ):
+        """Clicked the next button"""
+        self.currentChoice += 1
+        self.currentChoice = self.currentChoice % len( self.choices )
+        self.currentChoiceText.string = self.choices[self.currentChoice][1]
+        self.triggerRedraw(1)
+    def OnPrevious( self, event ):
+        """Clicked the previous button"""
+        self.currentChoice -= 1
+        self.currentChoice = self.currentChoice % len( self.choices )
+        self.currentChoiceText.string = self.choices[self.currentChoice][1]
+        self.triggerRedraw(1)
+        
+    def OnSave( self, event ):
+        """Save current choice to the preferences file"""
+        self.setDefaultContextType( self.choices[self.currentChoice][1] )
+        self.setSavedText( self.currentChoice )
+        self.triggerRedraw(1)
+
+def main():
+    """Mainloop redirecting to context's mainloop for operations"""
+    return ChoiceContext.ContextMainLoop()
+
+if __name__ == "__main__":
+    main()

OpenGLContext/bin/choosefonts.py

@@ -0,0 +1,209 @@
+#! /usr/bin/env python
+"""Test of text objects"""
+
+from OpenGLContext import testingcontext
+
+BaseContext = testingcontext.getInteractive()
+from OpenGL.GL import *
+from OpenGLContext.arrays import *
+import logging
+
+log = logging.getLogger(__name__)
+
+from OpenGLContext.scenegraph.basenodes import *
+from OpenGLContext.scenegraph.text import fontprovider
+
+
+class TestContext(BaseContext):
+    currentStyle = -1
+
+    def Render(self, mode=0):
+        BaseContext.Render(self, mode)
+        for shape in self.shapes:
+            mode.visit(shape)
+
+    def setupFontProviders(self):
+        """Load font providers for the context
+
+        See the OpenGLContext.scenegraph.text package for the
+        available font providers.
+        """
+        from OpenGLContext.scenegraph.text import fontprovider
+
+        try:
+            from OpenGLContext.scenegraph.text import toolsfont
+
+            assert toolsfont
+            registry = self.getTTFFiles()
+        except ImportError:
+            log.warning(
+                """Unable to import fonttools-based TTF-file registry, no TTF font support!"""
+            )
+        else:
+            fontprovider.setTTFRegistry(
+                registry,
+            )
+            self.families = registry.DEFAULT_FAMILY_SETS.keys()
+            self.families.sort()
+            self.family = self.families[0]
+        try:
+            from OpenGLContext.scenegraph.text import pygamefont
+
+            assert pygamefont
+        except ImportError:
+            log.warning(
+                """Unable to import PyGame TTF-font renderer, no PyGame anti-aliased font support!"""
+            )
+        try:
+            from OpenGLContext.scenegraph.text import glutfont
+
+            assert glutfont
+        except ImportError:
+            log.warning(
+                """Unable to import GLUT-based TTF-file registry, no GLUT bitmap font support!"""
+            )
+
+    def OnInit(self):
+        print("""You should see a 3D-rendered text message""")
+        print("  <p> previous fontstyle")
+        print("  <n> next fontstyle")
+        print("  <f> next font-family")
+        print("  <d> set current font as default font for family")
+        self.addEventHandler("keypress", name="n", function=self.OnNextStyle)
+        self.addEventHandler("keypress", name="p", function=self.OnPreviousStyle)
+        self.addEventHandler("keypress", name="d", function=self.OnSetDefault)
+        self.addEventHandler("keypress", name="f", function=self.OnNextFamily)
+        self.currentDefault = FontStyle(
+            justify="MIDDLE",
+            family=[self.family],
+        )
+        self.currentDisplay = FontStyle(
+            justify="MIDDLE",
+        )
+        self.defaultText = Text(
+            string=["Current Default"],
+            fontStyle=self.currentDefault,
+        )
+        self.displayText = Text(
+            string=["Hello World!", "VRML97 Text"],
+            fontStyle=self.currentDisplay,
+        )
+        self.sg = sceneGraph(
+            children=[
+                Transform(
+                    translation=(0, 3, 0),
+                    children=[
+                        Shape(
+                            geometry=self.defaultText,
+                            appearance=Appearance(
+                                material=Material(
+                                    diffuseColor=(0.3, 0.2, 0.8),
+                                    shininess=0.1,
+                                ),
+                            ),
+                        ),
+                    ],
+                ),
+                Shape(
+                    geometry=self.displayText,
+                    appearance=Appearance(
+                        material=Material(
+                            diffuseColor=(0.3, 0.2, 0.8),
+                            shininess=0.1,
+                        ),
+                    ),
+                ),
+            ]
+        )
+        self.buildStyles()
+
+    def buildStyles(self):
+        """Build the set of styles from which to choose"""
+        try:
+            self.styles = self.getTTFFiles().familyMembers(self.family)
+        except ImportError:
+            self.styles = ["SERIF", "SANS", "TYPEWRITER"]
+        if self.styles:
+            self.currentDefaultName = (
+                self.getDefaultTTFFont(self.family) or self.styles[0]
+            )
+            self.defaultDisplayText()
+        if self.currentDefaultName in self.styles:
+            index = self.styles.index(self.currentDefaultName)
+        else:
+            index = 0
+        self.setStyle(index)
+
+    def setStyle(self, index=0):
+        """Set the current font style"""
+        if self.styles:
+            self.currentStyle = index % (len(self.styles))
+            name = self.styles[self.currentStyle]
+            self.currentDisplay.family = [
+                name,
+            ]
+            # self.sg.children[1].geometry.fontStyle = self.currentDisplay
+            # print 'node', repr(self.sg.children[1].geometry)
+            assert not self.cache.getData(
+                self.sg.children[1].geometry
+            ), """Cache wasn't cleared for the text node"""
+        self.mainDisplayText()
+
+    def OnPreviousStyle(self, event=None):
+        """Advance to the next font font style"""
+        self.currentStyle -= 1
+        if not self.currentStyle % 20:
+            providers = fontprovider.FontProvider.getProviders(self.currentStyle)
+            for provider in providers:
+                provider.clear()
+        self.setStyle(self.currentStyle)
+        self.triggerRedraw(1)
+
+    def OnNextStyle(self, event=None):
+        """Advance to the next font font style"""
+        self.currentStyle += 1
+        if not self.currentStyle % 20:
+            providers = fontprovider.FontProvider.getProviders(self.currentStyle)
+            for provider in providers:
+                provider.clear()
+        self.setStyle(self.currentStyle)
+        self.triggerRedraw(1)
+
+    def OnSetDefault(self, event=None):
+        """Set default font for OpenGLContext to currently displayed"""
+        if self.styles:
+            name = self.currentDisplay.family[0]
+            self.setDefaultTTFFont(name, type=self.family)
+            self.currentDefaultName = name
+            self.defaultDisplayText()
+        self.triggerRedraw(1)
+
+    def OnNextFamily(self, event=None):
+        """Choose the next font-family to display"""
+        index = self.families.index(self.family)
+        index += 1
+        index = index % len(self.families)
+        self.family = self.families[index]
+        self.buildStyles()
+
+        self.triggerRedraw(1)
+
+    def mainDisplayText(self):
+        """Decide on what text to display in the main text area"""
+        base = []
+        if self.styles:
+            base.append("Hello World!")
+            base.append(self.styles[self.currentStyle])
+            base.append("(%s)" % (self.family))
+        else:
+            base.extend(["No", repr(self.family), "fonts available"])
+        self.displayText.string = base
+        return base
+
+    def defaultDisplayText(self):
+        self.currentDefault.family = [self.currentDefaultName]
+        self.defaultText.string = ["Current Default", self.currentDefaultName]
+
+
+if __name__ == "__main__":
+    TestContext.ContextMainLoop()

OpenGLContext/bin/gltest.py

@@ -0,0 +1,121 @@
+#! /usr/bin/env python
+"""Automated test runner for OpenGLContext contexts"""
+
+import optparse, sys, os, logging
+try:
+    import configparser as ConfigParser
+except ImportError:
+    import ConfigParser
+
+log = logging.getLogger("gltest")
+from OpenGLContext import testingcontext, context, plugins
+
+
+def main():
+    """Do the test for the passed elements"""
+    parser = optparse.OptionParser()
+    parser.add_option(
+        "-c",
+        "--config",
+        action="append",
+        type="string",
+        dest="configs",
+        default=None,
+    )
+    parser.add_option(
+        "-s",
+        "--script",
+        action="store",
+        type="string",
+        dest="script",
+        default=None,
+    )
+    parser.add_option(
+        "-o",
+        "--output",
+        action="store",
+        type="string",
+        dest="output",
+        default="test-results",
+    )
+    parser.add_option(
+        "-f",
+        "--frame-count",
+        action="store",
+        type="int",
+        dest="frame_count",
+        default=3,
+    )
+    options, args = parser.parse_args(sys.argv[1:])
+    if not options.script:
+        if args:
+            options.script = args[0]
+    script = os.path.abspath(options.script)
+    log.info("Script: %s", script)
+    if not os.path.exists(script):
+        log.error("""Couldn't find script file: %s""", script)
+    script_name = os.path.splitext(os.path.basename(script))[0]
+
+    ref_name = os.path.join(options.output, "%(script_name)s-ref.png" % locals())
+    if not os.path.exists(ref_name):
+        output_name = ref_name
+        log.warning("Recording reference image for %s", script_name)
+    else:
+        output_name = os.path.join(options.output, "%(script)s-new.png")
+
+    if options.configs:
+        configs = [c for c in options.configs if c]
+    else:
+        configs = []
+    if configs:
+        cfg = ConfigParser.ConfigParser()
+        cfg.read(*configs)
+        cls = context.Context.fromConfig(cfg)
+    else:
+        cls = context.Context.getContextType("pygame", plugins.VRMLContext)
+    if cls is None:
+        cls = context.Context.getContextType(None, plugins.VRMLContext)
+
+    class SaveAndExit(cls):
+        """Context which exits after the Nth rendering pass"""
+
+        target_frame_count = options.frame_count
+        frame_count = 0
+
+        def setupFrameRateCounter(self):
+            """Don't want the frame-rate counter to mess up the diffs"""
+
+        def OnDraw(self, *args, **named):
+            super(SaveAndExit, self).OnDraw(*args, **named)
+            self.frame_count += 1
+            if self.frame_count > self.target_frame_count:
+                self.setCurrent()
+                width, height = self.OnSaveImage(
+                    template=output_name,
+                    script=script_name,
+                    overwrite=True,
+                )
+                self.unsetCurrent()
+                if (not width) or (not height):
+                    log.warning("Did not write retrying")
+                sys.exit(0)
+                os._exit(0)
+            self.triggerRedraw()
+
+    testingcontext.CONFIGURED_BASE = SaveAndExit
+    # now, execute the script...
+    try:
+        os.makedirs(options.output)
+    except (IOError, OSError) as err:
+        pass
+    sys.path.insert(0, os.path.dirname(script))
+    g = {}
+    g["__name__"] = "__main__"
+    g["__file__"] = script
+    with open(script, 'rb') as f:
+        exec(compile(f.read(), script, 'exec'), g)
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    main()