def main():
root = Ogre.Root("plugins.cfg", "ogre.cfg", "")
cfg = Ogre.ConfigFile()
cfg.loadDirect("resources.cfg")
rgm = Ogre.ResourceGroupManager.getSingleton()
for sec, settings in cfg.getSettingsBySection().items():
for kind, loc in settings.items():
rgm.addResourceLocation(loc, kind, sec)
arch = cfg.getSettings("General").values()[0]
rgm.addResourceLocation(arch + "/materials/programs/GLSL", "FileSystem",
"General")
arch += "/RTShaderLib"
rgm.addResourceLocation(arch + "/materials", "FileSystem", "General")
rgm.addResourceLocation(arch + "/GLSL", "FileSystem", "General")
if not root.restoreConfig():
root.showConfigDialog(Ogre.ConfigDialog())
win = root.initialise(True)
OgreRTShader.ShaderGenerator.initialize()
shadergen = OgreRTShader.ShaderGenerator.getSingleton()
sgres = SGResolver(shadergen)
Ogre.MaterialManager.getSingleton().addListener(sgres)
rgm.initialiseAllResourceGroups()
rs = shadergen.getRenderState(
OgreRTShader.cvar.ShaderGenerator_DEFAULT_SCHEME_NAME)
rs.addTemplateSubRenderState(
shadergen.createSubRenderState(
OgreRTShader.cvar.PerPixelLighting_Type))
scn_mgr = root.createSceneManager(Ogre.ST_GENERIC)
shadergen.addSceneManager(scn_mgr)
scn_mgr.setAmbientLight(Ogre.ColourValue(.1, .1, .1))
light = scn_mgr.createLight("MainLight")
lightnode = scn_mgr.getRootSceneNode().createChildSceneNode()
lightnode.setPosition(0, 10, 15)
lightnode.attachObject(light)
cam = scn_mgr.createCamera("myCam")
cam.setPosition(0, 0, 15)
cam.setNearClipDistance(5)
cam.lookAt(0, 0, -1)
vp = win.addViewport(cam)
vp.setBackgroundColour(Ogre.ColourValue(.3, .3, .3))
ent = scn_mgr.createEntity("Sinbad.mesh")
node = scn_mgr.getRootSceneNode().createChildSceneNode()
node.attachObject(ent)
root.startRendering()
def __init__(self, scn_mgr, moonpos, cam):
#skybox and distance of the skybox
#scn_mgr.setSkyDome(True,"Skyes/Night1",50,5)
scn_mgr.setSkyBox(True, "Skyes/NightSkyBox", 100)
#scn_mgr.setSkyDome(True,"Examples/SpaceSkyPlane",5,8)
#lets set a fog
#Fadecolor=Ogre.ColourValue(0,0,0)
#vp.setBackgroundColour(Fadecolor)
#scn_mgr.setFog(Ogre.Ogre.FOG_LINEAR,Fadecolor,0,600,900)
scn_mgr.setAmbientLight(Ogre.ColourValue(.1, .1, .1))
dirlight = scn_mgr.createLight("MoonLight1")
dirlight.setType(Ogre.Light.LT_DIRECTIONAL)
dirlight.setDiffuseColour(Ogre.ColourValue(0, .1, .7))
dirlight.setSpecularColour(Ogre.ColourValue(0, 0, .5))
#dirlight.setDirection(-0.5, -0.5, -0.3)
dirlight.setDirection(moonpos * -1)
moon = scn_mgr.createBillboardSet("Moon")
moon.setMaterialName("Skyes/Moon")
moon.setDefaultDimensions(2000, 2000)
#self.mBurstSet.setCullIndividually(True)
#self.mBurstSet.setQueryFlags(0)
moonNode = scn_mgr.getRootSceneNode().createChildSceneNode()
moonboard = moon.createBillboard(moonpos)
#moonboard.setDimensions(1,1)
moonNode.attachObject(moon)
moonNode.setPosition(0, 1, 1)
#lens flare
self.lensflare = Lensflare.LensFlare(moonpos, cam, scn_mgr)
def setupScene(self):
# Step 1: https://ogrecave.github.io/ogre/api/latest/setup.html
sceneManager = self._root.createSceneManager()
# In Python, whenever you see `getSingleton()` you need to call
# `.initialize()` first. Note that here it's with a 'z', in other
# cases its spelled with an 's'.
OgreRTShader.ShaderGenerator.initialize()
shaderGen = OgreRTShader.ShaderGenerator.getSingleton()
shaderGen.addSceneManager(sceneManager)
rootNode = sceneManager.getRootSceneNode()
light = sceneManager.createLight('MainLight')
lightNode = rootNode.createChildSceneNode()
lightNode.setPosition(0, 100, 200)
lightNode.attachObject(light)
self.camNode = rootNode.createChildSceneNode()
self.camNode.setPosition(0, 0, 200)
self.camNode.lookAt(Ogre.Vector3(0, 0, -1), Ogre.Node.TS_PARENT)
camera = sceneManager.createCamera('My Camera')
camera.setNearClipDistance(5)
camera.setAutoAspectRatio(True)
self.camNode.attachObject(camera)
viewport = self._rend.addViewport(camera)
viewport.setBackgroundColour(Ogre.ColourValue(.1, .1, .1))
athena = sceneManager.createEntity('athene.mesh')
athenaNode = rootNode.createChildSceneNode()
athenaNode.attachObject(athena)
def main():
root = Ogre.Root("plugins.cfg", "ogre.cfg", "")
cfg = Ogre.ConfigFile()
cfg.loadDirect("resources.cfg")
rgm = Ogre.ResourceGroupManager.getSingleton()
for sec, settings in cfg.getSettingsBySection().items():
for kind, loc in settings.items():
rgm.addResourceLocation(loc, kind, sec)
if not root.restoreConfig():
root.showConfigDialog(None)
root.saveConfig()
win = root.initialise(True)
Ogre.RTShader.ShaderGenerator.initialize()
shadergen = Ogre.RTShader.ShaderGenerator.getSingleton()
sgres = SGResolver(shadergen)
Ogre.MaterialManager.getSingleton().addListener(sgres)
rgm.initialiseAllResourceGroups()
rs = shadergen.getRenderState(
Ogre.RTShader.ShaderGenerator.DEFAULT_SCHEME_NAME)
rs.addTemplateSubRenderState(
shadergen.createSubRenderState("SGX_PerPixelLighting"))
scn_mgr = root.createSceneManager()
shadergen.addSceneManager(scn_mgr)
scn_mgr.setAmbientLight((.1, .1, .1))
light = scn_mgr.createLight("MainLight")
lightnode = scn_mgr.getRootSceneNode().createChildSceneNode()
lightnode.setPosition(0, 10, 15)
lightnode.attachObject(light)
cam = scn_mgr.createCamera("myCam")
cam.setNearClipDistance(5)
camnode = scn_mgr.getRootSceneNode().createChildSceneNode()
camnode.attachObject(cam)
camnode.lookAt((0, 0, -1), Ogre.Node.TS_WORLD)
camnode.setPosition(0, 0, 15)
vp = win.addViewport(cam)
vp.setBackgroundColour((.3, .3, .3))
ent = scn_mgr.createEntity("Sinbad.mesh")
node = scn_mgr.getRootSceneNode().createChildSceneNode()
node.attachObject(ent)
while not root.endRenderingQueued():
root.renderOneFrame()
def main():
app = Ogre.Bites.ApplicationContext("PySample")
app.initApp()
root = app.getRoot()
scn_mgr = root.createSceneManager()
shadergen = Ogre.RTShader.ShaderGenerator.getSingleton()
shadergen.addSceneManager(scn_mgr)
## [numpy_image]
arr = np.zeros((256, 256, 3), dtype=np.uint8)
arr[:, :, 1] = np.mgrid[0:256, 0:256][1]
## [numpy_image]
## [np_to_ogre]
ogre_img = Ogre.Image()
ogre_img.loadDynamicImage(arr, 256, 256, Ogre.PF_BYTE_RGB)
Ogre.TextureManager.getSingleton().loadImage("gradient", "General",
ogre_img)
## [np_to_ogre]
## [apply_to_rect]
mat = Ogre.MaterialManager.getSingleton().create("gradient_mat", "General")
rpass = mat.getTechniques()[0].getPasses()[0]
rpass.setLightingEnabled(False)
rpass.createTextureUnitState("gradient")
rect = scn_mgr.createScreenSpaceRect(True)
rect.setCorners(-0.5, 0.5, 0.5, -0.5) # in normalized screen space
rect.setMaterial(mat)
rect.setBoundingBox(Ogre.AxisAlignedBox.BOX_INFINITE)
scn_mgr.getRootSceneNode().createChildSceneNode().attachObject(rect)
## [apply_to_rect]
cam = scn_mgr.createCamera("myCam")
win = app.getRenderWindow()
vp = win.addViewport(cam)
## [py_to_primitive]
gray = np.array([0.3, 0.3, 0.3])
vp.setBackgroundColour(gray)
## [py_to_primitive]
root.startRendering()
## [ogre_to_np]
mem = np.empty((win.getHeight(), win.getWidth(), 3), dtype=np.uint8)
pb = Ogre.PixelBox(win.getWidth(), win.getHeight(), 1, Ogre.PF_BYTE_RGB,
mem)
win.copyContentsToMemory(pb, pb)
## [ogre_to_np]
## [zero_copy_view]
pyplot.imsave("screenshot.png", mem)
def setup(self):
Bites.ApplicationContext.setup(self)
self.addInputListener(self)
root = self.getRoot()
scn_mgr = root.createSceneManager()
shadergen = RTShader.ShaderGenerator.getSingleton()
shadergen.addSceneManager(
scn_mgr) # must be done before we do anything with the scene
# overlay/ trays
scn_mgr.addRenderQueueListener(self.getOverlaySystem())
self.trays.showFrameStats(Bites.TL_TOPRIGHT)
self.trays.refreshCursor()
# enable per pixel lighting
rs = shadergen.getRenderState(
RTShader.cvar.ShaderGenerator_DEFAULT_SCHEME_NAME)
rs.addTemplateSubRenderState(
shadergen.createSubRenderState(
RTShader.cvar.PerPixelLighting_Type))
scn_mgr.setAmbientLight(Ogre.ColourValue(.1, .1, .1))
light = scn_mgr.createLight("MainLight")
lightnode = scn_mgr.getRootSceneNode().createChildSceneNode()
lightnode.setPosition(0, 10, 15)
lightnode.attachObject(light)
cam = scn_mgr.createCamera("myCam")
cam.setNearClipDistance(5)
cam.setAutoAspectRatio(True)
camnode = scn_mgr.getRootSceneNode().createChildSceneNode()
camnode.attachObject(cam)
self.camman = Bites.CameraMan(camnode)
self.camman.setStyle(Bites.CS_ORBIT)
self.camman.setYawPitchDist(Ogre.Radian(0), Ogre.Radian(0.3), 15)
self.addInputListener(self.camman)
# must keep a reference to ctrls so it does not get deleted
self.ctrls = Bites.AdvancedRenderControls(self.trays, cam)
self.addInputListener(self.ctrls)
vp = self.getRenderWindow().addViewport(cam)
vp.setBackgroundColour(Ogre.ColourValue(.3, .3, .3))
ent = scn_mgr.createEntity("Sinbad.mesh")
node = scn_mgr.getRootSceneNode().createChildSceneNode()
node.attachObject(ent)
def update(self):
#If the Light is out of the Camera field Of View, the lensflare is hidden.
if (not self.mCamera.isVisible(self.mLightPosition)):
self.mHaloSet.setVisible(False);
self.mBurstSet.setVisible(False)
return
else:
self.mCamerapos=self.mCamera.getDerivedPosition()
self.raydir=self.mLightPosition-self.mCamerapos
#self.raydir.normalise()
#updateline(self.line,self.mLightPosition,self.mCamerapos)
self.ray=Ogre.Ray(self.mCamerapos,self.raydir)
self.query.setRay(self.ray)
#self.query.clearResults()
if len(self.query.execute())>1:
#print (self.query.getLastResults()[0].movable.getName())
#self.query.getLastResults()[0].movable.setVisible(False)
#self.query.getLastResults()[0].movable.getParentSceneNode().showBoundingBox(True)
self.mHaloSet.setVisible(False);
self.mBurstSet.setVisible(False)
return
self.mHaloSet.setVisible(True)
self.mBurstSet.setVisible(True)
self.LightDistance = self.mLightPosition.distance(self.mCamerapos)
#self.CameraVect = self.mCamera.getDirection() # normalized vector (length 1)
#self.CameraVect = self.mCamera.getPosition() + (self.LightDistance * self.CameraVect)
#self.LightDistance = self.mLightPosition.distance(self.camnode.getDerivedPosition())
#self.mSceneMgr.destroyQuery(query)
self.CameraVect = self.mCamera.getDerivedOrientation() * Ogre.Vector3(0, 0, -1)# normalized vector (length 1)
self.CameraVect = self.mCamerapos + ( self.CameraVect *self.LightDistance)
#The LensFlare effect takes place along this vector.
self.LFvect = (self.CameraVect - self.mLightPosition)
self.LFvect += Ogre.Vector3(-64,-64,0) # sprite dimension (to be adjusted, but not necessary)
#The different sprites are placed along this line.
self.mHaloSet.getBillboard(0).setPosition(self.LFvect*0.500)
self.mHaloSet.getBillboard(1).setPosition( self.LFvect*0.125)
self.mHaloSet.getBillboard(2).setPosition(-self.LFvect*0.250)
self.mBurstSet.getBillboard(0).setPosition( self.LFvect*0.333)
self.mBurstSet.getBillboard(1).setPosition(-self.LFvect*0.500)
self.mBurstSet.getBillboard(2).setPosition(-self.LFvect*0.180)
#We redraw the lensflare (in case it was previouly out of the camera field, and hidden)
self.setVisible(True)
def locateResources(self):
rgm = Ogre.ResourceGroupManager.getSingleton()
# ensure our resource group is separate, even with a local resources.cfg
rgm.createResourceGroup(RGN_MESHVIEWER, False)
# use parent implementation to locate system-wide RTShaderLib
OgreBites.ApplicationContext.locateResources(self)
# allow override by local resources.cfg
if not self.getFSLayer().fileExists("resources.cfg"):
# we use the fonts from SdkTrays.zip
trays_loc = self.getDefaultMediaDir() + "/packs/SdkTrays.zip"
rgm.addResourceLocation(trays_loc, "Zip", RGN_MESHVIEWER)
if self.rescfg:
cfg = Ogre.ConfigFile()
cfg.loadDirect(self.rescfg)
for sec, settings in cfg.getSettingsBySection().items():
for kind, loc in settings.items():
rgm.addResourceLocation(loc, kind, sec)
# explicitly add mesh location to be safe
if not rgm.resourceLocationExists(self.meshdir, Ogre.RGN_DEFAULT):
rgm.addResourceLocation(self.meshdir, "FileSystem",
Ogre.RGN_DEFAULT)
def getTerrainImage(self, flipX, flipY):
img = Ogre.Image()
img.load("terrain.png",
Ogre.ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME)
if flipX:
img.flipAroundY()
if flipY:
img.flipAroundX()
return img
def __init__(self,LightPosition,camera,SceneMgr):
self.mSceneMgr=SceneMgr
self.mCamera=camera
self.mHidden=True
self.createlensflare()
self.setLightPosition(LightPosition)
self.raydir=self.mLightPosition-self.mCamera.getDerivedPosition()
self.mCamerapos=self.mCamera.getDerivedPosition()
self.ray=Ogre.Ray(self.mCamera.getDerivedPosition(),self.raydir)
self.query=self.mSceneMgr.createRayQuery(self.ray)
self.query.getSortByDistance()
def frameStarted(self, evt):
OgreBites.ApplicationContext.frameStarted(self, evt)
OgreImgui.ImguiManager.getSingleton().newFrame(
evt.timeSinceLastFrame,
Ogre.Rect(0, 0,
self.getRenderWindow().getWidth(),
self.getRenderWindow().getHeight()))
OgreImgui.ShowDemoWindow()
return True
def AsDataStream(arr):
"""
copy numpy array to Ogre.MemoryDataStream that can be used in Ogre
@param arr: some numpy array
"""
size = int(np.prod(arr.shape) * arr.dtype.itemsize)
ret = Ogre.MemoryDataStream(size)
tp = ctypes.POINTER(ctypes.c_ubyte)
np_view = npc.as_array(ctypes.cast(int(ret.getPtr()), tp), (size, ))
np_view[:] = arr.ravel().view(np.ubyte)
return ret
def setup(self):
OgreBites.ApplicationContext.setup(self)
self.addInputListener(self)
OgreImgui.ImguiManager.createSingleton()
root = self.getRoot()
scn_mgr = root.createSceneManager()
OgreImgui.ImguiManager.getSingleton().init(scn_mgr)
self.addInputListener(
OgreImgui.ImguiManager.getSingleton().getInputListener())
shadergen = OgreRTShader.ShaderGenerator.getSingleton()
shadergen.addSceneManager(
scn_mgr) # must be done before we do anything with the scene
scn_mgr.setAmbientLight(Ogre.ColourValue(.1, .1, .1))
light = scn_mgr.createLight("MainLight")
lightnode = scn_mgr.getRootSceneNode().createChildSceneNode()
lightnode.setPosition(0, 10, 15)
lightnode.attachObject(light)
cam = scn_mgr.createCamera("myCam")
cam.setNearClipDistance(5)
cam.setAutoAspectRatio(True)
camnode = scn_mgr.getRootSceneNode().createChildSceneNode()
camnode.setPosition(0, 0, 15)
camnode.lookAt(Ogre.Vector3(0, 0, -1), Ogre.Node.TS_PARENT)
camnode.attachObject(cam)
vp = self.getRenderWindow().addViewport(cam)
vp.setBackgroundColour(Ogre.ColourValue(.3, .3, .3))
ent = scn_mgr.createEntity("Sinbad.mesh")
node = scn_mgr.getRootSceneNode().createChildSceneNode()
node.attachObject(ent)
def __init__(self, parent: qw.QWidget = None):
qw.QOpenGLWidget.__init__(self, parent=parent)
self._root = Ogre.Root()
# Ensure we are using the basic OpenGL renderer
for renderer in self._root.getAvailableRenderers():
if 'OpenGL' in renderer.getName():
break
else:
raise ValueError('OpenGL Rendering System not available to Ogre')
# Note: British spellings on names in Ogre
self._root.setRenderSystem(renderer)
self._root.initialise(False)
# Will be created in `initializeGL`
self._rend: 'Ogre' = None
def locateResources(self):
rgm = Ogre.ResourceGroupManager.getSingleton()
# ensure our resource group is separate, even with a local resources.cfg
rgm.createResourceGroup(self.RGN_THIS_APP, False)
# use parent implementation to locate system-wide RTShaderLib
OgreBites.ApplicationContext.locateResources(self)
if self.rescfg:
cfg = Ogre.ConfigFile()
cfg.loadDirect(self.rescfg)
for sec, settings in cfg.getSettingsBySection().items():
for kind, loc in settings.items():
rgm.addResourceLocation(loc, kind, sec)
if not rgm.resourceLocationExists('.', Ogre.RGN_DEFAULT):
rgm.addResourceLocation('.', "FileSystem", Ogre.RGN_DEFAULT)
def initializeGL(self):
windowId = self.parent().winId()
# print('Window ID: ', windowId)
params = Ogre.NameValuePairList()
params['parentWindowHandle'] = str(windowId)
# TODO: consider making the render window the screen shape so that it
# can grow and shrink as needed.
self._rend = self._root.createRenderWindow(str(windowId), self.width(),
self.height(), False,
params)
self._rend.setActive(True)
self._rend.setVisible(True)
ogreWindowId = self._rend.getCustomAttribute('WINDOW')
# print('OgreWinId: ', ogreWindowId)
self.setAttribute(Qt.WA_OpaquePaintEvent)
self.locateResources()
self.setupScene()
def setup(self):
print("setup")
#Primero llamamos a la base y ponemos el listener
OgreBites.ApplicationContext.setup(self)
self.addInputListener(self)
self.restart = False
#get a pointer to the already created root
#create the scene manager
root = self.getRoot()
scn_mgr = root.createSceneManager()
scn_mgr.addRenderQueueListener(self.getOverlaySystem())
self.scn_mgr = scn_mgr
# must be done before we do anything with the scene
shadergen = OgreRTShader.ShaderGenerator.getSingleton()
shadergen.addSceneManager(scn_mgr)
# -- tutorial section start --
# Creamos la camara y la posicionamos en la escena
camNode = scn_mgr.getRootSceneNode().createChildSceneNode()
cam = scn_mgr.createCamera("myCam")
camNode.setPosition(200, 300, 400)
camNode.lookAt(Ogre.Vector3(0, 0, 0), Ogre.Node.TS_WORLD)
cam.setNearClipDistance(5)
camNode.attachObject(cam)
vp = self.getRenderWindow().addViewport(cam)
vp.setBackgroundColour(Ogre.ColourValue(0, 0, 0))
#cam.setAspectRatio(Ogre.Real(vp.getActualWidth()) / Ogre.Real(vp.getActualHeight()))
cam.setAspectRatio((vp.getActualWidth()) / (vp.getActualHeight()))
#Put entities
ninjaEntity = scn_mgr.createEntity("ninja.mesh")
ninjaEntity.setCastShadows(True)
scn_mgr.getRootSceneNode().createChildSceneNode().attachObject(
ninjaEntity)
#make a plane
plane = Ogre.Ogre.Plane()
n = plane.normal
n.x, n.y, n.z = 0, 1, 0
#plane.d=5000
#plane=Ogre.Ogre.Plane(Ogre.Vector3(0,1,0))
#Plane plane(Vector3::UNIT_Y, 0);
Ogre.MeshManager.getSingleton().createPlane("ground",
Ogre.Ogre.RGN_DEFAULT,
plane, 1500, 1500, 20, 20,
True, 1, 5, 5,
Ogre.Vector3(0, 0, 1))
groundEntity = scn_mgr.createEntity("ground")
scn_mgr.getRootSceneNode().createChildSceneNode().attachObject(
groundEntity)
groundEntity.setCastShadows(False)
groundEntity.setMaterialName("Examples/Rockwall")
scn_mgr.setAmbientLight(Ogre.ColourValue(0, 0, 0))
scn_mgr.setShadowTechnique(Ogre.Ogre.SHADOWTYPE_STENCIL_MODULATIVE)
spotLight = scn_mgr.createLight("SpotLight")
spotLight.setDiffuseColour(0, 0, 1.0)
spotLight.setSpecularColour(0, 0, 1.0)
spotLight.setType(Ogre.Ogre.Light.LT_SPOTLIGHT)
spotLightNode = scn_mgr.getRootSceneNode().createChildSceneNode()
spotLightNode.attachObject(spotLight)
spotLightNode.setDirection(-1, -1, 0)
spotLightNode.setPosition(Ogre.Vector3(200, 200, 0))
#spotLight.setSpotlightRange(Ogre.Degree(35), Ogre.Degree(50));
spotLight.setSpotlightRange(Ogre.Radian(0.61), Ogre.Radian(0.8727))
directionalLight = scn_mgr.createLight("DirectionalLight")
directionalLight.setType(Ogre.Light.LT_DIRECTIONAL)
directionalLight.setDiffuseColour(Ogre.ColourValue(0.4, 0, 0))
directionalLight.setSpecularColour(Ogre.ColourValue(0.4, 0, 0))
directionalLightNode = scn_mgr.getRootSceneNode().createChildSceneNode(
)
directionalLightNode.attachObject(directionalLight)
directionalLightNode.setDirection(Ogre.Vector3(0, -1, 1))
pointLight = scn_mgr.createLight("PointLight")
pointLight.setType(Ogre.Light.LT_POINT)
pointLight.setDiffuseColour(0.3, 0.3, 0.3)
pointLight.setSpecularColour(0.3, 0.3, 0.3)
pointLightNode = scn_mgr.getRootSceneNode().createChildSceneNode()
pointLightNode.attachObject(pointLight)
pointLightNode.setPosition(Ogre.Vector3(0, 150, 250))
def main(ctx):
## random calibration data. your mileage may vary
imsize = (800, 600)
K = cv2.getDefaultNewCameraMatrix(np.diag([800, 800, 1]), imsize, True)
## setup Ogre for AR
scn_mgr = ctx.getRoot().createSceneManager()
Ogre.RTShader.ShaderGenerator.getSingleton().addSceneManager(scn_mgr)
cam = scn_mgr.createCamera("camera")
cam.setNearClipDistance(5)
ctx.getRenderWindow().addViewport(cam)
camnode = scn_mgr.getRootSceneNode().createChildSceneNode()
# convert OpenCV to OGRE coordinate system
camnode.rotate((1, 0, 0), math.pi)
camnode.attachObject(cam)
set_camera_intrinsics(cam, K, imsize)
bgtex = create_image_background(scn_mgr)
## setup 3D scene
scn_mgr.setAmbientLight((.1, .1, .1))
scn_mgr.getRootSceneNode().createChildSceneNode().attachObject(
scn_mgr.createLight())
marker_node = scn_mgr.getRootSceneNode().createChildSceneNode()
mesh_node = marker_node.createChildSceneNode()
mesh_node.attachObject(scn_mgr.createEntity("Sinbad.mesh"))
mesh_node.rotate((1, 0, 0), math.pi / 2)
mesh_node.translate((0, 0, 5))
mesh_node.setVisible(False)
## video capture
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, imsize[0])
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, imsize[1])
## aruco
adict = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_4X4_50)
cv2.imshow("marker", cv2.aruco.drawMarker(adict, 0, 400))
rvec, tvec = None, None
while cv2.waitKey(1) != 27:
cont, img = cap.read()
if not cont: break
im = Ogre.Image(Ogre.PF_BYTE_BGR, img.shape[1], img.shape[0], 1, img,
False)
if bgtex.getBuffer():
bgtex.getBuffer().blitFromMemory(im.getPixelBox())
else:
bgtex.loadImage(im)
corners, ids = cv2.aruco.detectMarkers(img, adict)[:2]
if ids is not None:
rvecs, tvecs = cv2.aruco.estimatePoseSingleMarkers(
corners, 5, K, None)[:2]
rvec, tvec = rvecs[0].ravel(), tvecs[0].ravel()
ax = Ogre.Vector3(*rvec)
ang = ax.normalise()
marker_node.setOrientation(Ogre.Quaternion(ang, ax))
marker_node.setPosition(tvec)
mesh_node.setVisible(True)
ctx.getRoot().renderOneFrame()
def setup(self):
OgreBites.ApplicationContext.setup(self)
self.addInputListener(self)
self.restart = False
imgui_overlay = ImGuiOverlay()
GetIO().IniFilename = self.getFSLayer().getWritablePath("imgui.ini")
root = self.getRoot()
scn_mgr = root.createSceneManager()
scn_mgr.addRenderQueueListener(self.getOverlaySystem())
self.scn_mgr = scn_mgr
# set listener to deal with missing materials
self.mat_creator = MaterialCreator()
Ogre.MeshManager.getSingleton().setListener(self.mat_creator)
# for picking
self.ray_query = scn_mgr.createRayQuery(Ogre.Ray())
#imgui_overlay.addFont("SdkTrays/Value", RGN_MESHVIEWER)
imgui_overlay.show()
OverlayManager.getSingleton().addOverlay(imgui_overlay)
imgui_overlay.disown() # owned by OverlayMgr now
shadergen = OgreRTShader.ShaderGenerator.getSingleton()
shadergen.addSceneManager(
scn_mgr) # must be done before we do anything with the scene
scn_mgr.setAmbientLight(Ogre.ColourValue(.1, .1, .1))
self.highlight_mat = Ogre.MaterialManager.getSingleton().create(
"Highlight", RGN_MESHVIEWER)
self.highlight_mat.getTechniques()[0].getPasses()[0].setEmissive(
Ogre.ColourValue(1, 1, 0))
self.entity = scn_mgr.createEntity(self.meshname)
scn_mgr.getRootSceneNode().createChildSceneNode().attachObject(
self.entity)
diam = self.entity.getBoundingBox().getSize().length()
axes_node = scn_mgr.getRootSceneNode().createChildSceneNode()
axes_node.getDebugRenderable(
) # make sure Ogre/Debug/AxesMesh is created
self.axes = scn_mgr.createEntity("Ogre/Debug/AxesMesh")
axes_node.attachObject(self.axes)
axes_node.setScale(Ogre.Vector3(diam / 4))
self.axes.setVisible(False)
self.axes.setQueryFlags(0) # exclude from picking
self.cam = scn_mgr.createCamera("myCam")
self.cam.setNearClipDistance(diam * 0.01)
self.cam.setAutoAspectRatio(True)
camnode = scn_mgr.getRootSceneNode().createChildSceneNode()
camnode.attachObject(self.cam)
light = scn_mgr.createLight("MainLight")
light.setType(Ogre.Light.LT_DIRECTIONAL)
light.setSpecularColour(Ogre.ColourValue.White)
camnode.attachObject(light)
vp = self.getRenderWindow().addViewport(self.cam)
vp.setBackgroundColour(Ogre.ColourValue(.3, .3, .3))
self.camman = OgreBites.CameraMan(camnode)
self.camman.setStyle(OgreBites.CS_ORBIT)
self.camman.setYawPitchDist(Ogre.Radian(0), Ogre.Radian(0.3), diam)
self.camman.setFixedYaw(False)
self.imgui_input = OgreBites.ImGuiInputListener()
self.input_dispatcher = OgreBites.InputListenerChain(
[self.imgui_input, self.camman])
self.addInputListener(self.input_dispatcher)
def setup(self):
# SETUP es la primera función a la que se llama
# Primero llamamos a la base y ponemos el listener
OgreBites.ApplicationContext.setup(self)
#Ahora se llama a locate resources
self.addInputListener(self)
#imgui_overlay = ImGuiOverlay()
self.restart = False
imgui_overlay = OgreOverlay.ImGuiOverlay()
OgreOverlay.GetIO().IniFilename = self.getFSLayer().getWritablePath(
"imgui.ini")
#Inicializamos ogre u hacemos un puntero a Root
root = self.getRoot()
#Creamos el scene manager
scn_mgr = root.createSceneManager()
scn_mgr.addRenderQueueListener(self.getOverlaySystem())
self.scn_mgr = scn_mgr
imgui_overlay.show()
OgreOverlay.OverlayManager.getSingleton().addOverlay(imgui_overlay)
imgui_overlay.disown() # owned by OverlayMgr now
# Creamos el Shader y definimos las sombras
shadergen = OgreRTShader.ShaderGenerator.getSingleton()
shadergen.addSceneManager(scn_mgr)
scn_mgr.setShadowTechnique(Ogre.Ogre.SHADOWTYPE_TEXTURE_MODULATIVE)
#scn_mgr.setShadowTechnique(Ogre.Ogre.SHADOWTYPE_TEXTURE_ADDITIVE)
#scn_mgr.setShadowTechnique(Ogre.Ogre.SHADOWTYPE_STENCIL_MODULATIVE)
scn_mgr.setShadowDirLightTextureOffset(1)
scn_mgr.setShadowFarDistance(200)
#para que los objetos emitan shadow sobre si mismos
scn_mgr.setShadowTextureSelfShadow(True)
#skybox and distance of the skybox
#scn_mgr.setSkyBox(True,"Skyes/Night1",100)
scn_mgr.setSkyDome(True, "Skyes/Night1", 50, 5)
#scn_mgr.setSkyDome(True,"Examples/SpaceSkyPlane",5,8)
#lets set a fog
#Fadecolor=Ogre.ColourValue(0,0,0)
#vp.setBackgroundColour(Fadecolor)
#scn_mgr.setFog(Ogre.Ogre.FOG_LINEAR,Fadecolor,0,600,900)
#Creamos el mapa
#mapa=Ogretmxmap.tmxmap("Maps/cathedral.tmx")
mapa = Ogretmxmap.tmxmap("resources/tiled/cathedral.tmx")
mannode = scn_mgr.getRootSceneNode().createChildSceneNode()
mannode.setPosition(0, 0, 0)
mapa.createmap(scn_mgr)
# Vamos a crear el nodo perteneciente al personaje
Playernode = scn_mgr.getRootSceneNode().createChildSceneNode()
#Playernode.setPosition(self.pos)
self.Playernode = Playernode
# Creo el player y lo fusiono con su nodo
self.Player = Player.Player(Playernode)
self.Player.mapa = mapa
self.Player.setpos(10, 10, 0)
# Creamos la camara y la posicionamos en el personaje
camNode = Playernode.createChildSceneNode()
camNode.setPosition(0, 1.5, 0)
self.cam = scn_mgr.createCamera("MainCam")
#camNode.setPosition(0, 0, 80)
camNode.lookAt(Ogre.Vector3(300, 1.5, 0), Ogre.Node.TS_WORLD)
self.cam.setNearClipDistance(.2)
camNode.attachObject(self.cam)
vp = self.getRenderWindow().addViewport(self.cam)
vp.setBackgroundColour(Ogre.ColourValue(0, 0, 0))
self.cam.setAspectRatio((vp.getActualWidth()) / (vp.getActualHeight()))
self.camNode = camNode
# Setup the scene
#night light
scn_mgr.setAmbientLight(Ogre.ColourValue(.1, .1, .1))
dirlight = scn_mgr.createLight("MoonLight1")
dirlight.setType(Ogre.Light.LT_DIRECTIONAL)
dirlight.setDiffuseColour(Ogre.ColourValue(0, .1, .7))
dirlight.setSpecularColour(Ogre.ColourValue(0, 0, .5))
dirlight.setDirection(-0.5, -0.5, -0.3)
# spotlight=scn_mgr.createLight("MoonLight2")
# spotlight.setType(Ogre.Light.LT_SPOTLIGHT);
# spotlight.setDiffuseColour(Ogre.ColourValue(.02, .2, .9));
# spotlight.setSpecularColour(Ogre.ColourValue(0, 0, .5))
# spotlight.setSpotlightInnerAngle(Ogre.Radian(0.09))
# spotlight.setSpotlightOuterAngle(Ogre.Radian(3))
# spotlight.setSpotlightFalloff(.0)
# spotLightNode = Playernode.createChildSceneNode()
# spotLightNode.setPosition(Ogre.Vector3(3, 3, 3))
# spotlight.setDirection(0, -1, -0.7)
# spotLightNode.attachObject(spotlight)
#spotlight.setCastShadows(True)
pointLight = scn_mgr.createLight("PointLight")
pointLight.setType(Ogre.Light.LT_POINT)
pointLight.setDiffuseColour(1, 1, 1)
pointLight.setSpecularColour(1, 1, 1)
pointLightNode = Playernode.createChildSceneNode()
pointLightNode.attachObject(pointLight)
pointLightNode.setPosition(0, 1.5, 0)
pointLight.setAttenuation(100, 1, 0.045, 0.0075)
#Daylight, esta tecnica de sombreado queda mucho mejor
# scn_mgr.setShadowTechnique(Ogre.Ogre.SHADOWTYPE_TEXTURE_ADDITIVE)
# scn_mgr.setAmbientLight(Ogre.ColourValue(.2, .2, .2))
# light=scn_mgr.createLight("MainLight")
# light.setType(Ogre.Light.LT_DIRECTIONAL);
# light.setDiffuseColour(Ogre.ColourValue(.6, .6, 1));
# light.setSpecularColour(Ogre.ColourValue(.6, .6, 1))
# light.setDirection(1, -0.5, 0.5)
# lightNode = scn_mgr.getRootSceneNode().createChildSceneNode()
# lightNode.attachObject(light)
# lightNode.setPosition(0, 3, 0)
self.mapa = mapa
self.cam.getViewport().setOverlaysEnabled(True)
#self.mtraymanager=OgreBites.TrayManager("Interface",self.getRenderWindow())
#self.mtraymanager.createLabel(OgreBites.TL_TOP,"TInfo","",350)
self.imgui_input = OgreBites.ImGuiInputListener()
self.input_dispatcher = OgreBites.InputListenerChain(
[self.imgui_input])
self.addInputListener(self.input_dispatcher)
def frameStarted(self, evt):
OgreBites.ApplicationContext.frameStarted(self, evt)
ImguiManager.getSingleton().newFrame(
evt.timeSinceLastFrame,
Ogre.Rect(0, 0,
self.getRenderWindow().getWidth(),
self.getRenderWindow().getHeight()))
if BeginMainMenuBar():
if BeginMenu("File"):
if MenuItem("Select Renderer"):
self.getRoot().queueEndRendering()
self.restart = True
if MenuItem("Quit", "Esc"):
self.getRoot().queueEndRendering()
EndMenu()
if BeginMenu("View"):
enode = self.entity.getParentSceneNode()
if MenuItem("Show Axes", "A", self.axes.getVisible()):
self._toggle_axes()
if MenuItem("Show Bounding Box", "B",
enode.getShowBoundingBox()):
self._toggle_bbox()
if self.entity.hasSkeleton() and MenuItem(
"Show Skeleton", None,
self.entity.getDisplaySkeleton()):
self.entity.setDisplaySkeleton(
not self.entity.getDisplaySkeleton())
EndMenu()
if BeginMenu("Help"):
if MenuItem("Metrics", None, self.show_metrics):
self.show_metrics = not self.show_metrics
if MenuItem("About"):
self.show_about = True
EndMenu()
EndMainMenuBar()
if self.show_about:
self.draw_about()
if self.show_metrics:
self.draw_metrics()
# Mesh Info Sidebar
mesh = Ogre.MeshManager.getSingleton().getByName(self.meshname)
SetNextWindowPos(ImVec2(0, 30))
flags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoMove
Begin("MeshProps", None, flags)
Text(self.meshname)
highlight = -1
if CollapsingHeader("Geometry"):
if mesh.sharedVertexData:
Text("Shared Vertices: {}".format(
mesh.sharedVertexData.vertexCount))
else:
Text("Shared Vertices: None")
for i, sm in enumerate(mesh.getSubMeshes()):
submesh_details = TreeNode("SubMesh #{}".format(i))
if IsItemHovered():
highlight = i
if submesh_details:
BulletText("Material: {}".format(sm.getMaterialName()))
if sm.indexData:
bits = sm.indexData.indexBuffer.getIndexSize() * 8
BulletText("Indices: {} ({} bit)".format(
sm.indexData.indexCount, bits))
else:
BulletText("Indices: None")
if sm.vertexData:
BulletText("Vertices: {}".format(
sm.vertexData.vertexCount))
else:
BulletText("Vertices: shared")
TreePop()
if self.highlighted > -1:
self.entity.getSubEntities()[self.highlighted].setMaterialName(
self.orig_mat)
if highlight > -1:
self.orig_mat = self.entity.getSubEntities(
)[highlight].getMaterial().getName()
self.entity.getSubEntities()[highlight].setMaterial(
self.highlight_mat)
self.highlighted = highlight
animations = self.entity.getAllAnimationStates()
if animations is not None and CollapsingHeader("Animations"):
controller_mgr = Ogre.ControllerManager.getSingleton()
if self.entity.hasSkeleton():
Text("Skeleton: {}".format(mesh.getSkeletonName()))
# self.entity.setUpdateBoundingBoxFromSkeleton(True)
if mesh.hasVertexAnimation():
Text("Vertex Animations")
for name, astate in animations.getAnimationStates().items():
if TreeNode(name):
if astate.getEnabled():
if Button("Reset"):
astate.setEnabled(False)
astate.setTimePosition(0)
if name in self.active_controllers:
controller_mgr.destroyController(
self.active_controllers[name])
elif Button("Play"):
astate.setEnabled(True)
self.active_controllers[
name] = controller_mgr.createFrameTimePassthroughController(
Ogre.AnimationStateControllerValue.create(
astate, True))
changed = False
if astate.getLength() > 0:
SameLine()
changed, value = SliderFloat("",
astate.getTimePosition(),
0, astate.getLength(),
"%.3fs")
if changed:
astate.setEnabled(True)
astate.setTimePosition(value)
TreePop()
if CollapsingHeader("Bounds"):
bounds = mesh.getBounds()
s = bounds.getSize()
BulletText("Size: {:.2f}, {:.2f}, {:.2f}".format(s[0], s[1], s[2]))
c = bounds.getCenter()
BulletText("Center: {:.2f}, {:.2f}, {:.2f}".format(
c[0], c[1], c[2]))
BulletText("Radius: {:.2f}".format(mesh.getBoundingSphereRadius()))
End()
# ShowDemoWindow()
return True
def setup(self):
print("setup")
#Primero llamamos a la base y ponemos el listener
OgreBites.ApplicationContext.setup(self)
self.addInputListener(self)
mesh = Ogre.MeshManager.getSingleton().getByName("ogrehead.mesh")
self.restart = False
#get a pointer to the already created root
#create the scene manager
root = self.getRoot()
scn_mgr = root.createSceneManager()
scn_mgr.addRenderQueueListener(self.getOverlaySystem())
self.scn_mgr = scn_mgr
# must be done before we do anything with the scene
shadergen = OgreRTShader.ShaderGenerator.getSingleton()
shadergen.addSceneManager(scn_mgr)
# Ponemos las luces
scn_mgr.setAmbientLight(Ogre.ColourValue(0.5, 0.5, 0.5))
light = scn_mgr.createLight("MainLight")
lightNode = scn_mgr.getRootSceneNode().createChildSceneNode()
lightNode.attachObject(light)
lightNode.setPosition(20, 80, 50)
#Ponemos la camara
camNode = scn_mgr.getRootSceneNode().createChildSceneNode()
cam = scn_mgr.createCamera("myCam")
cam.setNearClipDistance(5) # specific to this sample
cam.setAutoAspectRatio(True)
camNode.attachObject(cam)
camNode.setPosition(0, 0, 140)
#and tell it to render into the main window
self.getRenderWindow().addViewport(cam)
#ponemos la entidad 1
ogreEntity = scn_mgr.createEntity("ogrehead.mesh")
ogreNode = scn_mgr.getRootSceneNode().createChildSceneNode()
ogreNode.attachObject(ogreEntity)
#CAmera movement
camNode.setPosition(0, 47, 222)
#Second entity
ogreEntity2 = scn_mgr.createEntity("ogrehead.mesh")
ogreNode2 = scn_mgr.getRootSceneNode().createChildSceneNode(
Ogre.Vector3(84, 48, 0))
ogreNode2.attachObject(ogreEntity2)
#Third entity
ogreEntity3 = scn_mgr.createEntity("ogrehead.mesh")
ogreNode3 = scn_mgr.getRootSceneNode().createChildSceneNode()
ogreNode3.setPosition(0, 104, 0)
ogreNode3.setScale(2, 1.2, 1)
ogreNode3.attachObject(ogreEntity3)
#Fourth entity
ogreEntity4 = scn_mgr.createEntity("ogrehead.mesh")
ogreNode4 = scn_mgr.getRootSceneNode().createChildSceneNode()
ogreNode4.setPosition(-84, 48, 0)
#ogreNode4.roll(Ogre.Degree(-90))
ogreNode4.roll(Ogre.Radian(-1.5508))
ogreNode4.attachObject(ogreEntity4)
def setup(self):
print("setup")
#Primero llamamos a la base y ponemos el listener
OgreBites.ApplicationContext.setup(self)
self.addInputListener(self)
self.restart = False
#get a pointer to the already created root
#create the scene manager
root = self.getRoot()
scn_mgr = root.createSceneManager()
scn_mgr.addRenderQueueListener(self.getOverlaySystem())
self.scn_mgr = scn_mgr
# must be done before we do anything with the scene
shadergen = OgreRTShader.ShaderGenerator.getSingleton()
shadergen.addSceneManager(scn_mgr)
# -- tutorial section start --
# Creamos la camara y la posicionamos en la escena
camNode = scn_mgr.getRootSceneNode().createChildSceneNode()
cam = scn_mgr.createCamera("myCam")
mTerrainPos = Ogre.Vector3(1000, 0, 5000)
camNode.setPosition(mTerrainPos + Ogre.Vector3(1683, 50, 2116))
camNode.lookAt(Ogre.Vector3(1963, 50, 1660), Ogre.Node.TS_PARENT)
cam.setNearClipDistance(40) # tight near plane important for shadows
if root.getRenderSystem().getCapabilities().hasCapability(
Ogre.RSC_INFINITE_FAR_PLANE):
print("ponemos far clip distance a infinito")
cam.setFarClipDistance(
0) # enable infinite far clip distance if we can
else:
cam.setFarClipDistance(50000)
camNode.attachObject(cam)
vp = self.getRenderWindow().addViewport(cam)
vp.setBackgroundColour(Ogre.ColourValue(0, 0, 0))
#Ponemos las luces
l = scn_mgr.createLight("tstLight")
l.setType(Ogre.Light.LT_DIRECTIONAL)
l.setDiffuseColour(Ogre.ColourValue.White)
l.setSpecularColour(Ogre.ColourValue(0.4, 0.4, 0.4))
ln = scn_mgr.getRootSceneNode().createChildSceneNode()
ln.setDirection(Ogre.Vector3(0.55, -0.3, 0.75).normalisedCopy())
ln.attachObject(l)
#Terreno
TERRAIN_SIZE = 513
TERRAIN_WORLD_SIZE = 12000
#scn_mgr.setWorldGeometry("terrain.cfg")
self.mTerrainGlobals = ogreterrain.TerrainGlobalOptions()
mTerrainGroup = ogreterrain.TerrainGroup(scn_mgr,
ogreterrain.Terrain.ALIGN_X_Z,
TERRAIN_SIZE,
TERRAIN_WORLD_SIZE)
self.mTerrainGroup = mTerrainGroup
mTerrainGroup.setFilenameConvention("BasicTutorial3Terrain", "dat")
mTerrainGroup.setOrigin(mTerrainPos)
self.configureTerrainDefaults(l)
self.defineTerrain(0, 0)
for x in range(TERRAIN_PAGE_MIN_X, TERRAIN_PAGE_MAX_X):
for y in range(TERRAIN_PAGE_MIN_Y, TERRAIN_PAGE_MAX_Y):
self.defineTerrain(x, y)
# sync load since we want everything in place when we start
mTerrainGroup.loadAllTerrains(True)
if (self.mTerrainsImported):
for t in mTerrainGroup.getTerrainIterator():
self.initBlendMaps(t.instance())
mTerrainGroup.freeTemporaryResources()