// while 循环
void CodeGenerator::While() {
match("(");
int Begin = CurLabel;
string res = Expr();
match(")");
addQuad("J==", res, "1", itos(CurLabel + 2));
int OUT = addQuad("J", "$", "$", "Unknow");
match("{");
Block();
addQuad("J", "$", "$", itos(Begin));
QuadList[OUT].name_res = itos(CurLabel);
match("}");
}
template <typename PointInT> void
pcl::OrganizedFastMesh<PointInT>::makeQuadMesh (std::vector<pcl::Vertices>& polygons)
{
int last_column = input_->width - triangle_pixel_size_columns_;
int last_row = input_->height - triangle_pixel_size_rows_;
int i = 0, index_down = 0, index_right = 0, index_down_right = 0, idx = 0;
int y_big_incr = triangle_pixel_size_rows_ * input_->width,
x_big_incr = y_big_incr + triangle_pixel_size_columns_;
// Reserve enough space
polygons.resize (input_->width * input_->height);
// Go over the rows first
for (int y = 0; y < last_row; y += triangle_pixel_size_rows_)
{
// Initialize a new row
i = y * input_->width;
index_right = i + triangle_pixel_size_columns_;
index_down = i + y_big_incr;
index_down_right = i + x_big_incr;
// Go over the columns
for (int x = 0; x < last_column; x += triangle_pixel_size_columns_,
i += triangle_pixel_size_columns_,
index_right += triangle_pixel_size_columns_,
index_down += triangle_pixel_size_columns_,
index_down_right += triangle_pixel_size_columns_)
{
if (isValidQuad (i, index_right, index_down_right, index_down))
if (store_shadowed_faces_ || !isShadowedQuad (i, index_right, index_down_right, index_down))
addQuad (i, index_right, index_down_right, index_down, idx++, polygons);
}
}
polygons.resize (idx);
}
void Model::addBall(float radius, size_t step, size_t rstep, const glm::vec3 ¢er) {
if (step < 2) {
step = 2; // step < 2 => straight line
}
if (rstep < 3) {
rstep = 2 * step; // rstep < 3 => flat polygon
}
float phi = 0, theta = 0, dPhi = Pi / (step), dTheta = 2.0f * Pi / rstep;
step += 1;
rstep += 1;
reserveVertices((step) * (rstep));
reserveIndices((step) * (rstep) * 2);
glm::vec3 n;
size_t i, j, k = mVertices.size();
for (i = 0; i < rstep; i++, theta += dTheta) {
for (j = 0, phi = 0; j < step; j++, phi += dPhi) {
n.x = std::sin(phi)*std::cos(theta);
n.y = std::cos(phi);
n.z = std::sin(phi)*std::sin(theta);
addVertex(Vertex(n, center+n*radius));
size_t p = (i + 1) % rstep;
size_t q = (j + 1) % step;
addQuad(k+(i*step)+j, k+(p*step)+j, k+(p*step)+q, k+(i*step)+q);
}
}
}
void ofxParametricSurface::reload(){
if (!isSetup) {
ofLogError("ofxMathMesh") << "cannot reload if the surface is not setup";
return;
}
clear();
int uMinDomainPoint = round(ofMap(uMin, absUMin, absUMax, 0, uDomainPoints.size()-1));
int uMaxDomainPoint = round(ofMap(uMax, absUMin, absUMax, 0, uDomainPoints.size()-1));
int vMinDomainPoint = round(ofMap(vMin, absVMin, absVMax, 0, vDomainPoints.size()-1));
int vMaxDomianPoint = round(ofMap(vMax, absVMin, absVMax, 0, vDomainPoints.size()-1));
for (int u = uMinDomainPoint; u < uMaxDomainPoint; u++) {
for (int v = vMinDomainPoint; v < vMaxDomianPoint; v++) {
ofPoint value1 = valueForPoint(uDomainPoints[u], vDomainPoints[v]);
ofPoint value2 = valueForPoint(uDomainPoints[u], vDomainPoints[v+1]);
ofPoint value3 = valueForPoint(uDomainPoints[u+1], vDomainPoints[v+1]);
ofPoint value4 = valueForPoint(uDomainPoints[u+1], vDomainPoints[v]);
ParametricPosition one(uDomainPoints[u],vDomainPoints[v],value1);
ParametricPosition two(uDomainPoints[u],vDomainPoints[v+1],value2);
ParametricPosition three(uDomainPoints[u+1],vDomainPoints[v+1],value3);
ParametricPosition four(uDomainPoints[u+1],vDomainPoints[v],value4);
addQuad(one, two, three, four);
}
}
}
void diamondSquareIterationByIdx() {
if (iterations >= MAX_ITERATIONS)
return;
indicesEnabled = true;
auto & previousItVertices = mesh.getVertices();
auto previousItIndices = mesh.getIndices();
mesh.clearIndices();
// mesh.clear();
iterations++;
auto previousItIdx = previousItIndices.begin();
while (previousItIdx != previousItIndices.end()) {
IndexType bottomLeftIdx = *previousItIdx++;
IndexType topLeftIdx = *previousItIdx++;
IndexType topRightIdx = *previousItIdx++;
previousItIdx++; // skip top right
IndexType bottomRightIdx = *previousItIdx++;
previousItIdx++; // skip bottom left
ofVec3f bottomLeft = getVertex(bottomLeftIdx);
ofVec3f topLeft = getVertex(topLeftIdx);
ofVec3f topRight = getVertex(topRightIdx);
ofVec3f bottomRight = getVertex(bottomRightIdx);
IndexType middlePointIdx = addVertex(((bottomLeft + bottomRight + topRight + topLeft)/4.f));
disturbMidpoint(getVertex(middlePointIdx), bottomLeft, topLeft, topRight, bottomRight);
IndexType leftMidIdx = addVertex((topLeft + bottomLeft)/2.f);
IndexType botMidIdx = addVertex((bottomRight + bottomLeft)/2.f);
IndexType topMidIdx = addVertex((topRight + topLeft)/2.f);
IndexType rightMidIdx = addVertex((bottomRight + topRight)/2.f);
addQuad(bottomLeftIdx, leftMidIdx, middlePointIdx, botMidIdx);
addQuad(leftMidIdx, topLeftIdx, topMidIdx, middlePointIdx);
addQuad(middlePointIdx, topMidIdx, topRightIdx, rightMidIdx);
addQuad(botMidIdx, middlePointIdx, rightMidIdx, bottomRightIdx);
}
std::cout << "Diamond Square iterations: " << iterations << " resulted in " << mesh.getNumVertices() << " vertices, " << mesh.getNumIndices() / 4 << " quads" << std::endl;
generateVertexNormal(mesh);
updateTexCoordinates();
std::cout << "MinHeight: " << minHeight << " MaxHeight: " << maxHeight << std::endl;
}
void CodeGenerator::If() {
match("("); string res = Expr(); match(")");
match("{");
int ET = addQuad("J==", res, "1", itos(CurLabel + 2));
int EF = addQuad("J", "$", "$", "Unknow");
Block();
int OUT = addQuad("J", "$", "$", "Unknow");
QuadList[EF].name_res = itos(CurLabel);
match("}");
if(isNext("else")) {
match("else"); match("{");
Block();
match("}");
}
QuadList[OUT].name_res = itos(CurLabel);
}
void HEC_FromFaceList::copyFromVertexData(VertexData& vd) {
for(int i = 0; i < vd.getNumVertices(); ++i) {
addVertex(vd.getVertex(i));
}
for(int i = 0; i < vd.getNumQuads(); ++i) {
Quad& q = *vd.getQuadPtr(i);
addQuad(q.a, q.b, q.c, q.d);
}
}
void Galaxy::generate(int seed)
{
srand(seed);
int q = rand() % 3 +3; //random int betweeen 3 and 6
for(int i = 0; i < q; i++)
{
Quadrant x = Quadrant();
x.generate(seed + q);
addQuad(x);
}
}
// For循环
void CodeGenerator::For() {
match("(");
// init
Assign();
// cond
int Begin = CurLabel;
string res = Expr();
addQuad("J==", res, "1", itos(CurLabel + 2));
int OUT = addQuad("J", "$", "$", "Unknow");
match(";");
string inc = getToken().value;
string op = getToken().value;
match(")");
match("{");
Block();
// step
addQuad(op, inc, "$", inc);
addQuad("J", "$", "$", itos(Begin));
QuadList[OUT].name_res = itos(CurLabel);
match("}");
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void GeometryBuilder::addQuadByVertices(const Vec3f& v0, const Vec3f& v1, const Vec3f& v2, const Vec3f& v3)
{
Vec3fArray verts;
verts.resize(4);
verts[0] = v0;
verts[1] = v1;
verts[2] = v2;
verts[3] = v3;
uint firstVertexIdx = addVertices(verts);
addQuad(firstVertexIdx, firstVertexIdx + 1, firstVertexIdx + 2, firstVertexIdx + 3);
}
Ogre::ManualObject* ProceduralShape::createCube(
Ogre::SceneManager* i_pSceneMngr,
Ogre::SceneNode* i_pParent,
const Ogre::String& i_name,
float i_size)
{
// create ManualObject
Ogre::ManualObject* manual = i_pSceneMngr->createManualObject(i_name);
// define start and end point
float &s = i_size;
std::vector<Ogre::Vector3> p{
Ogre::Vector3(s, -s, -s),
Ogre::Vector3(s, s, -s),
Ogre::Vector3(-s, s, -s),
Ogre::Vector3(-s, -s, -s),
Ogre::Vector3(s, -s, s),
Ogre::Vector3(s, s, s),
Ogre::Vector3(-s, s, s),
Ogre::Vector3(-s, -s, s)
};
std::vector<std::vector<int>> q{
{ 0,1,2,3 },
{ 1,5,6,2 },
{ 2,6,7,3 },
{ 3,7,4,0 },
{ 0,4,5,1 },
{ 4,7,6,5 }
};
std::vector<Ogre::Vector3> n{
Ogre::Vector3(0.f, 0.f, -1.f),
Ogre::Vector3(0.f, 1.f, 0.f),
Ogre::Vector3(-1.f, 0.f, 0.f),
Ogre::Vector3(0.f, -1.f, 0.f),
Ogre::Vector3(1.f, 0.f, 0.f),
Ogre::Vector3(0.f, 0.f, 1.f),
};
for (size_t i = 0; i < q.size(); ++i)
{
std::vector<Ogre::Vector3> clockwiseQuad{
p[q[i][0]], p[q[i][1]], p[q[i][2]], p[q[i][3]] };
addQuad(clockwiseQuad, n[i], 10, 10, Ogre::String("BeanOfLight/Avatar"), *manual);
}
i_pParent->attachObject(manual);
return manual;
}
//--------------------------------------------------------------------------------------------------
/// Add a quad strip
///
/// Vertex ordering for quad strips:
/// <PRE>
/// v0 v2 v4 v6 Resulting quads:
/// *-----*-----*-----* q1: v0, v1, v3, v2
/// | | | | q2: v2, v3, v5, v4
/// | | | | q3: v4, v5, v7, v6
/// | | | |
/// *-----*-----*-----*
/// v1 v3 v5 v7 </PRE>
///
/// \remarks There must be at least 4 entries in the \a indices array, and the total number of
/// entries must be a multiple of 2.
//--------------------------------------------------------------------------------------------------
void GeometryBuilder::addQuadStrip(const UIntArray& indices)
{
size_t numIndices = indices.size();
CVF_ASSERT(numIndices >= 4);
CVF_ASSERT(numIndices % 2 == 0);
size_t numQuads = (numIndices - 2)/2;
CVF_ASSERT(numQuads >= 1);
size_t i;
for (i = 0; i < numQuads; i++)
{
addQuad(indices[2*i], indices[2*i + 1], indices[2*i + 3], indices[2*i + 2]);
}
}
// 函数块
void CodeGenerator::Block() {
while(!isNext("}")) {
CodeToken T = getToken();
string value = T.value;
if(value == "if") {
If();
} else if(value == "while") {
While();
} else if(value == "for") {
For();
} else if(value == "read") {
match("("); addQuad("read", getToken().value, "$", "$"); match(")"); match(";");
} else if(value == "write") {
match("("); addQuad("write", getToken().value, "$", "$"); match(")"); match(";");
} else if(value == "return") {
addQuad("return", itos(getToken().num), "$", "$"); match(";");
} else if(CodeToString(T) == "id") {
CurToken--;
Assign();
} else {
puts("函数块错误！！"); printf("in %d", CurLine()); exit(0);
}
}
}
//--------------------------------------------------------------------------------------------------
/// Add multiple quads
///
/// The default implementation utilizes addQuad() to add each quad separately.
///
/// \remarks There must be at least 4 entries in the \a indices array, and the total number of
/// entries must be a multiple of 4.
//--------------------------------------------------------------------------------------------------
void GeometryBuilder::addQuads(const UIntArray& indices)
{
size_t numIndices = indices.size();
CVF_ASSERT(numIndices >= 4);
CVF_ASSERT(numIndices % 4 == 0);
size_t numQuads = numIndices/4;
CVF_ASSERT(numQuads >= 1);
CVF_ASSERT(4*numQuads == numIndices);
size_t i;
for (i = 0; i < numQuads; i++)
{
addQuad(indices[4*i], indices[4*i + 1], indices[4*i + 2], indices[4*i + 3]);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void GeometryBuilder::addQuads(const IntArray& indices)
{
size_t numIndices = indices.size();
CVF_ASSERT(numIndices >= 4);
CVF_ASSERT(numIndices % 4 == 0);
size_t numQuads = numIndices/4;
CVF_ASSERT(numQuads >= 1);
CVF_ASSERT(4*numQuads == numIndices);
size_t i;
for (i = 0; i < numQuads; i++)
{
CVF_ASSERT(indices[4*i] >= 0 && indices[4*i + 1] && indices[4*i + 2] && indices[4*i + 3]);
addQuad(static_cast<uint>(indices[4*i]), static_cast<uint>(indices[4*i + 1]), static_cast<uint>(indices[4*i + 2]), static_cast<uint>(indices[4*i + 3]));
}
}
void Font::buildTextGeometry(const char * str, Vector2 const& offset, Geometry * geom, Color const& textColor)
{
if (!texture)
return;
Vector2 pos = offset;
for (; *str; ++str)
{
int character = *str - 32;
if (character >= 0 && character < 96)
{
Glyph & glyph = glyphs[character];
addQuad(geom, glyph.topLeft + pos, glyph.bottomRight + pos, glyph.uvTopLeft, glyph.uvBottomRight, textColor);
pos.x += glyph.advance;
}
}
}
void CubeRenderer::begin(const Vector3& directionalLightPosition)
{
m_started = true;
m_dmaChain.addSrcCntTag(0, VIF_FLUSH());
m_dmaChain.endPacket();
//Vu1::instance()->clearCache();
// Make sure that everything is finished
Vu1::instance()->clearCache();
#ifndef PS2_EMU
m_started = Vu1::instance()->getProgram(m_dmaChain, Vu1::CubeRenderer,
&CubeRendererVu1_CodeStart,
&CubeRendererVu1_CodeEnd);
#endif
m_dmaChain.addSrcCntTag(0);
m_dmaChain.add32(VIF_BASE(100));
m_dmaChain.add32(VIF_OFFSET(600));
m_dmaChain.add32(VIF_STCYCL(1, 1));
m_dmaChain.add32(VIF_MSCAL(m_started));
m_dmaChain.endPacket();
// Add cubedata
// TODO: Use a refchain here.
m_dmaChain.addSrcCntTag(VIF_STCYCL(1, 1), VIF_UNPACK(zenic::ps2::vif::V4_32, 1, 22));
m_dmaChain.addFloat(directionalLightPosition.x);
m_dmaChain.addFloat(directionalLightPosition.y);
m_dmaChain.addFloat(directionalLightPosition.z);
m_dmaChain.addFloat(1.0f);
m_dmaChain.endPacket();
m_dmaChain.addSrcCntTag(VIF_STCYCL(1, 1), VIF_UNPACK(zenic::ps2::vif::V4_32, 24, 23));
addQuad(s_cubeCoords[1], s_cubeCoords[0], s_cubeCoords[3], s_cubeCoords[2]);
addQuad(s_cubeCoords[4], s_cubeCoords[5], s_cubeCoords[6], s_cubeCoords[7]);
addQuad(s_cubeCoords[0], s_cubeCoords[1], s_cubeCoords[5], s_cubeCoords[4]);
addQuad(s_cubeCoords[7], s_cubeCoords[6], s_cubeCoords[2], s_cubeCoords[3]);
addQuad(s_cubeCoords[5], s_cubeCoords[1], s_cubeCoords[2], s_cubeCoords[6]);
addQuad(s_cubeCoords[0], s_cubeCoords[4], s_cubeCoords[7], s_cubeCoords[3]);
m_dmaChain.endPacket();
}
void VirtualFont::addCluster(const Cluster &cluster, const Vec3f &position)
{
for (auto &shape : cluster.shapes)
{
Vec2f p = properties.useMipmap ? position.xy() : Vec2f(snap(position.x), snap(position.y));
Quad quad;
auto glyph = cluster.font->fillQuad(quad, shape, p, sizeRatio);
if (glyph)
{
if (!hasClip || clipQuad(quad, glyph->texture))
{
auto batch = batchMap->getBatch(glyph->texture);
batch->addQuad(quad, position.z);
incrementSequence(batch);
}
}
}
}
BEGIN_JLIB_GRAPHICS_SHADER_NAMESPACE
postProcess::postProcess( entity::entityG *p, string fS ) : triangleCloud( p ), surfaceShader( fS, POSTPROCESSVERTEXSHADER )/*,
_colour( colName ), _depth( depName )*/
{
setTriangleArraySize( 2 );
setPointArraySize( 4 );
addQuad( addPoint( math::triple( 1, 1, 0 ), math::triple( 0, 0, 0 ), math::vector2( 1, 1 ), math::colour4::WHITE ),
addPoint( math::triple( 1, -1, 0 ), math::triple( 0, 0, 0 ), math::vector2( 1, -1 ), math::colour4::WHITE ),
addPoint( math::triple( -1, -1, 0 ), math::triple( 0, 0, 0 ), math::vector2( -1, -1 ), math::colour4::WHITE ),
addPoint( math::triple( -1, 1, 0 ), math::triple( 0, 0, 0 ), math::vector2( -1, 1 ), math::colour4::WHITE ) );
triangleCloud::setShader( *this );
//triangleCloud::shaderVariableSet().add( _colour );
//triangleCloud::shaderVariableSet().add( _depth );
triangleCloud::shaderVariableSet().setShader( *this );
triangleCloud::setUseShaderVariableSet( );
}
void Model::addPlane(const glm::vec3 &a, const glm::vec3 &b, const glm::vec3 &c, const glm::vec4 &texRect) {
glm::vec3 normal = normalize(cross(c - b, a - b));
glm::vec3 d = a + c - b;
glm::vec2 t0(texRect.x, texRect.y);
glm::vec2 t1(texRect.x + texRect.z, texRect.y + texRect.w);
switch (mPrimitive) {
case GLTriangles: {
reserveIndices(6);
size_t n = mVertices.size();
addQuad(n+0, n+1, n+2, n+3);
reserveVertices(4);
addVertex(Vertex(glm::vec2(t1.x,t0.y), normal, c));
addVertex(Vertex(glm::vec2(t1.x,t1.y), normal, d));
addVertex(Vertex(glm::vec2(t0.x,t1.y), normal, a));
addVertex(Vertex(glm::vec2(t0.x,t0.y), normal, b));
break;
}
}
}
//--------------------------------------------------------------------------------------------------
/// Add one face
///
/// The type of primitive added will be determined from the number of indices passed in \a indices
///
/// \remarks Currently, points and lines are not supported. Faces with more than 4 indices will
/// be triangulated using fanning
//--------------------------------------------------------------------------------------------------
void GeometryBuilder::addFace(const UIntArray& indices)
{
size_t numIndices = indices.size();
CVF_ASSERT(numIndices >= 3);
if (numIndices == 3)
{
addTriangle(indices[0], indices[1], indices[2]);
}
else if (numIndices == 4)
{
addQuad(indices[0], indices[1], indices[2], indices[3]);
}
else
{
size_t numTriangles = numIndices - 2;
size_t i;
for (i = 0; i < numTriangles; i++)
{
addTriangle(indices[0], indices[i + 1], indices[i + 2]);
}
}
}
CardBuilder::CardBuilder(const CardSpecifications& specifications)
: _specifications(specifications)
{
float w = _specifications.width() / 2.0f;
float h = _specifications.height() / 2.0f;
float cr = _specifications.cornerRadius();
int cd = _specifications.cornerDetail();
int vertexCount = 8 * cd + 16;
_vertices.reserve(vertexCount * 3);
_textureCoordinates.reserve(vertexCount * 2);
// upper left corner
addVertex(cr - w, h - cr, cr / _specifications.width(),
cr / _specifications.height());
addVertex(-w, h - cr, 0.0f, cr / _specifications.height());
float theta = 90.0f / float(cd);
for (int i = 1; i < cd; ++i)
{
float radians = float(i) * theta * (3.1415926535898f / 180.0f);
float dx = cr * cos(radians);
float dy = cr * sin(radians);
addVertex(cr - w - dx, h - cr + dy,
(cr - dx) / _specifications.width(),
(cr - dy) / _specifications.height());
}
addVertex(cr - w, h, cr / _specifications.width(), 0.0f);
// upper right corner
addVertex(-_vertices[0], _vertices[1],
1.0f - _textureCoordinates[0],
_textureCoordinates[1]);
int previousVertex = _vertices.size() - 6;
int previousTexture = _textureCoordinates.size() - 4;
int mirrorVertex = _vertices.size() - 12;
int mirrorTexture = _textureCoordinates.size() - 8;
for (int i = 0; i <= cd; ++i)
{
addVertex(-_vertices[mirrorVertex], _vertices[mirrorVertex + 1],
1.0f - _textureCoordinates[mirrorTexture],
_textureCoordinates[mirrorTexture + 1]);
mirrorVertex -= 6;
mirrorTexture -= 4;
}
// lower right corner
addVertex(_vertices[previousVertex], -_vertices[previousVertex + 1],
_textureCoordinates[previousTexture],
1.0f - _textureCoordinates[previousTexture + 1]);
previousVertex = _vertices.size() - 6;
previousTexture = _textureCoordinates.size() - 4;
mirrorVertex = _vertices.size() - 12;
mirrorTexture = _textureCoordinates.size() - 8;
for (int i = 0; i <= cd; ++i)
{
addVertex(_vertices[mirrorVertex], -_vertices[mirrorVertex + 1],
_textureCoordinates[mirrorTexture],
1.0f - _textureCoordinates[mirrorTexture + 1]);
mirrorVertex -= 6;
mirrorTexture -= 4;
}
// lower left corner
addVertex(-_vertices[previousVertex], _vertices[previousVertex + 1],
1.0f - _textureCoordinates[previousTexture],
_textureCoordinates[previousTexture + 1]);
previousVertex = _vertices.size() - 6;
previousTexture = _textureCoordinates.size() - 4;
mirrorVertex = _vertices.size() - 12;
mirrorTexture = _textureCoordinates.size() - 8;
for (int i = 0; i <= cd; ++i)
{
addVertex(-_vertices[mirrorVertex], _vertices[mirrorVertex + 1],
1.0f - _textureCoordinates[mirrorTexture],
_textureCoordinates[mirrorTexture + 1]);
mirrorVertex -= 6;
mirrorTexture -= 4;
}
// texture correction
for (int i = 0; i < vertexCount; ++i)
{
int index = i * 2 + 1;
_textureCoordinates[index] = 1.0f - _textureCoordinates[index];
}
// index creation
int triangleCount = 16 * cd + 28;
int middleTriangleCount = 8 * cd + 8;
int topTriangleCount = (triangleCount - middleTriangleCount) / 2;
_topIndices.reserve(topTriangleCount * 3);
_middleIndices.reserve(middleTriangleCount * 3);
_bottomIndices.reserve(topTriangleCount * 3);
GLushort corners[5];
int cornerSize = 2 * cd + 4;
for (int i = 0; i < 5; ++i)
corners[i] = cornerSize * i;
for (int i = 0; i < 4; ++i)
{
int i4 = (i + 1) % 4;
addQuads(corners[i], corners[i + 1] - 2, corners[i4] + 2, corners[i4]);
addQuad(corners[i + 1] - 2, corners[i + 1] - 1, corners[i4] + 3,
corners[i4] + 2);
for (int j = 0; j < cd; ++j)
{
int k = 2 * (j + 1);
addTriangles(corners[i], corners[i] + k, corners[i] + k + 2);
addQuad(corners[i] + k, corners[i] + k + 1, corners[i] + k + 3,
corners[i] + k + 2);
}
}
addQuads(corners[0], corners[1], corners[2], corners[3]);
}
// 表达式
string CodeGenerator::Expr() {
if(Tokens[CurToken].Type == String) {
string res = newTemp("string");
newConst("string", Tokens[CurToken].value);
CurToken++;
return res;
}
int L = CurToken, R;
int cntBrac = 0;
for(R = L; R < Tokens.size(); R++) {
string val = Tokens[R].value;
if(val == ";" || val == ")" && cntBrac == 0) break;
if(val == "(") cntBrac++;
if(val == ")") cntBrac--;
}
CurToken = R;
map<string, int> Prior;
Prior["("] = 10, Prior[")"] = 0;
Prior["!"] = 1;
Prior["%"] = Prior["*"] = Prior["/"] = 2;
Prior["+"] = Prior["-"] = 3;
Prior[">="] = Prior["<="] = Prior[">"] = Prior["<"] = 4;
Prior["=="] = Prior["!="] = 5;
Prior["&&"] = 6;
Prior["||"] = 7;
stack<string> Num, Op;
for(int i = L; i < R; i++) {
string Type = CodeToString(Tokens[i]);
string val = Tokens[i].value;
if(Type == "number" || Type == "id") {
if(Type == "id") Num.push(val);
else Num.push(newConst((string)(Tokens[i].Type == Integer ? "int" : "double"), itos(Tokens[i].num)));
} else {
if(val == "(") {
Op.push(val);
} else if(val == ")") {
while(Op.top() != "(") {
string op = Op.top(); Op.pop();
string y = Num.top(); Num.pop();
if(op == "!") {
string res = newTemp(VarTable[y].Type); Num.push(res);
addQuad(op, y, "$", res);
continue;
}
string x = Num.top(); Num.pop();
string res = newTemp(VarTable[x].Type); Num.push(res);
if(op == ">=" || op == "<=" || op == "==" || op == "!=" || op == ">" || op == "<") {
addQuad("J" + op, x, y, itos(CurLabel + 3));
addQuad("=", res, "0", res);
addQuad("J", "$", "$", itos(CurLabel + 2));
addQuad("=", res, "1", res);
} else {
addQuad(op, x, y, res);
}
}
Op.pop();
} else {
while(!Op.empty() && Prior[val] >= Prior[Op.top()]) {
string op = Op.top(); Op.pop();
string y = Num.top(); Num.pop();
if(op == "!") {
string res = newTemp(VarTable[y].Type); Num.push(res);
addQuad(op, y, "$", res);
continue;
}
string x = Num.top(); Num.pop();
string res = newTemp(VarTable[x].Type); Num.push(res);
if(op == ">=" || op == "<=" || op == "==" || op == "!=" || op == ">" || op == "<") {
addQuad("J" + op, x, y, itos(CurLabel + 3));
addQuad("=", res, "0", res);
addQuad("J", "$", "$", itos(CurLabel + 2));
addQuad("=", res, "1", res);
} else {
addQuad(op, x, y, res);
}
}
Op.push(val);
}
}
}
while(!Op.empty()) {
string op = Op.top(); Op.pop();
string y = Num.top(); Num.pop();
if(op == "!") {
string res = newTemp(VarTable[y].Type); Num.push(res);
addQuad(op, y, "$", res);
continue;
}
string x = Num.top(); Num.pop();
string res = newTemp(VarTable[x].Type); Num.push(res);
if(op == ">=" || op == "<=" || op == "==" || op == "!=" || op == ">" || op == "<") {
addQuad("J" + op, x, y, itos(CurLabel + 3));
addQuad("=", res, "0", res);
addQuad("J", "$", "$", itos(CurLabel + 2));
addQuad("=", res, "1", res);
} else {
addQuad(op, x, y, res);
}
}
return Num.top();
}
void CodeGenerator::Assign() {
string arg1 = getToken().value; match("=");
string arg2 = Expr();
addQuad("=", arg1, arg2, arg1);
match(";");
}
size_t VertexData::addQuadAndIndices(int a, int b, int c, int d) {
addQuadIndices(a,b,c,d);
return addQuad(a,b,c,d);
}
Ogre::ManualObject* ProceduralShape::createAvatar(
Ogre::SceneManager* i_pSceneMngr,
Ogre::SceneNode* i_pParent,
const Ogre::String& i_name,
float i_height,
float i_width,
float i_depth,
float i_sameHeight,
float i_seamWidth,
float i_resolution,
const Ogre::String& i_material)
{
// create ManualObject
Ogre::ManualObject* manual = i_pSceneMngr->createManualObject(i_name);
// define start and end point
const float &h = i_height / 2.f;
const float &w = i_width / 2.f;
const float &d = i_depth / 2.f;
const float &sh = i_sameHeight;
const float &sw = i_seamWidth / 2.f;
std::vector<Ogre::Vector3> p{
Ogre::Vector3(d, -w, -h), Ogre::Vector3(d, -sw, -h), Ogre::Vector3(-d, -sw, -h), Ogre::Vector3(-d, -w, -h), // 0, 1, 2, 3
Ogre::Vector3(d, sw, -h), Ogre::Vector3(d, w, -h), Ogre::Vector3(-d, w, -h), Ogre::Vector3(-d, sw, -h), // 4, 5, 6, 7
Ogre::Vector3(d, -w, -h + sh), Ogre::Vector3(d, -sw, -h + sh), Ogre::Vector3(d, sw, -h + sh), Ogre::Vector3(d, w, -h + sh), // 8, 9, 10, 11
Ogre::Vector3(-d, w, -h + sh), Ogre::Vector3(-d, sw, -h + sh), Ogre::Vector3(-d, -sw, -h + sh), Ogre::Vector3(-d, -w, -h + sh), // 12, 13, 14, 15
Ogre::Vector3(d, -w, h), Ogre::Vector3(d, w, h), Ogre::Vector3(-d, w, h), Ogre::Vector3(-d, -w, h), // 16, 17, 18, 19
};
std::vector<std::vector<std::vector<int>>> q{
{ { 0, 1, 2, 3 }, { 9, 10, 13, 14 }, { 4, 5, 6, 7 } },
{ { 5, 17, 18, 6 }, { 1, 9, 14, 2 } },
{ { 17, 16, 19, 18 } },
{ { 19, 16, 0, 3 }, { 10, 4, 7, 13 } },
{ { 0, 8, 9, 1 }, { 4, 10 , 11, 5}, { 8, 16, 17, 11 } },
{ { 2 ,14 ,15 ,3 }, {6, 12, 13, 7}, {12, 18, 19, 15 } }
};
std::vector<Ogre::Vector3> n{
Ogre::Vector3(0.f, 0.f, 0.f),
Ogre::Vector3(0.f, 1.f, 0.f),
Ogre::Vector3(0.f, 0.f, 1.f),
Ogre::Vector3(0.f, -1.f, 0.f),
Ogre::Vector3(1.f, 0.f, 0.f),
Ogre::Vector3(-1.f, 0.f, 0.f)
};
for (size_t f = 0; f < q.size(); f++) // for each face
{
for (size_t iq = 0; iq < q[f].size(); iq++) // for each quad
{
std::vector<Ogre::Vector3> clockwiseQuad{
p[q[f][iq][0]], p[q[f][iq][1]], p[q[f][iq][2]], p[q[f][iq][3]] };
size_t nCols = (size_t)ceil((clockwiseQuad[0] - clockwiseQuad[1]).length() / i_resolution);
size_t nRows = (size_t)ceil((clockwiseQuad[0] - clockwiseQuad[3]).length() / i_resolution);
addQuad(clockwiseQuad, n[f], nRows, nCols, i_material, *manual);
}
}
i_pParent->attachObject(manual);
return manual;
}
void Mesh::addFace(VertexList<Vertex>* vertexList, const Face& face) {
if (face.type == Quad)
addQuad(vertexList, face);
else
addTri(vertexList, face);
}
bool Magic3D::TextData::update(Object* object)
{
if (object)
{
}
Renderer* renderer = Renderer::getInstance();
Font* font = getFont();
std::vector<float> lines;
if (!font)
{
return false;
}
float fsize = (textSize / 512.0f) / font->getLineHeightInPixels();
float lineHeight = fsize * (font->getLineHeightInPixels() + 2.0f);
int quadCount = getVerticesCount() / 4;
if (quadCount < (int)text.size() - lastReturns)
{
lastReturns = 0;
size_t tsize = text.size();
for (size_t i = 0; i < tsize; i++)
{
if (text.at(i) == '\n')
{
lastReturns++;
continue;
}
else if (renderer->hasMapBuffer() || ((int)i >= quadCount))
{
addQuad(0.0f, 0.0f, 1.0f, 1.0f, eAXIS_Z, false);
}
}
createVbo();
quadCount = getVerticesCount() / 4;
}
width = 0.0f;
height = lineHeight;
if (getVerticesCount() > 0)
{
int quad = -1;
float startX = 0.0f;
float startY = 0.0f;
float* buffer = mapBuffer();
int lastIndex = 0;
size_t tsize = text.size();
for (size_t i = 0; i < tsize; i++)
{
int index = text.at(i);
if (index < 0)
{
index = 256 + index;
}
FontChar* fchar = font->getChar(index);
if (text.at(i) == '\n')
{
lines.push_back(startX);
if (width < startX)
{
width = startX;
}
startX = 0.0f;
if (invert)
{
startY -= lineHeight;
}
else
{
startY += lineHeight;
}
height += lineHeight;
continue;
}
else
{
quad++;
}
float texX = fchar->x;
float texY = 1.0f - fchar->y;
float texW = fchar->width;
float texH = fchar->height;
float cwidth = fchar->width * font->getTextureWidth() * fsize;
float cheight = fchar->height * font->getTextureHeight() * fsize;
float coffsetX = fchar->offsetX * font->getTextureWidth() * fsize;
float coffsetY = fchar->offsetY * font->getTextureHeight() * fsize;
float cadvanceX = fchar->advanceX * font->getTextureWidth() * fsize;
float ckernel = 0.0f;
std::map<int, float>::const_iterator k = fchar->kernel.find(lastIndex);
if (k != fchar->kernel.end())
{
ckernel = (*k).second * fsize;
}
setQuad(buffer, quad, startX + coffsetX + ckernel, startY + coffsetY * 0.5f, cwidth, cheight);
if (invert)
{
setQuadTexture(buffer, quad, texX, texY - texH, texW, -texH);
}
else
{
setQuadTexture(buffer, quad, texX, texY, texW, texH);
}
startX += cadvanceX;
lastIndex = index;
}
quad++;
for (int i = quad; i < quadCount; i++)
{
setQuad(buffer, i, startX, startY, 0.0f, 0.0f);
}
lines.push_back(startX);
if (width < startX)
{
width = startX;
}
width += (2.0f * fsize);
quad = 0;
int line = 0;
tsize = text.size();
for (size_t i = 0; i < tsize; i++)
{
if (text.at(i) != '\n')
{
float w = width * -0.5f;
float diff = line < (int)lines.size() ? lines.at(line) : width;
switch (textAlignment)
{
case eHORIZONTAL_ALIGN_CENTER: w += (width - diff) * 0.5f; break;
case eHORIZONTAL_ALIGN_RIGHT: w += (width - diff); break;
default: break;
}
if (invert)
{
moveQuad(buffer, quad, w, height * 0.5f - lineHeight, 0.0f);
}
else
{
moveQuad(buffer, quad, w, height * -0.5f, 0.0f);
}
quad++;
}
else
{
line++;
}
}
unmapBuffer();
}
changed = false;
box.corners[0] = Vector3(-width * 0.5f, -height * 0.5f, 0.0f);
box.corners[1] = Vector3(width * 0.5f, height * 0.5f, 0.0f);
return true;
}
void main()
{
//Check grid coordinate in range
ivec2 gridCoord = ivec2( gl_FragCoord.xy );
if (gridCoord.x < 0 || gridCoord.x >= gridSize.x ||
gridCoord.y < 0 || gridCoord.y >= gridSize.y)
{ discard; return; }
bool found1=false, found2=false, inside=false;
float yy1=0.0, yy2=0.0, xx1=0.0, xx2=0.0;
//Get object pointer and object grid info
int *ptrObj = ptrObjects + objectId * NODE_SIZE_OBJINFO;
ivec2 objGridOrigin = ivec2( ptrObj[0], ptrObj[1] );
ivec2 objGridSize = ivec2( ptrObj[2], ptrObj[3] );
int objGridOffset = ptrObj[4];
//Get object grid pointer
coherent int *ptrObjGrid = ptrGrid + objGridOffset;
//Check object grid coordinate in range
ivec2 objGridCoord = gridCoord - objGridOrigin;
if (objGridCoord.x < 0 || objGridCoord.x >= objGridSize.x ||
objGridCoord.y < 0 || objGridCoord.y >= objGridSize.y)
{ discard; return; }
//Get object grid cell pointer
coherent int* ptrObjCell = ptrObjGrid
+ (objGridCoord.y * objGridSize.x + objGridCoord.x) * NUM_OBJCELL_COUNTERS;
//Find cell origin
vec2 cmin = gridOrigin + gridCoord * cellSize;
//Transform quad coords into cell space
vec2 q0 = (quad0 - cmin) / cellSize;
vec2 q1 = (quad1 - cmin) / cellSize;
vec2 q2 = (quad2 - cmin) / cellSize;
//Check if quad intersects bottom edge
quadIntersectionY( q0, q1, q2, 1.0, 0.0, 1.0, found1, found2, xx1, xx2 );
if (found1 != found2)
{
//Walk all the cells to the left
for (int x = (int)objGridCoord.x - 1; x >= 0; --x)
{
//Get object grid cell pointer
coherent int *ptrObjCellAux = ptrObjGrid
+ (objGridCoord.y * objGridSize.x + x) * NUM_OBJCELL_COUNTERS;
//Increase auxiliary vertical counter
atomicAdd( ptrObjCellAux + OBJCELL_COUNTER_AUX, 1 );
}
}
if (found1 || found2) inside = true;
//Check if quad intersects right edge
quadIntersectionY( q0.yx, q1.yx, q2.yx, 1.0, 0.0, 1.0, found1, found2, yy1, yy2 );
if (found1)
{
//Add line spanning from intersection point to upper-right corner
addLine( vec2( 1.0, yy1 ), vec2( 1.0, -0.25 ), ptrObjCell );
inside = true;
}
if (found2)
{
//Add line spanning from intersection point to upper-right corner
addLine( vec2( 1.0, yy2 ), vec2( 1.0, -0.25 ), ptrObjCell );
inside = true;
}
//Check for additional conditions if these two failed
if (!inside)
{
//Check if start point inside
if (q0.x >= 0.0 && q0.x <= 1.0 && q0.y >= 0.0 && q0.y <= 1.0)
inside = true;
else
{
//Check if end point inside
if (q2.x >= 0.0 && q2.x <= 1.0 && q2.y >= 0.0 && q2.y <= 1.0)
inside = true;
else
{
//Check if quad intersects top edge
quadIntersectionY( q0, q1, q2, 0.0, 0.0, 1.0, found1, found2, xx1, xx2 );
if (found1 || found2) inside = true;
else
{
//Check if quad intersects left edge
quadIntersectionY( q0.yx, q1.yx, q2.yx, 0.0, 0.0, 1.0, found1, found2, yy1, yy2 );
if (found1 || found2) inside = true;
}
}
}
}
if (inside)
{
//Add quad data to stream
addQuad( q0,q1,q2, ptrObjCell );
}
discard;
}
void QuadList::addQuads(const std::vector<Quad> &quads, int x, int y)
{
for (unsigned int i = 0; i < quads.size(); i++)
addQuad(quads[i], x, y);
}
