size_t size;

const char *resData = (const char *)LoadResource(res, &size);

// Sigh, here we go... We want to deploy to four platforms: Linux, Windows, OS X, mobile+web.

// These platforms are basically disjunctive in the OpenGL versions and profiles that they

// support: mobile+web support GLES2, Windows can only be guaranteed to support GL1 without

// vendor's drivers installed but supports D3D9+ natively, Linux supports GL3.2+ and/or

// GLES2+ depending on whether we run on X11 or Wayland, and OS X supports either a legacy

// profile or a GL3.2 core profile or (on 10.9+) a GL4.1 core profile.

// The platforms barely have a common subset of features:

// * Linux Mesa/NVidia accept basically everything thrown at it;

// * mobile+web and Windows (D3D9 through ANGLE) are strictly GLES2/GLSL1.0;

// * OS X legacy compatibility profile has GLSL1.2 only shaders, and GL3.2 core profile

// that has GLSL1.0 shaders compatible with GLES2 makes mandatory the use of vertex array

// objects, which cannot be used in GLES2 at all; similarly GL3.2 core has GL_RED but not

// GL_ALPHA whereas GLES2 has GL_ALPHA but not GL_RED.

// While we're at it, let's remember that GLES2 has *only* glDepthRangef, GL3.2 has *only*

// glDepthRange, and GL4.1+ has both glDepthRangef and glDepthRange. Also, that GLSL1.0

// makes `precision highp float;` mandatory in fragment shaders, and GLSL1.2 removes

// the `precision` keyword entirely, because that's clearly how minor versions work.

// Christ, what a trash fire.

std::string src(resData, size);

#ifdef __APPLE__

src = "#version 120\n" + src;

#else

src = "#version 100\nprecision highp float;\n" + src;

#endif

GLuint shader = glCreateShader(type);

ssassert(shader != 0, "glCreateShader failed");

const GLint glSize[] = { (int)src.length() };

const GLchar* glSource[] = { src.c_str() };

glShaderSource(shader, 1, glSource, glSize);

glCompileShader(shader);

GLint infoLen;

glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);

if(infoLen > 1) {

std::string infoStr(infoLen, '\0');

glGetShaderInfoLog(shader, infoLen, NULL, &infoStr[0]);

dbp(infoStr.c_str());

}

GLint compiled;

glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);

ssassert(compiled, "Cannot compile shader");

return shader;

const std::vector<std::pair<GLuint, std::string> > &locations) {

GLuint vert = CompileShader(vertexRes, GL_VERTEX_SHADER);

GLuint frag = CompileShader(fragmentRes, GL_FRAGMENT_SHADER);

program = glCreateProgram();

ssassert(program != 0, "glCreateProgram failed");

glAttachShader(program, vert);

glAttachShader(program, frag);

for(const auto &l : locations) {

glBindAttribLocation(program, l.first, l.second.c_str());

}

glLinkProgram(program);

GLint infoLen;

glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLen);

if(infoLen > 1) {

std::string infoStr(infoLen, '\0');

glGetProgramInfoLog(program, infoLen, NULL, &infoStr[0]);

dbp(infoStr.c_str());

}

GLint linked;

glGetProgramiv(program, GL_LINK_STATUS, &linked);

ssassert(linked, "Cannot link shader");

Enable();

float mf[16];

for(int i = 0; i < 16; i++) mf[i] = (float)md[i];

glUniformMatrix4fv(glGetUniformLocation(program, name), 1, false, mf);

lightShader.Init(

"shaders/mesh.vert", "shaders/mesh.frag",

{

{ ATTRIB_POS, "pos" },

{ ATTRIB_NOR, "nor" },

{ ATTRIB_COL, "col" },

}

);

fillShader.Init(

"shaders/mesh_fill.vert", "shaders/mesh_fill.frag",

{

{ ATTRIB_POS, "pos" },

}

);

fillShader.SetUniformTextureUnit("texture", 0);

selectedShader = &lightShader;

Handle handle;

glGenBuffers(1, &handle.vertexBuffer);

glBindBuffer(GL_ARRAY_BUFFER, handle.vertexBuffer);

MeshVertex *vertices = new MeshVertex[m.l.n * 3];

