CWireframeBoxPrimitive::CWireframeBoxPrimitive(const glm::vec3 &dimensions)
{
	std::vector<GLfloat> vertices;
	std::vector<GLushort> indices;

	PUSH_TRIPLE(vertices, -dimensions.x, -dimensions.y,  dimensions.z);
	PUSH_TRIPLE(vertices,  dimensions.x, -dimensions.y,  dimensions.z);
	PUSH_TRIPLE(vertices,  dimensions.x, -dimensions.y, -dimensions.z);
	PUSH_TRIPLE(vertices, -dimensions.x, -dimensions.y, -dimensions.z);
	PUSH_TRIPLE(vertices, -dimensions.x,  dimensions.y,  dimensions.z);
	PUSH_TRIPLE(vertices,  dimensions.x,  dimensions.y,  dimensions.z);
	PUSH_TRIPLE(vertices,  dimensions.x,  dimensions.y, -dimensions.z);
	PUSH_TRIPLE(vertices, -dimensions.x,  dimensions.y, -dimensions.z);

	PUSH_TUPLE(indices, 0, 1);
	PUSH_TUPLE(indices, 1, 2);
	PUSH_TUPLE(indices, 2, 3);
	PUSH_TUPLE(indices, 3, 0);
	PUSH_TUPLE(indices, 4, 5);
	PUSH_TUPLE(indices, 5, 6);
	PUSH_TUPLE(indices, 6, 7);
	PUSH_TUPLE(indices, 7, 4);
	PUSH_TUPLE(indices, 0, 4);
	PUSH_TUPLE(indices, 1, 5);
	PUSH_TUPLE(indices, 2, 6);
	PUSH_TUPLE(indices, 3, 7);

	m_elementCount = 24;
	m_drawMode = GL_LINES;

	glGenVertexArrays(1, &m_vaoId);
	glBindVertexArray(m_vaoId);

	glGenBuffers(1, &m_vboId);
	glBindBuffer(GL_ARRAY_BUFFER, m_vboId);
	glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(GLfloat), vertices.data(), GL_STATIC_DRAW);

	glVertexAttribPointer(OPENGL_VXA_POSITION_ID, 3, GL_FLOAT, GL_FALSE, 12, (void *)0);
	glEnableVertexAttribArray(OPENGL_VXA_POSITION_ID);

	glGenBuffers(1, &m_iboId);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_iboId);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLushort), indices.data(), GL_STATIC_DRAW);

	glBindVertexArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
Пример #2
0
int
ppcall(register struct ppsymbol* sym, int tok)
{
	register int			c;
	register char*			p;
	register char*			q;
	register struct ppmacro*	mac;
	int				n;
	int				m;
	int				ret;
	int				old_hidden;
	int				last_line;
	long				old_state;
	char*				last_file;
	char*				old_next;
	char*				old_token;
	struct ppmacstk*		mp;
	struct ppinstk*			old_in;
	struct ppinstk*			kp;
	struct pptuple*			tp;

	ret = -1;
	sym->flags |= SYM_NOTICED;
	if (mac = sym->macro)
	{
		count(macro);
		if ((sym->flags & SYM_PREDICATE) && (pp.state & (CONDITIONAL|WARN)) == (CONDITIONAL|WARN))
			error(1, "%s: macro definition overrides assertion: use #%s ...", sym->name, sym->name);
		if (sym->flags & SYM_DISABLED)
#if COMPATIBLE
			if ((pp.state & (COMPATIBILITY|TRANSITION)) != COMPATIBILITY || !mac->arity)
#endif
		{
			pp.mode |= MARKMACRO;
#if COMPATIBLE
			if ((pp.state & (COMPATIBILITY|STRICT)) == (COMPATIBILITY|STRICT))
				error(1, "%s: macro recursion inhibited", sym->name);
#endif
			goto disable;
		}
		if ((sym->flags & SYM_PREDEFINED) && !(pp.mode & (HOSTED|INACTIVE)))
		{
#if COMPATIBLE
			if (*sym->name != '_' && !(pp.state & COMPATIBILITY))
#else
			if (*sym->name != '_')
#endif
			{
				if (pp.state & STRICT)
				{
					error(1, "%s: obsolete predefined symbol expansion disabled", sym->name);
					goto disable;
				}
				error(1, "%s: obsolete predefined symbol expanded%s", sym->name, (pp.state & DIRECTIVE) ? "" : " outside of directive");
			}
			else if (!(pp.state & DIRECTIVE) && mac->value && (ppisdig(*mac->value) || *mac->value == '#'))
				error(1, "%s: predefined symbol expanded outside of directive", sym->name);
		}
		debug((-5, "macro %s = %s", sym->name, mac->value));
		if (pp.macref)
			(*pp.macref)(sym, error_info.file, error_info.line, (pp.state & CONDITIONAL) ? REF_IF : REF_NORMAL, 0L);
		if (tp = mac->tuple)
		{
			old_state = pp.state;
			pp.state |= DEFINITION|NOSPACE;
			old_token = pp.token;
			n = 2 * MAXTOKEN;
			pp.token = p = oldof(0, char, 0, n);
			q = p + MAXTOKEN;
			*pp.token++ = ' ';
			old_hidden = pp.hidden;
			while (c = pplex())
			{
				if (c == '\n')
				{
					pp.hidden++;
					pp.state |= HIDDEN|NEWLINE;
					old_state |= HIDDEN|NEWLINE;
					error_info.line++;
				}
				else if (c == '#')
				{
					ungetchr(c);
					break;
				}
				else
				{
					for (;;)
					{
						if (streq(pp.token, tp->token))
						{
							if (!(tp = tp->match))
								break;
							if (!tp->nomatch)
							{
								free(p);
								pp.state = old_state;
								pp.token = old_token;
								PUSH_TUPLE(sym, tp->token);
								ret = 1;
								goto disable;
							}
						}
						else if (!(tp = tp->nomatch))
							break;
					}
					if (!tp)
					{
						pp.token = pp.toknxt;
						break;
					}
				}
				if ((pp.token = pp.toknxt) > q)
				{
					c = pp.token - p;
					p = newof(p, char, n += MAXTOKEN, 0);
					q = p + n - MAXTOKEN;
					pp.token = p + c;
				}
				*pp.token++ = ' ';
			}