yvt/openspades
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
openspades/Sources/Draw/GLMapChunk.cpp

539 lines
15 KiB
C++
Raw Blame History

/*
Copyright (c) 2013 yvt
This file is part of OpenSpades.
OpenSpades is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenSpades is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenSpades. If not, see <http://www.gnu.org/licenses/>.
*/
#include <algorithm>
#include <cstddef>
#include <Client/GameMap.h>
#include <Core/Debug.h>
#include <Core/Settings.h>
#include "GLDynamicLightShader.h"
#include "GLMapChunk.h"
#include "GLMapRenderer.h"
#include "GLProgramAttribute.h"
#include "GLProgramUniform.h"
#include "GLRenderer.h"
#include "IGLDevice.h"
#include <AngelScript/include/angelscript.h> // for asOFFSET. somehow `offsetof` fails on gcc-4.8
namespace spades {
namespace draw {
GLMapChunk::GLMapChunk(spades::draw::GLMapRenderer *r, client::GameMap *mp, int cx, int cy,
int cz) {
SPADES_MARK_FUNCTION();
renderer = r;
device = r->device;
map = mp;
chunkX = cx;
chunkY = cy;
chunkZ = cz;
needsUpdate = true;
realized = false;
centerPos =
MakeVector3(cx * Size + Size / 2, cy * Size + Size / 2, cz * Size + Size / 2);
radius = (float)Size * 0.5f * sqrtf(3.f);
aabb = AABB3(cx * Size, cy * Size, cz * Size, Size, Size, Size);
buffer = 0;
iBuffer = 0;
}
GLMapChunk::~GLMapChunk() { SetRealized(false); }
void GLMapChunk::SetRealized(bool b) {
SPADES_MARK_FUNCTION_DEBUG();
if (realized == b)
return;
if (!b) {
if (buffer) {
device->DeleteBuffer(buffer);
buffer = 0;
}
if (iBuffer) {
device->DeleteBuffer(iBuffer);
iBuffer = 0;
}
std::vector<Vertex> i;
i.swap(vertices);
std::vector<uint16_t> i2;
i2.swap(indices);
} else {
needsUpdate = true;
}
realized = b;
}
uint8_t GLMapChunk::calcAOID(int x, int y, int z, int ux, int uy, int uz, int vx, int vy,
int vz) {
int v = 0;
if (IsSolid(x - ux, y - uy, z - uz))
v |= 1;
if (IsSolid(x + ux, y + uy, z + uz))
v |= 1 << 1;
if (IsSolid(x - vx, y - vy, z - vz))
v |= 1 << 2;
if (IsSolid(x + vx, y + vy, z + vz))
v |= 1 << 3;
if (IsSolid(x - ux + vx, y - uy + vy, z - uz + vz))
v |= 1 << 4;
if (IsSolid(x - ux - vx, y - uy - vy, z - uz - vz))
v |= 1 << 5;
if (IsSolid(x + ux + vx, y + uy + vy, z + uz + vz))
v |= 1 << 6;
if (IsSolid(x + ux - vx, y + uy - vy, z + uz - vz))
v |= 1 << 7;
return (uint8_t)v;
}
/**
* @param aoX Global X coordinate of the cell to evaluate ambient occlusion.
* @param aoY Global Y coordinate of the cell to evaluate ambient occlusion.
* @param aoZ Global Z coordinate of the cell to evaluate ambient occlusion.
* @param x Chunk local X coordinate
* @param y Chunk local Y coordinate
* @param z Chunk local Z coordinate
*/
void GLMapChunk::EmitVertex(int x, int y, int z, int aoX, int aoY, int aoZ, int ux, int uy,
int vx, int vy, uint32_t color, int nx, int ny, int nz) {
SPADES_MARK_FUNCTION_DEBUG();
int uz = (ux == 0 && uy == 0) ? 1 : 0;
int vz = (vx == 0 && vy == 0) ? 1 : 0;
Vertex inst;
// evaluate ambient occlusion
unsigned int aoID = calcAOID(aoX, aoY, aoZ, ux, uy, uz, vx, vy, vz);
if (nz == 1 || ny == 1) {
inst.shading = 0;
} else if (nx == 1 || nx == -1) {
inst.shading = 0; // 50;
} else if (nz == -1) {
inst.shading = 220;
} else {
inst.shading = 255;
}
inst.x = x;
inst.y = y;
inst.z = z;
inst.colorRed = (uint8_t)(color);
inst.colorGreen = (uint8_t)(color >> 8);
inst.colorBlue = (uint8_t)(color >> 16);
inst.nx = nx;
inst.ny = ny;
inst.nz = nz;
// fixed position to avoid self-shadow glitch
inst.sx = (x << 1) + ux + vx;
inst.sy = (y << 1) + uy + vy;
inst.sz = (z << 1) + uz + vz;
unsigned int aoTexX = aoID & 15;
unsigned int aoTexY = aoID >> 4;
aoTexX *= 16;
aoTexY *= 16;
uint16_t idx = (uint16_t)vertices.size();
inst.x = x;
inst.y = y;
inst.z = z;
inst.aoX = aoTexX;
inst.aoY = aoTexY;
vertices.push_back(inst);
inst.x = x + ux;
inst.y = y + uy;
inst.z = z + uz;
inst.aoX = aoTexX + 15;
inst.aoY = aoTexY;
vertices.push_back(inst);
inst.x = x + vx;
inst.y = y + vy;
inst.z = z + vz;
inst.aoX = aoTexX;
inst.aoY = aoTexY + 15;
vertices.push_back(inst);
inst.x = x + ux + vx;
inst.y = y + uy + vy;
inst.z = z + uz + vz;
inst.aoX = aoTexX + 15;
inst.aoY = aoTexY + 15;
vertices.push_back(inst);
indices.push_back(idx);
indices.push_back(idx + 1);
indices.push_back(idx + 2);
indices.push_back(idx + 1);
indices.push_back(idx + 3);
indices.push_back(idx + 2);
}
bool GLMapChunk::IsSolid(int x, int y, int z) {
if (z < 0)
return false;
if (z >= 64)
return true;
// FIXME: variable map size
x &= 511;
y &= 511;
if (z == 63) {
if (renderer->renderer->GetSettings().r_water) {
return map->IsSolid(x, y, 62);
} else {
return map->IsSolid(x, y, 63);
}
} else {
return map->IsSolid(x, y, z);
}
}
void GLMapChunk::Update() {
SPADES_MARK_FUNCTION();
vertices.clear();
indices.clear();
if (buffer) {
device->DeleteBuffer(buffer);
buffer = 0;
}
if (iBuffer) {
device->DeleteBuffer(iBuffer);
iBuffer = 0;
}
int rchunkX = chunkX * Size;
int rchunkY = chunkY * Size;
int rchunkZ = chunkZ * Size;
int x, y, z;
for (x = 0; x < Size; x++) {
for (y = 0; y < Size; y++) {
for (z = 0; z < Size; z++) {
int xx = x + rchunkX;
int yy = y + rchunkY;
int zz = z + rchunkZ;
if (!IsSolid(xx, yy, zz))
continue;
uint32_t col = map->GetColor(xx, yy, zz);
// col = 0xffffffff;
// damaged block?
int health = col >> 24;
if (health < 100) {
col &= 0xffffff;
col &= 0xfefefe;
col >>= 1;
}
if (!IsSolid(xx, yy, zz + 1)) {
EmitVertex(x + 1, y, z + 1, xx, yy, zz + 1, -1, 0, 0, 1, col, 0, 0, 1);
}
if (!IsSolid(xx, yy, zz - 1)) {
EmitVertex(x, y, z, xx, yy, zz - 1, 1, 0, 0, 1, col, 0, 0, -1);
}
if (!IsSolid(xx - 1, yy, zz)) {
EmitVertex(x, y + 1, z, xx - 1, yy, zz, 0, 0, 0, -1, col, -1, 0, 0);
}
if (!IsSolid(xx + 1, yy, zz)) {
EmitVertex(x + 1, y, z, xx + 1, yy, zz, 0, 0, 0, 1, col, 1, 0, 0);
}
if (!IsSolid(xx, yy - 1, zz)) {
EmitVertex(x, y, z, xx, yy - 1, zz, 0, 0, 1, 0, col, 0, -1, 0);
}
if (!IsSolid(xx, yy + 1, zz)) {
EmitVertex(x + 1, y + 1, z, xx, yy + 1, zz, 0, 0, -1, 0, col, 0, 1, 0);
}
}
}
}
if (vertices.size() == 0)
return;
buffer = device->GenBuffer();
device->BindBuffer(IGLDevice::ArrayBuffer, buffer);
device->BufferData(IGLDevice::ArrayBuffer,
static_cast<IGLDevice::Sizei>(vertices.size() * sizeof(Vertex)),
vertices.data(), IGLDevice::DynamicDraw);
if (!indices.empty()) {
iBuffer = device->GenBuffer();
device->BindBuffer(IGLDevice::ArrayBuffer, iBuffer);
device->BufferData(IGLDevice::ArrayBuffer,
static_cast<IGLDevice::Sizei>(indices.size() * sizeof(uint16_t)),
indices.data(), IGLDevice::DynamicDraw);
}
device->BindBuffer(IGLDevice::ArrayBuffer, 0);
}
void GLMapChunk::RenderDepthPass() {
SPADES_MARK_FUNCTION();
Vector3 eye = renderer->renderer->GetSceneDef().viewOrigin;
if (!realized)
return;
if (needsUpdate) {
Update();
needsUpdate = false;
}
if (!buffer) {
// empty chunk
return;
}
AABB3 bx = aabb;
Vector3 diff = eye - centerPos;
float sx = 0.f, sy = 0.f;
// FIXME: variable map size?
if (diff.x > 256.f)
sx += 512.f;
if (diff.y > 256.f)
sy += 512.f;
if (diff.x < -256.f)
sx -= 512.f;
if (diff.y < -256.f)
sy -= 512.f;
bx.min.x += sx;
bx.min.y += sy;
bx.max.x += sx;
bx.max.y += sy;
if (!renderer->renderer->BoxFrustrumCull(bx))
return;
GLProgram *depthonlyProgram = renderer->depthonlyProgram;
static GLProgramUniform chunkPosition("chunkPosition");
chunkPosition(depthonlyProgram);
chunkPosition.SetValue((float)(chunkX * Size) + sx, (float)(chunkY * Size) + sy,
(float)(chunkZ * Size));
static GLProgramAttribute positionAttribute("positionAttribute");
positionAttribute(depthonlyProgram);
device->BindBuffer(IGLDevice::ArrayBuffer, buffer);
device->VertexAttribPointer(positionAttribute(), 3, IGLDevice::UnsignedByte, false,
sizeof(Vertex), (void *)asOFFSET(Vertex, x));
device->BindBuffer(IGLDevice::ArrayBuffer, 0);
device->BindBuffer(IGLDevice::ElementArrayBuffer, iBuffer);
device->DrawElements(IGLDevice::Triangles,
static_cast<IGLDevice::Sizei>(indices.size()),
IGLDevice::UnsignedShort, NULL);
device->BindBuffer(IGLDevice::ElementArrayBuffer, 0);
}
void GLMapChunk::RenderSunlightPass() {
SPADES_MARK_FUNCTION();
Vector3 eye = renderer->renderer->GetSceneDef().viewOrigin;
if (!realized)
return;
if (needsUpdate) {
Update();
needsUpdate = false;
}
if (!buffer) {
// empty chunk
return;
}
AABB3 bx = aabb;
Vector3 diff = eye - centerPos;
float sx = 0.f, sy = 0.f;
// FIXME: variable map size?
if (diff.x > 256.f)
sx += 512.f;
if (diff.y > 256.f)
sy += 512.f;
if (diff.x < -256.f)
sx -= 512.f;
if (diff.y < -256.f)
sy -= 512.f;
bx.min.x += sx;
bx.min.y += sy;
bx.max.x += sx;
bx.max.y += sy;
if (!renderer->renderer->BoxFrustrumCull(bx))
return;
GLProgram *basicProgram = renderer->basicProgram;
static GLProgramUniform chunkPosition("chunkPosition");
chunkPosition(basicProgram);
chunkPosition.SetValue((float)(chunkX * Size) + sx, (float)(chunkY * Size) + sy,
(float)(chunkZ * Size));
static GLProgramAttribute positionAttribute("positionAttribute");
static GLProgramAttribute ambientOcclusionCoordAttribute(
"ambientOcclusionCoordAttribute");
static GLProgramAttribute colorAttribute("colorAttribute");
static GLProgramAttribute normalAttribute("normalAttribute");
static GLProgramAttribute fixedPositionAttribute("fixedPositionAttribute");
positionAttribute(basicProgram);
ambientOcclusionCoordAttribute(basicProgram);
colorAttribute(basicProgram);
normalAttribute(basicProgram);
fixedPositionAttribute(basicProgram);
device->BindBuffer(IGLDevice::ArrayBuffer, buffer);
device->VertexAttribPointer(positionAttribute(), 3, IGLDevice::UnsignedByte, false,
sizeof(Vertex), (void *)asOFFSET(Vertex, x));
if (ambientOcclusionCoordAttribute() != -1)
device->VertexAttribPointer(ambientOcclusionCoordAttribute(), 2,
IGLDevice::UnsignedShort, false, sizeof(Vertex),
(void *)asOFFSET(Vertex, aoX));
device->VertexAttribPointer(colorAttribute(), 4, IGLDevice::UnsignedByte, true,
sizeof(Vertex), (void *)asOFFSET(Vertex, colorRed));
if (normalAttribute() != -1)
device->VertexAttribPointer(normalAttribute(), 3, IGLDevice::Byte, false,
sizeof(Vertex), (void *)asOFFSET(Vertex, nx));
device->VertexAttribPointer(fixedPositionAttribute(), 3, IGLDevice::Byte, false,
sizeof(Vertex), (void *)asOFFSET(Vertex, sx));
device->BindBuffer(IGLDevice::ArrayBuffer, 0);
device->BindBuffer(IGLDevice::ElementArrayBuffer, iBuffer);
device->DrawElements(IGLDevice::Triangles,
static_cast<IGLDevice::Sizei>(indices.size()),
IGLDevice::UnsignedShort, NULL);
device->BindBuffer(IGLDevice::ElementArrayBuffer, 0);
}
void GLMapChunk::RenderDLightPass(std::vector<GLDynamicLight> lights) {
SPADES_MARK_FUNCTION();
Vector3 eye = renderer->renderer->GetSceneDef().viewOrigin;
if (!realized)
return;
if (needsUpdate) {
Update();
needsUpdate = false;
}
if (!buffer) {
// empty chunk
return;
}
AABB3 bx = aabb;
Vector3 diff = eye - centerPos;
float sx = 0.f, sy = 0.f;
// FIXME: variable map size?
if (diff.x > 256.f)
sx += 512.f;
if (diff.y > 256.f)
sy += 512.f;
if (diff.x < -256.f)
sx -= 512.f;
if (diff.y < -256.f)
sy -= 512.f;
bx.min.x += sx;
bx.min.y += sy;
bx.max.x += sx;
bx.max.y += sy;
if (!renderer->renderer->BoxFrustrumCull(bx))
return;
GLProgram *program = renderer->dlightProgram;
static GLProgramUniform chunkPosition("chunkPosition");
chunkPosition(program);
chunkPosition.SetValue((float)(chunkX * Size) + sx, (float)(chunkY * Size) + sy,
(float)(chunkZ * Size));
static GLProgramAttribute positionAttribute("positionAttribute");
static GLProgramAttribute colorAttribute("colorAttribute");
static GLProgramAttribute normalAttribute("normalAttribute");
positionAttribute(program);
colorAttribute(program);
normalAttribute(program);
device->BindBuffer(IGLDevice::ArrayBuffer, buffer);
device->VertexAttribPointer(positionAttribute(), 3, IGLDevice::UnsignedByte, false,
sizeof(Vertex), (void *)asOFFSET(Vertex, x));
device->VertexAttribPointer(colorAttribute(), 4, IGLDevice::UnsignedByte, true,
sizeof(Vertex), (void *)asOFFSET(Vertex, colorRed));
device->VertexAttribPointer(normalAttribute(), 3, IGLDevice::Byte, false,
sizeof(Vertex), (void *)asOFFSET(Vertex, nx));
device->BindBuffer(IGLDevice::ArrayBuffer, 0);
device->BindBuffer(IGLDevice::ElementArrayBuffer, iBuffer);
for (size_t i = 0; i < lights.size(); i++) {
static GLDynamicLightShader lightShader;
lightShader(renderer->renderer, program, lights[i], 1);
if (!lights[i].Cull(bx))
continue;
device->DrawElements(IGLDevice::Triangles,
static_cast<IGLDevice::Sizei>(indices.size()),
IGLDevice::UnsignedShort, NULL);
}
device->BindBuffer(IGLDevice::ElementArrayBuffer, 0);
}
float GLMapChunk::DistanceFromEye(const Vector3 &eye) {
Vector3 diff = eye - centerPos;
// FIXME: variable map size
if (diff.x < -256.f)
diff.x += 512.f;
if (diff.y < -256.f)
diff.y += 512.f;
if (diff.x > 256.f)
diff.x -= 512.f;
if (diff.y > 256.f)
diff.y -= 512.f;
float dist = fabsf(diff.x);
dist = std::max(dist, fabsf(diff.y));
// note: there's no vertical fog
// return std::max(diff.GetLength() - radius, 0.f);
return std::max(dist - ((float)Size * .5f), 0.f);
}
}
}
Reference in New Issue View Git Blame Copy Permalink