def setRoadUniforms():
Shaders.updateUniversalUniform(
'roadcontrols',
np.insert(np.array(allControlPoints[::2]), 1, 0, axis=1)[:800])
Shaders.updateUniversalUniform('roadcontrolscount',
min(800,
len(allControlPoints) / 2))
def main_display(self, width, height, **kwargs):
if self.line:
gl.glPolygonMode(gl.GL_FRONT_AND_BACK,gl.GL_LINE)
# gl.glEnable(gl.GL_CULL_FACE)
self.camera.render()
projection = transforms.perspective( 60.0, width/float(height), 0.3, 1e7 )
Shaders.updateUniversalUniform('projectionNear', 0.3)
Shaders.updateUniversalUniform('projectionFar', 1e7)
Shaders.setUniform('projection', projection)
Shaders.setUniform('aspectRatio', width/float(height))
Shaders.setUniform('windowWidth', float(width))
self.camera.render()
self.camera.render('user')
self.Terrain.display(self.camera)
self.Marker.display()
self.grass.display(self.camera)
self.Forest.display(self.camera.position)
self.Characters.display(self.camera)
self.Buildings.display(self.camera)
self.particles.render_all()
gl.glDisable(gl.GL_CULL_FACE)
gl.glPolygonMode(gl.GL_FRONT_AND_BACK,gl.GL_FILL);
def render(scene):
global count,sunTheta
sunTheta = gameTime
shadowCamera.theta = sunTheta
shadowCamera.phi = sunPhi
shadowCamera.update()
shadowCamera.render()
sunDirection = -shadowCamera.direction
Shaders.setUniform('sunDirection',sunDirection)
for i in range(3):
if count % 20 ** i != 0:
continue
if np.sum(shadowCamera.lockObject.position*shadowCamera.lockObject.position) > 6e4**2 or shadowCamera.lockObject.position[1]>4e3:
if i<2:
continue
renderStages[i].load(shadowSize, shadowSize)
Shaders.setUniform('projection',projections[i])
shadowCamera.render('shadow'+str(i+1))
scene.Terrain.display(shadowCamera.lockObject)
scene.Characters.display(shadowCamera.lockObject)
scene.Marker.display()
scene.Buildings.display(shadowCamera.lockObject)
scene.grass.display(shadowCamera.lockObject)
scene.Forest.display(shadowCamera.lockObject.position,i)
Shaders.setUniform('shadowLevel',-1)
count+=1
import numpy as np
from dent.configuration import config
import logging
import dent.MultiObject as MultiObject
import dent.Shaders as Shaders
import OpenGL.GL as gl
logging.info("Loading trees")
tree = MultiObject.MultiObject('assets/tree5/Conifers tree 1 N1006162.3DS', scale=15)
logging.info("Generating trees")
shaderObj = Shaders.TransformFeedbackShader('testTransform')
shaderObj.addProgram(gl.GL_VERTEX_SHADER, Shaders.ShaderFile('shaders/forestFeedback/vertex.shd', gl.GL_VERTEX_SHADER))
shaderObj.addProgram(gl.GL_GEOMETRY_SHADER, Shaders.ShaderFile('shaders/forestFeedback/geometry.shd',gl.GL_GEOMETRY_SHADER))
shaderObj.addOutput('outValue')
Shaders.setUniversalUniforms(shaderObj)
shaderObj.build()
shaderObj.load()
N = int(config.forest_tree_count ** 0.5)
shaderObj['scan'] = N
shaderObj['range'] = N * 12.
shaderObj['center'] = np.zeros(0, dtype=np.float32)
ips = np.zeros(N*N, dtype=[('id', np.int32, 1)])
ips['id'] = np.arange(N*N)
idd = shaderObj.setData(ips)
# On average one out of four trees is placed.
import dent.Shaders as Shaders
import logging
import OpenGL.GL as gl
import numpy as np
transform_shader = Shaders.TransformFeedbackShader('rock_placement_feedback')
transform_shader.addProgram(gl.GL_VERTEX_SHADER, Shaders.ShaderFile('rock_placement', gl.GL_VERTEX_SHADER))
Shaders.shaders['rock_placement_feedback'] = transform_shader
transform_shader.addProgram(gl.GL_GEOMETRY_SHADER, Shaders.ShaderFile('rock_placement',gl.GL_GEOMETRY_SHADER))
transform_shader.addOutput('outValue')
transform_shader.build()
transform_shader.load()
input_sizes = []
render_ids = []
output_buffers = []
def initialise(buffer_sizes):
for max_N in buffer_sizes:
ids = np.zeros(max_N, dtype=[('id',np.int32,1)])
ids['id'] = np.arange(max_N)
render_id = transform_shader.setData(ids)
output_buffer = transform_shader.getOutputBufferObject(render_id, max_N*16*4)
input_sizes.append(max_N)
render_ids.append(render_id)
output_buffers.append(output_buffer)
def update(centre):
import numpy as np
import heapq
import dent.args as args
import dent.assets as assets
import random
import dent.Shaders as Shaders
import dent.transforms as transforms
import OpenGL.GL as gl
import logging
import Terrain
pagingShader = Shaders.getShader('roadPaging')
data = np.zeros(4, dtype=[("position", np.float32, 3)])
data['position'] = [(-1, -1, 0.999999), (-1, 1, 0.999999), (1, -1, 0.999999),
(1, 1, 0.999999)]
I = [0, 1, 2, 1, 2, 3]
indices = np.array(I, dtype=np.int32)
pagingRenderID = pagingShader.setData(data, indices)
def generateControls(start, end):
"""Sigh. Don't try debug this too hard. Its an A* counting the gradient as
a weight."""
start = np.array(start, dtype=np.float32)
end = np.array(end, dtype=np.float32)
logging.info("Generating road from {} to {}".format(start, end))
curr = start.copy()
ans = []
nz = x1+np.sin(s*2*np.pi)*dx / (2*np.pi)
nw = y1+np.sin(t*2*np.pi)*dy / (2*np.pi)
t = noise.snoise4(nx, ny, nz, nw, octaves=10, persistence=0.5)
d[i, j] = t
d -= np.min(d)
d /= np.max(d)-np.min(d)
d *= 2
d -= 1
for i in tqdm.trange(textWidth, leave=False):
for j in range(textHeight):
v1 = np.array([float(i)/textWidth, d[i, j][3], float(j)/textWidth])
v2 = np.array([float(i+1)/textWidth, d[(i+1)%textWidth, j][3], float(j)/textWidth])
v3 = np.array([float(i)/textWidth, d[i, (j+1)%textHeight][3], float(j+1)/textWidth])
d[i, j][:3] = np.cross(v3-v1, v2-v1)
d[i, j][:3] /= np.linalg.norm(d[i, j][:3])
d[i, j][0], d[i, j][2] = d[i, j][2], d[i, j][0]
return d
d = assets.getAsset('noisedata', generateNoise, (), args.args.remake_noise)
logging.info("Uploading texture to GPU")
noiseTexture.loadData(d, keep_copy=True)
noiseTexture.load()
Shaders.updateUniversalUniform('noise', Texture.NOISE_NUM)
Shaders.updateUniversalUniform('noisemap', Texture.NOISE_NUM)
def get(x, y):
return d[int(d.shape[0]*x)%d.shape[0]][int(d.shape[1]*y)%d.shape[1]]
shadowCamera.update()
sunDirection = shadowCamera.direction
renderStages = [RenderStage(depth_only=True) for _ in xrange(3)]
for i in renderStages:
i.reshape(shadowSize, shadowSize)
renderStages[0].displayDepthTexture.loadAs(Texture.SHADOWS1)
renderStages[1].displayDepthTexture.loadAs(Texture.SHADOWS2)
renderStages[2].displayDepthTexture.loadAs(Texture.SHADOWS3)
projections = []
for i in range(3):
width = 20 * 15**i
projections.append(transforms.ortho(-width,width,-width,width, 40000. - 2*width, 40000. + 2*width))
Shaders.setUniform('shadowProjection'+str(i+1),projections[i])
count = 0
Shaders.setUniform('shadowTexture1',Texture.SHADOWS1_NUM)
Shaders.setUniform('shadowTexture2',Texture.SHADOWS2_NUM)
Shaders.setUniform('shadowTexture3',Texture.SHADOWS3_NUM)
def render(scene):
global count,sunTheta
sunTheta = gameTime
shadowCamera.theta = sunTheta
shadowCamera.phi = sunPhi
shadowCamera.update()
import dent.Shaders as Shaders
import numpy as np
import OpenGL.GL as gl
import dent.Texture as Texture
import lighting
shader = Shaders.getShader('general', instance=True)
shader['colormap'] = Texture.COLORMAP_NUM
data = np.zeros(24,
dtype=[("position", np.float32, 3), ("normal", np.float32, 3),
("uv", np.float32, 2)])
I = []
for i in range(8):
I += [i * 3, i * 3 + 1, i * 3 + 2]
h = 2**0.5
data['position'] = [(-1, 0, -1), (0, h, 0), (-1, 0, 1), (-1, 0, 1), (0, h, 0),
(1, 0, 1), (1, 0, 1), (0, h, 0), (1, 0, -1), (1, 0, -1),
(0, h, 0), (-1, 0, -1), (-1, 0, -1),
(0, -h, 0), (-1, 0, 1), (-1, 0, 1), (0, -h, 0), (1, 0, 1),
(1, 0, 1), (0, -h, 0), (1, 0, -1), (1, 0, -1), (0, -h, 0),
(-1, 0, -1)]
data['normal'] = [(-1, 1, 0)] * 3 +\
[(0, 1, 1)] * 3 + \
[(1, 1, 0)] * 3 + \
[(0, 1, -1)] * 3 + \
[(-1, -1, 0)] * 3 + \
[(0, -1, 1)] * 3 + \
[(1, -1, 0)] * 3 + \
[(0, -1, -1)] * 3
data['uv'] = [0, 0]
import numpy as np
import dent.assets
import procgen.Rock
import dent.Shaders as Shaders
import dent.transforms
import OpenGL.GL as gl
shader = Shaders.getShader('rock', instance=True)
class Rock(object):
def __init__(self, instance_buffer, instance_count, detail):
self.position = np.array([0,0.5,0],dtype=float)
self.shader = shader
self.meshdata, self.meshindices = dent.assets.getAsset('rock'+str(detail),
procgen.Rock.get_rock_mesh, (1, detail))
self.instance_template = np.zeros(0, dtype=[("model", np.float32, (4, 4))])
self.renderID = self.shader.setData(self.meshdata,
self.meshindices,
self.instance_template,
instance_buffer)
self.instance_count = instance_count
def display(self):
if self.renderID is None:
return
self.shader.draw(gl.GL_TRIANGLES, self.renderID, self.instance_count)