anulax
/
stb
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

various voxel/caveview improvements

Browse Source
master
Sean Barrett ago%!(EXTRA string=10 years)
parent 0669a6659a
commit 0f8e471f7b
3 changed files with 132 additions and 80 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 143
      stb_voxel_render.h
  2. 45
      tests/caveview/cave_mesher.c
  3. 24
      tests/caveview/cave_render.c

143
stb_voxel_render.h
Unescape View File

@ -1,20 +1,21 @@
// @TODO
//
// - API for texture rotation on side faces (& top&bottom ?)
// - edge clamp
// - test API for texture rotation on side faces
// - API for texture rotation on top & bottom
// - better culling of vheight faces with vheight neighbors
// - better culling of non-vheight faces with fheight neighbors
// - gather vertex lighting from slopes correctly
// - better support texture edge_clamp: explicitly mod texcoords by 1, use textureGrad to avoid
// mipmap articats. Need to do compute texcoords in vertex shader, offset towards
// center before modding, need 2 bits per vertex to know offset direction (is implicit
// for modes without vertex data)
// - better support texture edge_clamp: currently if you fall
// exactly on 1.0 you get wrapped incorrectly; this is rare, but
// can avoid: compute texcoords in vertex shader, offset towards
// center before modding, need 2 bits per vertex to know offset direction)
// - add 10-byte quad type (loses per-face tex1/tex2 blend mode)
// - add 6-byte quad type (loses baked ao, most geometry, flags, texlerp)
// - add 4-byte quad type (only texture or only color, no baked light, no recolor)
// - fog properties
// - enable/disable fog at run-time
// stb_voxel_render.h - 0.01 - Sean Barrett, 2015
// stb_voxel_render.h - 0.01 - Sean Barrett, 2015 - public domain
//
// This library helps render large "voxel" worlds for games,
// in this case one with blocks that can have textures and that
@ -381,6 +382,7 @@ enum
#define STBVOX_MAKE_TEXLERP1(vert,e2,n2,w2,s2,u4,d2) STBVOX_MAKE_TEXLERP(s2, w2, d2, vert)
#define STBVOX_MAKE_TEXLERP2(vert,e2,n2,w2,s2,u4,d2) ((u2)*16 + (n2)*4 + (s2))
#define STBVOX_MAKE_FACE_MASK(e,n,w,s,u,d) ((e)+(n)*2+(w)*4+(s)*8+(u)*16+(d)*32)
#define STBVOX_MAKE_SIDE_TEXROT(e,n,w,s) ((e)+(n)*4+(w)*16+(s)*64)
#ifdef STBVOX_ROTATION_IN_LIGHTING
#define STBVOX_MAKE_LIGHTING(lighting, rot) (((lighting)&~3)+(rot))
@ -408,6 +410,7 @@ struct stbvox_input_description
unsigned char *tex2; // raw tex2 value to use on all sides of block
unsigned char *tex2_replace; // STBVOX_MAKE_TEX2_REPLACE -- tex2:6, face_1:2
unsigned char *tex2_facemask; // facemask:6 (use all bits of tex2_replace as texture)
unsigned char *side_texrot; // e:2,n:2,w:2,s:2 texture rotation
unsigned char *vheight; // STBVOX_MAKE_VHEIGHT -- sw:2, se:2, nw:2, ne:2, doesn't rotate
unsigned char *texlerp; // STBVOX_MAKE_TEXLERP -- vert:2, ud:2, ew:2, ns:2
unsigned char *texlerp2; // STBVOX_MAKE_TEXLERP2 (and use STBVOX_MAKE_TEXLERP1 for 'texlerp' -- e:2, n:2, u:3, unused:1
@ -440,11 +443,13 @@ struct stbvox_input_description
unsigned char *block_color;
unsigned char *block_texlerp;
unsigned char *block_selector;
unsigned char *block_side_texrot;
// indexed by overlay*6+side; in all cases 0 means 'nochange'
unsigned char (*overlay_tex1)[6];
unsigned char (*overlay_tex2)[6];
unsigned char (*overlay_color)[6];
unsigned char *overlay_side_texrot;
// indexed by extended_color
unsigned char *ecolor_color; // 256
@ -824,7 +829,7 @@ static char *stbvox_fragment_program =
"uniform vec4 camera_pos;\n" // 4th value is used for arbitrary hacking
// probably constant data
"uniform vec3 ambient[4];\n"
"uniform vec4 ambient[4];\n"
#ifndef STBVOX_ICONFIG_UNTEXTURED
// generally constant data
@ -875,7 +880,9 @@ static char *stbvox_fragment_program =
" vec3 texgen_s = texelFetch(texgen, int(texprojid)).xyz;\n"
" vec3 texgen_t = texelFetch(texgen, int(texprojid+32u)).xyz;\n"
" float tex1_scale = texelFetch(texscale, int(tex1_id & 127u)).x;\n"
#ifndef STBVOX_CONFIG_DISABLE_TEX2
" float tex2_scale = texelFetch(texscale, int(tex2_id & 127u)).y;\n"
#endif
" vec4 color = texelFetch(color_table, int(color_id & 63u));\n"
#endif
" vec2 texcoord;\n"
@ -883,35 +890,55 @@ static char *stbvox_fragment_program =
" texcoord.s = dot(texturespace_pos, texgen_s);\n"
" texcoord.t = dot(texturespace_pos, texgen_t);\n"
// @TODO: use 2 bits of facedata.w to enable animation of facedata.x & y?
" vec2 texcoord_1 = tex1_scale * texcoord;\n"
#ifndef STBVOX_CONFIG_DISABLE_TEX2
" vec2 texcoord_2 = tex2_scale * texcoord;\n"
#endif
#ifdef STBVOX_CONFIG_TEX1_EDGE_CLAMP
" texcoord_1 = texcoord_1 - floor(texcoord_1);\n"
" vec4 tex1 = textureGrad(tex_array[0], vec3(texcoord_1, float(tex1_id)), dFdx(tex1_scale*texcoord), dFdy(tex1_scale*texcoord));\n"
#else
" vec4 tex1 = texture(tex_array[0], vec3(texcoord_1, float(tex1_id)));\n"
#endif
" vec4 tex1 = texture(tex_array[0], vec3(tex1_scale * texcoord, float(tex1_id)));\n"
" vec4 tex2 = texture(tex_array[1], vec3(tex2_scale * texcoord, float(tex2_id)));\n"
#ifndef STBVOX_CONFIG_DISABLE_TEX2
#ifdef STBVOX_CONFIG_TEX2_EDGE_CLAMP
" texcoord_2 = texcoord_2 - floor(texcoord_2);\n"
" vec4 tex2 = textureGrad(tex_array[0], vec3(texcoord_2, float(tex2_id)), dFdx(tex2_scale*texcoord), dFdy(tex2_scale*texcoord));\n"
#else
" vec4 tex2 = texture(tex_array[1], vec3(texcoord_2, float(tex2_id)));\n"
#endif
#endif
" bool emissive = (int(color.w) & 1) != 0;\n"
// recolor textures
" if ((color_id & 64u) != 0u) tex1.xyz *= color.xyz;\n"
" if ((color_id & 128u) != 0u) tex2.xyz *= color.xyz;\n"
" fragment_alpha = tex1.a;\n"
#ifndef STBVOX_CONFIG_DISABLE_TEX2
" if ((color_id & 128u) != 0u) tex2.xyz *= color.xyz;\n"
#ifdef STBVOX_CONFIG_PREMULTIPLIED_ALPHA
" tex2.rgba *= texlerp;\n"
#else
" tex2.a *= texlerp;\n"
#endif
#ifdef STBVOX_CONFIG_PREMULTIPLIED_ALPHA
" tex2.rgba *= texlerp;\n"
#else
" tex2.a *= texlerp;\n"
#endif
" if (texblend_mode)\n"
" albedo = tex2.xyz * rlerp(tex2.a, 2.0*tex1.xyz, vec3(1.0,1.0,1.0));\n"
" else {\n"
#ifdef STBVOX_CONFIG_PREMULTIPLIED_ALPHA
" albedo = (1.0-tex2.a)*tex1.xyz + tex2.xyz;\n"
" if (texblend_mode)\n"
" albedo = tex2.xyz * rlerp(tex2.a, 2.0*tex1.xyz, vec3(1.0,1.0,1.0));\n"
" else {\n"
#ifdef STBVOX_CONFIG_PREMULTIPLIED_ALPHA
" albedo = (1.0-tex2.a)*tex1.xyz + tex2.xyz;\n"
#else
" albedo = rlerp(tex2.a, tex1.xyz, tex2.xyz);\n"
#endif
" fragment_alpha = tex1.a*(1-tex2.a)+tex2.a;\n"
" }\n"
#else
" albedo = rlerp(tex2.a, tex1.xyz, tex2.xyz);\n"
" albedo = tex1.xyz;\n"
#endif
" fragment_alpha = tex1.a*(1-tex2.a)+tex2.a;\n"
" }\n"
" fragment_alpha = tex1.a;\n"
#else // UNTEXTURED
" vec4 color;"
" color.xyz = vec3(facedata.xyz) / 255.0;\n"
@ -928,7 +955,7 @@ static char *stbvox_fragment_program =
" vec3 normal = vnormal;\n"
#endif
" vec3 ambient_color = dot(normal, ambient[0]) * ambient[1] + ambient[2];\n"
" vec3 ambient_color = dot(normal, ambient[0].xyz) * ambient[1].xyz + ambient[2].xyz;\n"
" ambient_color = clamp(ambient_color, 0.0, 1.0);"
" ambient_color *= amb_occ;\n"
@ -972,14 +999,15 @@ static char *stbvox_fragment_program =
"\n"
"vec3 compute_fog(vec3 color, vec3 relative_pos, float fragment_alpha)\n"
"{\n"
" float f = sqrt(dot(relative_pos,relative_pos))/1320.0;\n"
" float f = dot(relative_pos,relative_pos)*ambient[3].w;\n"
//" f = rlerp(f, -2,1);\n"
" f = clamp(f, 0.0, 1.0);\n"
" f = 3.0*f*f - 2.0*f*f*f;\n" // smoothstep
" f = f*f;\n" // fade in more smoothly
//" f = f*f;\n" // fade in more smoothly
#ifdef STBVOX_CONFIG_PREMULTIPLIED_ALPHA
" return rlerp(f, color.xyz, ambient[3]*fragment_alpha);\n"
" return rlerp(f, color.xyz, ambient[3].xyz*fragment_alpha);\n"
#else
" return rlerp(f, color.xyz, ambient[3]);\n"
" return rlerp(f, color.xyz, ambient[3].xyz);\n"
#endif
"}\n"
#endif
@ -1042,10 +1070,22 @@ static char *stbvox_fragment_program_alpha_only =
" texcoord.s = dot(texturespace_pos, texgen_s);\n"
" texcoord.t = dot(texturespace_pos, texgen_t);\n"
// @TODO: use 2 bits of facedata.w to enable animation of facedata.x & y?
" vec2 texcoord_1 = tex1_scale * texcoord;\n"
" vec2 texcoord_2 = tex2_scale * texcoord;\n"
" vec4 tex1 = texture(tex_array[0], vec3(tex1_scale * texcoord, float(tex1_id)));\n"
" vec4 tex2 = texture(tex_array[1], vec3(tex2_scale * texcoord, float(tex2_id)));\n"
#ifdef STBVOX_CONFIG_TEX1_EDGE_CLAMP
" texcoord_1 = texcoord_1 - floor(texcoord_1);\n"
" vec4 tex1 = textureGrad(tex_array[0], vec3(texcoord_1, float(tex1_id)), dFdx(tex1_scale*texcoord), dFdy(tex1_scale*texcoord));\n"
#else
" vec4 tex1 = texture(tex_array[0], vec3(texcoord_1, float(tex1_id)));\n"
#endif
#ifdef STBVOX_CONFIG_TEX2_EDGE_CLAMP
" texcoord_2 = texcoord_2 - floor(texcoord_2);\n"
" vec4 tex2 = textureGrad(tex_array[0], vec3(texcoord_2, float(tex2_id)), dFdx(tex2_scale*texcoord), dFdy(tex2_scale*texcoord));\n"
#else
" vec4 tex2 = texture(tex_array[1], vec3(texcoord_2, float(tex2_id)));\n"
#endif
" tex2.a *= texlerp;\n"
@ -1094,8 +1134,8 @@ static stbvox_uniform_info stbvox_uniforms[] =
{ STBVOX_UNIFORM_TYPE_vec4 , 16, 64, "color_table" , stbvox_default_palette[0] , STBVOX_TEXBUF },
{ STBVOX_UNIFORM_TYPE_vec3 , 12, 32, "normal_table" , stbvox_default_normals[0] },
{ STBVOX_UNIFORM_TYPE_vec3 , 12, 64, "texgen" , stbvox_default_texgen[0][0], STBVOX_TEXBUF },
{ STBVOX_UNIFORM_TYPE_vec3 , 12, 4, "ambient" , 0 },
{ STBVOX_UNIFORM_TYPE_vec4 , 12, 1, "camera_pos" , stbvox_dummy_transform[0] },
{ STBVOX_UNIFORM_TYPE_vec4 , 16, 4, "ambient" , 0 },
{ STBVOX_UNIFORM_TYPE_vec4 , 16, 1, "camera_pos" , stbvox_dummy_transform[0] },
};
STBVXDEC int stbvox_get_uniform_info(stbvox_uniform_info *info, int uniform)
@ -1141,6 +1181,7 @@ stbvox_mesh_face stbvox_compute_mesh_face_value(stbvox_mesh_maker *mm, stbvox_ro
stbvox_mesh_face face_data = { 0 };
stbvox_block_type bt = mm->input.blocktype[v_off];
unsigned char bt_face = STBVOX_ROTATE(face, rot.block);
int facerot = rot.facerot;
if (mm->input.color)
face_data.color = mm->input.color[v_off];
@ -1167,6 +1208,13 @@ stbvox_mesh_face stbvox_compute_mesh_face_value(stbvox_mesh_maker *mm, stbvox_ro
face_data.color = mcol;
}
if (face <= STBVOX_FACE_south) {
if (mm->input.side_texrot)
facerot = mm->input.side_texrot[v_off] >> (2 * face);
else if (mm->input.block_side_texrot)
facerot = mm->input.block_side_texrot[v_off] >> (2 * bt_face);
}
if (mm->input.overlay) {
int over_face = STBVOX_ROTATE(face, rot.overlay);
unsigned char over = mm->input.overlay[v_off];
@ -1185,7 +1233,11 @@ stbvox_mesh_face stbvox_compute_mesh_face_value(stbvox_mesh_maker *mm, stbvox_ro
if (rep3)
face_data.color = rep3;
}
if (face <= STBVOX_FACE_south)
facerot = mm->input.overlay_side_texrot[over] >> (2*over_face);
}
if (mm->input.tex2_for_tex1)
face_data.tex2 = mm->input.tex2_for_tex1[face_data.tex1];
if (mm->input.tex2)
@ -1195,19 +1247,22 @@ stbvox_mesh_face stbvox_compute_mesh_face_value(stbvox_mesh_maker *mm, stbvox_ro
if (mm->input.tex2_facemask[v_off] & (1 << tex2_face))
face_data.tex2 = mm->input.tex2_replace[v_off];
}
color_face = STBVOX_ROTATE(face, rot.ecolor);
if (mm->input.extended_color) {
unsigned char ec = mm->input.extended_color[v_off];
if (mm->input.ecolor_facemask[ec] & (1 << color_face))
face_data.color = mm->input.ecolor_color[ec];
}
if (mm->input.color2) {
if (mm->input.color2_facemask[v_off] & (1 << color_face))
face_data.color = mm->input.color2[v_off];
if (mm->input.color3 && (mm->input.color3_facemask[v_off] & (1 << color_face)))
face_data.color = mm->input.color3[v_off];
}
face_data.face_info = (normal<<2) + rot.facerot;
face_data.face_info = (normal<<2) + facerot;
return face_data;
}
@ -1309,8 +1364,9 @@ void stbvox_make_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int fac
if (mm->input.lighting_at_vertices) {
int i;
for (i=0; i < 4; ++i) {
*mv[i] = vertbase + face_coord[i];
+ stbvox_vertex_encode(0,0,0,mm->input.lighting[v_off + mm->cube_vertex_offset[face][i]] & 63,0);
*mv[i] = vertbase + face_coord[i]
+ stbvox_vertex_encode(0,0,0,mm->input.lighting[v_off + mm->cube_vertex_offset[face][i]] & 63,0)
+ p1[i];
}
} else {
unsigned char *amb = &mm->input.lighting[v_off];
@ -1330,7 +1386,8 @@ void stbvox_make_mesh_for_face(stbvox_mesh_maker *mm, stbvox_rotate rot, int fac
for (j=0; j < 4; ++j)
total += STBVOX_GET_LIGHTING(vamb[mm->vertex_gather_offset[face][j]]);
*mv[i] = vertbase + face_coord[i]
+ stbvox_vertex_encode(0,0,0,(total+STBVOX_LIGHTING_ROUNDOFF)>>4,0);
+ stbvox_vertex_encode(0,0,0,(total+STBVOX_LIGHTING_ROUNDOFF)>>4,0)
+ p1[i];
// >> 4 is because:
// >> 2 to divide by 4 to get average over 4 samples
// >> 2 because input is 8 bits, output is 6 bits
@ -2143,9 +2200,9 @@ void stbvox_get_transform(stbvox_mesh_maker *mm, float transform[3][3])
transform[1][1] = (float) (mm->pos_y);
transform[1][2] = (float) (mm->pos_z);
// texture coordinate projection translation
transform[2][0] = (float) (mm->pos_x & 63); // @TODO depends on max texture scale
transform[2][1] = (float) (mm->pos_y & 63);
transform[2][2] = (float) (mm->pos_z & 63);
transform[2][0] = (float) (mm->pos_x & 255); // @TODO depends on max texture scale
transform[2][1] = (float) (mm->pos_y & 255);
transform[2][2] = (float) (mm->pos_z & 255);
}
void stbvox_get_bounds(stbvox_mesh_maker *mm, float bounds[2][3])

45
tests/caveview/cave_mesher.c
Unescape View File

@ -21,8 +21,10 @@
#define STBVOX_CONFIG_PREFER_TEXBUFFER
//#define STBVOX_CONFIG_LIGHTING_SIMPLE
#define STBVOX_CONFIG_FOG_SMOOTHSTEP
//#define STBVOX_CONFIG_PREMULTIPLIED_ALPHA // use this even though it doesn't really work for alpha test without next #define
//#define STBVOX_CONFIG_UNPREMULTIPLY // slower, makes windows & fancy leaves look better
//#define STBVOX_CONFIG_PREMULTIPLIED_ALPHA // this doesn't work properly alpha test without next #define
//#define STBVOX_CONFIG_UNPREMULTIPLY // slower, fixes alpha test makes windows & fancy leaves look better
//#define STBVOX_CONFIG_TEX1_EDGE_CLAMP
#define STBVOX_CONFIG_DISABLE_TEX2
#define STBVOX_ROTATION_IN_LIGHTING
#define STB_VOXEL_RENDER_IMPLEMENTATION
@ -300,7 +302,6 @@ unsigned char minecraft_info[256][7] =
unsigned char minecraft_tex1_for_blocktype[256][6];
unsigned char effective_blocktype[256];
unsigned char effective_block_add[256];
unsigned char minecraft_color_for_blocktype[256][6];
unsigned char minecraft_geom_for_blocktype[256];
@ -703,26 +704,21 @@ unsigned char mc_rot[4] = { 1,3,2,0 };
// in lighting
void build_stair_rotations(int blocktype, unsigned char *map)
{
int i,j,k;
for (j=0; j < 2; ++j) {
int geom = j ? STBVOX_GEOM_ceil_slope_north_is_bottom : STBVOX_GEOM_floor_slope_north_is_top;
//int geom = STBVOX_GEOM_solid;
for (i=0; i < 4; ++i) {
if (i == 0 && j == 0) {
map[j*4+i+8] = map[j*4+i] = blocktype;
minecraft_geom_for_blocktype[blocktype] = (unsigned char) STBVOX_MAKE_GEOMETRY(geom, 0, 0);
} else {
map[j*4+i+8] = map[j*4+i] = next_blocktype;
int i;
for (k=0; k < 6; ++k) {
minecraft_color_for_blocktype[next_blocktype][k] = minecraft_color_for_blocktype[blocktype][k];
minecraft_tex1_for_blocktype [next_blocktype][k] = minecraft_tex1_for_blocktype [blocktype][k];
}
minecraft_geom_for_blocktype[next_blocktype] = (unsigned char) STBVOX_MAKE_GEOMETRY(geom, 0, 0);
--next_blocktype;
}
}
// use the existing block type for floor stairs; allocate a new type for ceil stairs
for (i=0; i < 6; ++i) {
minecraft_color_for_blocktype[next_blocktype][i] = minecraft_color_for_blocktype[blocktype][i];
minecraft_tex1_for_blocktype [next_blocktype][i] = minecraft_tex1_for_blocktype [blocktype][i];
}
minecraft_geom_for_blocktype[next_blocktype] = (unsigned char) STBVOX_MAKE_GEOMETRY(STBVOX_GEOM_ceil_slope_north_is_bottom, 0, 0);
minecraft_geom_for_blocktype[ blocktype] = (unsigned char) STBVOX_MAKE_GEOMETRY(STBVOX_GEOM_floor_slope_north_is_top, 0, 0);
for (i=0; i < 4; ++i) {
map[0+i+8] = map[0+i] = blocktype;
map[4+i+8] = map[4+i] = next_blocktype;
}
--next_blocktype;
}
void build_wool_variations(int bt, unsigned char *map)
@ -847,11 +843,4 @@ void mesh_init(void)
// set the remap flags for these so they write the rotation values
remap_in_place(54, 9);
remap_in_place(146, 10);
for (i=0; i < 256; ++i) {
if (remap[i])
effective_block_add[i] = 0;
else
effective_block_add[i] = effective_blocktype[i];
}
}

24
tests/caveview/cave_render.c
Unescape View File

@ -18,6 +18,7 @@
#include <math.h>
#include <assert.h>
//#define STBVOX_CONFIG_TEX1_EDGE_CLAMP
// currently no dynamic way to set mesh cache size or view distance
@ -182,6 +183,7 @@ static void upload_mesh_data(raw_mesh *rm)
GLint uniform_loc[16];
float table3[128][3];
float table4[64][4];
GLint tablei[2];
float step=0;
@ -238,9 +240,9 @@ void setup_uniforms(float pos[3])
// ambient direction is sky-colored upwards
// "ambient" lighting is from above
table3[0][0] = 0.3f;
table3[0][1] = -0.5f;
table3[0][2] = 0.9f;
table4[0][0] = 0.3f;
table4[0][1] = -0.5f;
table4[0][2] = 0.9f;
amb[1][0] = 0.3f; amb[1][1] = 0.3f; amb[1][2] = 0.3f; // dark-grey
amb[2][0] = 1.0; amb[2][1] = 1.0; amb[2][2] = 1.0; // white
@ -252,16 +254,16 @@ void setup_uniforms(float pos[3])
// amb[1] + (amb[2] - amb[1]) * dot/2 + (amb[2]-amb[1])/2
for (j=0; j < 3; ++j) {
table3[1][j] = (amb[2][j] - amb[1][j])/2 * bright;
table3[2][j] = (amb[1][j] + amb[2][j])/2 * bright;
table4[1][j] = (amb[2][j] - amb[1][j])/2 * bright;
table4[2][j] = (amb[1][j] + amb[2][j])/2 * bright;
}
// fog color
table3[3][0] = 0.6f, table3[3][1] = 0.7f, table3[3][2] = 0.9f;
// fog distance
//table3[3][3] = 1200;
table4[3][0] = 0.6f, table4[3][1] = 0.7f, table4[3][2] = 0.9f;
table4[3][3] = 1.0f / 1320.0f;
table4[3][3] *= table4[3][3];
data = table3;
data = table4;
break;
}
}
@ -407,6 +409,10 @@ void render_init(void)
glTexParameteri(GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MAX_ANISOTROPY_EXT, 16);
#ifdef STBVOX_CONFIG_TEX1_EDGE_CLAMP
glTexParameteri(GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
#endif
glGenerateMipmapEXT(GL_TEXTURE_2D_ARRAY_EXT);

Write Preview
Loading…
Cancel
Save