for(int i = 0; i < m.l.n; i++) {

const STriangle &t = m.l.elem[i];

vertices[i * 3 + 0].pos = Vector3f::From(t.a);

vertices[i * 3 + 1].pos = Vector3f::From(t.b);

vertices[i * 3 + 2].pos = Vector3f::From(t.c);

if(t.an.EqualsExactly(Vector::From(0, 0, 0))) {

Vector3f normal = Vector3f::From(t.Normal());

vertices[i * 3 + 0].nor = normal;

vertices[i * 3 + 1].nor = normal;

vertices[i * 3 + 2].nor = normal;

} else {

vertices[i * 3 + 0].nor = Vector3f::From(t.an);

vertices[i * 3 + 1].nor = Vector3f::From(t.bn);

vertices[i * 3 + 2].nor = Vector3f::From(t.cn);

}

for(int j = 0; j < 3; j++) {

vertices[i * 3 + j].col = Vector4f::From(t.meta.color);

}

}

glBufferData(GL_ARRAY_BUFFER, m.l.n * 3 * sizeof(MeshVertex),

vertices, dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);

handle.size = m.l.n * 3;

delete []vertices;

return handle;

bool useColors, RgbaColor overrideColor) {

selectedShader->Enable();

glBindBuffer(GL_ARRAY_BUFFER, handle.vertexBuffer);

glEnableVertexAttribArray(ATTRIB_POS);

glVertexAttribPointer(ATTRIB_POS, 3, GL_FLOAT, GL_FALSE, sizeof(MeshVertex),

(void *)offsetof(MeshVertex, pos));

if(selectedShader == &lightShader) {

glEnableVertexAttribArray(ATTRIB_NOR);

glVertexAttribPointer(ATTRIB_NOR, 3, GL_FLOAT, GL_FALSE, sizeof(MeshVertex),

(void *)offsetof(MeshVertex, nor));

if(useColors) {

glEnableVertexAttribArray(ATTRIB_COL);

glVertexAttribPointer(ATTRIB_COL, 4, GL_FLOAT, GL_FALSE, sizeof(MeshVertex),

(void *)offsetof(MeshVertex, col));

} else {

glVertexAttrib4f(ATTRIB_COL, overrideColor.redF(), overrideColor.greenF(), overrideColor.blueF(), overrideColor.alphaF());

}

}

glDrawArrays(GL_TRIANGLES, 0, handle.size);

glDisableVertexAttribArray(ATTRIB_POS);

if(selectedShader == &lightShader) {

glDisableVertexAttribArray(ATTRIB_NOR);

if(useColors) glDisableVertexAttribArray(ATTRIB_COL);

}

glBindBuffer(GL_ARRAY_BUFFER, 0);

selectedShader->Disable();

Handle handle = Add(mesh, /*dynamic=*/true);

Draw(handle, useColors, overrideColor);

Remove(handle);

Vector dir0 = lighting.lightDirection[0];

Vector dir1 = lighting.lightDirection[1];

dir0.z = -dir0.z;

dir1.z = -dir1.z;

lightShader.SetUniformVector("lightDir0", dir0);

lightShader.SetUniformFloat("lightInt0", (float)lighting.lightIntensity[0]);

lightShader.SetUniformVector("lightDir1", dir1);

lightShader.SetUniformFloat("lightInt1", (float)lighting.lightIntensity[1]);

lightShader.SetUniformFloat("ambient", (float)lighting.ambientIntensity);

selectedShader = &lightShader;

v = max(0.0, min(1.0, v));

double er = v;

double eg = Frac(255.0 * v);

double eb = Frac(65025.0 * v);

double ea = Frac(160581375.0 * v);

double r = er - eg / 255.0;

double g = eg - eb / 255.0;

double b = eb - ea / 255.0;

return RgbaColor::From((int)floor( r * 255.0 + 0.5),

(int)floor( g * 255.0 + 0.5),

(int)floor( b * 255.0 + 0.5),

(int)floor(ea * 255.0 + 0.5));

double patternLen = 0.0;

for(double s : pattern) {

patternLen += s;

}

GLuint texture;

glGenTextures(1, &texture);

glBindTexture(GL_TEXTURE_2D, texture);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

GLint size;

glGetIntegerv(GL_MAX_TEXTURE_SIZE, &size);

RgbaColor *textureData = new RgbaColor[size];

int mipCount = (int)log2(size) + 1;

for(int mip = 0; mip < mipCount; mip++) {

int dashI = 0;

double dashT = 0.0;

for(int i = 0; i < size; i++) {

if(pattern.size() == 0) {

textureData[i] = EncodeLengthAsFloat(0.0);

continue;

}

double t = (double)i / (double)(size - 1);

while(t - LENGTH_EPS > dashT + pattern[dashI] / patternLen) {

dashT += pattern[dashI] / patternLen;

dashI++;

}

double dashW = pattern[dashI] / patternLen;

if(dashI % 2 == 0) {

textureData[i] = EncodeLengthAsFloat(0.0);

} else {

double value;

if(t - dashT < pattern[dashI] / patternLen / 2.0) {

value = t - dashT;

} else {

value = dashT + dashW - t;

}

value = value * patternLen;

textureData[i] = EncodeLengthAsFloat(value);

}

}

glTexImage2D(GL_TEXTURE_2D, mip, GL_RGBA, size, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,

textureData);

size /= 2;

}

delete []textureData;

return texture;

for(uint32_t i = 0; i <= (uint32_t)StipplePattern::LAST; i++) {

patterns.push_back(Generate(StipplePatternDashes((StipplePattern)i)));

}

for(GLuint p : patterns) {

glDeleteTextures(1, &p);

}

if(pattern == StipplePattern::CONTINUOUS) {

return 1.0;

}

return StipplePatternLength(pattern);

atlas = a;

shader.Init(

"shaders/edge.vert", "shaders/edge.frag",

{

{ ATTRIB_POS, "pos" },

{ ATTRIB_LOC, "loc" },

{ ATTRIB_TAN, "tan" }

}

);

Handle handle;

glGenBuffers(1, &handle.vertexBuffer);

glGenBuffers(1, &handle.indexBuffer);

glBindBuffer(GL_ARRAY_BUFFER, handle.vertexBuffer);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, handle.indexBuffer);

