Vector3 &Spline::getControlPoint(int pos)
{
AX_ASSERT(pos < (int) m_controlPoints.size());
return m_controlPoints[pos];
}
bool Point::fromString(const char *str) {
int v = sscanf(str, "%d %d", &x, &y);
AX_ASSERT(v == 2);
return v == 2;
}
void Spline::generateSplineData(std::vector<Vector3>& result)
{
result.clear();
float t, f, g, h;
float len=0;
int nDiv = 1;
Vector3 point;
// 线条模式
if (m_width == 0)
{
for (int i=0; i<(int)m_controlPoints.size()-1; ++i)
{
nDiv = (int)(std::max(std::max(abs(m_helpers[i].A.x), abs(m_helpers[i].A.y)), abs(m_helpers[i].A.z)) / m_intervalLength);
if (nDiv == 0)
{
nDiv = 1;
}
point = m_controlPoints[i];
if (i == 0)
{
result.push_back(point);
}
else if ((point - result[result.size()-1]).getLength() >= m_intervalLength/5.0f)
{
result.push_back(point);
}
for (int j=1; j<=nDiv; ++j)
{
t = 1.0f / (float)nDiv * (float)j;
AX_ASSERT(t >= 0 && t <= 1.0 && "t is overflow!");
f = t * t * (3.0f - 2.0f*t);
g = t * (t-1.0f) * (t-1.0f);
h = t * t * (t-1.0f);
point.x = m_controlPoints[i].x + m_helpers[i].A.x * f + m_helpers[i].B.x * g + m_helpers[i].C.x * h;
point.y = m_controlPoints[i].y + m_helpers[i].A.y * f + m_helpers[i].B.y * g + m_helpers[i].C.y * h;
point.z = m_controlPoints[i].z + m_helpers[i].A.z * f + m_helpers[i].B.z * g + m_helpers[i].C.z * h;
// 如果宽度为零, 是线条模式
result.push_back(point);
} // for
} // for
}
else // 带状模式
{
std::vector<Vector3> tResult;
for (int i=0; i<(int)m_controlPoints.size()-1; ++i)
{
#if 0
len = (m_controlPoints[i+1] - m_controlPoints[i]).getLength();
nDiv = len / m_intervalLength;
#else
nDiv = (int)(std::max(std::max(abs(m_helpers[i].A.x), abs(m_helpers[i].A.y)), abs(m_helpers[i].A.z)) / m_intervalLength);
#endif
if (nDiv == 0)
{
nDiv = 1;
}
point = m_controlPoints[i];
if (i == 0)
{
tResult.push_back(point);
}
else if ((point - tResult[tResult.size()-1]).getLength() >= m_intervalLength/5.0f)
{
tResult.push_back(point);
}
for (int j=1; j<=nDiv; ++j)
{
#if 0
t = (float)(m_intervalLength * j) / len;
#else
t = 1.0f / (float)nDiv * (float)j;
#endif
AX_ASSERT(t >= 0 && t <= 1.0 && "t is overflow!");
f = t * t * (3.0f - 2.0f*t);
g = t * (t-1.0f) * (t-1.0f);
h = t * t * (t-1.0f);
point.x = m_controlPoints[i].x + m_helpers[i].A.x * f + m_helpers[i].B.x * g + m_helpers[i].C.x * h;
point.y = m_controlPoints[i].y + m_helpers[i].A.y * f + m_helpers[i].B.y * g + m_helpers[i].C.y * h;
point.z = m_controlPoints[i].z + m_helpers[i].A.z * f + m_helpers[i].B.z * g + m_helpers[i].C.z * h;
tResult.push_back(point);
} // for
} // for
int numResult = (int) tResult.size();
if (numResult < 2)
{
return ;
}
Vector3 dir = tResult[1] - tResult[0];
Vector3 crossDir;
dir.z = 0;
dir.normalize();
crossDir = dir ^ Vector3(0, 0, 1);
crossDir *= m_width / 2.0f;
result.push_back(tResult[0] + crossDir);
result.push_back(tResult[0]);
result.push_back(tResult[0] - crossDir);
for (int i=1; i<numResult-1; ++i)
{
dir = tResult[i+1] - tResult[i-1];
if (dir.getLength() < 0.001 || (tResult[i+1]-tResult[i]).getLength() < 0.001)
{
continue ;
}
dir.z = 0;
dir.normalize();
Vector3 crossDir = dir ^ Vector3(0, 0, 1);
crossDir *= m_width / 2.0f;
result.push_back(tResult[i] + crossDir);
result.push_back(tResult[i]);
result.push_back(tResult[i] - crossDir);
}
dir = tResult[numResult-1] - tResult[numResult-2];
dir.z = 0;
dir.normalize();
crossDir = dir ^ Vector3(0, 0, 1);
crossDir *= m_width / 2.0f;
result.push_back(tResult[numResult-1] + crossDir);
result.push_back(tResult[numResult-1]);
result.push_back(tResult[numResult-1] - crossDir);
}
}
Thread::Thread() {
m_exitEvent = new SyncEvent();
m_handle = ::CreateThread(NULL, 0, ThreadProc, this, CREATE_SUSPENDED, NULL);
AX_ASSERT(m_handle);
}
SyncEvent::SyncEvent() : m_object(NULL) {
m_object = ::CreateEvent(NULL, FALSE, FALSE, NULL);
AX_ASSERT(m_object);
}
void OutdoorEnv::createOceanMesh() {
m_oceanMesh = nullptr;
// calculate vertexbuffer and indexbuffer size
float r = 1.0f;
float num = 1;
while (r < OCEAN_RADIUS) {
num++;
r *= OCEAN_MULTIPLY;
}
int numverts = num * OCEAN_SUBDIVIDE + 1; // + 1 for center
int numidxes =(num - 1) * OCEAN_SUBDIVIDE * 2 * 3 + OCEAN_SUBDIVIDE * 3;
// create render mesh
m_oceanMesh = new Render::Mesh(Render::Mesh::Static);
m_oceanMesh->initialize(numverts, numidxes);
// initialize render mesh's vertexbuffer and indexbuffer
Vertex* verts = m_oceanMesh->lockVertexes();
Vertex* oldverts = verts;
// clear to zero
memset(verts, 0, sizeof(Vertex) * numverts);
// first vertex is zero center
verts->xyz.set(0, 0, 0);
verts->normal.set(0, 0, 1);
verts->tangent.set(1, 0, 0);
verts->binormal.set(0, 1, 0);
verts->st.set(0, 0); // verts->st = verts->xyz.xy() * 0.01f;
verts->rgba.set(255, 255, 255, 255);
verts++;
// inner vertexes
const float angelStep = AX_PI * 2.0f / OCEAN_SUBDIVIDE;
r = 1.0f;
for (int i = 0; i < num; i++, r *= OCEAN_MULTIPLY) {
for (int j = 0; j < OCEAN_SUBDIVIDE; j++) {
float angle = j * angelStep;
float s, c;
Math::sincos(angle, s, c);
verts->xyz.set(r * c, r * s, 0);
verts->normal.set(0, 0, 1);
verts->tangent.set(1, 0, 0);
verts->binormal.set(0, 1, 0);
verts->st.set(0, 0); // verts->st = verts->xyz.xy() * 0.01f;
verts->rgba.set(255, 255, 255, 255);
if (i == num - 1) {
verts->st.set(0, 1);
}
verts++;
}
}
m_oceanMesh->unlockVertexes();
AX_ASSERT(verts - oldverts == numverts);
// fill index buffer
ushort_t* idxes = m_oceanMesh->lockIndexes();
ushort_t* oldidxes = idxes;
// innermost triangles
for (int i = 0; i < OCEAN_SUBDIVIDE; i++) {
*idxes++ = 0;
*idxes++ =((i + 1) % OCEAN_SUBDIVIDE) + 1;
*idxes++ = i + 1;
}
for (int i = 0; i < num-1; i++) {
int start = i * OCEAN_SUBDIVIDE + 1;
for (int j = 0; j < OCEAN_SUBDIVIDE; j++) {
int p0 = start + j;
int p1 = start +((j + 1) % OCEAN_SUBDIVIDE);
int p2 = p0 + OCEAN_SUBDIVIDE;
int p3 = p1 + OCEAN_SUBDIVIDE;
*idxes++ = p0;
*idxes++ = p1;
*idxes++ = p2;
*idxes++ = p2;
*idxes++ = p1;
*idxes++ = p3;
}
}
m_oceanMesh->unlockIndexes();
AX_ASSERT(idxes - oldidxes == numidxes);
MaterialPtr mat = FindAsset_<Render::Material>("ocean");
m_oceanMesh->setMaterial(mat);
}
void OutdoorEnv::createSkyDome() {
int tess = SKYDOME_TESS;
int halftess = tess / 2;
float radius = SKYDOME_RADIUS;
int numverts = (tess + 1) * (halftess+1);
int numidxes = tess * halftess * 2 * 3;
m_skydome = new Mesh(Mesh::Static);
m_skydome->initialize(numverts, numidxes);
// fill vertexes
Vertex* verts = m_skydome->lockVertexes();
Vertex* vertsStart = verts;
memset(verts, 0, sizeof(Vertex) * numverts);
for (int i = 0; i <= halftess; i++) {
float y = (float)i / halftess;
float beta = AX_PI_2 *(y * 1.1f);
float bs, bc;
float vertbeta = AX_PI_2 * i / halftess;
float vbs, vbc;
Math::sincos(beta, bs, bc);
Math::sincos(vertbeta, vbs, vbc);
for (int j = 0; j <= tess; j++) {
float alpha = AX_PI * 2.0f / tess * j;
float as, ac;
Math::sincos(alpha, as, ac);
verts->xyz.x = vbs * ac;
verts->xyz.y = vbs * as;
verts->xyz.z = vbc;
verts->normal.x = bs * ac;
verts->normal.y = bs * as;
verts->normal.z = bc;
verts->xyz *= radius;
verts->st.set(j / (float)tess, i / (float)halftess);
verts->rgba.set(255,255,255,255);
verts++;
}
}
AX_ASSERT(verts - vertsStart == numverts);
m_skydome->unlockVertexes();
// fill indexes
ushort_t* idxes = m_skydome->lockIndexes();
ushort_t* idxesStart = idxes;
for (int i = 0; i < halftess; i++) {
for (int j = 0; j < tess; j++) {
int p0 = i *(tess + 1) + j;
int p1 = p0 + 1;
int p2 = (i+1) *(tess + 1) + j;
int p3 = p2 + 1;
idxes[0] = p0;
idxes[1] = p2;
idxes[2] = p1;
idxes[3] = p1;
idxes[4] = p2;
idxes[5] = p3;
idxes += 6;
}
}
AX_ASSERT(idxes - idxesStart == numidxes);
m_skydome->unlockIndexes();
#if 0
Material* mat = UniqueAsset_<Material>("null");
Texture* tex = FindAsset_<Texture>("textures/testlalo");
mat->setTexture(SamplerType::Diffuse, tex);
m_skydome->setMaterial(mat);
#endif
// create nishita render target
m_skyNishitaRt = nullptr;
if (!g_targetManager->isFormatSupport(TexFormat::RGBA16F)) {
return;
}
m_skyNishitaRt = g_targetManager->allocTarget(Target::PermanentAlloc, 128, 64, TexFormat::RGBA16F);
Target* miert = g_targetManager->allocTarget(Target::PermanentAlloc, 128, 64, TexFormat::RGBA16F);
m_skyNishitaRt->getTexture()->setClampMode(Texture::CM_ClampToEdge);
miert->getTexture()->setClampMode(Texture::CM_ClampToEdge);
m_skyNishitaRt->attachColor(0, miert);
m_skyNishitaMat = UniqueAsset_<Material>("_skyNishita");
m_skyNishitaMat->setTexture(SamplerType::Diffuse, m_skyNishitaRt->getTexture());
m_skyNishitaMat->setTexture(SamplerType::Specular, miert->getTexture());
m_skyNishitaGenMat = 0; //UniqueAsset_<Material>("_skyNishitaGen");
m_skydome->setMaterial(m_skyNishitaMat);
}
Target* D3D9target::getColorAttached(int index) const
{
AX_ASSERT(index < MAX_COLOR_ATTACHMENT);
return m_colorAttached[index];
}
void D3D9target::detachColor(int index)
{
AX_ASSERT(index < MAX_COLOR_ATTACHMENT);
m_colorAttached[index] = nullptr;
}
void D3D9target::attachColor(int index, Target* c)
{
AX_ASSERT(index < MAX_COLOR_ATTACHMENT);
m_colorAttached[index] = (D3D9target*)c;
}
