def DrawGLScene():
global scene
global camera
global hud
global frametimer
global SceneMstr
global Signals
#update the scene
frametimer.update()
RequestManager.update()
t0 = time.time()
SceneMstr.update()
Signals['update'].setvalue((time.time()-t0)*1000)
# Clear The Screen And The Depth Buffer
glFinish()
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
t0 = time.time()
#draw all objects in the scene
SceneMstr.draw()
Signals['draw'].setvalue((time.time()-t0)*1000)
# since this is double buffered, swap the buffers to display what just got drawn.
glFinish()
glutSwapBuffers()
def main():
if '-r' in sys.argv:
RequestManager.read_tiindicators()
sys.exit()
config.verbose_log = ('-v' in sys.argv)
print('fetching & parsing data from misp...')
events = _get_events()
parsed_events = list()
for event in events:
parsed_event = defaultdict(list)
for key, mapping in EVENT_MAPPING.items():
parsed_event[mapping] = event.get(key, "")
parsed_event['tags'] = [
tag['name'].strip() for tag in event.get("Tag", [])
]
_handle_diamond_model(parsed_event)
_handle_tlp_level(parsed_event)
_handle_timestamp(parsed_event)
for attr in event['Attribute']:
if attr['type'] == 'threat-actor':
parsed_event['activityGroupNames'].append(attr['value'])
if attr['type'] == 'comment':
parsed_event['description'] += attr['value']
if attr['type'] in MISP_ACTIONABLE_TYPES:
parsed_event['request_objects'].append(RequestObject(attr))
parsed_events.append(parsed_event)
del events
total_indicators = sum([len(v['request_objects']) for v in parsed_events])
with RequestManager(total_indicators) as request_manager:
for request_body in _graph_post_request_body_generator(parsed_events):
request_manager.handle_indicator(request_body)
def get_fiat_value(self, start_date=datetime.date(datetime.now() - timedelta(days=1)), stop_date=datetime.date(datetime.now()),
base_currency="EUR", target_currency="USD"):
"""
FIAT currency converter from European Central Bank, through https://exchangeratesapi.io API
Parameters
----------
start_date : datetime
starting date for currency retrieval (default value: yesterday)
stop_date : datetime
stop date for currency retrieval (default value = today)
base_currency : string
base currency to convert from (EUR, USD, ...)
target_currency : string
target currency to convert to (USD, JPY, GBP, ...)
Returns
-------
current_rate : float
Exchange rate for stop date
currecy_rates : dictionary(date: string<YYYY-MM-DD>, float)
Exchange rates for whole configured date span (bank holidays not included, no rate for those dates)
Raises
------
ValueError
If base currency and target currency are the same
If stop date is previous to start date
If any of the dates is in the future (beyond today)
ConnectionError
If response from server is not 200
"""
currency_rates = dict()
if base_currency == target_currency:
raise ValueError("Base currency and target currency can not be equal")
elif start_date >= datetime.now():
raise ValueError("Start date must not be in the future or current date")
elif stop_date > datetime.now():
raise ValueError("Start date must not be in the future or current date")
elif start_date > stop_date:
raise ValueError("Start date can not be greater than stop date")
else:
# EUR / fiat_currency exchange rate from BCE
date_start = start_date.strftime('%Y-%m-%d')
date_stop = stop_date.strftime('%Y-%m-%d')
headers = {
'Accepts': 'application/json',
'Accept-Encoding': 'deflate, gzip',
}
request_address = f'https://api.exchangeratesapi.io/history?base={base_currency.value}&start_at={date_start}&end_at={date_stop}&symbols={target_currency.value}'
manager_fiat = RequestManager(headers)
data = manager_fiat.send_request(parameters={}, url=request_address)
# Check that everything was OK
if manager_fiat.status_code == 200:
rates = data["rates"]
for rate in rates:
currency_rates[rate] = round(rates[rate][target_currency.value],4)
return currency_rates[stop_date.strftime('%Y-%m-%d')], currency_rates
else:
raise ConnectionError("Connection did not finish as expected. HTTP error code {}\nRequest was: {}".format(manager_fiat.status_code, request_address))
def __init__(self):
self.authorizer = Authorizer("auth_info.json")
self.request_manager = RequestManager()
self.sockets: Dict[int, socket.socket] = {} # fileno : sock
self.clients: Dict[int, Client] = {} # fileno : client
self.authorized_clients: Dict[str, Client] = {} # username : client
self.buffered_data: Dict[int, str] = {} # fileno : data
self.poller = select.poll()
self.remove_idle_clients_forever()
def CheckLevelZeroTexComplete(self):
if self.state <> 0:
incomplete = False
print 'checking completeness'
for i in range(0, 6):
if not (self.face[i].texture_baked):
incomplete = True
if incomplete:
print 'not complete, rescheduling'
RequestManager.add_request(self.CheckLevelZeroTexComplete, [],
'default', None, True)
else:
self.state = 0
# TODO 2017 - do not work - self.TexAtlas.save_texture_atlas_bmp("test2017")
print 'complete now'
def send_message(comments, footer, footer_icon):
star = ":star:"
data = {
'score': comments['score'],
'title': comments['title'],
'date': comments['date'],
'comment': comments['comment'],
'pretext': '`TEST` UtaPass Android has a new review!',
'text': ''.join(star * int(comments['score']) + ' Score : %s' % str(comments['score'])),
'content': u'{}\n\n [Translation]\n*{}*\n\n{}\n\n_{} ver.{}_'.format(comments['comment'],
comments['translated_title'],
comments['translated_comment'],
(comments['date']).strftime('%Y-%m-%d'),
comments['version']),
'thumb_url': 'https://img.au-market.com/mapi/pc_icon/39767/3976700000002/100211_116788.png',
'footer': footer,
'footer_icon': footer_icon
}
# if review has no version info or from au Market, wouldn't show comments['version']
if comments['version'] is None or footer == FOOTER[0]:
data['content'] = u'{}\n\n [Translation]\n*{}*\n\n{}\n\n_{}_'.format(comments['comment'],
comments['translated_title'],
comments['translated_comment'],
(comments['date']).strftime('%Y-%m-%d'))
RequestManager().slackAttachmentsWithFieldsMessager('#test-b0t', data['pretext'], "", data['text'], "", "",
"Android Reviews Bot", data['footer'], data['title'],
data['content'], data['thumb_url'], data['footer_icon'])
def writeNewValues(self):
file = open(self.file_path)
config = json.load(file)
data = RequestManager.getPrices(config)
CSVManager.write(data[0], data[1])
print("---------------- Added Line ----------------- ")
print(data[0])
print(data[1])
self.scheduler.enter(self.timer, 1, self.writeNewValues)
def do_triangles_finalize(self, force_completion=False):
#before doing anything let's check if a texture is baking
if (self.texture_baking == True) and (force_completion == False):
#reschedule and exit
RequestManager.add_request(self.do_triangles_finalize, [],
'get_triangles' + str(self.face),
self.MinimumPriority)
else:
#update triangle count info
self.NodesStats['Triangles'] -= self.currenttrianglecount
self.currenttrianglecount = self.datadict['index'].__len__()
self.NodesStats['Triangles'] += self.currenttrianglecount
t01 = time.time() * 1000
self.vertici = np.concatenate(self.datadict['vertex'])
self.indici = np.array(self.datadict['index'], dtype='uint32')
print(" **** time conversion to nparrays: " +
str(time.time() * 1000 - t01))
self.VBO_update = [True, True]
def VBOupdate(self, vboindex):
nact = 1 - self.activeVBO[vboindex]
if self.VBO_need_update[vboindex] == 2 and self.face[
vboindex].VBO_update[nact]:
#update the nact vbo and reschedule an update
self.vertexVBO[nact][vboindex].set_array(
self.face[vboindex].vertici)
self.indexVBO[nact][vboindex].set_array(self.face[vboindex].indici)
self.VBO_need_update[vboindex] = self.activeVBO[vboindex]
if self.VBO_need_update[vboindex] == nact and self.face[
vboindex].VBO_update[nact]:
#update the vbo and it's over
self.vertexVBO[nact][vboindex].set_array(
self.face[vboindex].vertici)
self.indexVBO[nact][vboindex].set_array(self.face[vboindex].indici)
self.VBO_need_update[vboindex] = 3
if (self.VBO_need_update[vboindex] == self.activeVBO[vboindex]) or (
self.face[vboindex].VBO_update[nact] == False):
#cannot update now, reschedule the update
RequestManager.add_request(self.VBOupdate, [vboindex])
def do_triangles(self, force_completion=False):
#per il momento presuppone che datadict sia un dizionario con campi 'vertex' e 'index'
#se l'oggetto e una foglia
self.VBO_update = [False, False]
self.datadict = {'vertex': [], 'index': []}
if self.datadict['vertex'] == []:
len = 0
else:
len = self.datadict['vertex'].__len__()
if force_completion:
if self.children == 0:
self.get_triangles(self.datadict, True)
else:
for ch in self.children:
ch.get_triangles(self.datadict, True)
self.do_triangles_finalize(True)
else:
if self.children == 0:
RequestManager.add_request(self.get_triangles, [self.datadict],
'get_triangles' + str(self.face),
self.NodePriority)
else:
for ch in self.children:
RequestManager.add_request(ch.get_triangles,
[self.datadict],
'get_triangles' + str(ch.face),
ch.NodePriority)
#now the job that have to be executed last
RequestManager.add_request(self.do_triangles_finalize, [],
'get_triangles' + str(self.face),
self.MinimumPriority)
def get_metadata(self, galleries):
assert len(galleries) <= self.API_MAX_ENTRIES
payload = copy.deepcopy(self.BASE_REQUEST)
payload["gidlist"] = [g.id for g in galleries]
response = RequestManager.post(self.API_URL, payload=payload)
self.signals.progress.emit(self.inc_val)
for gallery in galleries:
for metadata in response["gmetadata"]:
id = [metadata["gid"], metadata["token"]]
if id == gallery.id:
gallery.update_metadata({"gmetadata": metadata})
gallery.update_qgallery()
break
def get_cypto_value(self,
start_date=datetime.date(datetime.now() -
timedelta(days=1)),
stop_date=datetime.date(datetime.now()),
currency="XBT"):
"""
Crypto assets information gathered from CoinMarketCap
Assets denomination can be found in ISO-4217 from IETF
(https://tools.ietf.org/html/draft-stanish-x-iso4217-a3-01)
Parameters
----------
start_date : datetime
starting date for currency retrieval (default value: yesterday)
stop_date : datetime
stop date for currency retrieval (default value = today)
currency : string
crypto currency to get information from (XBTC, XETH, ...)
Returns
-------
data : JSON object
data retreived from CoinMarketCap
"""
url = 'https://sandbox-api.coinmarketcap.com/v1/cryptocurrency/listings/latest'
parameters = {
'start': '1',
'limit': '1',
'convert': f'{base_currency}'
}
headers = {
'Accepts': 'application/json',
'Accept-Encoding': 'deflate, gzip'
}
if self.api_key_coinmarketcap:
headers['X-CMC_PRO_API_KEY'] = self.api_key_coinmarketcap
crypto_manager = RequestManager(headers)
data = crypto_manager.send_request(parameters, url)
return data
def CheckTessellation(self):
t1 = time.time() * 1000
#retrieve the camera position in objectspace
campostr = self.campostr
self.GetHeightFieldValue(campostr)
#check if there are cube faces to update from previous loop, otherwise, re-evaluate the needs
if self.updatelist == []: # the list of required updates is empty, reevaluate priorities
#compute for each face the dot product with oncubecam
#then sort the refresh order by this value
for oneface in self.face:
dotp = np.dot(campostr, oneface.facenormal)
#if dotp >=0.0:
self.updatelist.append([dotp, oneface])
#sort the list by dot product decreasing
if self.updatelist <> []:
self.updatelist.sort(key=lambda el: el[0], reverse=True)
else: # the are updates to complete from previous cycles
curr_face = self.updatelist[0][
1] #get the second element (face pointer) of the first element of the update list
normalized_surface_height = GlobalSignals.read(
'height:'
) * self.PlanetDescriptor.height / self.PlanetDescriptor.radius
if curr_face.tessellate_by_distance(
campostr, normalized_surface_height, self.kdiv,
self.kred) > 0: #check the tessellation by distance
RequestManager.add_request(curr_face.do_triangles, [])
self.VBO_need_update[self.face.index(curr_face)] = 2
del self.updatelist[0]
GlobalSignals.set('Nodes', self.face[0].NodesStats['Nodes'])
GlobalSignals.set('Triangles', self.face[0].NodesStats['Triangles'])
#debug code
t2 = time.time() * 1000 - t1
GlobalSignals.set('tessel ms', t2)
def update(self):
#funny test: rotate o fa fraction around the rand_axis
ca = np.cos(self.rand_angle / 2)
sa = np.sin(self.rand_angle / 2)
v = np.append(self.axis * sa, ca)
qr = qts.Quat(v)
self.orientation = qr.__mul__(self.orientation)
#adapt near plane to current distance
obj_space_distance = np.linalg.norm(self.ActiveCamera.position -
self.position) / self.scale
near_plane = smoothstephilo(0.1, 10, 1.005, 1.1, obj_space_distance)
self.ActiveCamera.set_near_far(near_plane, 200000.0)
GlobalSignals.set('near distance: ', near_plane)
#check if we tessellate
RequestManager.add_request(self.CheckTessellation, [])
#check if a reduction of lod is required
if self.TexAtlas.free_below_level(0.05):
self.kdiv *= 0.995
self.kred *= 0.995
elif self.kdiv < 3.0 and self.TexAtlas.free_over_level(0.25):
self.kdiv *= 1.001
self.kred *= 1.001
GlobalSignals.set('kdiv: ', self.kdiv)
GlobalSignals.set('kred: ', self.kred)
#debug
GlobalSignals.set('req nr', RequestManager.get_queue_length())
GlobalSignals.set('req max time',
RequestManager.get_queue_max_wait_time_ms())
GlobalSignals.set(
'size of patch:', 2 * 3.14 * self.PlanetDescriptor.radius / 4 /
(2**GlobalSignals.read('level:')))
GlobalSignals.set('size of unit:',
GlobalSignals.read('size of patch:') / 16)
def send_message(comments):
star = ":star:"
data = {
'score': comments['score'],
'title': comments['title'],
'date': comments['date'],
'comment': comments['comment'],
'pretext': '`TEST` UtaPass iOS has a new review!',
'text': ''.join(star * int(comments['score']) + ' Score : %s' % str(comments['score'])),
'content': u'{}\n\n [Translation]\n*{}*\n\n{}\n\n_{} ver.{}_'.format(comments['comment'],
comments['translated_title'],
comments['translated_comment'],
(comments['date']).strftime('%Y-%m-%d'),
comments['version']),
'thumb_url': 'https://img.au-market.com/mapi/pc_icon/39767/3976700000002/100211_116788.png',
'footer': 'App Store reviews crawler',
'footer_icon': 'https://banner2.kisspng.com/20180729/cup/kisspng-app-store-iphone-apple-app-store-icon-transparent-5b5e1adc964cf5.4117097315328939166156.jpg',
}
RequestManager().slackAttachmentsWithFieldsMessager('#test-b0t', data['pretext'], "", data['text'], "", "",
"iOS Reviews Bot", data['footer'], data['title'],
data['content'], data['thumb_url'], data['footer_icon'])
def Prepare_Own_Lod_Texture(self, step):
if step == 0: #just reserve a tex slot and schedule execution of 1step
if self.level < self.MAX_DEPTH and self.tex_atlas.count_free_slots(
) > 0:
self.temp_slot = self.tex_atlas.reserve_slot(self)
self.texture_baking = True
RequestManager.add_request(self.Prepare_Own_Lod_Texture, [1],
'NodeTexBaking',
self.Distance_From_Camera)
if step == 1: #prepare height texture
self.su['fbo'].set_fbo_scene()
self.temp_htex = self.su['fbo'].draw_fbo_cube(
self.pd, self.face, 'pass_1', self.cf[0], self.cf[1],
self.level, 0)
#print(self.temp_htex)
self.su['fbo'].set_base_scene()
RequestManager.add_request(self.Prepare_Own_Lod_Texture, [2],
'NodeTexBaking',
self.Distance_From_Camera)
if step == 2: #prepare hnorm texture
self.su['fbo'].set_fbo_scene()
self.temp_hnorm = self.su['fbo'].draw_fbo_cube(
self.pd, self.face, 'pass_2', self.cf[0], self.cf[1],
self.level, self.temp_htex)
#print(self.temp_hnorm)
self.su['fbo'].set_base_scene()
RequestManager.add_request(self.Prepare_Own_Lod_Texture, [3],
'NodeTexBaking',
self.Distance_From_Camera)
if step == 3: #set textures and cascade text coordinates
self.tex_atlas.fill_reserved_slot(self.temp_hnorm, self.temp_slot)
self.Assign_TexAtlas_Layer(self.temp_slot)
self.Rescale_Tex_Coord(0.0, 0.0, 1.0, 1.0)
#delete temp textures to free memory
glDeleteTextures([self.temp_htex, self.temp_hnorm])
self.texture_baking = False
self.texture_baked = True
def __init__(self):
self._torManager = TorManager()
self._steamScraper = SteamScraper(730)
self._requestManager = RequestManager(None)
self._logger = logging.getLogger('BatchMain')
self._logger.setLevel(logging.DEBUG)
class BatchMain:
_torManager = None
_steamScraper = None
_logger = None
_torIPRatingFilename = "tor-ip-rating.json"
def __init__(self):
self._torManager = TorManager()
self._steamScraper = SteamScraper(730)
self._requestManager = RequestManager(None)
self._logger = logging.getLogger('BatchMain')
self._logger.setLevel(logging.DEBUG)
def main(self):
ProgrammStateVars.lastRequest = datetime.now()
logging.debug(ProgrammStateVars.programmDir)
self._prepareDir()
steamMarketUrl = self._steamScraper.getUrl()
realIP = self.testRealIP()
torIPDict = {}
if (path.isfile(
path.join(ProgrammStateVars.programmDir,
ProgrammStateVars.jsonDir,
self._torIPRatingFilename))):
torIPDict = self.loadTorIPRatingFromFile()
torIP = ""
while (steamMarketUrl != ""):
if (torIP != "" and realIP != torIP):
logging.info(steamMarketUrl)
responseNormal = self._torManager.doRequest(steamMarketUrl)
requestState = {
"Cookies": self._torManager.getCookies().get_dict(),
"RequestHeader": dict(self._torManager.getHeader()),
"ResponseHeader": dict(responseNormal.headers)
}
logging.info(requestState)
if isinstance(responseNormal, Response):
if (responseNormal.status_code == 200):
self.writeTextToFile(
"csgo_" +
str(self._steamScraper.getStartPointer()) +
".json", responseNormal.text)
self._steamScraper.nextPointer()
steamMarketUrl = self._steamScraper.getUrl()
torIPDict[torIP]["goodReq"].append(requestState)
else: # among others HTTP Status 429
logging.error(
"Steam Rest Api Request wasn't successfull status_code != 200: "
.format(responseNormal.status_code))
logging.error("Response Text: {}".format(
responseNormal.headers))
torIPDict[torIP]["badReq"].append(requestState)
self._torManager.newOnionPath()
torIP = ""
else:
logging.error(
"Returned Object of SteamAPI Request isn't a Response")
break
else:
torIP = self.testTORIP()
if (torIP not in torIPDict):
torIPDict[torIP] = {"goodReq": [], "badReq": []}
logging.debug(torIPDict)
self.writeTorIPRatingFromFile(torIPDict)
self.writeTorIPRatingFromFile(torIPDict)
def _prepareDir(self):
logging.debug("Create Dir \"{}\" for Dumps if not exists.".format(
ProgrammStateVars.jsonDir))
# Create Base Dir for JSONs
Path(
path.join(ProgrammStateVars.programmDir,
ProgrammStateVars.jsonDir)).mkdir(parents=True,
exist_ok=True)
# Create Sub Dir for current Exec
self._steamScraper.createNewDir()
jsonDumpsDir = self._steamScraper.getDir()
logging.debug(
"Create Dir \"{}\" for current run JSON-Dumps if not exists.".
format(jsonDumpsDir))
Path(
path.join(ProgrammStateVars.programmDir, ProgrammStateVars.jsonDir,
jsonDumpsDir)).mkdir(parents=True, exist_ok=True)
def testTORIP(self):
urlForIP = 'http://blob.bplaced.net'
ipResponse = self._torManager.doRequest(urlForIP)
if isinstance(ipResponse, Response):
if (ipResponse.status_code == 200):
logging.info("Tor IP: " + ipResponse.text)
return ipResponse.text
else:
logging.error(
"Request for IP not successfull status_code != 200: {}".
format(ipResponse.status_code))
logging.error("Response Text: {}".format(ipResponse.text))
else:
logging.error(
"Returned Object of Request for IP isn't a Response: {}".
format(ipResponse))
self._torManager.getCookies().clear()
return ""
def testRealIP(self):
urlForIP = 'http://blob.bplaced.net'
ipResponse = self._requestManager.doRequest(urlForIP)
if isinstance(ipResponse, Response):
if (ipResponse.status_code == 200):
logging.info("Real IP: " + ipResponse.text)
return ipResponse.text
else:
logging.error(
"Request for IP not successfull status_code != 200: {}".
format(ipResponse.status_code))
logging.error("Response Text: {}".format(ipResponse.text))
else:
logging.error(
"Returned Object of Request for IP isn't a Response: {}".
format(ipResponse))
self._torManager.getCookies().clear()
return ""
def loadTorIPRatingFromFile(self):
data = None
with open(
path.join(ProgrammStateVars.programmDir,
ProgrammStateVars.jsonDir,
self._torIPRatingFilename)) as file:
data = json.load(file)
return data
def writeTextToFile(self, filename, text):
with open(
path.join(ProgrammStateVars.programmDir,
ProgrammStateVars.jsonDir,
self._steamScraper.getDir(), filename), 'w') as file:
file.write(text)
def writeTorIPRatingFromFile(self, dictJson):
with open(
path.join(ProgrammStateVars.programmDir,
ProgrammStateVars.jsonDir,
self._torIPRatingFilename), 'w') as file:
json.dump(dictJson, file)
import threading
import socket
import pickle
import struct
from RequestManager import RequestManager
requestManager = RequestManager()
requestManagerLock = threading.Lock()
bufferSize = 4096
host = ''
port = 20041
def sendMsg(sock, msg):
msg = struct.pack('>I', len(msg)) + msg
sock.sendall(msg)
def recvMsg(sock):
raw_msglen = recvall(sock, 4)
if not raw_msglen:
return None
msglen = struct.unpack('>I', raw_msglen)[0]
return recvall(sock, msglen)
def recvall(sock, n):
data = ''.encode()
while len(data) < n:
packet = sock.recv(min(n - len(data), bufferSize))
if not packet:
def __init__(self, host, user, pw):
RequestManager.__init__(self, host, user, pw)
self.stakeholderProtocol = StakeholderProtocol(host, user, pw)
def __init__(self, type, x, y, z, SceneUtils, PlanetDesc):
# create the texture atlas for the cube
self.TexAtlas = TextureAtlasArray(96 * 4, 128, 128)
self.PlanetDescriptor = PlanetDesc
#in the future, the active camera should be linked to the object using a more global methods
# or making sceneutils a global access object
self.ActiveCamera = SceneUtils['cam']
self.SceneMgr = SceneUtils['fbo']
#code to be put only if the planet has water bodies
#set up a helper fbo for difraction maps
self.helpfbo = FBO_RTT(1024, 1024)
# and one for reflection maps
self.helpfbo2 = FBO_RTT(1024, 1024)
# state of the main texture data: 0 = full, <>0, not fully completed
self.state = 1
#create the cube face object
# - define corners
c000 = np.array([-1.0, -1.0, 1.0], dtype='float32')
c010 = np.array([-1.0, 1.0, 1.0], dtype='float32')
c110 = np.array([1.0, 1.0, 1.0], dtype='float32')
c100 = np.array([1.0, -1.0, 1.0], dtype='float32')
c001 = np.array([-1.0, -1.0, -1.0], dtype='float32')
c011 = np.array([-1.0, 1.0, -1.0], dtype='float32')
c111 = np.array([1.0, 1.0, -1.0], dtype='float32')
c101 = np.array([1.0, -1.0, -1.0], dtype='float32')
t00 = np.array([0.0, 0.0, 0.0, 1.0, 0.0, 0.0], dtype='float32')
t10 = np.array([1.0, 0.0, 0.0, 1.0, 1.0, 0.0], dtype='float32')
t11 = np.array([1.0, 1.0, 0.0, 1.0, 1.0, 1.0], dtype='float32')
t01 = np.array([0.0, 1.0, 0.0, 1.0, 0.0, 1.0], dtype='float32')
# - create the 6 cube faces, specifying vertices and texture coordinates with np.lib.append([x,y,z],[s,t]) calls
self.face = []
self.face.append(
SurfaceNode(0, 0, 0, 0, np.lib.append(c000, t00),
np.lib.append(c010, t01), np.lib.append(c110, t11),
np.lib.append(c100, t10), SceneUtils, PlanetDesc,
self.TexAtlas))
self.face.append(
SurfaceNode(1, 0, 0, 0, np.lib.append(c001, t00),
np.lib.append(c011, t01), np.lib.append(c010, t11),
np.lib.append(c000, t10), SceneUtils, PlanetDesc,
self.TexAtlas))
self.face.append(
SurfaceNode(2, 0, 0, 0, np.lib.append(c101, t00),
np.lib.append(c111, t01), np.lib.append(c011, t11),
np.lib.append(c001, t10), SceneUtils, PlanetDesc,
self.TexAtlas))
self.face.append(
SurfaceNode(3, 0, 0, 0, np.lib.append(c100, t00),
np.lib.append(c110, t01), np.lib.append(c111, t11),
np.lib.append(c101, t10), SceneUtils, PlanetDesc,
self.TexAtlas))
self.face.append(
SurfaceNode(4, 0, 0, 0, np.lib.append(c001, t00),
np.lib.append(c000, t01), np.lib.append(c100, t11),
np.lib.append(c101, t10), SceneUtils, PlanetDesc,
self.TexAtlas))
self.face.append(
SurfaceNode(5, 0, 0, 0, np.lib.append(c010, t00),
np.lib.append(c011, t01), np.lib.append(c111, t11),
np.lib.append(c110, t10), SceneUtils, PlanetDesc,
self.TexAtlas))
# generate heigthmap
#self.GenHeightMapTex(SceneUtils['fbo'])
RequestManager.add_request(self.CheckLevelZeroTexComplete, [])
for aface in self.face:
#aface.tessellate_all_to_level(2)
aface.do_triangles(True)
aface.VBO_All_Updated()
#parameters for dynamic level of detail
self.kdiv = 3.0
self.kred = 3.2
leng = 0
self.activeVBO = [0, 0, 0, 0, 0, 0] #implementing doublevbo
self.VBO_need_update = [3, 3, 3, 3, 3, 3] # to check
self.sidetocheck = 6 #temporarily we check one side at a time to see if we tessellate
self.updatelist = []
self.vbotocomplete = [7, 7] #face number and active number
self.vertexVBO = [[]]
self.indexVBO = [[]]
self.vertexVBO.append([])
self.indexVBO.append([])
index = 0
for i in self.face:
i.faceindex = index
index += 1
self.vertici = np.array(
np.array(i.datadict['vertex'], dtype='float32'))
self.vertexVBO[0].append(
vbo.VBO(data=self.vertici,
usage=GL_DYNAMIC_DRAW,
target=GL_ARRAY_BUFFER))
self.vertexVBO[1].append(
vbo.VBO(data=self.vertici,
usage=GL_DYNAMIC_DRAW,
target=GL_ARRAY_BUFFER))
self.indici = np.array(
np.array(i.datadict['index'], dtype='uint32'))
self.indexVBO[0].append(
vbo.VBO(data=self.indici,
usage=GL_DYNAMIC_DRAW,
target=GL_ELEMENT_ARRAY_BUFFER))
self.indexVBO[1].append(
vbo.VBO(data=self.indici,
usage=GL_DYNAMIC_DRAW,
target=GL_ELEMENT_ARRAY_BUFFER))
leng += self.vertici.shape[0]
# assign other object properties
self.scale = PlanetDesc.radius
self.position = [x, y, z]
self.orientation = qts.Quat([0.0, 0.3, 0.5])
#add a light as a test ..light should not be there
self.light = RendLight((2000000.0, 0.0, 0.0), (1.0, 1.0, 0.8))
#add a test skydome object
self.sky = RenderableSkydome(16)
self.sky.attach_light(self.light)
# assign the shader and get attribute and uniform indexes (pointers)
self.program = MaterialManager.Materials[PlanetDesc.main_material]
self.program_sea = MaterialManager.Materials['planetsea']
self.attrib_position = glGetAttribLocation(self.program, 'position')
self.attrib_texcoord = glGetAttribLocation(self.program, 'texcoord')
self.attrib_texcoord2 = glGetAttribLocation(self.program, 'texcoord2')
self.attrib_scale = glGetAttribLocation(self.program, 'nodescale')
self.main_attribs = {
'position': glGetAttribLocation(self.program, 'position'),
'texcoord': glGetAttribLocation(self.program, 'texcoord'),
'nodescale': glGetAttribLocation(self.program, 'nodescale'),
'texcoord2': glGetAttribLocation(self.program, 'texcoord2'),
}
self.sea_attribs = {
'position': glGetAttribLocation(self.program_sea, 'position'),
'texcoord': glGetAttribLocation(self.program_sea, 'texcoord'),
'nodescale': glGetAttribLocation(self.program_sea, 'nodescale'),
'texcoord2': glGetAttribLocation(self.program_sea, 'texcoord2'),
}
self.main_unifs = {
'u_model': glGetUniformLocation(self.program, 'u_model'),
'u_view': glGetUniformLocation(self.program, 'u_view'),
'u_normal': glGetUniformLocation(self.program, 'u_normal'),
'u_proj': glGetUniformLocation(self.program, 'u_proj'),
'u_lposition3': glGetUniformLocation(self.program, 'u_lposition3'),
'u_lintensity3': glGetUniformLocation(self.program,
'u_lintensity3'),
'planet_radius': glGetUniformLocation(self.program,
'planet_radius'),
'planet_height': glGetUniformLocation(self.program,
'planet_height'),
'sea_level': glGetUniformLocation(self.program, 'sea_level'),
'camdist': glGetUniformLocation(self.program, 'camdist'),
'skirt_off': glGetUniformLocation(self.program, 'skirt_off'),
'state': glGetUniformLocation(self.program, 'state'),
'verse': glGetUniformLocation(self.program, 'verse'),
}
self.sea_unifs = {
'model_m':
glGetUniformLocation(self.program_sea, 'model_m'),
'view_m':
glGetUniformLocation(self.program_sea, 'view_m'),
'normal_m':
glGetUniformLocation(self.program_sea, 'normal_m'),
'proj_m':
glGetUniformLocation(self.program_sea, 'proj_m'),
'u_lposition3':
glGetUniformLocation(self.program_sea, 'u_lposition3'),
'u_lintensity3':
glGetUniformLocation(self.program_sea, 'u_lintensity3'),
'planetradius':
glGetUniformLocation(self.program_sea, 'planetradius'),
'planetheight':
glGetUniformLocation(self.program_sea, 'planetheight'),
'sealevel':
glGetUniformLocation(self.program_sea, 'sealevel'),
'time':
glGetUniformLocation(self.program_sea, 'time'),
'camdist':
glGetUniformLocation(self.program_sea, 'camdist'),
'skirt_off':
glGetUniformLocation(self.program_sea, 'skirt_off'),
}
# inscribe the object in the static list of the parent object
RenderablePlanet.ListRends.append(self)
# funny test code
rand_axis = np.array(
[random.random(),
random.random(),
random.random()])
norma = np.linalg.norm(rand_axis)
rand_axis /= norma
#self.axis = np.array([0.0,1.0,0.0])
self.axis = rand_axis
self.rand_angle = 0.000 * (random.uniform(0.0, 20.0) - 10)
self.cam_distance = 10
##test signals for the hud
GlobalSignals.set('Triangles', leng)
GlobalSignals.set('req nr', 0)
GlobalSignals.set('req max time', 0)
GlobalSignals.set('draw ms', 0)
GlobalSignals.set('tessel ms', 0)
GlobalSignals.set('tex slot free', 0)
GlobalSignals.set('Nodes', leng)
def draw(self):
#pre draw stuff and preparation
t1 = time.time() * 1000
if GlobalSettings.read('linemode') == GL_LINE:
skirt_off = 1.0
else:
skirt_off = 0.0
#apply local transformations
selfrot = np.ascontiguousarray(
np.transpose(
np.append(
np.append(self.orientation._get_transform(),
[[0], [0], [0]], 1), [[0, 0, 0, 1]], 0)))
S = scale_matrix(self.scale)
R = selfrot
T = translation_matrix(self.position)
self.model = np.dot(T, np.dot(R, S))
#calculate mirror matrix
#normalize camera position in object space
selfrot = np.ascontiguousarray(
np.transpose(
np.append(
np.append(self.orientation._get_transform(),
[[0], [0], [0]], 1), [[0, 0, 0, 1]], 0)))
Si = scale_matrix(float(1 / self.scale))
Ri = np.transpose(selfrot)
Ti = translation_matrix(
[-self.position[0], -self.position[1], -self.position[2]])
Minv = np.dot(Si, np.dot(Ri, Ti))
self.campostr = np.ravel(
np.dot(Minv, np.append(self.ActiveCamera.position, 1)))[0:3]
self.cam_distance = np.linalg.norm(self.campostr)
GlobalSignals.set('cam distance', self.cam_distance)
#mcamera = np.dot(flip,np.dot(mirror,np.linalg.inv(self.ActiveCamera.view)))
#mview = self.ActiveCamera.view
if (self.cam_distance < 1.3) and (self.PlanetDescriptor.sea_level >
0) and (self.state == 0):
self.draw_fbo_refraction()
self.draw_fbo_reflection(self.ActiveCamera.view)
#test draw the sky if we are inside
if (self.cam_distance <= 100):
glBlendFunc(GL_SRC_ALPHA, GL_ZERO)
#glDisable(GL_CULL_FACE)
glCullFace(GL_FRONT)
self.sky.draw_inner_sky(self.ActiveCamera.proj,
self.ActiveCamera.view, self.model)
#glEnable(GL_CULL_FACE)
glCullFace(GL_BACK)
#draw the planet
glBlendFunc(GL_ONE, GL_ZERO)
MaterialManager.use_material('planetmat1')
#glUseProgram(self.program)
glEnableVertexAttribArray(self.main_attribs['position'])
glEnableVertexAttribArray(self.main_attribs['texcoord'])
glEnableVertexAttribArray(self.main_attribs['nodescale'])
glEnableVertexAttribArray(self.main_attribs['texcoord2'])
glUniformMatrix4fv(self.main_unifs['u_model'], 1, GL_TRUE, self.model)
glUniformMatrix4fv(self.main_unifs['u_view'], 1, GL_FALSE,
self.ActiveCamera.view)
glUniformMatrix4fv(
self.main_unifs['u_normal'], 1, GL_FALSE,
np.transpose(
np.linalg.inv(
np.dot(np.transpose(self.model), self.ActiveCamera.view))))
glUniformMatrix4fv(self.main_unifs['u_proj'], 1, GL_FALSE,
self.ActiveCamera.proj)
glUniform3fv(self.main_unifs['u_lposition3'], 1, self.light.get_pos())
glUniform3fv(self.main_unifs['u_lintensity3'], 1,
self.light.get_intensity())
glUniform1f(self.main_unifs['planet_radius'],
self.PlanetDescriptor.radius)
glUniform1f(self.main_unifs['planet_height'],
self.PlanetDescriptor.height)
glUniform1f(self.main_unifs['sea_level'],
self.PlanetDescriptor.sea_level)
glUniform1f(self.main_unifs['camdist'], self.cam_distance)
glUniform1f(self.main_unifs['skirt_off'], skirt_off)
glUniform1i(self.main_unifs['state'], self.state)
glUniform1f(self.main_unifs['verse'], 1.0)
glEnable(GL_TEXTURE_2D)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, self.PlanetDescriptor.mixmap)
glUniform1i(glGetUniformLocation(self.program, 'surfacecolor'), 0)
#bind the texture (from texture atlas array) for heightmap / normals
glActiveTexture(GL_TEXTURE1)
glBindTexture(GL_TEXTURE_2D_ARRAY, self.TexAtlas.get_tex_id())
glUniform1i(glGetUniformLocation(self.program, 'heightmap'), 1)
glActiveTexture(GL_TEXTURE2)
glBindTexture(GL_TEXTURE_2D_ARRAY,
self.PlanetDescriptor.surface_textures.get_tex_id())
glUniform1i(glGetUniformLocation(self.program, 'surface'), 2)
#draw pass of the 6 VBOs
for index in range(0, 6):
#bind the VBO
act = self.activeVBO[index]
self.vertexVBO[act][index].bind()
self.indexVBO[act][index].bind()
#draw
glVertexAttribPointer(self.attrib_position, 3, GL_FLOAT, GL_FALSE,
36, self.vertexVBO[act][index])
glVertexAttribPointer(self.attrib_texcoord, 3, GL_FLOAT, GL_FALSE,
36, self.vertexVBO[act][index] + (3 * 4))
glVertexAttribPointer(self.attrib_scale, 1, GL_FLOAT, GL_FALSE, 36,
self.vertexVBO[act][index] + (6 * 4))
glVertexAttribPointer(self.attrib_texcoord2, 2, GL_FLOAT, GL_FALSE,
36, self.vertexVBO[act][index] + (7 * 4))
nb_elements = self.indexVBO[act][index].shape[0]
glDrawElements(GL_TRIANGLES, nb_elements, GL_UNSIGNED_INT,
self.indexVBO[act][index])
# disable/unbind the arrays
self.vertexVBO[act][index].unbind()
self.indexVBO[act][index].unbind()
glDisableVertexAttribArray(self.main_attribs['position'])
glDisableVertexAttribArray(self.main_attribs['texcoord'])
glDisableVertexAttribArray(self.main_attribs['nodescale'])
glDisableVertexAttribArray(self.main_attribs['texcoord2'])
# draw the sea
#glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
if (self.cam_distance <
1.05) and (self.PlanetDescriptor.sea_level > 0) and (
GlobalSettings.read('nosea')) and (self.state == 0):
glUseProgram(self.program_sea)
#enable attributes arrays
glEnableVertexAttribArray(self.sea_attribs['position'])
glEnableVertexAttribArray(self.sea_attribs['texcoord'])
glEnableVertexAttribArray(self.sea_attribs['nodescale'])
glEnableVertexAttribArray(self.sea_attribs['texcoord2'])
glUniformMatrix4fv(self.sea_unifs['model_m'], 1, GL_TRUE,
self.model)
glUniformMatrix4fv(self.sea_unifs['view_m'], 1, GL_FALSE,
self.ActiveCamera.view)
glUniformMatrix4fv(
self.sea_unifs['normal_m'], 1, GL_FALSE,
np.transpose(
np.linalg.inv(
np.dot(np.transpose(self.model),
self.ActiveCamera.view))))
glUniformMatrix4fv(self.sea_unifs['proj_m'], 1, GL_FALSE,
self.ActiveCamera.proj)
glUniform3fv(self.sea_unifs['u_lposition3'], 1,
self.light.get_pos())
glUniform3fv(self.sea_unifs['u_lintensity3'], 1,
self.light.get_intensity())
glUniform1f(self.sea_unifs['planetradius'],
self.PlanetDescriptor.radius)
glUniform1f(self.sea_unifs['planetheight'],
self.PlanetDescriptor.height)
glUniform1f(self.sea_unifs['sealevel'],
self.PlanetDescriptor.sea_level)
glUniform1f(self.sea_unifs['time'], time.clock())
glUniform1f(self.sea_unifs['camdist'], self.cam_distance)
glUniform1f(self.sea_unifs['skirt_off'], skirt_off)
glEnable(GL_TEXTURE_2D)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D_ARRAY, self.PlanetDescriptor.wavetext)
glUniform1i(glGetUniformLocation(self.program_sea, 'wavetext'), 0)
#bind the texture (from texture atlas array) for heightmap / normals
glActiveTexture(GL_TEXTURE1)
glBindTexture(GL_TEXTURE_2D_ARRAY, self.TexAtlas.get_tex_id())
glUniform1i(glGetUniformLocation(self.program_sea, 'heightmap'), 1)
glActiveTexture(GL_TEXTURE2)
glBindTexture(GL_TEXTURE_2D, self.helpfbo.rtt)
glUniform1i(
glGetUniformLocation(self.program_sea, 'refractiontexture'), 2)
glActiveTexture(GL_TEXTURE3)
glBindTexture(GL_TEXTURE_2D, self.helpfbo2.rtt)
glUniform1i(
glGetUniformLocation(self.program_sea, 'reflectiontexture'), 3)
for index in range(0, 6):
#bind the VBO
act = self.activeVBO[index]
self.vertexVBO[act][index].bind()
self.indexVBO[act][index].bind()
#draw
glVertexAttribPointer(self.attrib_position, 3, GL_FLOAT,
GL_FALSE, 36, self.vertexVBO[act][index])
glVertexAttribPointer(self.attrib_texcoord, 3, GL_FLOAT,
GL_FALSE, 36,
self.vertexVBO[act][index] + (3 * 4))
glVertexAttribPointer(self.attrib_scale, 1, GL_FLOAT, GL_FALSE,
36, self.vertexVBO[act][index] + (6 * 4))
glVertexAttribPointer(self.attrib_texcoord2, 2, GL_FLOAT,
GL_FALSE, 36,
self.vertexVBO[act][index] + (7 * 4))
nb_elements = (self.indexVBO[act][index].shape[0])
glDrawElements(GL_TRIANGLES, nb_elements, GL_UNSIGNED_INT,
self.indexVBO[act][index])
# disable/unbind the arrays
self.vertexVBO[act][index].unbind()
self.indexVBO[act][index].unbind()
glDisableVertexAttribArray(self.sea_attribs['position'])
glDisableVertexAttribArray(self.sea_attribs['texcoord'])
glDisableVertexAttribArray(self.sea_attribs['nodescale'])
glDisableVertexAttribArray(self.sea_attribs['texcoord2'])
#test draw the sky if we are outside
if (self.cam_distance >= 1.1):
glBlendFunc(GL_SRC_ALPHA, GL_ONE)
glCullFace(GL_BACK)
self.sky.draw_inner_sky(self.ActiveCamera.proj,
self.ActiveCamera.view, self.model)
glUseProgram(0)
#VBO updating / maintenance
for index in range(0, 6):
#check if current face has a VBO to complete update
if self.VBO_need_update[index] <> 3:
RequestManager.add_request(self.VBOupdate, [index])
#swap active VBO if no pending updates
if self.VBO_need_update[index] <> (1 - act):
self.activeVBO[index] = 1 - act
#debug code
t2 = time.time() * 1000 - t1
GlobalSignals.set('draw ms', t2)
GlobalSignals.set('tex slot free', self.TexAtlas.free_count)
def startup(args: argparse.Namespace, **kwargs: Dict[str, Any]) -> None:
global announce, dispatcher, group, httpServer, notification, validator
global registration, remote, request, security, statistics, storage, event
global rootDirectory
global aeStatistics
global supportedReleaseVersions, cseType, defaultSerialization, cseCsi, cseRi, cseRn
global cseOriginator
global isHeadless
rootDirectory = os.getcwd() # get the root directory
os.environ[
"FLASK_ENV"] = "development" # get rid if the warning message from flask.
# Hopefully it is clear at this point that this is not a production CSE
# Handle command line arguments and load the configuration
if args is None:
args = argparse.Namespace(
) # In case args is None create a new args object and populate it
args.configfile = None
args.resetdb = False
args.loglevel = None
args.headless = False
for key, value in kwargs.items():
args.__setattr__(key, value)
isHeadless = args.headless
if not Configuration.init(args):
return
# Initialize configurable constants
supportedReleaseVersions = Configuration.get(
'cse.supportedReleaseVersions')
cseType = Configuration.get('cse.type')
cseCsi = Configuration.get('cse.csi')
cseRi = Configuration.get('cse.ri')
cseRn = Configuration.get('cse.rn')
cseOriginator = Configuration.get('cse.originator')
defaultSerialization = Configuration.get('cse.defaultSerialization')
# init Logging
Logging.init()
if not args.headless:
Logging.console('Press ? for help')
Logging.log('============')
Logging.log('Starting CSE')
Logging.log(f'CSE-Type: {cseType.name}')
Logging.log('Configuration:')
Logging.log(Configuration.print())
# Initiatlize the resource storage
storage = Storage()
# Initialize the event manager
event = EventManager()
# Initialize the statistics system
statistics = Statistics()
# Initialize the registration manager
registration = RegistrationManager()
# Initialize the resource validator
validator = Validator()
# Initialize the resource dispatcher
dispatcher = Dispatcher()
# Initialize the request manager
request = RequestManager()
# Initialize the security manager
security = SecurityManager()
# Initialize the HTTP server
httpServer = HttpServer()
# Initialize the notification manager
notification = NotificationManager()
# Initialize the group manager
group = GroupManager()
# Import a default set of resources, e.g. the CSE, first ACP or resource structure
# Import extra attribute policies for specializations first
importer = Importer()
if not importer.importAttributePolicies() or not importer.importResources(
):
return
# Initialize the remote CSE manager
remote = RemoteCSEManager()
# Initialize the announcement manager
announce = AnnouncementManager()
# Start AEs
startAppsDelayed(
) # the Apps are actually started after the CSE finished the startup
# Start the HTTP server
event.cseStartup() # type: ignore
httpServer.run() # This does return (!)
Logging.log('CSE started')
if isHeadless:
# when in headless mode give the CSE a moment (2s) to experience fatal errors before printing the start message
BackgroundWorkerPool.newActor(
delay=2,
workerCallback=lambda: Logging.console('CSE started')
if not shuttingDown else None).start()
#
# Enter an endless loop.
# Execute keyboard commands in the keyboardHandler's loop() function.
#
commands = {
'?': _keyHelp,
'h': _keyHelp,
'\n': lambda c: print(), # 1 empty line
'\x03': _keyShutdownCSE, # See handler below
'c': _keyConfiguration,
'C': _keyClearScreen,
'D': _keyDeleteResource,
'i': _keyInspectResource,
'l': _keyToggleLogging,
'Q': _keyShutdownCSE, # See handler below
'r': _keyCSERegistrations,
's': _keyStatistics,
't': _keyResourceTree,
'T': _keyChildResourceTree,
'w': _keyWorkers,
}
# Endless runtime loop. This handles key input & commands
# The CSE's shutdown happens in one of the key handlers below
loop(commands, catchKeyboardInterrupt=True, headless=args.headless)
shutdown()
def get_triangles(self, datadict, force_completion=False):
#before doing anything let's check if a texture is baking
if (self.texture_baking == True) and (force_completion
== False) and False:
#reschedule and exit
RequestManager.add_request(self.get_triangles, [datadict],
'get_triangles' + str(self.face),
self.NodePriority)
else:
if datadict['vertex'] == []:
len = 0
else:
len = datadict['vertex'].__len__()
if self.children == 0:
#add all vertexes of this node to the data dictionary
self.ustep = (self.c01 - self.c00) / float(self.GRID)
self.vstep = (self.c10 - self.c00) / float(self.GRID)
self.ustep[6] = 0.0
self.vstep[6] = 0.0
diag = 0
offset = 0
#nodescale = 2**self.scalelevel
for u in range(0, self.GRID):
u_ustep = u * self.ustep
for v in range(0, self.GRID):
self.cd00 = self.c00 + v * self.vstep + u_ustep
self.cd01 = self.cd00 + self.ustep
self.cd10 = self.cd00 + self.vstep
self.cd11 = self.cd01 + self.vstep
datadict['vertex'].append(self.cd00)
datadict['vertex'].append(self.cd10)
datadict['vertex'].append(self.cd11)
datadict['vertex'].append(self.cd01)
if diag == 0:
datadict['index'].extend([
0 + len + offset, 2 + len + offset,
3 + len + offset
])
datadict['index'].extend([
0 + len + offset, 1 + len + offset,
2 + len + offset
])
else:
datadict['index'].extend([
0 + len + offset, 1 + len + offset,
3 + len + offset
])
datadict['index'].extend([
3 + len + offset, 1 + len + offset,
2 + len + offset
])
offset += 4
diag = 1 - diag
diag = 1 - diag # at column's end double inversion to make a diamond at the new column
#emit the skirts
for u in range(0, self.GRID):
u_ustep = u * self.ustep
self.cd00 = self.c00 + u_ustep
self.cd01 = self.cd00 + self.ustep
self.cd10 = self.cd00 - self.zstep
self.cd11 = self.cd01 - self.zstep
datadict['vertex'].append(self.cd00)
datadict['vertex'].append(self.cd10)
datadict['vertex'].append(self.cd11)
datadict['vertex'].append(self.cd01)
datadict['index'].extend(
[0 + len + offset, 3 + len + offset, 2 + len + offset])
datadict['index'].extend(
[0 + len + offset, 2 + len + offset, 1 + len + offset])
offset += 4
self.cd00 = self.c10 + u_ustep
self.cd01 = self.cd00 + self.ustep
self.cd10 = self.cd00 - self.zstep
self.cd11 = self.cd01 - self.zstep
datadict['vertex'].append(self.cd00)
datadict['vertex'].append(self.cd10)
datadict['vertex'].append(self.cd11)
datadict['vertex'].append(self.cd01)
datadict['index'].extend(
[0 + len + offset, 2 + len + offset, 3 + len + offset])
datadict['index'].extend(
[0 + len + offset, 1 + len + offset, 2 + len + offset])
offset += 4
for v in range(0, self.GRID):
v_vstep = v * self.vstep
self.cd00 = self.c00 + v_vstep
self.cd01 = self.cd00 + self.vstep
self.cd10 = self.cd00 - self.zstep
self.cd11 = self.cd01 - self.zstep
datadict['vertex'].append(self.cd00)
datadict['vertex'].append(self.cd10)
datadict['vertex'].append(self.cd11)
datadict['vertex'].append(self.cd01)
datadict['index'].extend(
[0 + len + offset, 2 + len + offset, 3 + len + offset])
datadict['index'].extend(
[0 + len + offset, 1 + len + offset, 2 + len + offset])
offset += 4
self.cd00 = self.c01 + v_vstep
self.cd01 = self.cd00 + self.vstep
self.cd10 = self.cd00 - self.zstep
self.cd11 = self.cd01 - self.zstep
datadict['vertex'].append(self.cd00)
datadict['vertex'].append(self.cd10)
datadict['vertex'].append(self.cd11)
datadict['vertex'].append(self.cd01)
datadict['index'].extend(
[0 + len + offset, 3 + len + offset, 2 + len + offset])
datadict['index'].extend(
[0 + len + offset, 2 + len + offset, 1 + len + offset])
offset += 4
else:
if force_completion:
for ch in self.children:
ch.get_triangles(datadict, True)
else:
for ch in self.children:
RequestManager.add_request(
ch.get_triangles, [datadict],
'get_triangles' + str(ch.face), ch.NodePriority)
from EWSClientType import EWSClientType
from RequestManager import RequestManager
from FileManager import FileManager
try:
import thread
except ImportError:
import _thread as thread
import time
pi_id = str(3)
if len(sys.argv) > 1:
pi_id = str(sys.argv[1])
rm = RequestManager()
fm = FileManager()
HOST = "wss://cs70esocmi.execute-api.us-east-1.amazonaws.com/dev"
def send_to_display_controller(message):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host = '127.0.0.1'
port = 1234
s.connect((host, port))
s.sendall(bytes(message, encoding="utf-8"))
s.close()
def main():
global window
global scene
global hud
global camera
global mousex
global mousey
global action
global frametimer
global SceneMgr
global SceneMstr
global Signals
global speed
speed = 10.0
RequestManager.set_time_budget(10)
GlobalSettings.set('snapshot',False)
#define the scenemaster object for the main scene
SceneMstr = SceneMaster('Main Scene')
#create the camera object & attach to scenemaster
camera = CameraObj()
SceneMstr.camera = camera #to be replaced by a setter function
#define the scene manager for the switching between main scene and fbos
SceneMgr = SceneManager(128,camera)
#initialise the globals for mouse control
mousex = 0
mousey = 0
action = 'NONE'
#init the timer object
frametimer = UtilTimer(20)
#init the graphic system and create a window
glutInit(sys.argv)
# Select type of Display mode: double buffer,RGBA color,Alpha components supported , Depth buffer
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
# get a 640 x 480 window
glutInitWindowSize(1024, 800)
# the window starts at the upper left corner of the screen
glutInitWindowPosition(0, 0)
window = glutCreateWindow("GL Planet")
print(glGetIntegerv(GL_DEPTH_BITS))
# Register the drawing function with glut, BUT in Python land, at least using PyOpenGL, we need to
# set the function pointer and invoke a function to actually register the callback, otherwise it
# would be very much like the C version of the code.
glutDisplayFunc(DrawGLScene)
# Uncomment this line to get full screen.
#glutFullScreen()
# When we are doing nothing, redraw the scene.
glutIdleFunc(DrawGLScene)
# Register the function called when our window is resized.
glutReshapeFunc(ReSizeGLScene)
#registra la funzione per il mouse
glutMouseFunc(MouseButton)
glutMotionFunc(MouseMove)
# Register the function called when the keyboard is pressed.
glutKeyboardFunc(keyPressed)
# Initialize our window.
InitGL(SceneMgr, 800, 480)
#create the HUD object & attach to scenemaster
hud = HUDObject()
SceneMstr.hud = hud #to be replaced by a setter function
#DEBUG: register some measurements
Signals = {}
r1 = ReadableSignal('update time: ',0,10)
r2 = ReadableSignal('draw time: ',0,10)
hud.registersignal(r1)
hud.registersignal(r2)
Signals['update'] = r1
Signals['draw'] = r2
#planet_texture = loadTexture('Media/Textures/Planet2.png')
SceneUtils = {}
SceneUtils['fbo'] = SceneMgr
SceneUtils['hud'] = hud
SceneUtils['cam'] = camera
#initialise materials
MaterialManager.load_material('Media/Materials/heightmat1.glsv', 'Media/Materials/heightmat1.glsf', 'fbomatheight')
MaterialManager.load_material('Media/Materials/terra_v1.glsv','Media/Materials/terra_v1.glsf','planetmat1')
MaterialManager.load_material('Media/Materials/normmat2.glsv','Media/Materials/normmat2.glsf','fbomatnorm')
MaterialManager.load_material('Media/Materials/ocean_v1.glsv','Media/Materials/ocean_v1.glsf','planetsea')
MaterialManager.load_material('Media/Materials/surfmeasure.glsv','Media/Materials/surfmeasure.glsf','surfacemeasure')
MaterialManager.load_material('Media/Materials/sky_int_v1.glsv','Media/Materials/sky_int_v1.glsf','skybox_inside')
MaterialManager.load_material('Media/Materials/underwater_v1.glsv','Media/Materials/underwater_v1.glsf','underwater')
GlobalSettings.set('nosea',True)
#create the planet descriptor
P1 = PlanetDescriptor('Primum',10000.0,30.0, 0.2,'fbomatheight','fbomatnorm','planetmat1')
#P1.GenerateTexture()
# create the cube & attach to scenemaster
# TO CHANGE: all various methods to attach things to the rendcubevbo object camera, scenemgr, materialmgr, to be
# replaced by a SceneMaster pointer
scene = RenderablePlanet.RenderablePlanet('facevbo',0,0,-1500,SceneUtils,P1)
SceneMstr.drawables.append(scene) # to be replaced by a setter in scenemaster
scene.Timer = frametimer
# Start Event Processing Engine
glutMainLoop()
def __init__(self, host, user, pw):
RequestManager.__init__(self, host, user, pw)
self.activityProtocol = ActivityProtocol(host, user, pw)
self.activityLayer = None
class ClientManager:
TIMEOUT = 120 # seconds
def __init__(self):
self.authorizer = Authorizer("auth_info.json")
self.request_manager = RequestManager()
self.sockets: Dict[int, socket.socket] = {} # fileno : sock
self.clients: Dict[int, Client] = {} # fileno : client
self.authorized_clients: Dict[str, Client] = {} # username : client
self.buffered_data: Dict[int, str] = {} # fileno : data
self.poller = select.poll()
self.remove_idle_clients_forever()
def client_exists(self, sock: socket.socket):
return sock.fileno() in self.clients
def create_client(self, sock: socket.socket):
if self.client_exists(sock):
return
client = Client(sock)
self.clients[sock.fileno()] = client
self.sockets[sock.fileno()] = sock
self.poller.register(sock, select.POLLIN)
print(str(client), "connected.")
def login_client(self, client: Client, username: str):
self.authorized_clients[username] = client
client.set_authorized(username)
print(str(client), "authorized.")
def remove_client(self, client: Client):
self.clients.pop(client.sock.fileno(), None)
if client.username:
self.authorized_clients.pop(client.username, None)
self.sockets.pop(client.sock.fileno(), None)
self.buffered_data.pop(client.sock.fileno(), None)
if client.sock.fileno() > -1:
self.poller.unregister(client.sock.fileno())
client.sock.close()
print(str(client), "disconnected.")
def broadcast(self, response: Response):
for client in self.authorized_clients.values():
client.send_response(response)
def remove_idle_clients_forever(self):
now = time.time()
for client in list(self.clients.values()):
if now - client.last_interaction_time > ClientManager.TIMEOUT:
self.remove_client(client)
self.broadcast(SignOff(client.username))
print("removing", str(client), "due to inactivity")
Timer(10, self.remove_idle_clients_forever).start()
def add_data(self, fileno, data):
if fileno not in self.buffered_data:
self.buffered_data[fileno] = ""
self.buffered_data[fileno] += data
def pop_buffered_requests(self, fileno: int):
raw_messages = self.buffered_data.get(fileno)
if not raw_messages:
return []
client = self.clients.get(fileno)
split = raw_messages.split("\n")
raw_messages = split[:-1]
requests = []
for raw_message in raw_messages:
try:
requests.append(
self.request_manager.get_request(client, raw_message))
except InvalidRequestSyntax:
self.remove_client(client)
return []
self.buffered_data[fileno] = split[-1]
return requests