EdgeVertex *vertices = new EdgeVertex[edges.l.n * 8];

uint32_t *indices = new uint32_t[edges.l.n * 6 * 3];

double phase = 0.0;

uint32_t curVertex = 0;

uint32_t curIndex = 0;

for(int i = 0; i < edges.l.n; i++) {

const SEdge &curr = edges.l.elem[i];

const SEdge &next = edges.l.elem[(i + 1) % edges.l.n];

// 3d positions

Vector3f a = Vector3f::From(curr.a);

Vector3f b = Vector3f::From(curr.b);

// tangent

Vector3f tan = Vector3f::From(curr.b.Minus(curr.a));

// length

double len = curr.b.Minus(curr.a).Magnitude();

// make line start cap

for(int j = 0; j < 2; j++) {

vertices[curVertex + j].pos = a;

vertices[curVertex + j].tan = tan;

}

vertices[curVertex + 0].loc = Vector3f::From(-1.0f, -1.0f, float(phase));

vertices[curVertex + 1].loc = Vector3f::From(-1.0f, +1.0f, float(phase));

indices[curIndex++] = curVertex + 0;

indices[curIndex++] = curVertex + 1;

indices[curIndex++] = curVertex + 2;

indices[curIndex++] = curVertex + 1;

indices[curIndex++] = curVertex + 2;

indices[curIndex++] = curVertex + 3;

curVertex += 2;

// make line body

vertices[curVertex + 0].pos = a;

vertices[curVertex + 1].pos = a;

vertices[curVertex + 2].pos = b;

vertices[curVertex + 3].pos = b;

for(int j = 0; j < 4; j++) {

vertices[curVertex + j].tan = tan;

}

vertices[curVertex + 0].loc = Vector3f::From( 0.0f, -1.0f, float(phase));

vertices[curVertex + 1].loc = Vector3f::From( 0.0f, +1.0f, float(phase));

vertices[curVertex + 2].loc = Vector3f::From( 0.0f, +1.0f, float(phase + len));

vertices[curVertex + 3].loc = Vector3f::From( 0.0f, -1.0f, float(phase + len));

indices[curIndex++] = curVertex + 0;

indices[curIndex++] = curVertex + 1;

indices[curIndex++] = curVertex + 2;

indices[curIndex++] = curVertex + 0;

indices[curIndex++] = curVertex + 2;

indices[curIndex++] = curVertex + 3;

curVertex += 4;

// make line end cap

for(int j = 0; j < 2; j++) {

vertices[curVertex + j].pos = b;

vertices[curVertex + j].tan = tan;

}

vertices[curVertex + 0].loc = Vector3f::From(+1.0, +1.0, float(phase + len));

vertices[curVertex + 1].loc = Vector3f::From(+1.0, -1.0, float(phase + len));

indices[curIndex++] = curVertex - 2;

indices[curIndex++] = curVertex - 1;

indices[curIndex++] = curVertex;

indices[curIndex++] = curVertex - 1;

indices[curIndex++] = curVertex;

indices[curIndex++] = curVertex + 1;

curVertex += 2;

// phase stitching

if(curr.a.EqualsExactly(next.a) ||

curr.a.EqualsExactly(next.b) ||

curr.b.EqualsExactly(next.a) ||

curr.b.EqualsExactly(next.b))

{

phase += len;

} else {

phase = 0.0;

}

}

