DXGL r691 - Code Review

Repository:	DXGL
Revision:	< r690‎ \| r691 \| r692 >
Date:	02:16, 24 December 2016
Author:	admin
Status:	new
Tags:
Comment:
Modified paths:	/ddraw/glRenderer.cpp (modified) (history) /ddraw/glRenderer.h (modified) (history) /ddraw/struct.h (modified) (history) /ddraw/struct_command.h (modified) (history) /ddraw/util.c (modified) (history)

Diff [purge]

Index: ddraw/glRenderer.cpp
—	—	@@ -27,6 +27,7 @@
28	28	#include "ShaderGen3D.h"
29	29	#include "matrix.h"
30	30	#include "util.h"
	31	+#include <stdarg.h>
31	32
32	33	extern "C" {
33	34
—	—	@@ -132,6 +133,445 @@
133	134	}
134	135
135	136	/**
	137	+ * Check buffer for SetUniformCmd command and post it if it would overflow
	138	+ * @param This
	139	+ * Pointer to glRenderer object
	140	+ * @param cmd
	141	+ * Command to check, will be reinitialized if posted
	142	+ * @param ptr
	143	+ * Address of SetUniformCmdData pointer, will be updated if command is posted
	144	+ * @param buffer_size
	145	+ * Size of buffer holding command
	146	+ * @param request_size
	147	+ * Size of buffer to be requested
	148	+ * @param inner
	149	+ * Inner parameter for glRenderer_AddCommand if command is posted
	150	+ * @return
	151	+ * TRUE if command gets posted and reinitialized
	152	+ */
	153	+BOOL check_uniform_cmd_buffer(glRenderer This, SetUniformCmd cmd, SetUniformCmdData **ptr, DWORD buffer_size, DWORD request_size, BOOL inner)
	154	+{
	155	+ if (request_size > buffer_size)
	156	+ {
	157	+ glRenderer_AddCommand(This, (QueueCmd*)cmd, inner, FALSE);
	158	+ cmd->size = sizeof(SetUniformCmdBase) - 8;
	159	+ cmd->tmp_ptr = (BYTE*)&cmd->data;
	160	+ cmd->count = 0;
	161	+ ptr = (SetUniformCmdData)cmd->tmp_ptr;
	162	+ return TRUE;
	163	+ }
	164	+ else return FALSE;
	165	+}
	166	+
	167	+/**
	168	+* Check buffer for SetAttribCmd command and post it if it would overflow
	169	+* @param This
	170	+* Pointer to glRenderer object
	171	+* @param cmd
	172	+* Command to check, will be reinitialized if posted
	173	+* @param ptr
	174	+* Address of SetUniformCmdData pointer, will be updated if command is posted
	175	+* @param buffer_size
	176	+* Size of buffer holding command
	177	+* @param request_size
	178	+* Size of buffer to be requested
	179	+* @param inner
	180	+* Inner parameter for glRenderer_AddCommand if command is posted
	181	+* @return
	182	+* TRUE if command gets posted and reinitialized
	183	+*/
	184	+BOOL check_attrib_cmd_buffer(glRenderer This, SetAttribCmd cmd, DWORD buffer_size, DWORD request_size, BOOL inner)
	185	+{
	186	+ if (request_size > buffer_size)
	187	+ {
	188	+ glRenderer_AddCommand(This, (QueueCmd*)cmd, inner, FALSE);
	189	+ cmd->size = sizeof(SetAttribCmdBase) - 8;
	190	+ cmd->count = 0;
	191	+ return TRUE;
	192	+ }
	193	+ else return FALSE;
	194	+}
	195	+
	196	+
	197	+/**
	198	+ * Appends data to a SetUniformCmd command.
	199	+ * The size, count, and tmp_ptr fields must be initialized before the first
	200	+ * call to this function.
	201	+ * @param This
	202	+ * Pointer to glRenderer object
	203	+ * @param cmd
	204	+ * Pointer to SetUniformCmd command
	205	+ * @param uniform
	206	+ * GLSL uniform to modify
	207	+ * For builtin shaders, this is the actual GLSL uniform.
	208	+ * For generated shaders, this is the array offset of the generated structure for the uniform.
	209	+ * @param type
	210	+ * Encoded type for uniform, see struct_command.h for more info
	211	+ * @param count
	212	+ * Count for certain types of uniforms, color order for colorkey
	213	+ * @param transpose
	214	+ * Transpose parameter for matrix uniforms
	215	+ * @param inner
	216	+ * Inner parameter for glRenderer_AddCommand if buffer overflows
	217	+ * @param buffer_size
	218	+ * Size of the buffer containing the SetUniformCmd command
	219	+ * @param data
	220	+ * First value to pass to glUniform function
	221	+ * @param ...
	222	+ * Additional commands for certain glUniform functions
	223	+ */
	224	+void append_uniform_cmd(glRenderer This, SetUniformCmd cmd, GLint uniform, DWORD type, GLsizei count, BOOL transpose, BOOL inner, size_t buffer_size, DWORD_PTR data, ...)
	225	+{
	226	+ DWORD r, g, b, a;
	227	+ DWORD *colorsizes;
	228	+ DWORD *colorbits;
	229	+ size_t size;
	230	+ size_t multiplier;
	231	+ SetUniformCmdData uniform_ptr = (SetUniformCmdData)cmd->tmp_ptr;
	232	+ va_list va;
	233	+ va_start(va, data);
	234	+ switch (type)
	235	+ {
	236	+ case 0: // glUniform1i()
	237	+ default:
	238	+ check_uniform_cmd_buffer(This, cmd, &uniform_ptr, buffer_size,
	239	+ cmd->size + 8 + sizeof(SetUniformCmdData), inner);
	240	+ uniform_ptr->size = sizeof(SetUniformCmdData);
	241	+ uniform_ptr->type = type;
	242	+ uniform_ptr->data[0] = (GLint)data;
	243	+ break;
	244	+ case 1: // glUniform2i()
	245	+ check_uniform_cmd_buffer(This, cmd, &uniform_ptr, buffer_size,
	246	+ cmd->size + 8 + sizeof(SetUniformCmdData) + sizeof(GLint), inner);
	247	+ uniform_ptr->size = sizeof(SetUniformCmdData) + sizeof(GLint);
	248	+ uniform_ptr->type = type;
	249	+ uniform_ptr->data[0] = (GLint)data;
	250	+ uniform_ptr->data[1] = va_arg(va, GLint);
	251	+ break;
	252	+ case 2: // glUniform3i()
	253	+ check_uniform_cmd_buffer(This, cmd, &uniform_ptr, buffer_size,
	254	+ cmd->size + 8 + sizeof(SetUniformCmdData) + (2 * sizeof(GLint)), inner);
	255	+ uniform_ptr->size = sizeof(SetUniformCmdData) + (2 * sizeof(GLint));
	256	+ uniform_ptr->type = type;
	257	+ uniform_ptr->data[0] = (GLint)data;
	258	+ uniform_ptr->data[1] = va_arg(va, GLint);
	259	+ uniform_ptr->data[2] = va_arg(va, GLint);
	260	+ break;
	261	+ case 3: // glUniform4i()
	262	+ check_uniform_cmd_buffer(This, cmd, &uniform_ptr, buffer_size,
	263	+ cmd->size + 8 + sizeof(SetUniformCmdData) + (3 * sizeof(GLint)), inner);
	264	+ uniform_ptr->size = sizeof(SetUniformCmdData) + (3 * sizeof(GLint));
	265	+ uniform_ptr->type = type;
	266	+ uniform_ptr->data[0] = (GLint)data;
	267	+ uniform_ptr->data[1] = va_arg(va, GLint);
	268	+ uniform_ptr->data[2] = va_arg(va, GLint);
	269	+ uniform_ptr->data[3] = va_arg(va, GLint);
	270	+ break;
	271	+ case 4: // glUniform1f()
	272	+ check_uniform_cmd_buffer(This, cmd, &uniform_ptr, buffer_size,
	273	+ cmd->size + 8 + sizeof(SetUniformCmdData) - sizeof(GLint) + sizeof(GLfloat), inner);
	274	+ uniform_ptr->size = sizeof(SetUniformCmdData) - sizeof(GLint) + sizeof(GLfloat);
	275	+ uniform_ptr->type = type;
	276	+ ((GLfloat)&uniform_ptr->data[0]) = (GLfloat)data;
	277	+ break;
	278	+ case 5: // glUniform2f()
	279	+ check_uniform_cmd_buffer(This, cmd, &uniform_ptr, buffer_size,
	280	+ cmd->size + 8 + sizeof(SetUniformCmdData) - sizeof(GLint) + (2 * sizeof(GLfloat)), inner);
	281	+ uniform_ptr->size = sizeof(SetUniformCmdData) - sizeof(GLint) + (2 * sizeof(GLfloat));
	282	+ uniform_ptr->type = type;
	283	+ ((GLfloat)&uniform_ptr->data[0]) = (GLfloat)data;
	284	+ ((GLfloat)&uniform_ptr->data[1]) = va_arg(va, GLfloat);
	285	+ break;
	286	+ case 6: // glUniform3f()
	287	+ check_uniform_cmd_buffer(This, cmd, &uniform_ptr, buffer_size,
	288	+ cmd->size + 8 + sizeof(SetUniformCmdData) - sizeof(GLint) + (3 * sizeof(GLfloat)), inner);
	289	+ uniform_ptr->size = sizeof(SetUniformCmdData) - sizeof(GLint) + (3 * sizeof(GLfloat));
	290	+ uniform_ptr->type = type;
	291	+ ((GLfloat)&uniform_ptr->data[0]) = (GLfloat)data;
	292	+ ((GLfloat)&uniform_ptr->data[1]) = va_arg(va, GLfloat);
	293	+ ((GLfloat)&uniform_ptr->data[2]) = va_arg(va, GLfloat);
	294	+ break;
	295	+ case 7: // glUniform4f()
	296	+ check_uniform_cmd_buffer(This, cmd, &uniform_ptr, buffer_size,
	297	+ cmd->size + 8 + sizeof(SetUniformCmdData) - sizeof(GLint) + (4 * sizeof(GLfloat)), inner);
	298	+ uniform_ptr->size = sizeof(SetUniformCmdData) - sizeof(GLint) + (4 * sizeof(GLfloat));
	299	+ uniform_ptr->type = type;
	300	+ ((GLfloat)&uniform_ptr->data[0]) = (GLfloat)data;
	301	+ ((GLfloat)&uniform_ptr->data[1]) = va_arg(va, GLfloat);
	302	+ ((GLfloat)&uniform_ptr->data[2]) = va_arg(va, GLfloat);
	303	+ ((GLfloat)&uniform_ptr->data[3]) = va_arg(va, GLfloat);
	304	+ break;
	305	+ case 8: // glUniform1ui()
	306	+ check_uniform_cmd_buffer(This, cmd, &uniform_ptr, buffer_size,
	307	+ uniform_ptr->size + 8 + sizeof(SetUniformCmdData) - sizeof(GLint) + sizeof(GLuint), inner);
	308	+ uniform_ptr->size = sizeof(SetUniformCmdData) - sizeof(GLint) + sizeof(GLuint);
	309	+ uniform_ptr->type = type;
	310	+ ((GLuint)&uniform_ptr->data[0]) = (GLuint)data;
	311	+ break;
	312	+ case 9: // glUniform2ui()
	313	+ check_uniform_cmd_buffer(This, cmd, &uniform_ptr, buffer_size,
	314	+ cmd->size + 8 + sizeof(SetUniformCmdData) - sizeof(GLint) + (2 * sizeof(GLuint)), inner);
	315	+ uniform_ptr->size = sizeof(SetUniformCmdData) - sizeof(GLint) + (2 * sizeof(GLuint));
	316	+ uniform_ptr->type = type;
	317	+ ((GLuint)&uniform_ptr->data[0]) = (GLuint)data;
	318	+ ((GLuint)&uniform_ptr->data[1]) = va_arg(va, GLuint);
	319	+ break;
	320	+ case 10: // glUniform3ui()
	321	+ check_uniform_cmd_buffer(This, cmd, &uniform_ptr, buffer_size,
	322	+ cmd->size + 8 + sizeof(SetUniformCmdData) - sizeof(GLint) + (3 * sizeof(GLuint)), inner);
	323	+ uniform_ptr->size = sizeof(SetUniformCmdData) - sizeof(GLint) + (3 * sizeof(GLuint));
	324	+ uniform_ptr->type = type;
	325	+ ((GLuint)&uniform_ptr->data[0]) = (GLuint)data;
	326	+ ((GLuint)&uniform_ptr->data[1]) = va_arg(va, GLuint);
	327	+ ((GLuint)&uniform_ptr->data[2]) = va_arg(va, GLuint);
	328	+ break;
	329	+ case 11: // glUniform4ui()
	330	+ check_uniform_cmd_buffer(This, cmd, &uniform_ptr, buffer_size,
	331	+ cmd->size + 8 + sizeof(SetUniformCmdData) - sizeof(GLint) + (4 * sizeof(GLuint)), inner);
	332	+ uniform_ptr->size = sizeof(SetUniformCmdData) - sizeof(GLint) + (4 * sizeof(GLuint));
	333	+ uniform_ptr->type = type;
	334	+ ((GLuint)&uniform_ptr->data[0]) = (GLuint)data;
	335	+ ((GLuint)&uniform_ptr->data[1]) = va_arg(va, GLuint);
	336	+ ((GLuint)&uniform_ptr->data[2]) = va_arg(va, GLuint);
	337	+ ((GLuint)&uniform_ptr->data[3]) = va_arg(va, GLuint);
	338	+ break;
	339	+ case 16: // glUniform1iv()
	340	+ case 17: // glUniform12v()
	341	+ case 18: // glUniform13v()
	342	+ case 19: // glUniform14v()
	343	+ multiplier = (type & 3) - 1;
	344	+ check_uniform_cmd_buffer(This, cmd, &uniform_ptr, buffer_size,
	345	+ cmd->size + 8 + sizeof(SetUniformCmdData) - sizeof(GLint) +
	346	+ (multiplier * count * sizeof(GLint)), inner);
	347	+ uniform_ptr->size = sizeof(SetUniformCmdData) - sizeof(GLint) +
	348	+ (multiplier * count * sizeof(GLint));
	349	+ uniform_ptr->type = type;
	350	+ uniform_ptr->count = count;
	351	+ memcpy(uniform_ptr->data, (GLint)data, (multiplier count * sizeof(GLint)));
	352	+ break;
	353	+ case 20: // glUniform1fv()
	354	+ case 21: // glUniform2fv()
	355	+ case 22: // glUniform3fv()
	356	+ case 23: // glUniform4fv()
	357	+ multiplier = (type & 3) - 1;
	358	+ check_uniform_cmd_buffer(This, cmd, &uniform_ptr, buffer_size,
	359	+ cmd->size + 8 + sizeof(SetUniformCmdData) - sizeof(GLint) +
	360	+ (multiplier * count * sizeof(GLfloat)), inner);
	361	+ uniform_ptr->size = sizeof(SetUniformCmdData) - sizeof(GLint) +
	362	+ (multiplier * count * sizeof(GLfloat));
	363	+ uniform_ptr->type = type;
	364	+ uniform_ptr->count = count;
	365	+ memcpy(uniform_ptr->data, (GLfloat)data, (multiplier count * sizeof(GLfloat)));
	366	+ break;
	367	+ case 24: // glUniform1uiv()
	368	+ case 25: // glUniform2uiv()
	369	+ case 26: // glUniform3uiv()
	370	+ case 27: // glUniform4uiv()
	371	+ multiplier = (type & 3) - 1;
	372	+ check_uniform_cmd_buffer(This, cmd, &uniform_ptr, buffer_size,
	373	+ cmd->size + 8 + sizeof(SetUniformCmdData) - sizeof(GLint) +
	374	+ (multiplier * count * sizeof(GLint)), inner);
	375	+ uniform_ptr->size = sizeof(SetUniformCmdData) - sizeof(GLint) +
	376	+ (multiplier * count * sizeof(GLint));
	377	+ uniform_ptr->type = type;
	378	+ uniform_ptr->count = count;
	379	+ memcpy(uniform_ptr->data, (GLint)data, (multiplier count * sizeof(GLint)));
	380	+ break;
	381	+ case 33: // glUniformMatrix2fv()
	382	+ case 34: // glUniformMatrix3fv()
	383	+ case 35: // glUniformMatrix4fv()
	384	+ if (type == 33) multiplier = 4;
	385	+ else if (type == 34) multiplier = 9;
	386	+ else if (type == 35) multiplier = 16;
	387	+ check_uniform_cmd_buffer(This, cmd, &uniform_ptr, buffer_size,
	388	+ cmd->size + 8 + sizeof(SetUniformCmdData) - sizeof(GLint) +
	389	+ (multiplier * count * sizeof(GLfloat)), inner);
	390	+ uniform_ptr->size = sizeof(SetUniformCmdData) - sizeof(GLint) +
	391	+ (multiplier * count * sizeof(GLfloat));
	392	+ uniform_ptr->type = type;
	393	+ uniform_ptr->count = count;
	394	+ uniform_ptr->transpose = transpose;
	395	+ memcpy(uniform_ptr->data, (GLfloat)data, (multiplier count * sizeof(GLfloat)));
	396	+ break;
	397	+ case 256: // Color key, uses glUniform3i() or glUniform4i()
	398	+ colorsizes = va_arg(va, DWORD*);
	399	+ colorbits = va_arg(va, DWORD*);
	400	+ switch (count)
	401	+ {
	402	+ case 0:
	403	+ r = data & colorsizes[0];
	404	+ data >>= colorbits[0];
	405	+ g = data & colorsizes[1];
	406	+ data >>= colorbits[1];
	407	+ b = data & colorsizes[2];
	408	+ append_uniform_cmd(This, cmd, uniform, 2, 0, FALSE, inner, buffer_size, r, g, b);
	409	+ break;
	410	+ case 1:
	411	+ b = data & colorsizes[2];
	412	+ data >>= colorbits[2];
	413	+ g = data & colorsizes[1];
	414	+ data >>= colorbits[1];
	415	+ r = data & colorsizes[0];
	416	+ append_uniform_cmd(This, cmd, uniform, 2, 0, FALSE, inner, buffer_size, r, g, b);
	417	+ break;
	418	+ case 2:
	419	+ a = data & colorsizes[3];
	420	+ data >>= colorbits[3];
	421	+ r = data & colorsizes[0];
	422	+ data >>= colorbits[0];
	423	+ g = data & colorsizes[1];
	424	+ data >>= colorbits[1];
	425	+ b = data & colorsizes[2];
	426	+ append_uniform_cmd(This, cmd, uniform, 2, 0, FALSE, inner, buffer_size, r, g, b);
	427	+ break;
	428	+ case 3:
	429	+ a = data & colorsizes[3];
	430	+ data >>= colorbits[3];
	431	+ b = data & colorsizes[2];
	432	+ data >>= colorbits[2];
	433	+ g = data & colorsizes[1];
	434	+ data >>= colorbits[1];
	435	+ r = data & colorsizes[0];
	436	+ append_uniform_cmd(This, cmd, uniform, 2, 0, FALSE, inner, buffer_size, r, g, b);
	437	+ break;
	438	+ case 4:
	439	+ r = data & colorsizes[0];
	440	+ if (This->ext->glver_major >= 3)
	441	+ append_uniform_cmd(This, cmd, uniform, 2, 0, FALSE, inner, buffer_size, r, 0, 0);
	442	+ append_uniform_cmd(This, cmd, uniform, 2, 0, FALSE, inner, buffer_size, r, r, r);
	443	+ break;
	444	+ case 5:
	445	+ r = data & colorsizes[0];
	446	+ append_uniform_cmd(This, cmd, uniform, 2, 0, FALSE, inner, buffer_size, r, r, r);
	447	+ break;
	448	+ case 6:
	449	+ a = data & colorsizes[3];
	450	+ append_uniform_cmd(This, cmd, uniform, 3, 0, FALSE, inner, buffer_size, 0, 0, 0, a);
	451	+ break;
	452	+ case 7:
	453	+ r = data & colorsizes[0];
	454	+ data >>= colorbits[0];
	455	+ a = data & colorsizes[3];
	456	+ append_uniform_cmd(This, cmd, uniform, 3, 0, FALSE, inner, buffer_size, r, r, r, a);
	457	+ break;
	458	+ }
	459	+ va_end(va);
	460	+ return;
	461	+ case 257:
	462	+ colorsizes = va_arg(va, DWORD*);
	463	+ colorbits = va_arg(va, DWORD*);
	464	+ switch (count)
	465	+ {
	466	+ case 0:
	467	+ r = data & colorsizes[0];
	468	+ data >>= colorbits[0];
	469	+ g = data & colorsizes[1];
	470	+ data >>= colorbits[1];
	471	+ b = data & colorsizes[2];
	472	+ data >>= colorbits[2];
	473	+ a = data & colorsizes[3];
	474	+ append_uniform_cmd(This, cmd, uniform, 3, 0, FALSE, inner, buffer_size, r, g, b, a);
	475	+ break;
	476	+ case 1:
	477	+ b = data & colorsizes[2];
	478	+ data >>= colorbits[2];
	479	+ g = data & colorsizes[1];
	480	+ data >>= colorbits[1];
	481	+ r = data & colorsizes[0];
	482	+ data >>= colorbits[0];
	483	+ a = data & colorsizes[3];
	484	+ append_uniform_cmd(This, cmd, uniform, 3, 0, FALSE, inner, buffer_size, r, g, b, a);
	485	+ break;
	486	+ case 2:
	487	+ a = data & colorsizes[3];
	488	+ data >>= colorbits[3];
	489	+ r = data & colorsizes[0];
	490	+ data >>= colorbits[0];
	491	+ g = data & colorsizes[1];
	492	+ data >>= colorbits[1];
	493	+ b = data & colorsizes[2];
	494	+ append_uniform_cmd(This, cmd, uniform, 3, 0, FALSE, inner, buffer_size, r, g, b, a);
	495	+ break;
	496	+ case 3:
	497	+ a = data & colorsizes[3];
	498	+ data >>= colorbits[3];
	499	+ b = data & colorsizes[2];
	500	+ data >>= colorbits[2];
	501	+ g = data & colorsizes[1];
	502	+ data >>= colorbits[1];
	503	+ r = data & colorsizes[0];
	504	+ append_uniform_cmd(This, cmd, uniform, 3, 0, FALSE, inner, buffer_size, r, g, b, a);
	505	+ break;
	506	+ case 4:
	507	+ r = data & colorsizes[0];
	508	+ append_uniform_cmd(This, cmd, uniform, 3, 0, FALSE, inner, buffer_size, r, r, r, r);
	509	+ break;
	510	+ case 5:
	511	+ r = data & colorsizes[0];
	512	+ append_uniform_cmd(This, cmd, uniform, 3, 0, FALSE, inner, buffer_size, r, r, r, r);
	513	+ break;
	514	+ case 6:
	515	+ a = data & colorsizes[3];
	516	+ append_uniform_cmd(This, cmd, uniform, 3, 0, FALSE, inner, buffer_size, a, a, a, a);
	517	+ break;
	518	+ case 7:
	519	+ r = data & colorsizes[0];
	520	+ data >>= colorbits[0];
	521	+ a = data & colorsizes[3];
	522	+ append_uniform_cmd(This, cmd, uniform, 3, 0, FALSE, inner, buffer_size, r, r, r, a);
	523	+ break;
	524	+ }
	525	+ va_end(va);
	526	+ return;
	527	+ }
	528	+ cmd->size += uniform_ptr->size;
	529	+ cmd->tmp_ptr += uniform_ptr->size;
	530	+ cmd->count++;
	531	+ va_end(va);
	532	+}
	533	+
	534	+
	535	+/**
	536	+ * Appends data to a SetAttribCmd command.
	537	+ * The size, count, and tmp_ptr fields must be initialized before the first
	538	+ * call to this function.
	539	+ * @param This
	540	+ * Pointer to glRenderer object
	541	+ * @param cmd
	542	+ * Pointer to SetAttribCmd command
	543	+ * @param attrib
	544	+ * GLSL attribute to set up
	545	+ * For builtin shaders, this is the actual GLSL attribute.
	546	+ * For generated shaders, this is the array offset of the generated structure for the attribute.
	547	+ * @param size
	548	+ * Number of components per attribute, or GL_BGRA
	549	+ * @param type
	550	+ * Type of components in the attribute
	551	+ * @param normalized
	552	+ * Whether or not integer types are normalized to -1 to 1 for signed, 0 to 1 for unsinged.
	553	+ * @param stride
	554	+ * Number of bytes between the beginning of one attribute element and the beginning of the next.
	555	+ * @param inner
	556	+ * Inner parameter for glRenderer_AddCommand if buffer overflows
	557	+ * @param buffer_size
	558	+ * Size of the buffer containing the SetAttribCmd command
	559	+ */
	560	+void append_attrib_cmd(glRenderer This, SetAttribCmd cmd, GLuint attrib, GLint size,
	561	+ GLint type, GLboolean normalized, GLsizei stride, const GLvoid *pointer, BOOL inner, size_t buffer_size)
	562	+{
	563	+ check_attrib_cmd_buffer(This, cmd, buffer_size, cmd->size + sizeof(SetAttribCmdBase), inner);
	564	+ cmd->attrib[cmd->count].index = attrib;
	565	+ cmd->attrib[cmd->count].size = size;
	566	+ cmd->attrib[cmd->count].type = type;
	567	+ cmd->attrib[cmd->count].normalized = normalized;
	568	+ cmd->attrib[cmd->count].stride = stride;
	569	+ cmd->attrib[cmd->count].ptr = pointer;
	570	+ cmd->size += sizeof(SetAttribCmdBase);
	571	+ cmd->count++;
	572	+}
	573	+
	574	+const WORD indexbase[6] = { 0,1,2,2,3,0 };
	575	+/**
136	576	* Adds a command to the active command buffer.
137	577	* @param This
138	578	* Pointer to glRenderer object
—	—	@@ -159,6 +599,7 @@
160	600	int screenx, screeny;
161	601	LONG_PTR winstyle, winstyleex;
162	602	BOOL restart_cmd = FALSE;
	603	+ __int64 shaderid;
163	604	if (!inner) EnterCriticalSection(&This->cs);
164	605	switch (cmd->Generic.opcode)
165	606	{
—	—	@@ -224,12 +665,87 @@
225	666	{
226	667	if (rop_texture_usage[(cmd->Blt.cmd.bltfx.dwROP >> 16) & 0xFF] & 2) restart_cmd = TRUE;
227	668	}
	669	+ // Check if buffer can accomodate command
	670	+ if(!restart_cmd) restart_cmd = CheckCmdBuffer(This, 0, 0, 4 * sizeof(BltVertex), 6 * sizeof(WORD));
228	671	if(!restart_cmd)
229	672	{
	673	+ Vertex2DCmd lastcmd = (Vertex2DCmd)((BYTE*)(This->state.cmd->cmdbuffer + This->state.cmd->write_ptr_cmd));
	674	+ int rotates = 0;
	675	+ // cmdout.flags & 1 = usedest
230	676	// Generate vertices
	677	+ if (!memcmp(&cmd->Blt.cmd.srcrect, &nullrect, sizeof(RECT)))
	678	+ {
	679	+ r1.left = r1.top = 0;
	680	+ if (cmd->Blt.cmd.src)
	681	+ {
	682	+ r1.right = cmd->Blt.cmd.src->levels[cmd->Blt.cmd.srclevel].ddsd.dwWidth;
	683	+ r1.bottom = cmd->Blt.cmd.src->levels[cmd->Blt.cmd.srclevel].ddsd.dwHeight;
	684	+ }
	685	+ else r1.right = r1.bottom = 0;
	686	+ }
	687	+ else r1 = cmd->Blt.cmd.srcrect;
	688	+ if (!memcmp(&cmd->Blt.cmd.destrect, &nullrect, sizeof(RECT)))
	689	+ {
	690	+ r2.left = r2.top = 0;
	691	+ r2.right = cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwWidth;
	692	+ r2.bottom = cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwHeight;
	693	+ }
	694	+ else r2 = cmd->Blt.cmd.destrect;
	695	+ tmp_cmd.BltVertex_STORAGE.vertex[1].x = tmp_cmd.BltVertex_STORAGE.vertex[3].x = (GLfloat)r2.left;
	696	+ tmp_cmd.BltVertex_STORAGE.vertex[0].x = tmp_cmd.BltVertex_STORAGE.vertex[2].x = (GLfloat)r2.right;
	697	+ tmp_cmd.BltVertex_STORAGE.vertex[0].y = tmp_cmd.BltVertex_STORAGE.vertex[1].y = (GLfloat)cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwHeight - (GLfloat)r2.top;
	698	+ tmp_cmd.BltVertex_STORAGE.vertex[2].y = tmp_cmd.BltVertex_STORAGE.vertex[3].y = (GLfloat)cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwHeight - (GLfloat)r2.bottom;
	699	+ tmp_cmd.BltVertex_STORAGE.vertex[1].s = tmp_cmd.BltVertex_STORAGE.vertex[3].s = (GLfloat)r1.left / (GLfloat)cmd->Blt.cmd.src->levels[cmd->Blt.cmd.srclevel].ddsd.dwWidth;
	700	+ tmp_cmd.BltVertex_STORAGE.vertex[0].s = tmp_cmd.BltVertex_STORAGE.vertex[2].s = (GLfloat)r1.right / (GLfloat)cmd->Blt.cmd.src->levels[cmd->Blt.cmd.srclevel].ddsd.dwWidth;
	701	+ tmp_cmd.BltVertex_STORAGE.vertex[0].t = tmp_cmd.BltVertex_STORAGE.vertex[1].t = (GLfloat)r1.top / (GLfloat)cmd->Blt.cmd.src->levels[cmd->Blt.cmd.srclevel].ddsd.dwHeight;
	702	+ tmp_cmd.BltVertex_STORAGE.vertex[2].t = tmp_cmd.BltVertex_STORAGE.vertex[3].t = (GLfloat)r1.bottom / (GLfloat)cmd->Blt.cmd.src->levels[cmd->Blt.cmd.srclevel].ddsd.dwHeight;
	703	+ if (lastcmd->flags & 1)
	704	+ {
	705	+ tmp_cmd.BltVertex_STORAGE.vertex[1].dests =
	706	+ tmp_cmd.BltVertex_STORAGE.vertex[3].dests = 0.;
	707	+ tmp_cmd.BltVertex_STORAGE.vertex[0].dests =
	708	+ tmp_cmd.BltVertex_STORAGE.vertex[2].dests = (GLfloat)(r1.right - r1.left) / (GLfloat)This->backbuffer->levels[0].ddsd.dwWidth;
	709	+ tmp_cmd.BltVertex_STORAGE.vertex[0].destt =
	710	+ tmp_cmd.BltVertex_STORAGE.vertex[1].destt = 1.;
	711	+ tmp_cmd.BltVertex_STORAGE.vertex[2].destt =
	712	+ tmp_cmd.BltVertex_STORAGE.vertex[3].destt = 1.0 - ((GLfloat)(r1.bottom - r1.top) / (GLfloat)This->backbuffer->levels[0].ddsd.dwHeight);
	713	+ }
	714	+ if (cmd->Blt.cmd.flags & 0x10000000)
	715	+ {
	716	+ tmp_cmd.BltVertex_STORAGE.vertex[1].stencils = tmp_cmd.BltVertex_STORAGE.vertex[3].stencils = tmp_cmd.BltVertex_STORAGE.vertex[1].x / (GLfloat)cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwWidth;
	717	+ tmp_cmd.BltVertex_STORAGE.vertex[0].stencils = tmp_cmd.BltVertex_STORAGE.vertex[2].stencils = tmp_cmd.BltVertex_STORAGE.vertex[0].x / (GLfloat)cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwWidth;
	718	+ tmp_cmd.BltVertex_STORAGE.vertex[0].stencilt = tmp_cmd.BltVertex_STORAGE.vertex[1].stencilt = tmp_cmd.BltVertex_STORAGE.vertex[0].y / (GLfloat)cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwHeight;
	719	+ tmp_cmd.BltVertex_STORAGE.vertex[2].stencilt = tmp_cmd.BltVertex_STORAGE.vertex[3].stencilt = tmp_cmd.BltVertex_STORAGE.vertex[2].y / (GLfloat)cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwHeight;
	720	+ }
231	721	// Rotate vertices if necessary
	722	+ if ((cmd->Blt.cmd.bltfx.dwSize == sizeof(DDBLTFX)) && (cmd->Blt.cmd.flags & DDBLT_DDFX))
	723	+ {
	724	+ if (cmd->Blt.cmd.bltfx.dwDDFX & DDBLTFX_MIRRORLEFTRIGHT)
	725	+ BltFlipLR(tmp_cmd.BltVertex_STORAGE.vertex);
	726	+ if (cmd->Blt.cmd.bltfx.dwDDFX & DDBLTFX_MIRRORUPDOWN)
	727	+ BltFlipUD(tmp_cmd.BltVertex_STORAGE.vertex);
	728	+ if (cmd->Blt.cmd.bltfx.dwDDFX & DDBLTFX_ROTATE90) rotates++;
	729	+ if (cmd->Blt.cmd.bltfx.dwDDFX & DDBLTFX_ROTATE180) rotates += 2;
	730	+ if (cmd->Blt.cmd.bltfx.dwDDFX & DDBLTFX_ROTATE270) rotates += 3;
	731	+ rotates &= 3;
	732	+ if (rotates)
	733	+ {
	734	+ RotateBlt90(tmp_cmd.BltVertex_STORAGE.vertex, rotates);
	735	+ }
	736	+ }
232	737	// Write vertices to VBO
	738	+ memcpy(tmp_cmd.BltVertex_STORAGE.index, indexbase, 6 * sizeof(WORD));
	739	+ for (i = 0; i < 6; i++)
	740	+ tmp_cmd.BltVertex_STORAGE.index[i] += lastcmd->count;
	741	+ memcpy(This->state.cmd->vertices->pointer + This->state.cmd->write_ptr_vertex,
	742	+ tmp_cmd.BltVertex_STORAGE.vertex, 4 * sizeof(BltVertex));
	743	+ memcpy(This->state.cmd->indices->pointer + This->state.cmd->write_ptr_index,
	744	+ tmp_cmd.BltVertex_STORAGE.index, 6 * sizeof(WORD));
	745	+ This->state.cmd->write_ptr_vertex += 4 * sizeof(BltVertex);
	746	+ This->state.cmd->write_ptr_index += 6 * sizeof(WORD);
233	747	// Update command in buffer
	748	+ lastcmd->count += 4;
	749	+ lastcmd->indexcount += 6;
234	750	}
235	751
236	752	}
—	—	@@ -238,6 +754,7 @@
239	755	BOOL usedest = FALSE;
240	756	BOOL usepattern = FALSE;
241	757	BOOL usetexture = FALSE;
	758	+ int rotates = 0;
242	759	if ((cmd->Blt.cmd.bltfx.dwSize == sizeof(DDBLTFX)) && (cmd->Blt.cmd.flags & DDBLT_ROP))
243	760	{
244	761	if (rop_texture_usage[(cmd->Blt.cmd.bltfx.dwROP >> 16) & 0xFF] & 2) usedest = TRUE;
—	—	@@ -265,19 +782,19 @@
266	783	if (newdesc.dwWidth < r1.right) newdesc.dwWidth = r1.right;
267	784	if (newdesc.dwHeight < r1.bottom) newdesc.dwHeight = r1.bottom;
268	785	tmp_cmd.SetTextureSurfaceDesc.opcode = OP_SETTEXTURESURFACEDESC;
269		~~- tmp_cmd.SetTextureSurfaceDesc.size = sizeof(SetTextureSurfaceDescCmd);~~
	786	+ tmp_cmd.SetTextureSurfaceDesc.size = sizeof(SetTextureSurfaceDescCmd) - 8;
270	787	tmp_cmd.SetTextureSurfaceDesc.level = 0;
271	788	tmp_cmd.SetTextureSurfaceDesc.desc = newdesc;
272	789	glRenderer_AddCommand(This, &tmp_cmd, TRUE, TRUE);
273	790	}
274	791	tmp_cmd.Blt.opcode = OP_BLT;
275		~~- tmp_cmd.Blt.size = sizeof(BltCmd);~~
	792	+ tmp_cmd.Blt.size = sizeof(BltCmd) - 8;
276	793	tmp_cmd.Blt.cmd.flags = 0;
277	794	tmp_cmd.Blt.cmd.destrect = r1;
278	795	tmp_cmd.Blt.cmd.srcrect = cmd->Blt.cmd.destrect;
279	796	tmp_cmd.Blt.cmd.src = cmd->Blt.cmd.dest;
280	797	tmp_cmd.Blt.cmd.dest = This->backbuffer;
281		~~- tmp_cmd.Blt.cmd.srclevel = cmd->Blt.cmd.srclevel;~~
	798	+ tmp_cmd.Blt.cmd.srclevel = cmd->Blt.cmd.destlevel;
282	799	tmp_cmd.Blt.cmd.destlevel = 0;
283	800	glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
284	801	}
—	—	@@ -284,7 +801,7 @@
285	802	// Set Src texture (Unit 8)
286	803	i = -1;
287	804	tmp_cmd.SetTexture.opcode = OP_SETTEXTURE;
288		~~- tmp_cmd.SetTexture.size = sizeof(SetTextureCmd) - (sizeof(DWORD) + sizeof(glTexture*));~~
	805	+ tmp_cmd.SetTexture.size = sizeof(SetTextureCmd) - (sizeof(DWORD) + sizeof(glTexture*)) - 8;
289	806	if (cmd->Blt.cmd.src)
290	807	{
291	808	tmp_cmd.SetTexture.size += (sizeof(DWORD) + sizeof(glTexture*));
—	—	@@ -320,21 +837,95 @@
321	838	tmp_cmd.SetTexture.texstage[i].stage = 11;
322	839	tmp_cmd.SetTexture.texstage[i].texture = cmd->Blt.cmd.dest->stencil;
323	840	}
	841	+ tmp_cmd.SetTexture.count = i + 1;
324	842	if(usetexture) glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
325		~~- // Set shader mode and params~~
	843	+ // Set shader
326	844	tmp_cmd.SetShader2D.opcode = OP_SETSHADER2D;
327		~~- tmp_cmd.SetShader2D.size = sizeof(SetShader2DCmd);~~
	845	+ tmp_cmd.SetShader2D.size = sizeof(SetShader2DCmd) - 8;
328	846	tmp_cmd.SetShader2D.type = 1;
329	847	if ((cmd->Blt.cmd.bltfx.dwSize == sizeof(DDBLTFX)) && (cmd->Blt.cmd.flags & DDBLT_ROP))
330	848	tmp_cmd.SetShader2D.id = PackROPBits(cmd->Blt.cmd.bltfx.dwROP, cmd->Blt.cmd.flags);
331	849	else tmp_cmd.SetShader2D.id = cmd->Blt.cmd.flags & 0xF2FAADFF;
332	850	glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
	851	+ // Set shader uniforms
	852	+ tmp_cmd.SetUniform.opcode = OP_SETUNIFORM;
	853	+ tmp_cmd.SetUniform.size = 0;
	854	+ SetUniformCmdData *uniform_ptr = &tmp_cmd.SetUniform.data;
	855	+ tmp_cmd.SetUniform.size = sizeof(SetUniformCmdBase) - 8;
	856	+ tmp_cmd.SetUniform.tmp_ptr = (BYTE*)&tmp_cmd.SetUniform.data;
	857	+ tmp_cmd.SetUniform.count = 0;
	858	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, 0, 7, 0, FALSE, TRUE, sizeof(MIN_STORAGE_CMD),
	859	+ 0.0f, (GLfloat)cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwWidth,
	860	+ 0.0f, (GLfloat)cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwHeight);
	861	+ if (!(cmd->Blt.cmd.flags & DDBLT_COLORFILL))
	862	+ {
	863	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, 1, 0, 0, FALSE, TRUE, sizeof(MIN_STORAGE_CMD), 8);
	864	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, 10, 19, 1, FALSE, TRUE, sizeof(MIN_STORAGE_CMD),
	865	+ (DWORD_PTR)&cmd->Blt.cmd.src->colorsizes[0]);
	866	+ }
	867	+ if (usedest)
	868	+ {
	869	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, 2, 0, 0, FALSE, TRUE, sizeof(MIN_STORAGE_CMD), 9);
	870	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, 11, 19, 1, FALSE, TRUE, sizeof(MIN_STORAGE_CMD),
	871	+ (DWORD_PTR)&cmd->Blt.cmd.dest->colorsizes[0]);
	872	+ }
	873	+ if (usepattern)
	874	+ {
	875	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, 3, 0, 0, FALSE, TRUE, sizeof(MIN_STORAGE_CMD), 10);
	876	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, 9, 1, 0, FALSE, TRUE, sizeof(MIN_STORAGE_CMD),
	877	+ cmd->Blt.cmd.pattern->levels[cmd->Blt.cmd.patternlevel].ddsd.dwWidth,
	878	+ cmd->Blt.cmd.pattern->levels[cmd->Blt.cmd.patternlevel].ddsd.dwHeight);
	879	+ }
	880	+ if (cmd->Blt.cmd.dest->stencil)
	881	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, 4, 0, 0, FALSE, TRUE, sizeof(MIN_STORAGE_CMD), 11);
	882	+ if ((cmd->Blt.cmd.flags & DDBLT_KEYSRC) && (cmd->Blt.cmd.src &&
	883	+ (cmd->Blt.cmd.src->levels[cmd->Blt.cmd.srclevel].ddsd.dwFlags & DDSD_CKSRCBLT))
	884	+ && !(cmd->Blt.cmd.flags & DDBLT_COLORFILL))
	885	+ {
	886	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, 5, 256, cmd->Blt.cmd.src->colororder, FALSE, TRUE,
	887	+ sizeof(MIN_STORAGE_CMD), cmd->Blt.cmd.src->levels[cmd->Blt.cmd.srclevel].ddsd.ddckCKSrcBlt.dwColorSpaceLowValue,
	888	+ cmd->Blt.cmd.src->colorsizes, cmd->Blt.cmd.src->colorbits);
	889	+ if(cmd->Blt.cmd.flags & 0x20000000)
	890	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, 7, 256, cmd->Blt.cmd.src->colororder, FALSE, TRUE,
	891	+ sizeof(MIN_STORAGE_CMD), cmd->Blt.cmd.src->levels[cmd->Blt.cmd.srclevel].ddsd.ddckCKSrcBlt.dwColorSpaceHighValue,
	892	+ cmd->Blt.cmd.src->colorsizes, cmd->Blt.cmd.src->colorbits);
	893	+ }
	894	+ if ((cmd->Blt.cmd.flags & DDBLT_KEYDEST) && (This && (cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwFlags & DDSD_CKDESTBLT)))
	895	+ {
	896	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, 6, 256, cmd->Blt.cmd.dest->colororder, FALSE, TRUE,
	897	+ sizeof(MIN_STORAGE_CMD), cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.ddckCKSrcBlt.dwColorSpaceLowValue,
	898	+ cmd->Blt.cmd.dest->colorsizes, cmd->Blt.cmd.dest->colorbits);
	899	+ if (cmd->Blt.cmd.flags & 0x40000000)
	900	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, 8, 256, cmd->Blt.cmd.dest->colororder, FALSE, TRUE,
	901	+ sizeof(MIN_STORAGE_CMD), cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.ddckCKSrcBlt.dwColorSpaceHighValue,
	902	+ cmd->Blt.cmd.dest->colorsizes, cmd->Blt.cmd.dest->colorbits);
	903	+ }
	904	+ if (cmd->Blt.cmd.flags & DDBLT_COLORFILL)
	905	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, 12, 257, cmd->Blt.cmd.src->colororder, FALSE, TRUE,
	906	+ sizeof(MIN_STORAGE_CMD), cmd->Blt.cmd.bltfx.dwFillColor,
	907	+ cmd->Blt.cmd.src->colorsizes, cmd->Blt.cmd.src->colorbits);
	908	+ // Set shader attributes
	909	+ tmp_cmd.SetAttrib.opcode = OP_SETATTRIB;
	910	+ tmp_cmd.SetAttrib.size = sizeof(SetAttribCmdBase) - 8;
	911	+ tmp_cmd.SetAttrib.count = 0;
	912	+ BltVertex vertex = (BltVertex)This->state.cmd->write_ptr_vertex;
	913	+ append_attrib_cmd(This, &tmp_cmd.SetAttrib, 0, 2, GL_FLOAT, GL_FALSE, sizeof(BltVertex), &vertex->x,
	914	+ TRUE, sizeof(MIN_STORAGE_CMD));
	915	+ if (!(cmd->Blt.cmd.flags & DDBLT_COLORFILL))
	916	+ append_attrib_cmd(This, &tmp_cmd.SetAttrib, 3, 2, GL_FLOAT, GL_FALSE, sizeof(BltVertex), &vertex->s,
	917	+ TRUE, sizeof(MIN_STORAGE_CMD));
	918	+ if(usedest)
	919	+ append_attrib_cmd(This, &tmp_cmd.SetAttrib, 4, 2, GL_FLOAT, GL_FALSE, sizeof(BltVertex), &vertex->dests,
	920	+ TRUE, sizeof(MIN_STORAGE_CMD));
	921	+ if (cmd->Blt.cmd.flags & 0x10000000) // Use clipper
	922	+ append_attrib_cmd(This, &tmp_cmd.SetAttrib, 5, 2, GL_FLOAT, GL_FALSE, sizeof(BltVertex), &vertex->stencils,
	923	+ TRUE, sizeof(MIN_STORAGE_CMD));
333	924	// Set render target
334	925	if ((This->state.target.target != cmd->Blt.cmd.dest)
335	926	\|\| (This->state.target.level != cmd->Blt.cmd.destlevel))
336	927	{
337	928	tmp_cmd.SetRenderTarget.opcode = OP_SETRENDERTARGET;
338		~~- tmp_cmd.SetRenderTarget.size = sizeof(SetRenderTargetCmd);~~
	929	+ tmp_cmd.SetRenderTarget.size = sizeof(SetRenderTargetCmd) - 8;
339	930	tmp_cmd.SetRenderTarget.target.target = cmd->Blt.cmd.dest;
340	931	tmp_cmd.SetRenderTarget.target.level = cmd->Blt.cmd.destlevel;
341	932	tmp_cmd.SetRenderTarget.target.zbuffer = NULL;
—	—	@@ -363,14 +954,47 @@
364	955	(This->state.viewport.width != r2.right) \|\| (This->state.viewport.hieght != r2.bottom))
365	956	{
366	957	tmp_cmd.SetViewport.opcode = OP_SETVIEWPORT;
367		~~- tmp_cmd.SetViewport.size = sizeof(SetViewportCmd);~~
	958	+ tmp_cmd.SetViewport.size = sizeof(SetViewportCmd) - 8;
368	959	tmp_cmd.SetViewport.viewport.x = tmp_cmd.SetViewport.viewport.y = 0;
369	960	tmp_cmd.SetViewport.viewport.width = r2.right;
370	961	tmp_cmd.SetViewport.viewport.hieght = r2.bottom;
371	962	glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
372	963	}
	964	+ // Disable depth test
	965	+ if (This->state.depthtest)
	966	+ {
	967	+ tmp_cmd.SetDepthTest.opcode = OP_SETDEPTHTEST;
	968	+ tmp_cmd.SetDepthTest.size = sizeof(SetDepthTestCmd);
	969	+ tmp_cmd.SetDepthTest.enabled = FALSE;
	970	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
	971	+ }
373	972	// Generate vertices
374		~~- /tmp_cmd.BltVertex_STORAGE.vertex/~~
	973	+ if (!memcmp(&cmd->Blt.cmd.srcrect, &nullrect, sizeof(RECT)))
	974	+ {
	975	+ r1.left = r1.top = 0;
	976	+ if (cmd->Blt.cmd.src)
	977	+ {
	978	+ r1.right = cmd->Blt.cmd.src->levels[cmd->Blt.cmd.srclevel].ddsd.dwWidth;
	979	+ r1.bottom = cmd->Blt.cmd.src->levels[cmd->Blt.cmd.srclevel].ddsd.dwHeight;
	980	+ }
	981	+ else r1.right = r1.bottom = 0;
	982	+ }
	983	+ else r1 = cmd->Blt.cmd.srcrect;
	984	+ if (!memcmp(&cmd->Blt.cmd.destrect, &nullrect, sizeof(RECT)))
	985	+ {
	986	+ r2.left = r2.top = 0;
	987	+ r2.right = cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwWidth;
	988	+ r2.bottom = cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwHeight;
	989	+ }
	990	+ else r2 = cmd->Blt.cmd.destrect;
	991	+ tmp_cmd.BltVertex_STORAGE.vertex[1].x = tmp_cmd.BltVertex_STORAGE.vertex[3].x = (GLfloat)r2.left;
	992	+ tmp_cmd.BltVertex_STORAGE.vertex[0].x = tmp_cmd.BltVertex_STORAGE.vertex[2].x = (GLfloat)r2.right;
	993	+ tmp_cmd.BltVertex_STORAGE.vertex[0].y = tmp_cmd.BltVertex_STORAGE.vertex[1].y = (GLfloat)cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwHeight - (GLfloat)r2.top;
	994	+ tmp_cmd.BltVertex_STORAGE.vertex[2].y = tmp_cmd.BltVertex_STORAGE.vertex[3].y = (GLfloat)cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwHeight - (GLfloat)r2.bottom;
	995	+ tmp_cmd.BltVertex_STORAGE.vertex[1].s = tmp_cmd.BltVertex_STORAGE.vertex[3].s = (GLfloat)r1.left / (GLfloat)cmd->Blt.cmd.src->levels[cmd->Blt.cmd.srclevel].ddsd.dwWidth;
	996	+ tmp_cmd.BltVertex_STORAGE.vertex[0].s = tmp_cmd.BltVertex_STORAGE.vertex[2].s = (GLfloat)r1.right / (GLfloat)cmd->Blt.cmd.src->levels[cmd->Blt.cmd.srclevel].ddsd.dwWidth;
	997	+ tmp_cmd.BltVertex_STORAGE.vertex[0].t = tmp_cmd.BltVertex_STORAGE.vertex[1].t = (GLfloat)r1.top / (GLfloat)cmd->Blt.cmd.src->levels[cmd->Blt.cmd.srclevel].ddsd.dwHeight;
	998	+ tmp_cmd.BltVertex_STORAGE.vertex[2].t = tmp_cmd.BltVertex_STORAGE.vertex[3].t = (GLfloat)r1.bottom / (GLfloat)cmd->Blt.cmd.src->levels[cmd->Blt.cmd.srclevel].ddsd.dwHeight;
375	999	if (usedest)
376	1000	{
377	1001	tmp_cmd.BltVertex_STORAGE.vertex[1].dests =
—	—	@@ -382,38 +1006,351 @@
383	1007	tmp_cmd.BltVertex_STORAGE.vertex[2].destt =
384	1008	tmp_cmd.BltVertex_STORAGE.vertex[3].destt = 1.0 - ((GLfloat)(r1.bottom - r1.top) / (GLfloat)This->backbuffer->levels[0].ddsd.dwHeight);
385	1009	}
	1010	+ if (cmd->Blt.cmd.flags & 0x10000000)
	1011	+ {
	1012	+ tmp_cmd.BltVertex_STORAGE.vertex[1].stencils = tmp_cmd.BltVertex_STORAGE.vertex[3].stencils = tmp_cmd.BltVertex_STORAGE.vertex[1].x / (GLfloat)cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwWidth;
	1013	+ tmp_cmd.BltVertex_STORAGE.vertex[0].stencils = tmp_cmd.BltVertex_STORAGE.vertex[2].stencils = tmp_cmd.BltVertex_STORAGE.vertex[0].x / (GLfloat)cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwWidth;
	1014	+ tmp_cmd.BltVertex_STORAGE.vertex[0].stencilt = tmp_cmd.BltVertex_STORAGE.vertex[1].stencilt = tmp_cmd.BltVertex_STORAGE.vertex[0].y / (GLfloat)cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwHeight;
	1015	+ tmp_cmd.BltVertex_STORAGE.vertex[2].stencilt = tmp_cmd.BltVertex_STORAGE.vertex[3].stencilt = tmp_cmd.BltVertex_STORAGE.vertex[2].y / (GLfloat)cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwHeight;
	1016	+ }
386	1017	// Rotate vertices if necessary
	1018	+ if ((cmd->Blt.cmd.bltfx.dwSize == sizeof(DDBLTFX)) && (cmd->Blt.cmd.flags & DDBLT_DDFX))
	1019	+ {
	1020	+ if (cmd->Blt.cmd.bltfx.dwDDFX & DDBLTFX_MIRRORLEFTRIGHT)
	1021	+ BltFlipLR(tmp_cmd.BltVertex_STORAGE.vertex);
	1022	+ if (cmd->Blt.cmd.bltfx.dwDDFX & DDBLTFX_MIRRORUPDOWN)
	1023	+ BltFlipUD(tmp_cmd.BltVertex_STORAGE.vertex);
	1024	+ if (cmd->Blt.cmd.bltfx.dwDDFX & DDBLTFX_ROTATE90) rotates++;
	1025	+ if (cmd->Blt.cmd.bltfx.dwDDFX & DDBLTFX_ROTATE180) rotates += 2;
	1026	+ if (cmd->Blt.cmd.bltfx.dwDDFX & DDBLTFX_ROTATE270) rotates += 3;
	1027	+ rotates &= 3;
	1028	+ if (rotates)
	1029	+ {
	1030	+ RotateBlt90(tmp_cmd.BltVertex_STORAGE.vertex, rotates);
	1031	+ }
	1032	+ }
	1033	+ // Create command and check buffers
	1034	+ Vertex2DCmd cmdout;
	1035	+ cmdout.opcode = OP_VERTEX2D;
	1036	+ cmdout.size = sizeof(Vertex2DCmd) - 8;
	1037	+ cmdout.count = 4;
	1038	+ cmdout.indexcount = 6;
	1039	+ if (usedest) cmdout.flags = 1;
	1040	+ else cmdout.flags = 0;
	1041	+ CheckCmdBuffer(This, cmdout.size + 8, 0, 4sizeof(BltVertex), 6sizeof(WORD));
387	1042	// Write vertices to VBO
	1043	+ cmdout.offset = This->state.cmd->write_ptr_vertex;
	1044	+ cmdout.indexoffset = This->state.cmd->write_ptr_index;
	1045	+ memcpy(This->state.cmd->vertices->pointer + This->state.cmd->write_ptr_vertex,
	1046	+ tmp_cmd.BltVertex_STORAGE.vertex, 4 * sizeof(BltVertex));
	1047	+ memcpy(This->state.cmd->indices->pointer + This->state.cmd->write_ptr_index,
	1048	+ indexbase, 6 * sizeof(WORD));
	1049	+ This->state.cmd->write_ptr_vertex += 4 * sizeof(BltVertex);
	1050	+ This->state.cmd->write_ptr_index += 6 * sizeof(WORD);
388	1051	// Write command to buffer
	1052	+ memcpy(This->state.cmd->cmdbuffer + This->state.cmd->write_ptr_cmd, &cmdout, cmdout.size + 8);
	1053	+ This->state.cmd->write_ptr_cmd_modify = This->state.cmd->write_ptr_cmd;
	1054	+ This->state.cmd->write_ptr_cmd += (cmdout.size + 8);
389	1055	}
390		~~- error = DDERR_CURRENTLYNOTAVAIL;~~
	1056	+ error = DD_OK;
391	1057	break;
392	1058	case OP_DRAWSCREEN: // Draws the screen. Flip command buffer after executing.
	1059	+ // First get window dimensions and adjust renderer window if necessary
	1060	+ if (cmd->DrawScreen.texture->levels[0].ddsd.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
	1061	+ {
	1062	+ GetClientRect(This->hWnd, &r1);
	1063	+ GetClientRect(This->RenderWnd->GetHWnd(), &r2);
	1064	+ if (memcmp(&r2, &r1, sizeof(RECT)))
	1065	+ SetWindowPos(This->RenderWnd->GetHWnd(), NULL, 0, 0, r1.right, r1.bottom, SWP_SHOWWINDOW);
	1066	+ }
	1067	+ LONG sizes[6];
	1068	+ GLfloat view[4];
	1069	+ GLint viewport[4];
	1070	+ This->ddInterface->GetSizes(sizes);
	1071	+ if (cmd->DrawScreen.texture->levels[0].ddsd.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
	1072	+ {
	1073	+ if (This->ddInterface->GetFullscreen())
	1074	+ {
	1075	+ viewport[0] = viewport[1] = 0;
	1076	+ viewport[2] = sizes[4];
	1077	+ viewport[3] = sizes[5];
	1078	+ view[0] = (GLfloat)-(sizes[4] - sizes[0]) / 2;
	1079	+ view[1] = (GLfloat)(sizes[4] - sizes[0]) / 2 + sizes[0];
	1080	+ view[2] = (GLfloat)(sizes[5] - sizes[1]) / 2 + sizes[1];
	1081	+ view[3] = (GLfloat)-(sizes[5] - sizes[1]) / 2;
	1082	+ }
	1083	+ else
	1084	+ {
	1085	+ viewport[0] = viewport[1] = 0;
	1086	+ viewport[2] = r2.right;
	1087	+ viewport[3] = r2.bottom;
	1088	+ ClientToScreen(This->RenderWnd->GetHWnd(), (LPPOINT)&r2.left);
	1089	+ ClientToScreen(This->RenderWnd->GetHWnd(), (LPPOINT)&r2.right);
	1090	+ view[0] = (GLfloat)r2.left;
	1091	+ view[1] = (GLfloat)r2.right;
	1092	+ view[2] = (GLfloat)cmd->DrawScreen.texture->bigheight - (GLfloat)r2.top;
	1093	+ view[3] = (GLfloat)cmd->DrawScreen.texture->bigheight - (GLfloat)r2.bottom;
	1094	+ }
	1095	+ }
	1096	+ else
	1097	+ {
	1098	+ view[0] = 0;
	1099	+ view[1] = (GLfloat)cmd->DrawScreen.texture->bigwidth;
	1100	+ view[2] = 0;
	1101	+ view[3] = (GLfloat)cmd->DrawScreen.texture->bigheight;
	1102	+ }
	1103	+ // Mark primary as front buffer and clear frontbuffer bit on previous
	1104	+ tmp_cmd.SetFrontBufferBits.opcode = OP_SETFRONTBUFFERBITS;
	1105	+ tmp_cmd.SetFrontBufferBits.size = sizeof(SetFrontBufferBitsCmd) - 8;
	1106	+ tmp_cmd.SetFrontBufferBits.front = cmd->DrawScreen.texture;
	1107	+ tmp_cmd.SetFrontBufferBits.back = cmd->DrawScreen.previous;
	1108	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
	1109	+ // Set Src texture (Unit 8) to primary
	1110	+ i = 0;
	1111	+ tmp_cmd.SetTexture.opcode = OP_SETTEXTURE;
	1112	+ tmp_cmd.SetTexture.size = sizeof(SetTextureCmd);
	1113	+ tmp_cmd.SetTexture.texstage[0].stage = 8;
	1114	+ tmp_cmd.SetTexture.texstage[0].texture = cmd->DrawScreen.texture;
	1115	+ // Set Palette texture (Unit 9) to palette if 8-bit
	1116	+ if (This->ddInterface->GetBPP() == 8)
	1117	+ {
	1118	+ i++;
	1119	+ tmp_cmd.SetTexture.size += (sizeof(DWORD) + sizeof(glTexture*));
	1120	+ tmp_cmd.SetTexture.texstage[1].stage = 9;
	1121	+ tmp_cmd.SetTexture.texstage[1].texture = cmd->DrawScreen.paltex;
	1122	+ }
	1123	+ tmp_cmd.SetTexture.count = i + 1;
	1124	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
	1125	+ // Disable depth test
	1126	+ tmp_cmd.SetDepthTest.opcode = OP_SETDEPTHTEST;
	1127	+ tmp_cmd.SetDepthTest.size = sizeof(SetDepthTestCmd) - 8;
	1128	+ tmp_cmd.SetDepthTest.enabled = FALSE;
	1129	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
393	1130	// If 8 bit scaled linear:
394		~~- // Set Src texture (Unit 8) to primary~~
395		~~- // Set Palette texture (Unit 9) to palette~~
396		~~- // Set shader mode and params~~
397		~~- // Set render target to backbuffer~~
398		~~- // Set viewport to backbuffer~~
399		~~- // Generate vertices~~
400		~~- // Write vertices to FBO~~
401		~~- // Write Palette draw command to buffer~~
402		~~- // Set Src texture (Unit 8) to backbuffer~~
403		~~- // Set shader mode and params~~
	1131	+ if ((This->ddInterface->GetBPP() == 8) && (dxglcfg.scalingfilter) &&
	1132	+ ((cmd->DrawScreen.texture->bigwidth != (view[1]-view[0])) \|\|
	1133	+ (cmd->DrawScreen.texture->bigheight != (view[3]-view[2]))))
	1134	+ {
	1135	+ // Check backbuffer size and resize
	1136	+ if ((This->backbuffer->levels[0].ddsd.dwWidth < cmd->DrawScreen.texture->bigwidth) \|\|
	1137	+ (This->backbuffer->levels[0].ddsd.dwHeight < cmd->DrawScreen.texture->bigheight))
	1138	+ {
	1139	+ DDSURFACEDESC2 newdesc = This->backbuffer->levels[0].ddsd;
	1140	+ if (newdesc.dwWidth < cmd->DrawScreen.texture->bigwidth)
	1141	+ newdesc.dwWidth = cmd->DrawScreen.texture->bigwidth;
	1142	+ if (newdesc.dwHeight < cmd->DrawScreen.texture->bigheight)
	1143	+ newdesc.dwHeight = cmd->DrawScreen.texture->bigheight;
	1144	+ tmp_cmd.SetTextureSurfaceDesc.opcode = OP_SETTEXTURESURFACEDESC;
	1145	+ tmp_cmd.SetTextureSurfaceDesc.size = sizeof(SetTextureSurfaceDescCmd) - 8;
	1146	+ tmp_cmd.SetTextureSurfaceDesc.level = 0;
	1147	+ tmp_cmd.SetTextureSurfaceDesc.desc = newdesc;
	1148	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, TRUE);
	1149	+ }
	1150	+ // Set shader to 256-color palette
	1151	+ tmp_cmd.SetShader2D.opcode = OP_SETSHADER2D;
	1152	+ tmp_cmd.SetShader2D.size = sizeof(SetShader2DCmd) - 8;
	1153	+ tmp_cmd.SetShader2D.type = 0;
	1154	+ tmp_cmd.SetShader2D.id = PROG_PAL256;
	1155	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
	1156	+ // Set shader uniforms
	1157	+ tmp_cmd.SetUniform.opcode = OP_SETUNIFORM;
	1158	+ tmp_cmd.SetUniform.size = sizeof(SetUniformCmdBase) - 8;
	1159	+ tmp_cmd.SetUniform.tmp_ptr = (BYTE*)&tmp_cmd.SetUniform.data;
	1160	+ tmp_cmd.SetUniform.count = 0;
	1161	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, This->shaders->shaders[PROG_PAL256].tex0,
	1162	+ 0, 0, FALSE, TRUE, sizeof(MIN_STORAGE_CMD), 8);
	1163	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, This->shaders->shaders[PROG_PAL256].pal,
	1164	+ 0, 0, FALSE, TRUE, sizeof(MIN_STORAGE_CMD), 9);
	1165	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, This->shaders->shaders[PROG_PAL256].view,
	1166	+ 7, 0, FALSE, TRUE, sizeof(MIN_STORAGE_CMD), view[0], view[1], view[2], view[3]);
	1167	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
	1168	+ // Set shader attributes
	1169	+ tmp_cmd.SetAttrib.opcode = OP_SETATTRIB;
	1170	+ tmp_cmd.SetAttrib.size = sizeof(SetAttribCmdBase) - 8;
	1171	+ tmp_cmd.SetAttrib.count = 0;
	1172	+ BltVertex vertex = (BltVertex)This->state.cmd->write_ptr_vertex;
	1173	+ append_attrib_cmd(This, &tmp_cmd.SetAttrib, This->shaders->shaders[PROG_PAL256].pos, 2, GL_FLOAT, GL_FALSE,
	1174	+ sizeof(BltVertex), &vertex->x, TRUE, sizeof(MIN_STORAGE_CMD));
	1175	+ append_attrib_cmd(This, &tmp_cmd.SetAttrib, This->shaders->shaders[PROG_PAL256].texcoord, 2, GL_FLOAT, GL_FALSE,
	1176	+ sizeof(BltVertex), &vertex->s, TRUE, sizeof(MIN_STORAGE_CMD));
	1177	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
	1178	+ // Set render target to backbuffer
	1179	+ if ((This->state.target.target != This->backbuffer) \|\| (This->state.target.target != 0))
	1180	+ {
	1181	+ tmp_cmd.SetRenderTarget.opcode = OP_SETRENDERTARGET;
	1182	+ tmp_cmd.SetRenderTarget.size = sizeof(SetRenderTargetCmd) - 8;
	1183	+ tmp_cmd.SetRenderTarget.target.target = This->backbuffer;
	1184	+ tmp_cmd.SetRenderTarget.target.level = 0;
	1185	+ tmp_cmd.SetRenderTarget.target.zbuffer = NULL;
	1186	+ tmp_cmd.SetRenderTarget.target.zlevel = 0;
	1187	+ tmp_cmd.SetRenderTarget.target.mulx = tmp_cmd.SetRenderTarget.target.muly = 1.0f;
	1188	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
	1189	+ }
	1190	+ // Set viewport to backbuffer
	1191	+ r2.right = This->backbuffer->levels[0].ddsd.dwWidth;
	1192	+ r2.bottom = This->backbuffer->levels[0].ddsd.dwHeight;
	1193	+ if (This->state.viewport.x \|\| This->state.viewport.y \|\|
	1194	+ (This->state.viewport.width != r2.right) \|\| (This->state.viewport.hieght != r2.bottom))
	1195	+ {
	1196	+ tmp_cmd.SetViewport.opcode = OP_SETVIEWPORT;
	1197	+ tmp_cmd.SetViewport.size = sizeof(SetViewportCmd) - 8;
	1198	+ tmp_cmd.SetViewport.viewport.x = tmp_cmd.SetViewport.viewport.y = 0;
	1199	+ tmp_cmd.SetViewport.viewport.width = r2.right;
	1200	+ tmp_cmd.SetViewport.viewport.hieght = r2.bottom;
	1201	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
	1202	+ }
	1203	+ // Generate vertices
	1204	+ r2.left = r2.top = 0;
	1205	+ r2.right = cmd->DrawScreen.texture->bigwidth;
	1206	+ r2.bottom = cmd->DrawScreen.texture->bigheight;
	1207	+ tmp_cmd.BltVertex_STORAGE.vertex[1].x = tmp_cmd.BltVertex_STORAGE.vertex[3].x = (GLfloat)r2.left;
	1208	+ tmp_cmd.BltVertex_STORAGE.vertex[0].x = tmp_cmd.BltVertex_STORAGE.vertex[2].x = (GLfloat)r2.right;
	1209	+ tmp_cmd.BltVertex_STORAGE.vertex[0].y = tmp_cmd.BltVertex_STORAGE.vertex[1].y = (GLfloat)cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwHeight - (GLfloat)r2.top;
	1210	+ tmp_cmd.BltVertex_STORAGE.vertex[2].y = tmp_cmd.BltVertex_STORAGE.vertex[3].y = (GLfloat)cmd->Blt.cmd.dest->levels[cmd->Blt.cmd.destlevel].ddsd.dwHeight - (GLfloat)r2.bottom;
	1211	+ tmp_cmd.BltVertex_STORAGE.vertex[1].s = tmp_cmd.BltVertex_STORAGE.vertex[3].s =
	1212	+ tmp_cmd.BltVertex_STORAGE.vertex[0].t = tmp_cmd.BltVertex_STORAGE.vertex[1].t = 0.0f;
	1213	+ tmp_cmd.BltVertex_STORAGE.vertex[0].s = tmp_cmd.BltVertex_STORAGE.vertex[2].s =
	1214	+ tmp_cmd.BltVertex_STORAGE.vertex[2].t = tmp_cmd.BltVertex_STORAGE.vertex[3].t = 1.0f;
	1215	+ // Create Palette draw command and check buffers
	1216	+ Vertex2DCmd cmdout;
	1217	+ cmdout.opcode = sizeof(Vertex2DCmd) - 8;
	1218	+ cmdout.count = 4;
	1219	+ cmdout.indexcount = 6;
	1220	+ cmdout.flags = 0;
	1221	+ CheckCmdBuffer(This, cmdout.size + 8, 0, 4 * sizeof(BltVertex), 6 * sizeof(WORD));
	1222	+ // Write vertices to VBO
	1223	+ cmdout.offset = This->state.cmd->write_ptr_vertex;
	1224	+ cmdout.indexoffset = This->state.cmd->write_ptr_index;
	1225	+ memcpy(This->state.cmd->vertices->pointer + This->state.cmd->write_ptr_vertex,
	1226	+ tmp_cmd.BltVertex_STORAGE.vertex, 4 * sizeof(BltVertex));
	1227	+ memcpy(This->state.cmd->indices->pointer + This->state.cmd->write_ptr_index,
	1228	+ indexbase, 6 * sizeof(WORD));
	1229	+ This->state.cmd->write_ptr_vertex += 4 * sizeof(BltVertex);
	1230	+ This->state.cmd->write_ptr_index += 6 * sizeof(WORD);
	1231	+ // Write command to buffer
	1232	+ memcpy(This->state.cmd->cmdbuffer + This->state.cmd->write_ptr_cmd, &cmdout, cmdout.size + 8);
	1233	+ This->state.cmd->write_ptr_cmd_modify = This->state.cmd->write_ptr_cmd;
	1234	+ This->state.cmd->write_ptr_cmd += (cmdout.size + 8);
	1235	+ // Set Src texture (Unit 8) to backbuffer
	1236	+ tmp_cmd.SetTexture.opcode = OP_SETTEXTURE;
	1237	+ tmp_cmd.SetTexture.size = sizeof(SetTextureCmd) + sizeof(DWORD) + sizeof(glTexture*);
	1238	+ tmp_cmd.SetTexture.texstage[0].stage = 8;
	1239	+ tmp_cmd.SetTexture.texstage[0].texture = This->backbuffer;
	1240	+ tmp_cmd.SetTexture.count = 1;
	1241	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
	1242	+ }
	1243	+ // Set shader and texture filter
	1244	+ if ((This->ddInterface->GetBPP() == 8) && (!dxglcfg.scalingfilter \|\|
	1245	+ ((cmd->DrawScreen.texture->bigwidth == (view[1] - view[0])) &&
	1246	+ (cmd->DrawScreen.texture->bigheight == (view[3] - view[2])))))
	1247	+ {
	1248	+ // 256 color, unscaled or scaled nearest
	1249	+ tmp_cmd.SetShader2D.opcode = OP_SETSHADER2D;
	1250	+ tmp_cmd.SetShader2D.size = sizeof(SetShader2DCmd) - 8;
	1251	+ tmp_cmd.SetShader2D.type = 0;
	1252	+ tmp_cmd.SetShader2D.id = PROG_PAL256;
	1253	+ shaderid = PROG_PAL256;
	1254	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
	1255	+ tmp_cmd.SetTextureStageState.opcode = OP_SETTEXTURESTAGESTATE;
	1256	+ tmp_cmd.SetTextureStageState.size = sizeof(SetTextureStageStateCmd) - 8 + sizeof(DWORD)
	1257	+ + sizeof(D3DTEXTURESTAGESTATETYPE);
	1258	+ tmp_cmd.SetTextureStageState.dwStage = 8;
	1259	+ tmp_cmd.SetTextureStageState.count = 2;
	1260	+ tmp_cmd.SetTextureStageState.state[0].dwState = D3DTSS_MAGFILTER;
	1261	+ tmp_cmd.SetTextureStageState.state[0].dwValue = D3DTFG_POINT;
	1262	+ tmp_cmd.SetTextureStageState.state[1].dwState = D3DTSS_MINFILTER;
	1263	+ tmp_cmd.SetTextureStageState.state[1].dwValue = D3DTFN_POINT;
	1264	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
	1265	+ }
	1266	+ else
	1267	+ {
	1268	+ // Full-color mode or 256-color scaled linear
	1269	+ tmp_cmd.SetShader2D.opcode = OP_SETSHADER2D;
	1270	+ tmp_cmd.SetShader2D.size = sizeof(SetShader2DCmd) - 8;
	1271	+ tmp_cmd.SetShader2D.type = 0;
	1272	+ tmp_cmd.SetShader2D.id = PROG_TEXTURE;
	1273	+ shaderid = PROG_TEXTURE;
	1274	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
	1275	+ tmp_cmd.SetTextureStageState.opcode = OP_SETTEXTURESTAGESTATE;
	1276	+ tmp_cmd.SetTextureStageState.size = sizeof(SetTextureStageStateCmd) - 8 + sizeof(DWORD)
	1277	+ + sizeof(D3DTEXTURESTAGESTATETYPE);
	1278	+ tmp_cmd.SetTextureStageState.dwStage = 8;
	1279	+ tmp_cmd.SetTextureStageState.count = 2;
	1280	+ tmp_cmd.SetTextureStageState.state[0].dwState = D3DTSS_MAGFILTER;
	1281	+ if(dxglcfg.scalingfilter)
	1282	+ tmp_cmd.SetTextureStageState.state[0].dwValue = D3DTFG_LINEAR;
	1283	+ else tmp_cmd.SetTextureStageState.state[0].dwValue = D3DTFG_POINT;
	1284	+ tmp_cmd.SetTextureStageState.state[1].dwState = D3DTSS_MINFILTER;
	1285	+ if (dxglcfg.scalingfilter)
	1286	+ tmp_cmd.SetTextureStageState.state[1].dwValue = D3DTFG_LINEAR;
	1287	+ else tmp_cmd.SetTextureStageState.state[1].dwValue = D3DTFN_POINT;
	1288	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
	1289	+ }
	1290	+ // Set shader uniforms
	1291	+ tmp_cmd.SetUniform.opcode = OP_SETUNIFORM;
	1292	+ tmp_cmd.SetUniform.size = sizeof(SetUniformCmdBase) - 8;
	1293	+ tmp_cmd.SetUniform.tmp_ptr = (BYTE*)&tmp_cmd.SetUniform.data;
	1294	+ tmp_cmd.SetUniform.count = 0;
	1295	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, This->shaders->shaders[shaderid].tex0,
	1296	+ 0, 0, FALSE, TRUE, sizeof(MIN_STORAGE_CMD), 8);
	1297	+ if (shaderid == PROG_PAL256)
	1298	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, This->shaders->shaders[shaderid].pal,
	1299	+ 0, 0, FALSE, TRUE, sizeof(MIN_STORAGE_CMD), 9);
	1300	+ append_uniform_cmd(This, &tmp_cmd.SetUniform, This->shaders->shaders[shaderid].view,
	1301	+ 7, 0, FALSE, TRUE, sizeof(MIN_STORAGE_CMD), view[0], view[1], view[2], view[3]);
	1302	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
	1303	+ // Set shader attributes
	1304	+ tmp_cmd.SetAttrib.opcode = OP_SETATTRIB;
	1305	+ tmp_cmd.SetAttrib.size = sizeof(SetAttribCmdBase) - 8;
	1306	+ tmp_cmd.SetAttrib.count = 0;
	1307	+ BltVertex vertex = (BltVertex)This->state.cmd->write_ptr_vertex;
	1308	+ append_attrib_cmd(This, &tmp_cmd.SetAttrib, This->shaders->shaders[shaderid].pos, 2, GL_FLOAT, GL_FALSE,
	1309	+ sizeof(BltVertex), &vertex->x, TRUE, sizeof(MIN_STORAGE_CMD));
	1310	+ append_attrib_cmd(This, &tmp_cmd.SetAttrib, This->shaders->shaders[shaderid].pos, 2, GL_FLOAT, GL_FALSE,
	1311	+ sizeof(BltVertex), &vertex->s, TRUE, sizeof(MIN_STORAGE_CMD));
	1312	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
404	1313	// Set render target to null
	1314	+ if (This->state.target.target)
	1315	+ {
	1316	+ tmp_cmd.SetRenderTarget.opcode = OP_SETRENDERTARGET;
	1317	+ tmp_cmd.SetRenderTarget.size = sizeof(SetRenderTargetCmd) - 8;
	1318	+ tmp_cmd.SetRenderTarget.target.target = NULL;
	1319	+ tmp_cmd.SetRenderTarget.target.level = 0;
	1320	+ tmp_cmd.SetRenderTarget.target.zbuffer = NULL;
	1321	+ tmp_cmd.SetRenderTarget.target.zlevel = 0;
	1322	+ tmp_cmd.SetRenderTarget.target.mulx = tmp_cmd.SetRenderTarget.target.muly = 1.0f;
	1323	+ glRenderer_AddCommand(This, &tmp_cmd, TRUE, FALSE);
	1324	+ }
405	1325	// Set viewport to window buffer
	1326	+ #error do viewport
406	1327	// Generate vertices
	1328	+ if (This->ddInterface->GetFullscreen())
	1329	+ {
	1330	+ This->bltvertices[0].x = This->bltvertices[2].x = (float)sizes[0];
	1331	+ This->bltvertices[0].y = This->bltvertices[1].y = This->bltvertices[1].x = This->bltvertices[3].x = 0.;
	1332	+ This->bltvertices[2].y = This->bltvertices[3].y = (float)sizes[1];
	1333	+ }
	1334	+ else
	1335	+ {
	1336	+ This->bltvertices[0].x = This->bltvertices[2].x = (float)texture->bigwidth;
	1337	+ This->bltvertices[0].y = This->bltvertices[1].y = This->bltvertices[1].x = This->bltvertices[3].x = 0.;
	1338	+ This->bltvertices[2].y = This->bltvertices[3].y = (float)texture->bigheight;
	1339	+ }
	1340	+ if ((This->ddInterface->GetBPP() == 8) && (dxglcfg.scalingfilter) &&
	1341	+ ((cmd->DrawScreen.texture->bigwidth != (view[1] - view[0])) \|\|
	1342	+ (cmd->DrawScreen.texture->bigheight != (view[3] - view[2]))))
	1343	+ {
	1344	+ #error do texcoord for backbuffer
	1345	+ }
	1346	+ else
	1347	+ {
	1348	+ This->bltvertices[0].s = This->bltvertices[0].t = This->bltvertices[1].t = This->bltvertices[2].s = 1.;
	1349	+ This->bltvertices[1].s = This->bltvertices[2].t = This->bltvertices[3].s = This->bltvertices[3].t = 0.;
	1350	+ }
	1351	+ // Write 2D Vertex command and check buffers
407	1352	// Write vertices to VBO
408		~~- // Write Draw command to buffer~~
409		~~- // If 8-bit unscaled or scaled nearest:~~
410		~~- // Set Src texture (Unit 8) to primary~~
411		~~- // Set Palette texture (Unit 9) to palette~~
412		~~- // Set shader mode and params~~
413		~~- // Set render target to null~~
414		~~- // Set viewport to window buffer~~
415		~~- // Generate vertices~~
416		~~- // Write vertices to VBO~~
417		~~- // Write Palette Draw command to buffer~~
	1353	+ // Set swap interval
	1354	+ // Swap buffers
418	1355	error = DDERR_CURRENTLYNOTAVAIL;
419	1356	break;
420	1357	case OP_INITD3D: // Initialize renderer for Direct3D rendering.
—	—	@@ -491,6 +1428,27 @@
492	1429	case OP_SETVIEWPORT:
493	1430	error = DDERR_CURRENTLYNOTAVAIL;
494	1431	break;
	1432	+ case OP_VERTEX2D:
	1433	+ error = DDERR_CURRENTLYNOTAVAIL;
	1434	+ break;
	1435	+ case OP_SETDEPTHTEST:
	1436	+ error = DDERR_CURRENTLYNOTAVAIL;
	1437	+ break;
	1438	+ case OP_SETFRONTBUFFERBITS:
	1439	+ error = DDERR_CURRENTLYNOTAVAIL;
	1440	+ break;
	1441	+ case OP_SETSWAP:
	1442	+ error = DDERR_CURRENTLYNOTAVAIL;
	1443	+ break;
	1444	+ case OP_SWAPBUFFERS:
	1445	+ error = DDERR_CURRENTLYNOTAVAIL;
	1446	+ break;
	1447	+ case OP_SETUNIFORM:
	1448	+ error = DDERR_CURRENTLYNOTAVAIL;
	1449	+ break;
	1450	+ case OP_SETATTRIB:
	1451	+ error = DDERR_CURRENTLYNOTAVAIL;
	1452	+ break;
495	1453	default:
496	1454	error = DDERR_INVALIDPARAMS;
497	1455	break;
Index: ddraw/glRenderer.h
—	—	@@ -97,6 +97,13 @@
98	98	#define OP_SETSHADER 30
99	99	#define OP_SETRENDERTARGET 31
100	100	#define OP_SETVIEWPORT 32
	101	+#define OP_VERTEX2D 33
	102	+#define OP_SETDEPTHTEST 34
	103	+#define OP_SETFRONTBUFFERBITS 35
	104	+#define OP_SETSWAP 36
	105	+#define OP_SWAPBUFFERS 37
	106	+#define OP_SETUNIFORM 38
	107	+#define OP_SETATTRIB 39
101	108
102	109	extern const DWORD renderstate_default[153];
103	110	extern const TEXTURESTAGE texstagedefault0;
—	—	@@ -148,7 +155,7 @@
149	156	size_t scenesize, scenesizevertex, scenesizeindex;
150	157	} glRenderer;
151	158
152		~~-HRESULT glRenderer_AddCommand(glRenderer This, QueueCmd command, BOOL inner, BOOL wait);~~
	159	+HRESULT glRenderer_AddCommand(glRenderer This, QueueCmd cmd, BOOL inner, BOOL wait);
153	160	void glRenderer_Init(glRenderer This, int width, int height, int bpp, BOOL fullscreen, unsigned int frequency, HWND hwnd, glDirectDraw7 glDD7, BOOL devwnd);
154	161	void glRenderer_Delete(glRenderer *This);
155	162	DWORD glRenderer_GetBPP(glRenderer *This);
—	—	@@ -226,6 +233,10 @@
227	234	void glRenderer__DXGLBreak(glRenderer *This);
228	235	void glRenderer__EndCommand(glRenderer *This, BOOL wait);
229	236
	237	+void BltFlipLR(BltVertex *vertices);
	238	+void BltFlipUD(BltVertex *vertices);
	239	+void RotateBlt90(BltVertex *vertices, int times);
	240	+
230	241	#ifdef __cplusplus
231	242	}
232	243	#endif
Index: ddraw/struct.h
—	—	@@ -181,7 +181,7 @@
182	182	ULONG busy;
183	183	GLuint buffer;
184	184	GLsizei size;
185		~~- void *pointer;~~
	185	+ GLbyte *pointer;
186	186	BOOL mapped;
187	187	BOOL bound;
188	188	BOOL target;
—	—	@@ -438,6 +438,7 @@
439	439	BufferObject *vertices;
440	440	BufferObject *indices;
441	441	size_t write_ptr_cmd;
	442	+ size_t write_ptr_cmd_modify;
442	443	size_t read_ptr_cmd;
443	444	size_t write_ptr_upload;
444	445	size_t read_ptr_upload;
Index: ddraw/struct_command.h
—	—	@@ -257,11 +257,108 @@
258	258	DWORD size;
259	259	VIEWPORT viewport;
260	260	} SetViewportCmd;
	261	+typedef struct Vertex2DCmd
	262	+{
	263	+ DWORD opcode;
	264	+ DWORD size;
	265	+ DWORD count;
	266	+ DWORD indexcount;
	267	+ DWORD flags;
	268	+ size_t offset;
	269	+ size_t indexoffset;
	270	+} Vertex2DCmd;
	271	+typedef struct SetDepthTestCmd
	272	+{
	273	+ DWORD opcode;
	274	+ DWORD size;
	275	+ BOOL enabled;
	276	+} SetDepthTestCmd;
	277	+typedef struct SetFrontBufferBitsCmd
	278	+{
	279	+ DWORD opcode;
	280	+ DWORD size;
	281	+ glTexture *front;
	282	+ glTexture *back;
	283	+} SetFrontBufferBitsCmd;
	284	+typedef struct SetSwapCmd
	285	+{
	286	+ DWORD opcode;
	287	+ DWORD size;
	288	+ GLint interval;
	289	+} SetSwapCmd;
	290	+typedef struct SwapBuffersCmd
	291	+{
	292	+ DWORD opcode;
	293	+ DWORD size;
	294	+} SwapBuffersCmd;
	295	+typedef struct SetUniformCmdData
	296	+{
	297	+ size_t size;
	298	+ GLint uniform;
	299	+ DWORD type;
	300	+ // Types:
	301	+ // bits 0-1 number of fields - 1 (0-3 for 1-4 fields)
	302	+ // bit 2 floating point if 1, int if 0
	303	+ // bit 3 unsigned if 1/double if float
	304	+ // bit 4 pointer
	305	+ // bit 5 square matrix
	306	+ // Special types, processed client side, converted to above types
	307	+ // 256 - Color key, count is the color order, first data is key,
	308	+ // second data is pointer to color sizes,
	309	+ // third data is pointer to color bits
	310	+ // 257 - Color fill, count is the color order, first data is fill color,
	311	+ // second data is pointer to color sizes,
	312	+ // third data is pointer to color bits
	313	+ GLsizei count; // ignored if not pointer or matrix
	314	+ BOOL transpose; // for matrices only
	315	+ GLint data[1];
	316	+} SetUniformCmdData;
	317	+typedef struct SetUniformCmd
	318	+{
	319	+ DWORD opcode;
	320	+ DWORD size;
	321	+ DWORD count;
	322	+ BYTE *tmp_ptr; // For the append command, ignored in the command buffer
	323	+ SetUniformCmdData data;
	324	+} SetUniformCmd;
	325	+typedef struct SetUniformCmdBase // For getting size of SetUniformCmd before adding data
	326	+{
	327	+ DWORD opcode;
	328	+ DWORD size;
	329	+ DWORD count;
	330	+ BYTE *tmp_ptr; // For the append command, ignored in the command buffer
	331	+} SetUniformCmdBase;
	332	+typedef struct SetAttribCmdData
	333	+{
	334	+ GLuint index;
	335	+ GLint size;
	336	+ GLint type;
	337	+ BOOL normalized;
	338	+ GLsizei stride;
	339	+ const GLvoid *ptr;
	340	+} SetAttribCmdData;
	341	+typedef struct SetAttribCmd
	342	+{
	343	+ DWORD opcode;
	344	+ DWORD size;
	345	+ DWORD count;
	346	+ SetAttribCmdData attrib[1];
	347	+} SetAttribCmd;
	348	+typedef struct SetAttribCmdBase
	349	+{
	350	+ DWORD opcode;
	351	+ DWORD size;
	352	+ DWORD count;
	353	+} SetAttribCmdBase;
261	354
262	355	typedef struct BltVertex_STORAGE_Cmd // Store vertices in stack for Blt()
	356	+// Also for variables for DrawScreen
263	357	{
264	358	BltVertex vertex[4];
265		~~- WORD index[64];~~
	359	+ WORD index[6];
	360	+ LONG sizes[6];
	361	+ GLfloat view[4];
	362	+ GLint viewport[4];
266	363	} BltVertex_STORAGE_Cmd;
267	364	typedef struct MIN_STORAGE_Cmd
268	365	{
—	—	@@ -300,6 +397,13 @@
301	398	SetShaderCmd SetShader;
302	399	SetRenderTargetCmd SetRenderTarget;
303	400	SetViewportCmd SetViewport;
	401	+ Vertex2DCmd Vertex2D;
	402	+ SetDepthTestCmd SetDepthTest;
	403	+ SetFrontBufferBitsCmd SetFrontBufferBits;
	404	+ SetSwapCmd SetSwap;
	405	+ SwapBuffersCmd SwapBuffers;
	406	+ SetUniformCmd SetUniform;
	407	+ SetAttribCmd SetAttrib;
304	408	BltVertex_STORAGE_Cmd BltVertex_STORAGE;
305	409	MIN_STORAGE_CMD MIN_STORAGE;
306	410	} QueueCmd;
—	—	@@ -311,6 +415,7 @@
312	416	BYTE *last_cmd_start;
313	417	RenderTarget target;
314	418	VIEWPORT viewport;
	419	+ BOOL depthtest;
315	420	} RenderState;
316	421
317	422	#endif //__STRUCT_COMMAND_H
\ No newline at end of file
Index: ddraw/util.c
—	—	@@ -123,16 +123,16 @@
124	124	0x00000000, // dwZBufferHigh
125	125	0x00000000, // dwZBufferBaseDest
126	126	0xFFFFFFFF, // dwZDestConstBitDepth
127		~~- (LPDIRECTDRAWSURFACE)0x00000000, // dwZDestConst and lpDDSZBufferDest~~
	127	+ 0x00000000, // dwZDestConst and lpDDSZBufferDest
128	128	0xFFFFFFFF, // dwZSrcConstBitDepth
129		~~- (LPDIRECTDRAWSURFACE)0x00000000, // dwZSrcConst and lpDDSZBufferSrc~~
	129	+ 0x00000000, // dwZSrcConst and lpDDSZBufferSrc
130	130	0xFFFFFFFF, // dwAlphaEdgeBlendBitDepth
131	131	0x00000000, // dwAlphaEdgeBlend
132	132	0x00000000, // dwReserved
133	133	0xFFFFFFFF, // dwAlphaDestConstBitDepth
134		~~- (LPDIRECTDRAWSURFACE)0x00000000, // dwAlphaDestConst and lpDDSAlphaDest~~
	134	+ 0x00000000, // dwAlphaDestConst and lpDDSAlphaDest
135	135	0xFFFFFFFF, // dwAlphaSrcConstBitDepth
136		~~- (LPDIRECTDRAWSURFACE)0x00000000, // dwAlphaSrcConst and lpDDSAlphaSrc~~
	136	+ 0x00000000, // dwAlphaSrcConst and lpDDSAlphaSrc
137	137	0x00000000, // dwFillColor, dwFillDepth, dwFillPixel, and lpDDSPattern
138	138	{0,0}, // ddckDestColorkey
139	139	{0,0} // ddckSrcColorkey
—	—	@@ -148,12 +148,12 @@
149	149	if(flags & DDBLT_ROP)
150	150	{
151	151	if (rop_texture_usage[(a->dwROP >> 16) & 0xFF] & 4)
152		~~- comp_mask.lpDDSPattern = _PTR_MASK;~~
	152	+ comp_mask.lpDDSPattern = (LPDIRECTDRAWSURFACE)_PTR_MASK;
153	153	}
154		~~- if (flags & DDBLT_ZBUFFERDESTOVERRIDE) comp_mask.lpDDSZBufferDest = _PTR_MASK;~~
155		~~- if (flags & DDBLT_ZBUFFERSRCOVERRIDE) comp_mask.lpDDSZBufferSrc = _PTR_MASK;~~
156		~~- if (flags & DDBLT_ALPHADESTSURFACEOVERRIDE) comp_mask.lpDDSAlphaDest = _PTR_MASK;~~
157		~~- if (flags & DDBLT_ALPHASRCSURFACEOVERRIDE) comp_mask.lpDDSAlphaSrc = _PTR_MASK;~~
	154	+ if (flags & DDBLT_ZBUFFERDESTOVERRIDE) comp_mask.lpDDSZBufferDest = (LPDIRECTDRAWSURFACE)_PTR_MASK;
	155	+ if (flags & DDBLT_ZBUFFERSRCOVERRIDE) comp_mask.lpDDSZBufferSrc = (LPDIRECTDRAWSURFACE)_PTR_MASK;
	156	+ if (flags & DDBLT_ALPHADESTSURFACEOVERRIDE) comp_mask.lpDDSAlphaDest = (LPDIRECTDRAWSURFACE)_PTR_MASK;
	157	+ if (flags & DDBLT_ALPHASRCSURFACEOVERRIDE) comp_mask.lpDDSAlphaSrc = (LPDIRECTDRAWSURFACE)_PTR_MASK;
158	158	AndMem(&comp_a, a, &comp_mask, sizeof(DDBLTFX));
159	159	AndMem(&comp_b, b, &comp_mask, sizeof(DDBLTFX));
160	160	if (!memcmp(&comp_a, &comp_b, sizeof(DDBLTFX))) return FALSE;

DXGL r691 - Code Review

Diff [purge]

Navigation menu

Search