def render(self, view, renderingSystem):
glUseProgram(self.shader)
renderingSystem.setCommonUniforms(self.shader, view, lu.Mat4())
lu.setUniform(self.shader, "terrainHeightScale", self.heightScale)
lu.setUniform(self.shader, "terrainTextureXyScale",
self.textureXyScale)
xyNormScale = 1.0 / (vec2(self.imageWidth, self.imageHeight) *
self.xyScale)
lu.setUniform(self.shader, "xyNormScale", xyNormScale)
xyOffset = -(vec2(self.imageWidth, self.imageHeight) +
vec2(1.0)) * self.xyScale / 2.0
lu.setUniform(self.shader, "xyOffset", xyOffset)
#TODO 1.4: Bind the grass texture to the right texture unit, hint: lu.bindTexture
loc = glGetUniformLocation(self.shader, "someTexture")
glUniform1i(loc, 0)
lu.bindTexture(loc, glGenTextures(1))
if self.renderWireFrame:
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
glLineWidth(1.0)
glBindVertexArray(self.vertexArrayObject)
glDrawElements(GL_TRIANGLES, len(self.terrainInds), GL_UNSIGNED_INT,
None)
if self.renderWireFrame:
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
glBindVertexArray(0)
glUseProgram(0)
def update(self, dt, keyStateMap):
info = self.terrain.getInfoAt(self.position)
# Select max speed based on material
maxSpeed = self.maxSpeedRoad if info.material == TerrainInfo.M_Road else self.maxSpeedRough
targetVel = vec3(0.0)
if keyStateMap["UP"]:
targetVel = self.heading * maxSpeed
if keyStateMap["DOWN"]:
targetVel = self.heading * -maxSpeed
# linearly interpolate towards the target velocity - this means it is tied to the frame rate, which kind of is bad.
self.velocity = lu.mix(self.velocity, targetVel, 0.01)
self.speed = lu.length(self.velocity)
rotationMat = lu.Mat4()
if keyStateMap["LEFT"]:
rotationMat = lu.make_rotation_z(dt * self.angvel)
if keyStateMap["RIGHT"]:
rotationMat = lu.make_rotation_z(dt * -self.angvel)
self.heading = lu.Mat3(rotationMat) * self.heading
# get height of ground at this point.
self.position += self.velocity * dt
# TODO 1.1: After the terrain height is correct, uncomment this line to make the racer follow the ground height
self.position[2] = lu.mix(self.position[2], info.height + self.zOffset,
0.1)
def __make_inner_squares_front(squares):
rot_tfm = lu.Mat4()
translation = lambda i: lu.make_translation(0, 0, -1 - i)
CubeRenderer.__add_inner_squares(squares, rot_tfm, translation,
FRONT_TRANS)
translation = lambda i: lu.make_translation(0, 0, -1 + 2 * SPACING - i)
CubeRenderer.__add_inner_squares(squares, rot_tfm, translation,
FRONT_TRANS)
def render(self, view, renderingSystem, depthMap):
glUseProgram(self.shader)
renderingSystem.setCommonUniforms(self.shader, view, lu.Mat4())
lu.setUniform(self.shader, "terrainHeightScale", self.heightScale)
lu.setUniform(self.shader, "terrainTextureXyScale",
self.textureXyScale)
xyNormScale = 1.0 / (vec2(self.imageWidth, self.imageHeight) *
self.xyScale)
lu.setUniform(self.shader, "xyNormScale", xyNormScale)
xyOffset = -(vec2(self.imageWidth, self.imageHeight) + vec2(1.0)) / 2.0
lu.setUniform(self.shader, "xyOffset", xyOffset)
lu.setUniform(self.shader, "lightPOVTransform", view.depthMVPTransform)
#depthTexture binding for use in terrain frag shader
#lu.bindTexture(shadow.TU_depthTexture, depthMap)
#lu.setUniform(self.shader, "shadowMapTexture", shadow.TU_depthTexture)
#FINISH HERE
#TODO 1.4: Bind the grass texture to the right texture unit, hint: lu.bindTexture
lu.bindTexture(self.TU_Grass, self.terrainTexId)
lu.bindTexture(self.TU_high, self.highTexId)
lu.bindTexture(self.TU_road, self.roadTexId)
lu.bindTexture(self.TU_steep, self.steepTexId)
lu.bindTexture(self.TU_map, self.terrainDataSampleTexId)
#bind specs
lu.bindTexture(self.TU_spec_grass, self.specGrassTexId)
lu.bindTexture(self.TU_spec_high, self.specHighTexId)
lu.bindTexture(self.TU_spec_road, self.specRoadTexId)
lu.bindTexture(self.TU_spec_steep, self.specSteepTexId)
#set uniform specs
lu.setUniform(self.shader, "specularGrassTexture", self.TU_spec_grass)
lu.setUniform(self.shader, "specularHighTexture", self.TU_spec_high)
lu.setUniform(self.shader, "specularRoadTexture", self.TU_spec_road)
lu.setUniform(self.shader, "specularSteepTexture", self.TU_spec_steep)
#
lu.setUniform(self.shader, "terrainTexture", self.TU_Grass)
lu.setUniform(self.shader, "highTexture", self.TU_high)
lu.setUniform(self.shader, "roadTexture", self.TU_road)
lu.setUniform(self.shader, "steepTexture", self.TU_steep)
lu.setUniform(self.shader, "terrainDataSample", self.TU_map)
if self.renderWireFrame:
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
glLineWidth(1.0)
glBindVertexArray(self.vertexArrayObject)
glDrawElements(GL_TRIANGLES, len(self.terrainInds), GL_UNSIGNED_INT,
None)
if self.renderWireFrame:
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
glBindVertexArray(0)
glUseProgram(0)
def render(self, view, renderingSystem):
glUseProgram(self.shader)
renderingSystem.setCommonUniforms(self.shader, view, lu.Mat4())
lu.setUniform(self.shader, "terrainHeightScale", self.heightScale)
lu.setUniform(self.shader, "terrainTextureXyScale",
self.textureXyScale)
xyNormScale = 1.0 / (vec2(self.imageWidth, self.imageHeight) *
self.xyScale)
lu.setUniform(self.shader, "xyNormScale", xyNormScale)
xyOffset = -(vec2(self.imageWidth, self.imageHeight) +
vec2(1.0)) * self.xyScale / 2.0
lu.setUniform(self.shader, "xyOffset", xyOffset)
#TODO 1.4: Bind the grass texture to the right texture unit, hint: lu.bindTexture
lu.bindTexture(self.TU_Grass, self.grassTexture)
lu.setUniform(self.shader, "grassTexture", self.TU_Grass)
# 2.1
# High
lu.bindTexture(self.TU_Wall, self.wallTexture)
lu.setUniform(self.shader, "wallTexture", self.TU_Wall)
# Steep
lu.bindTexture(self.TU_Seats, self.seatsTexture)
lu.setUniform(self.shader, "seatsTexture", self.TU_Seats)
# Road
lu.bindTexture(self.TU_Track, self.trackTexture)
lu.bindTexture(self.TU_Map, self.mapTexture)
lu.setUniform(self.shader, "trackTexture", self.TU_Track)
lu.setUniform(self.shader, "mapTexture", self.TU_Map)
# Olympics
lu.bindTexture(self.TU_Concrete, self.concreteTexture)
lu.setUniform(self.shader, "concreteTexture", self.TU_Concrete)
if self.renderWireFrame:
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
glLineWidth(1.0)
glBindVertexArray(self.vertexArrayObject)
glDrawElements(GL_TRIANGLES, len(self.terrainInds), GL_UNSIGNED_INT,
None)
if self.renderWireFrame:
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
glBindVertexArray(0)
glUseProgram(0)
def render(self, view, renderingSystem):
glUseProgram(self.shader)
renderingSystem.setCommonUniforms(self.shader, view, lu.Mat4())
lu.setUniform(self.shader, "terrainHeightScale", self.heightScale)
lu.setUniform(self.shader, "terrainTextureXyScale",
self.textureXyScale)
xyNormScale = 1.0 / (vec2(self.imageWidth, self.imageHeight) *
self.xyScale)
lu.setUniform(self.shader, "xyNormScale", xyNormScale)
xyOffset = -(vec2(self.imageWidth, self.imageHeight) +
vec2(1.0)) * self.xyScale / 2.0
lu.setUniform(self.shader, "xyOffset", xyOffset)
#TODO 1.4: Bind the grass texture to the right texture unit, hint: lu.bindTexture
lu.setUniform(self.shader, "grassTexture", self.TU_Grass)
lu.bindTexture(self.TU_Grass, self.grass, None)
lu.setUniform(self.shader, "highRockTexture", self.TU_highRock)
lu.bindTexture(self.TU_highRock, self.highRock, None)
lu.setUniform(self.shader, "lowRockTexture", self.TU_lowRock)
lu.bindTexture(self.TU_lowRock, self.lowRock, None)
lu.setUniform(self.shader, "pavemenTexture", self.TU_pavement)
lu.bindTexture(self.TU_pavement, self.pavement, None)
lu.setUniform(self.shader, "terrainMapTexture", self.TU_terrainMap)
lu.bindTexture(self.TU_terrainMap, self.terrainMap, None)
if self.renderWireFrame:
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
glLineWidth(1.0)
glBindVertexArray(self.vertexArrayObject)
glDrawElements(GL_TRIANGLES, len(self.terrainInds), GL_UNSIGNED_INT,
None)
if self.renderWireFrame:
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
glBindVertexArray(0)
glUseProgram(0)
class ViewParams:
viewToClipTransform = lu.Mat4()
worldToViewTransform = lu.Mat4()
depthMVPTransform = lu.Mat4()
width = 0
height = 0
def render(self, shaderProgram=None, renderFlags=None, transforms={}):
if not renderFlags:
renderFlags = self.RF_All
if not shaderProgram:
shaderProgram = self.defaultShader
# Filter chunks based of render flags
chunks = [ch for ch in self.chunks if ch[3] & renderFlags]
glBindVertexArray(self.vertexArrayObject)
glUseProgram(shaderProgram)
# define defaults (identity)
defaultTfms = {
"modelToClipTransform": lu.Mat4(),
"modelToViewTransform": lu.Mat4(),
"modelToViewNormalTransform": lu.Mat3(),
}
# overwrite defaults
defaultTfms.update(transforms)
# upload map of transforms
for tfmName, tfm in defaultTfms.items():
loc = magic.getUniformLocationDebug(shaderProgram, tfmName)
tfm._set_open_gl_uniform(loc)
previousMaterial = None
for material, chunkOffset, chunkCount, renderFlags in chunks:
# as an optimization we only do this if the material has changed between chunks.
# for more efficiency still consider sorting chunks based on material (or fusing them?)
if material != previousMaterial:
previousMaterial = material
if self.overrideDiffuseTextureWithDefault:
bindTexture(self.TU_Diffuse, self.defaultTextureOne,
self.defaultTextureOne)
else:
bindTexture(self.TU_Diffuse,
material["texture"]["diffuse"],
self.defaultTextureOne)
bindTexture(self.TU_Opacity, material["texture"]["opacity"],
self.defaultTextureOne)
bindTexture(self.TU_Specular, material["texture"]["specular"],
self.defaultTextureOne)
bindTexture(self.TU_Normal, material["texture"]["normal"],
self.defaultNormalTexture)
# TODO: can I do uniform buffers from python (yes, I need to use that struct thingo!)
#uint32_t matUniformSize = sizeof(MaterialProperties_Std140);
#glBindBufferRange(GL_UNIFORM_BUFFER, UBS_MaterialProperties, m_materialPropertiesBuffer, (uint32_t)chunk.material->offset * matUniformSize, matUniformSize);
# TODO: this is very slow, it should be packed into an uniform buffer as per above!
for k, v in material["color"].items():
glUniform3fv(
magic.getUniformLocationDebug(shaderProgram,
"material_%s_color" % k),
1, v)
glUniform1f(
magic.getUniformLocationDebug(
shaderProgram, "material_specular_exponent"),
material["specularExponent"])
glUniform1f(
magic.getUniformLocationDebug(shaderProgram,
"material_alpha"),
material["alpha"])
glDrawArrays(GL_TRIANGLES, chunkOffset, chunkCount)
glUseProgram(0)
def __add_back_squares(self, squares):
translation = lambda row, col: lu.make_translation(
SPACING + 2 - col, SPACING + (2 - row), -3 + SPACING)
CubeRenderer.__add_squares(self.cube.front.squares, squares, lu.Mat4(),
translation)
def __add_front_squares(self, squares):
translation = FRONT_TRANS
CubeRenderer.__add_squares(self.cube.front.squares, squares, lu.Mat4(),
translation)