handle.size = curIndex;

GLenum mode = dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW;

glBufferData(GL_ARRAY_BUFFER, curVertex * sizeof(EdgeVertex), vertices, mode);

glBufferData(GL_ELEMENT_ARRAY_BUFFER, curIndex * sizeof(uint32_t), indices, mode);

delete []vertices;

delete []indices;

return handle;

glActiveTexture(GL_TEXTURE1);

glBindTexture(GL_TEXTURE_2D, atlas->GetTexture(pattern));

shader.SetUniformTextureUnit("pattern", 1);

shader.SetUniformFloat("patternLen", (float)atlas->GetLength(pattern));

shader.Enable();

glBindBuffer(GL_ARRAY_BUFFER, handle.vertexBuffer);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, handle.indexBuffer);

glEnableVertexAttribArray(ATTRIB_POS);

glEnableVertexAttribArray(ATTRIB_LOC);

glEnableVertexAttribArray(ATTRIB_TAN);

glVertexAttribPointer(ATTRIB_POS, 3, GL_FLOAT, GL_FALSE, sizeof(EdgeVertex), (void *)offsetof(EdgeVertex, pos));

glVertexAttribPointer(ATTRIB_LOC, 3, GL_FLOAT, GL_FALSE, sizeof(EdgeVertex), (void *)offsetof(EdgeVertex, loc));

glVertexAttribPointer(ATTRIB_TAN, 3, GL_FLOAT, GL_FALSE, sizeof(EdgeVertex), (void *)offsetof(EdgeVertex, tan));

glDrawElements(GL_TRIANGLES, handle.size, GL_UNSIGNED_INT, NULL);

glDisableVertexAttribArray(ATTRIB_POS);

glDisableVertexAttribArray(ATTRIB_LOC);

glDisableVertexAttribArray(ATTRIB_TAN);

glBindBuffer(GL_ARRAY_BUFFER, 0);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

shader.Disable();

Handle handle = Add(edges, /*dynamic=*/true);

Draw(handle);

Remove(handle);

double unitScale = stroke.unit == Canvas::Unit::PX ? pixel : 1.0;

shader.SetUniformFloat("width", float(stroke.width * unitScale / 2.0));

shader.SetUniformColor("color", stroke.color);

shader.SetUniformFloat("patternScale", float(stroke.stippleScale * unitScale * 2.0));

shader.SetUniformFloat("pixel", (float)pixel);

pattern = stroke.stipplePattern;

atlas = a;

shader.Init(

"shaders/outline.vert", "shaders/edge.frag",

{

{ ATTRIB_POS, "pos" },

{ ATTRIB_LOC, "loc" },

{ ATTRIB_TAN, "tan" },

{ ATTRIB_NOL, "nol" },

{ ATTRIB_NOR, "nor" }

}

);

Handle handle;

glGenBuffers(1, &handle.vertexBuffer);

glGenBuffers(1, &handle.indexBuffer);

glBindBuffer(GL_ARRAY_BUFFER, handle.vertexBuffer);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, handle.indexBuffer);

OutlineVertex *vertices = new OutlineVertex[outlines.l.n * 8];

uint32_t *indices = new uint32_t[outlines.l.n * 6 * 3];

double phase = 0.0;

uint32_t curVertex = 0;

uint32_t curIndex = 0;

for(int i = 0; i < outlines.l.n; i++) {

const SOutline &curr = outlines.l.elem[i];

const SOutline &next = outlines.l.elem[(i + 1) % outlines.l.n];

// 3d positions

Vector3f a = Vector3f::From(curr.a);

Vector3f b = Vector3f::From(curr.b);

Vector3f nl = Vector3f::From(curr.nl);

Vector3f nr = Vector3f::From(curr.nr);

// tangent

Vector3f tan = Vector3f::From(curr.b.Minus(curr.a));

// length

double len = curr.b.Minus(curr.a).Magnitude();

float tag = (float)curr.tag;

// make line start cap

for(int j = 0; j < 2; j++) {

vertices[curVertex + j].pos = a;

vertices[curVertex + j].nol = nl;

vertices[curVertex + j].nor = nr;

vertices[curVertex + j].tan = tan;

}

vertices[curVertex + 0].loc = Vector4f::From(-1.0f, -1.0f, float(phase), (float)tag);

vertices[curVertex + 1].loc = Vector4f::From(-1.0f, +1.0f, float(phase), (float)tag);

indices[curIndex++] = curVertex;

indices[curIndex++] = curVertex + 1;

indices[curIndex++] = curVertex + 2;

indices[curIndex++] = curVertex + 1;

indices[curIndex++] = curVertex + 2;

indices[curIndex++] = curVertex + 3;

curVertex += 2;

// make line body

vertices[curVertex + 0].pos = a;

vertices[curVertex + 1].pos = a;

vertices[curVertex + 2].pos = b;

vertices[curVertex + 3].pos = b;

for(int j = 0; j < 4; j++) {

vertices[curVertex + j].nol = nl;

vertices[curVertex + j].nor = nr;

vertices[curVertex + j].tan = tan;

}

vertices[curVertex + 0].loc = Vector4f::From( 0.0f, -1.0f, float(phase), (float)tag);

vertices[curVertex + 1].loc = Vector4f::From( 0.0f, +1.0f, float(phase), (float)tag);

vertices[curVertex + 2].loc = Vector4f::From( 0.0f, +1.0f,

float(phase + len), (float)tag);

vertices[curVertex + 3].loc = Vector4f::From( 0.0f, -1.0f,

float(phase + len), (float)tag);

indices[curIndex++] = curVertex + 0;

indices[curIndex++] = curVertex + 1;

indices[curIndex++] = curVertex + 2;

indices[curIndex++] = curVertex + 0;

indices[curIndex++] = curVertex + 2;

indices[curIndex++] = curVertex + 3;

curVertex += 4;

// make line end cap

for(int j = 0; j < 2; j++) {

vertices[curVertex + j].pos = b;

vertices[curVertex + j].nol = nl;

vertices[curVertex + j].nor = nr;

vertices[curVertex + j].tan = tan;

}

vertices[curVertex + 0].loc = Vector4f::From(+1.0f, +1.0f, float(phase + len), (float)tag);

vertices[curVertex + 1].loc = Vector4f::From(+1.0f, -1.0f, float(phase + len), (float)tag);

indices[curIndex++] = curVertex - 2;

indices[curIndex++] = curVertex - 1;

indices[curIndex++] = curVertex;

indices[curIndex++] = curVertex - 1;

indices[curIndex++] = curVertex;

indices[curIndex++] = curVertex + 1;

curVertex += 2;

// phase stitching

if(curr.a.EqualsExactly(next.a) ||

curr.a.EqualsExactly(next.b) ||

curr.b.EqualsExactly(next.a) ||

curr.b.EqualsExactly(next.b))

{

phase += len;

} else {

phase = 0.0;

}

}

handle.size = curIndex;

GLenum mode = dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW;

glBufferData(GL_ARRAY_BUFFER, curVertex * sizeof(OutlineVertex), vertices, mode);

glBufferData(GL_ELEMENT_ARRAY_BUFFER, curIndex * sizeof(uint32_t), indices, mode);

delete []vertices;

delete []indices;

return handle;

glActiveTexture(GL_TEXTURE1);

glBindTexture(GL_TEXTURE_2D, atlas->GetTexture(pattern));

shader.SetUniformTextureUnit("pattern", 1);

shader.SetUniformFloat("patternLen", (float)atlas->GetLength(pattern));

shader.SetUniformInt("mode", (GLint)mode);

shader.Enable();

glBindBuffer(GL_ARRAY_BUFFER, handle.vertexBuffer);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, handle.indexBuffer);

glEnableVertexAttribArray(ATTRIB_POS);

glEnableVertexAttribArray(ATTRIB_LOC);

glEnableVertexAttribArray(ATTRIB_TAN);

glEnableVertexAttribArray(ATTRIB_NOL);

glEnableVertexAttribArray(ATTRIB_NOR);

glVertexAttribPointer(ATTRIB_POS, 3, GL_FLOAT, GL_FALSE, sizeof(OutlineVertex),

(void *)offsetof(OutlineVertex, pos));

glVertexAttribPointer(ATTRIB_LOC, 4, GL_FLOAT, GL_FALSE, sizeof(OutlineVertex),

(void *)offsetof(OutlineVertex, loc));

glVertexAttribPointer(ATTRIB_TAN, 3, GL_FLOAT, GL_FALSE, sizeof(OutlineVertex),

(void *)offsetof(OutlineVertex, tan));

glVertexAttribPointer(ATTRIB_NOL, 3, GL_FLOAT, GL_FALSE, sizeof(OutlineVertex),

(void *)offsetof(OutlineVertex, nol));

glVertexAttribPointer(ATTRIB_NOR, 3, GL_FLOAT, GL_FALSE, sizeof(OutlineVertex),

(void *)offsetof(OutlineVertex, nor));

glDrawElements(GL_TRIANGLES, handle.size, GL_UNSIGNED_INT, NULL);

glDisableVertexAttribArray(ATTRIB_POS);

glDisableVertexAttribArray(ATTRIB_LOC);

glDisableVertexAttribArray(ATTRIB_TAN);

glDisableVertexAttribArray(ATTRIB_NOL);

glDisableVertexAttribArray(ATTRIB_NOR);

glBindBuffer(GL_ARRAY_BUFFER, 0);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

shader.Disable();

Handle handle = Add(outlines, /*dynamic=*/true);

Draw(handle, drawAs);

Remove(handle);

double unitScale = (stroke.unit == Canvas::Unit::PX) ? pixel : 1.0;

shader.SetUniformFloat("width", (float)(stroke.width * unitScale / 2.0));

shader.SetUniformColor("color", stroke.color);

shader.SetUniformFloat("patternScale", (float)(stroke.stippleScale * unitScale * 2.0));

shader.SetUniformFloat("pixel", (float)pixel);

pattern = stroke.stipplePattern;

uint32_t vstart = vertices.size();

vertices.resize(vertices.size() + 4);

vertices[vstart + 0].pos = Vector3f::From(p);

vertices[vstart + 0].tex = Vector2f::From(-1.0f, -1.0f);

vertices[vstart + 1].pos = Vector3f::From(p);

vertices[vstart + 1].tex = Vector2f::From(+1.0f, -1.0f);

vertices[vstart + 2].pos = Vector3f::From(p);

vertices[vstart + 2].tex = Vector2f::From(+1.0f, +1.0f);

vertices[vstart + 3].pos = Vector3f::From(p);

vertices[vstart + 3].tex = Vector2f::From(-1.0f, +1.0f);

size_t istart = indices.size();

indices.resize(indices.size() + 6);

indices[istart + 0] = vstart + 0;

indices[istart + 1] = vstart + 1;

indices[istart + 2] = vstart + 2;

indices[istart + 3] = vstart + 0;

indices[istart + 4] = vstart + 2;

indices[istart + 5] = vstart + 3;

uint32_t vstart = vertices.size();

vertices.resize(vertices.size() + 4);

vertices[vstart + 0].pos = Vector3f::From(a);

vertices[vstart + 1].pos = Vector3f::From(b);

vertices[vstart + 2].pos = Vector3f::From(c);

vertices[vstart + 3].pos = Vector3f::From(d);

size_t istart = indices.size();

indices.resize(indices.size() + 6);

indices[istart + 0] = vstart + 0;

indices[istart + 1] = vstart + 1;

indices[istart + 2] = vstart + 2;

indices[istart + 3] = vstart + 0;

indices[istart + 4] = vstart + 2;

indices[istart + 5] = vstart + 3;

const Point2d &ta, const Point2d &tb) {

uint32_t vstart = vertices.size();

vertices.resize(vertices.size() + 4);

vertices[vstart + 0].pos = Vector3f::From(o);

vertices[vstart + 0].tex = Vector2f::From(ta.x, ta.y);

vertices[vstart + 1].pos = Vector3f::From(o.Plus(v));

vertices[vstart + 1].tex = Vector2f::From(ta.x, tb.y);

vertices[vstart + 2].pos = Vector3f::From(o.Plus(u).Plus(v));

vertices[vstart + 2].tex = Vector2f::From(tb.x, tb.y);

vertices[vstart + 3].pos = Vector3f::From(o.Plus(u));

vertices[vstart + 3].tex = Vector2f::From(tb.x, ta.y);

size_t istart = indices.size();

indices.resize(indices.size() + 6);

indices[istart + 0] = vstart + 0;

indices[istart + 1] = vstart + 1;

indices[istart + 2] = vstart + 2;

indices[istart + 3] = vstart + 0;

indices[istart + 4] = vstart + 2;

indices[istart + 5] = vstart + 3;

colShader.Init(

"shaders/imesh.vert", "shaders/imesh.frag",

{

{ ATTRIB_POS, "pos" },

{ ATTRIB_TEX, "tex" }

}

);

texShader.Init(

"shaders/imesh_tex.vert", "shaders/imesh_tex.frag",

{

{ ATTRIB_POS, "pos" },

{ ATTRIB_TEX, "tex" }

}

);

texaShader.Init(

"shaders/imesh_tex.vert", "shaders/imesh_texa.frag",

{

{ ATTRIB_POS, "pos" },

{ ATTRIB_TEX, "tex" }

}

);

pointShader.Init(

"shaders/imesh_point.vert", "shaders/imesh_point.frag",

{

{ ATTRIB_POS, "pos" },

{ ATTRIB_TEX, "loc" }

}

);

texShader.SetUniformTextureUnit("texture", 0);

texaShader.SetUniformTextureUnit("texture", 0);

selectedShader = &colShader;

texShader.Clear();

texaShader.Clear();

colShader.Clear();

pointShader.Clear();

Handle handle;

glGenBuffers(1, &handle.vertexBuffer);

glGenBuffers(1, &handle.indexBuffer);

GLenum mode = dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW;

glBindBuffer(GL_ARRAY_BUFFER, handle.vertexBuffer);

glBufferData(GL_ARRAY_BUFFER, m.vertices.size() * sizeof(SIndexedMesh::Vertex),

m.vertices.data(), mode);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, handle.indexBuffer);

glBufferData(GL_ELEMENT_ARRAY_BUFFER, m.indices.size() * sizeof(uint32_t),

m.indices.data(), mode);

handle.size = m.indices.size();

return handle;

selectedShader->Enable();

glBindBuffer(GL_ARRAY_BUFFER, m.vertexBuffer);

glEnableVertexAttribArray(ATTRIB_POS);

glVertexAttribPointer(ATTRIB_POS, 3, GL_FLOAT, GL_FALSE, sizeof(SIndexedMesh::Vertex),

(void *)offsetof(SIndexedMesh::Vertex, pos));

if(NeedsTexture()) {

glEnableVertexAttribArray(ATTRIB_TEX);

glVertexAttribPointer(ATTRIB_TEX, 2, GL_FLOAT, GL_FALSE, sizeof(SIndexedMesh::Vertex),

(void *)offsetof(SIndexedMesh::Vertex, tex));

}

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m.indexBuffer);

glDrawElements(GL_TRIANGLES, m.size, GL_UNSIGNED_INT, NULL);

glDisableVertexAttribArray(ATTRIB_POS);

if(NeedsTexture()) glDisableVertexAttribArray(ATTRIB_TEX);

glBindBuffer(GL_ARRAY_BUFFER, 0);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

selectedShader->Disable();