Текущее время: 05 дек 2020 20:32

Часовой пояс: UTC + 3 часа


Правила форума


Внимание! Все права на материалы опубликованные в этом форуме принадлежат их авторам! Перепечатка туториалов и статей разрешена только со ссылкой на этот сайт! В противном случае факт перепечатки считается нарушением авторских прав!



Новая тема Ответить
Страница 10 из 11
[ Сообщений: 158 ]
На страницу Пред.  1 ... 7, 8, 9, 10, 11  След.
Автор
Сообщение
Заголовок сообщения: Re: Re: The Winners, Episode Single Player for RTCW
СообщениеДобавлено: 03 янв 2015 03:53
Eugeny писал(а):
melc_av писал(а):
What is that Eugeny? More informations please?

The Victors on Bers@RtCW

I understand that the project is under development. That means isn't dead. It's a good news Eugeny. Thank you.
Заголовок сообщения: Re: Re: The Winners, Episode Single Player for RTCW
СообщениеДобавлено: 03 янв 2015 04:02
Изображение
_________________
Официальный сайт Project-X

Заголовок сообщения: Re: Re: The Winners, Episode Single Player for RTCW
СообщениеДобавлено: 03 янв 2015 07:13
See, it's still in development. This is really looking great, Eugeny. :+:
_________________
My Website: http://mikebwolf.wix.com/ronboyproductions

My Blogspot site with reviews of recent Rtcw Sp maps: http://ronboyreviews.blogspot.com/

Mod DB: http://www.moddb.com/members/ronboy
Заголовок сообщения: Re: Re: The Winners, Episode Single Player for RTCW
СообщениеДобавлено: 03 янв 2015 16:48
Короче, у меня печалька... Ни на одном из трёх компов игра на новом двиге не запускается...

Мой комп: _replace.vsh: bad GLSL shader
Berserker@Wolfenstein win-x86 Jan 3 2015
----- FS_Startup -----
Current search path:
d:\Временное\Игры\Return to Castle Wolfenstein\Victors\main\victors_1.pk3 (5320 files)
d:\Временное\Игры\Return to Castle Wolfenstein\Victors\main\victors_0.pk3 (905 files)
d:\Временное\Игры\Return to Castle Wolfenstein\Victors/main

----------------------
6225 files in pk3 files
execing default.cfg
couldn't exec language.cfg
exec <filename> : execute a script file
exec <filename> : execute a script file
Hunk_Clear: reset the hunk ok
...detecting OS, found NT: Windows XP x86 Professional
...detecting CPU, found AuthenticAMD MMX SSE SSE2 SSE3 (2/2 available/total logical CPUs) 2600 MHz
...switching keyboard to English
...using profile 'Серёга'
Registered for RawInput.
----- Client Initialization -----
----- Initializing Renderer ----
-------------------------------
----- Client Initialization Complete -----
----- R_Init -----
Initializing OpenGL subsystem
...initializing QGL
...calling LoadLibrary( 'C:\WINDOWS\system32\opengl32.dll' ): succeeded
...setting mode 10: 2048 1536 FullScreen
...WARNING: fullscreen unavailable in this mode
...setting mode 10: 2048 1536 Windowed
...registered window class
...created window@250,31 (2054x1562)
...getting DC: succeeded
...GLW_ChoosePFD( 32, 24 )
...95 PFDs found
...hardware acceleration found
...PIXELFORMAT 2 selected
...creating standart GL context: succeeded
...making context current: succeeded
...setting mode 10: 2048 1536 Windowed
...using WGL_ARB_create_context (ARB)
...deleting standard GL context: succeeded
...creating GL 3.2 compatible context: succeeded
...allocating 3982 bytes for 163 GL_EXTENSION strings
...using 503 bytes of WGL_EXTENSIONS string (ARB)
X..GL_S3_s3tc not found
X..ignoring compression for textures
X..ignoring compression for normalmaps
...using GL_EXT_texture_filter_anisotropic [Max.level 16]
...using WGL_EXT_swap_control (EXT)
X..WGL_EXT_swap_control_tear not found
...using WGL_AMD_gpu_association (AMD)
...using GL_EXT_framebuffer_blit (Core)
...using GL_ARB_multitexture (Core)
...using GL_EXT_texture_edge_clamp
...using GL_ARB_texture_border_clamp
...using GL_ARB_shader_objects (ARB)
...using GL_ARB_vertex_shader (Core)
...using GL_ARB_fragment_shader
...using GL_ARB_texture_cube_map
...using GL_ARB_vertex_buffer_object (Core)
...using GL_ARB_vertex_array_object (Core)
...using GL_ARB_framebuffer_object (Core)
...using GL_ARB_texture_rectangle
...using GL_ARB_draw_buffers (Core) [8]
...using GL_ARB_texture_float
...using GL_ARB_texture_rg
...using GL_ARB_occlusion_query2 (Core)

GL_VENDOR: ATI Technologies Inc.
GL_RENDERER: ATI Radeon HD 4600 Series
AMD h/w detected. Video RAM size: 512 MB total, 0 MB free.
GL_VERSION: 3.2.10061 Core Profile Forward-Compatible Context
GLSL_VERSION: 3.30
GL_MAX_TEXTURE_SIZE: 8192
GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB: 8192
GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB: 1024
GL_MAX_VERTEX_ATTRIBS_ARB: 16
GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB: 16
GL_MAX_TEXTURE_IMAGE_UNITS_ARB: 16
GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB: 32
GL_MAX_VARYING_FLOATS_ARB: 64
GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB: 1024
GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: 16

PIXELFORMAT: color(32-bits) depth(24-bit)
MODE: 10, 2048 x 1536 windowed hz: 60
Using OpenGL 3.2 compatibility profile context
RENDERER: fake PPL
GAMMA: glsl shader
CPU: AuthenticAMD MMX SSE SSE2 SSE3 (2/2 available/total logical CPUs)
texturemode: GL_LINEAR_MIPMAP_NEAREST
picmip: 0
colorMap compression: none
normalMap compression: none
Using ATI specific paths
Forcing glFinish
Initializing GLSL programs
...using medium integer precision
...using high float precision
Vertex shader '_replace.vsh'
1: #version 130
2: precision mediump int;
3: precision highp float;
4: #ifndef CSM
5: #define CSM
6: #endif
7: #ifndef FAKE_PPL
8: #define FAKE_PPL
9: #endif
10:

11: uniform mat4 u_ModelViewMatrix;

12: uniform mat4 u_ModelViewProjectionMatrix;

13: out vec3 v_clipVertex;

14: out vec4 color;

15: out vec2 texCoord;
16: #define GLSL_DEFORM_EXPAND 1.0

17: #define GLSL_DEFORM_WAVE 2.0

18: #define GLSL_DEFORM_BULGE 3.0

19: #define GLSL_DEFORM_MOVE 4.0

20: #define GLSL_DEFORM_WAVE2 5.0

21:

22: #define GF_NONE 0.0

23: #define GF_SIN 1.0

24: #define GF_SQUARE 2.0

25: #define GF_TRIANGLE 3.0

26: #define GF_SAWTOOTH 4.0

27: #define GF_INVERSE_SAWTOOTH 5.0

28:

29: in vec3 attr_Position;

30: in vec3 attr_Position2;

31: in vec4 attr_Color;

32: in vec2 attr_texCoords;

33: in vec2 attr_lightCoords;

34: in vec3 attr_Normal;

35:

36: uniform float u_deformParms[31]; // MAX_SHADER_DEFORMS * 9 + MAX_SHADER_DEFORMS + 1

37: uniform float u_backlerp;

38:

39: float TABLE(in float table, in float v)

40: {

41: if (table == GF_SIN)

42: return sin(v);

43: if (table == GF_SQUARE)

44: return sign(sin(v));

45: if (table == GF_TRIANGLE)

46: return max(1.0 - abs(v), 0.0);

47: if (table == GF_SAWTOOTH)

48: return v - floor(v);

49: if (table == GF_INVERSE_SAWTOOTH)

50: return 1.0 - (v - floor(v));

51: return 0.0; // GF_NONE

52: }

53:

54: vec4 DeformGeometry()

55: {

56: float f;

57: int j = 0, deformOffs = 0;

58: int numDeforms = int(u_deformParms[deformOffs++]);

59:

60: vec3 xyz = mix(attr_Position, attr_Position2, u_backlerp);

61:

62: // unroll deform loop (#define MAX_SHADER_DEFORMS 3)

63: // for stupid NVidia GLSL compiler (new Detonator + old cards like 9600GT/8500GT)

64: if (numDeforms > 0)
65: {

66: f = u_deformParms[deformOffs++];

67: if (f == GLSL_DEFORM_EXPAND)

68: { // queue:

69: // scale

70: xyz += attr_Normal * u_deformParms[deformOffs++];

71: }

72: if (f == GLSL_DEFORM_BULGE)

73: { // queue:

74: // backEnd.refdef.time * ds->bulgeSpeed * 0.001f

75: // ds->bulgeWidth

76: // ds->bulgeHeight

77: float now = u_deformParms[deformOffs++];

78: float off = 0.7853981634 * attr_texCoords.s * u_deformParms[deformOffs++] + now;

79: xyz += attr_Normal * sin(off) * u_deformParms[deformOffs++];

80: }

81: if (f == GLSL_DEFORM_WAVE)

82: { // queue:

83: // deformationSpread

84: // table

85: // base

86: // amplitude

87: // phase + freq

88: float off = 6.2831853072 * ( xyz.x + xyz.y + xyz.z ) * u_deformParms[deformOffs++];

89: float table = u_deformParms[deformOffs++];

90: float base = u_deformParms[deformOffs++];

91: float amplitude = u_deformParms[deformOffs++];

92: float pf = u_deformParms[deformOffs++] + off;

93: xyz += attr_Normal * (base + TABLE(table, pf) * amplitude);

94: }

95: if (f == GLSL_DEFORM_MOVE)

96: { // queue:

97: // ds->moveVector[0]

98: // ds->moveVector[1]

99: // ds->moveVector[2]

100: xyz.x += u_deformParms[deformOffs++];

101: xyz.y += u_deformParms[deformOffs++];

102: xyz.z += u_deformParms[deformOffs++];

103: }

104: if (f == GLSL_DEFORM_WAVE2)

105: { // queue:

106: // deformationSpread

107: // table

108: // base

109: // amplitude

110: // phase + freq

111: // 1.0 or -1.0 for inverse

112: // vec3 worldUp

113: float off = 6.2831853072 * ( xyz.x + xyz.y + xyz.z ) * u_deformParms[deformOffs++];

114: float table = u_deformParms[deformOffs++];

115: float base = u_deformParms[deformOffs++];

116: float amplitude = u_deformParms[deformOffs++];

117: float pf = u_deformParms[deformOffs++] + off;

118: float inverse = u_deformParms[deformOffs++];

119: vec3 worldUp;

120: worldUp[0] = u_deformParms[deformOffs++];

121: worldUp[1] = u_deformParms[deformOffs++];

122: worldUp[2] = u_deformParms[deformOffs++];

123: float m = max(0.0, (base + TABLE(table, pf) * amplitude) * dot(attr_Normal, worldUp));

124: xyz += worldUp * inverse * m;

125: }

126: }

127:

128: if (numDeforms > 1)
129: {

130: f = u_deformParms[deformOffs++];

131: if (f == GLSL_DEFORM_EXPAND)

132: { // queue:

133: // scale

134: xyz += attr_Normal * u_deformParms[deformOffs++];

135: }

136: if (f == GLSL_DEFORM_BULGE)

137: { // queue:

138: // backEnd.refdef.time * ds->bulgeSpeed * 0.001f

139: // ds->bulgeWidth

140: // ds->bulgeHeight

141: float now = u_deformParms[deformOffs++];

142: float off = 0.7853981634 * attr_texCoords.s * u_deformParms[deformOffs++] + now;

143: xyz += attr_Normal * sin(off) * u_deformParms[deformOffs++];

144: }

145: if (f == GLSL_DEFORM_WAVE)

146: { // queue:

147: // deformationSpread

148: // table

149: // base

150: // amplitude

151: // phase + freq

152: float off = 6.2831853072 * ( xyz.x + xyz.y + xyz.z ) * u_deformParms[deformOffs++];

153: float table = u_deformParms[deformOffs++];

154: float base = u_deformParms[deformOffs++];

155: float amplitude = u_deformParms[deformOffs++];

156: float pf = u_deformParms[deformOffs++] + off;

157: xyz += attr_Normal * (base + TABLE(table, pf) * amplitude);

158: }

159: if (f == GLSL_DEFORM_MOVE)

160: { // queue:

161: // ds->moveVector[0]

162: // ds->moveVector[1]

163: // ds->moveVector[2]

164: xyz.x += u_deformParms[deformOffs++];

165: xyz.y += u_deformParms[deformOffs++];

166: xyz.z += u_deformParms[deformOffs++];

167: }

168: if (f == GLSL_DEFORM_WAVE2)

169: { // queue:

170: // deformationSpread

171: // table

172: // base

173: // amplitude

174: // phase + freq

175: // 1.0 or -1.0 for inverse

176: // vec3 worldUp

177: float off = 6.2831853072 * ( xyz.x + xyz.y + xyz.z ) * u_deformParms[deformOffs++];

178: float table = u_deformParms[deformOffs++];

179: float base = u_deformParms[deformOffs++];

180: float amplitude = u_deformParms[deformOffs++];

181: float pf = u_deformParms[deformOffs++] + off;

182: float inverse = u_deformParms[deformOffs++];

183: vec3 worldUp;

184: worldUp[0] = u_deformParms[deformOffs++];

185: worldUp[1] = u_deformParms[deformOffs++];

186: worldUp[2] = u_deformParms[deformOffs++];

187: float m = max(0.0, (base + TABLE(table, pf) * amplitude) * dot(attr_Normal, worldUp));

188: xyz += worldUp * inverse * m;

189: }

190: }

191:

192: if (numDeforms > 2)
193: {

194: f = u_deformParms[deformOffs++];

195: if (f == GLSL_DEFORM_EXPAND)

196: { // queue:

197: // scale

198: xyz += attr_Normal * u_deformParms[deformOffs++];

199: }

200: if (f == GLSL_DEFORM_BULGE)

201: { // queue:

202: // backEnd.refdef.time * ds->bulgeSpeed * 0.001f

203: // ds->bulgeWidth

204: // ds->bulgeHeight

205: float now = u_deformParms[deformOffs++];

206: float off = 0.7853981634 * attr_texCoords.s * u_deformParms[deformOffs++] + now;

207: xyz += attr_Normal * sin(off) * u_deformParms[deformOffs++];

208: }

209: if (f == GLSL_DEFORM_WAVE)

210: { // queue:

211: // deformationSpread

212: // table

213: // base

214: // amplitude

215: // phase + freq

216: float off = 6.2831853072 * ( xyz.x + xyz.y + xyz.z ) * u_deformParms[deformOffs++];

217: float table = u_deformParms[deformOffs++];

218: float base = u_deformParms[deformOffs++];

219: float amplitude = u_deformParms[deformOffs++];

220: float pf = u_deformParms[deformOffs++] + off;

221: xyz += attr_Normal * (base + TABLE(table, pf) * amplitude);

222: }

223: if (f == GLSL_DEFORM_MOVE)

224: { // queue:

225: // ds->moveVector[0]

226: // ds->moveVector[1]

227: // ds->moveVector[2]

228: xyz.x += u_deformParms[deformOffs++];

229: xyz.y += u_deformParms[deformOffs++];

230: xyz.z += u_deformParms[deformOffs++];

231: }

232: if (f == GLSL_DEFORM_WAVE2)

233: { // queue:

234: // deformationSpread

235: // table

236: // base

237: // amplitude

238: // phase + freq

239: // 1.0 or -1.0 for inverse

240: // vec3 worldUp

241: float off = 6.2831853072 * ( xyz.x + xyz.y + xyz.z ) * u_deformParms[deformOffs++];

242: float table = u_deformParms[deformOffs++];

243: float base = u_deformParms[deformOffs++];

244: float amplitude = u_deformParms[deformOffs++];

245: float pf = u_deformParms[deformOffs++] + off;

246: float inverse = u_deformParms[deformOffs++];

247: vec3 worldUp;

248: worldUp[0] = u_deformParms[deformOffs++];

249: worldUp[1] = u_deformParms[deformOffs++];

250: worldUp[2] = u_deformParms[deformOffs++];

251: float m = max(0.0, (base + TABLE(table, pf) * amplitude) * dot(attr_Normal, worldUp));

252: xyz += worldUp * inverse * m;

253: }

254: }

255:

256:

257: return vec4(xyz, 1.0);

258: }
259: uniform vec4 u_gen;

260: uniform vec4 u_parm0;

261: uniform vec4 u_parm1;

262: uniform vec4 u_parm2;

263: uniform vec4 u_parma0;

264: uniform vec3 u_parma1;

265: uniform vec4 u_fogDistanceVector;

266: uniform vec4 u_fogDepthVector;

267: uniform float u_eyeT;

268:

269: #define GLSL_CGEN_CONST 0.0

270: #define GLSL_CGEN_LIGHTING_DIFFUSE 1.0

271: #define GLSL_CGEN_VERTEX 2.0

272: #define GLSL_CGEN_ONE_MINUS_VERTEX 3.0

273: #define GLSL_CGEN_VERTEX_ALPHA 4.0

274: #define GLSL_CGEN_ONE_MINUS_VERTEX_ALPHA 5.0

275:

276: #define GLSL_AGEN_CONST 0.0

277: #define GLSL_AGEN_LIGHTING_SPECULAR 1.0

278: #define GLSL_AGEN_VERTEX 2.0

279: #define GLSL_AGEN_ONE_MINUS_VERTEX 3.0

280: #define GLSL_AGEN_VERTEX_COLOR 4.0

281: #define GLSL_AGEN_ONE_MINUS_VERTEX_COLOR 5.0

282: #define GLSL_AGEN_PORTAL 6.0

283: #define GLSL_AGEN_NORMALZFADE 7.0

284: #define GLSL_AGEN_NORMALZFADE_ZOMBIEFX 8.0

285:

286: vec4 colorGen (in vec3 glVertex, in vec4 gen, in vec4 parm0, in vec4 parm1, in vec4 parm2, in vec4 parma0, in vec3 parma1)

287: {

288: vec4 col = parm0; // default is GLSL_CGEN_CONST

289:

290: if (gen.x == GLSL_CGEN_LIGHTING_DIFFUSE)

291: { // parm0.xyz = lightDir

292: // parm1 = ambientLight

293: // parm2 = directedLight

294: float incoming = dot(attr_Normal, parm0.xyz);

295: col = vec4(parm1.rgb + max(incoming, 0.0) * parm2.rgb, 1.0);

296: }

297: if (gen.x == GLSL_CGEN_VERTEX)

298: col = attr_Color;

299: if (gen.x == GLSL_CGEN_ONE_MINUS_VERTEX)

300: col = 1.0 - attr_Color;

301: if (gen.x == GLSL_CGEN_VERTEX_ALPHA)

302: col = vec4(attr_Color.a);

303: if (gen.x == GLSL_CGEN_ONE_MINUS_VERTEX_ALPHA)

304: col = 1.0 - vec4(attr_Color.a);

305:

306: if (gen.y >= GLSL_AGEN_CONST)

307: {

308: if (gen.y == GLSL_AGEN_CONST)

309: col.a = parm0.a;

310: if (gen.y == GLSL_AGEN_LIGHTING_SPECULAR)

311: { // parma0.xyz = backEnd.or.viewOrigin

312: vec3 lightDir = normalize(vec3(-960.0, 1980.0, 96.0) - glVertex);

313: float d = dot(attr_Normal, lightDir);

314: vec3 reflected = attr_Normal * 2.0 * d - lightDir;

315: vec3 viewer = parma0.xyz - glVertex;

316: float ilength = inversesqrt(dot(viewer, viewer));

317: float l = max(dot(reflected, viewer) * ilength, 0.0);

318: col.a = l*l*l*l;

319: }

320: if (gen.y == GLSL_AGEN_NORMALZFADE)

321: { // parma0.xyz = worldUp

322: // parma0.w = pStage->constantColor[3]/255.0

323: // parma1.x = lowest

324: // parma1.y = highest

325: // parma1.z = scale

326: float dt = dot(attr_Normal, parma0.xyz);

327: float range = (parma1.y - parma1.x) * 0.5;

328: if (dt > parma1.x && dt < parma1.y)

329: {

330: if (dt < parma1.x + range)

331: col.a = parma1.z * clamp(parma0.w * (dt - parma1.x) / range, 0.0, 1.0);

332: else

333: col.a = parma1.z * clamp(parma0.w * (1.0 - (dt - parma1.x - range) / range), 0.0, 1.0);

334: }

335: else

336: col.a = 0.0;

337: }

338: if (gen.y == GLSL_AGEN_NORMALZFADE_ZOMBIEFX)

339: { // parma0.xyz = worldUp

340: // parma0.w = backEnd.currentEntity->e.shaderRGBA[3] / 255.0

341: float dt = dot(attr_Normal, parma0.xyz);

342: float tmp = (dt + 1.0) * 0.5;

343: col.a = clamp(parma0.w * (tmp + 2.0 * (1.0 - tmp)), 0.0, 1.0);

344: }

345: if (gen.y == GLSL_AGEN_VERTEX)

346: col.a = attr_Color.a;

347: if (gen.y == GLSL_AGEN_ONE_MINUS_VERTEX)

348: col.a = 1.0 - attr_Color.a;

349: if (gen.y == GLSL_AGEN_VERTEX_COLOR)

350: col.a = (attr_Color.r + attr_Color.g + attr_Color.b) * 0.33333;

351: if (gen.y == GLSL_AGEN_ONE_MINUS_VERTEX_COLOR)

352: col.a = 1.0 - (attr_Color.r + attr_Color.g + attr_Color.b) * 0.33333;

353: if (gen.y == GLSL_AGEN_PORTAL)

354: { // parma0.xyz = backEnd.viewParms.or.origin

355: // parma0.w = 1.0 / tess.shader->portalRange

356: col.a = length(glVertex - parma0.xyz) * parma0.w;

357: }

358: }

359:

360: if (gen.z != 0.0) // ACFF_MODULATE_*

361: {

362: float s = dot(glVertex, u_fogDistanceVector.xyz) + u_fogDistanceVector.w;

363: float t = dot(glVertex, u_fogDepthVector.xyz) + u_fogDepthVector.w;

364: if (u_eyeT < 0.0)

365: {

366: if (t < 1.0)

367: return col; // point is outside, so no fogging

368: t = 1.0/32.0 + 30.0/32.0 * t / ( t - u_eyeT ); // cut the distance at the fog plane

369: }

370: else

371: {

372: if (t < 0.0)

373: return col; // point is outside, so no fogging

374: t = 31.0/32.0;

375: }

376: s -= 1.0/512.0;

377: if ( s < 0.0 )

378: return col;

379: if ( t < 31.0/32.0 )

380: s *= (t - 1.0/32.0) / (30.0/32.0);

381: s = min(s * 8.0, 1.0);

382: float f = 1.0 - sqrt(s);

383: if (gen.z == 1.0) // ACFF_MODULATE_RGB

384: col.rgb *= f;

385: if (gen.z == 2.0) // ACFF_MODULATE_ALPHA

386: col.a *= f;

387: if (gen.z == 3.0) // ACFF_MODULATE_RGBA

388: col *= f;

389: }

390:

391: return col;

392: }
393: uniform vec2 u_tgen;

394: uniform vec3 u_parmtc;

395: uniform vec3 u_tcGenVectorS;

396: uniform vec3 u_tcGenVectorT;

397: uniform float u_tcModParms[29]; // TR_MAX_TEXMODS * 6 + TR_MAX_TEXMODS + 1

398:

399: #define TCGEN_TEXTURE 1.0

400: #define TCGEN_LIGHTMAP 2.0

401: #define TCGEN_ENVIRONMENT_MAPPED 3.0

402: #define TCGEN_FIRERISEENV_MAPPED 4.0

403: #define TCGEN_FOG 5.0

404: #define TCGEN_VECTOR 6.0

405:

406: #define GLSL_TMOD_NONE 0.0

407: #define GLSL_TMOD_TURBULENT 1.0

408: #define GLSL_TMOD_MATRIX 2.0

409: #define GLSL_TMOD_SWAP 3.0

410:

411: void tcGen (out vec2 st, in vec3 glVertex)

412: {

413: int tcOffs = 0;

414: // texGen:

415: st = vec2(0.0); // TCGEN_BAD (default) shut up compiler :(

416: if (u_tgen.x == TCGEN_TEXTURE)

417: st = attr_texCoords;

418: if (u_tgen.x == TCGEN_LIGHTMAP)

419: st = attr_lightCoords;

420: if (u_tgen.x == TCGEN_ENVIRONMENT_MAPPED)

421: { // u_parmtc = backEnd.or.viewOrigin

422: vec3 viewer = normalize(u_parmtc - glVertex);

423: float d = dot(attr_Normal, viewer);

424: vec3 reflected = attr_Normal * 2.0 * d - viewer;

425: st = 0.5 + reflected.yz * vec2(0.5, -0.5);

426: }

427: if (u_tgen.x == TCGEN_FIRERISEENV_MAPPED)

428: { // u_parmtc = normalize(-backEnd.currentEntity->e.fireRiseDir)

429: float d = dot(attr_Normal, u_parmtc);

430: vec3 reflected = attr_Normal * 2.0 * d - u_parmtc;

431: st = 0.5 + reflected.yz * vec2(0.5, -0.5);

432: }

433: if (u_tgen.x == TCGEN_FOG)

434: {

435: st.s = dot(glVertex, u_fogDistanceVector.xyz) + u_fogDistanceVector.w;

436: st.t = dot(glVertex, u_fogDepthVector.xyz) + u_fogDepthVector.w;

437: if (u_eyeT < 0.0)

438: {

439: if (st.t < 1.0)

440: st.t = 1.0/32.0; // point is outside, so no fogging

441: else

442: st.t = 1.0/32.0 + 30.0/32.0 * st.t / ( st.t - u_eyeT ); // cut the distance at the fog plane

443: }

444: else

445: {

446: if (st.t < 0.0)

447: st.t = 1.0/32.0; // point is outside, so no fogging

448: else

449: st.t = 31.0/32.0;

450: }

451: }

452: if (u_tgen.x == TCGEN_VECTOR)

453: st = vec2( dot(glVertex, u_tcGenVectorS), dot(glVertex, u_tcGenVectorT) );
454: {

455: float f = u_tcModParms[tcOffs++];

456: if (f == GLSL_TMOD_NONE)

457: return;

458: if (f == GLSL_TMOD_MATRIX)

459: { // stupid ATI HD2600 can't parse 'a*u[t++]+b*u[t++]+u[t++]' :((

460: vec2 sm = st;

461: float pa, pb, pc, pd, pe, pf;

462: pa = u_tcModParms[tcOffs++];

463: pb = u_tcModParms[tcOffs++];

464: pc = u_tcModParms[tcOffs++];

465: pd = u_tcModParms[tcOffs++];

466: pe = u_tcModParms[tcOffs++];

467: pf = u_tcModParms[tcOffs++];

468: st.s = dot(vec3(sm, 1.0), vec3(pa, pb, pc));

469: st.t = dot(vec3(sm, 1.0), vec3(pd, pe, pf));

470: }

471: if (f == GLSL_TMOD_TURBULENT)

472: {

473: vec2 sm;

474: float now = u_tcModParms[tcOffs++];

475: float amplitude = u_tcModParms[tcOffs++];

476: sm.x = sin(((glVertex.x + glVertex.z) * 0.125/128.0 + now) * 2.0 * 3.14159);

477: sm.y = sin((glVertex.y * 0.125/128.0 + now) * 2.0 * 3.14159);

478: st += sm * amplitude;

479: }

480: if (f == GLSL_TMOD_SWAP)

481: {

482: vec2 sm = st;

483: st = vec2(sm.t, 1.0 - sm.s);

484: }

485: }
486: {

487: float f = u_tcModParms[tcOffs++];

488: if (f == GLSL_TMOD_NONE)

489: return;

490: if (f == GLSL_TMOD_MATRIX)

491: { // stupid ATI HD2600 can't parse 'a*u[t++]+b*u[t++]+u[t++]' :((

492: vec2 sm = st;

493: float pa, pb, pc, pd, pe, pf;

494: pa = u_tcModParms[tcOffs++];

495: pb = u_tcModParms[tcOffs++];

496: pc = u_tcModParms[tcOffs++];

497: pd = u_tcModParms[tcOffs++];

498: pe = u_tcModParms[tcOffs++];

499: pf = u_tcModParms[tcOffs++];

500: st.s = dot(vec3(sm, 1.0), vec3(pa, pb, pc));

501: st.t = dot(vec3(sm, 1.0), vec3(pd, pe, pf));

502: }

503: if (f == GLSL_TMOD_TURBULENT)

504: {

505: vec2 sm;

506: float now = u_tcModParms[tcOffs++];

507: float amplitude = u_tcModParms[tcOffs++];

508: sm.x = sin(((glVertex.x + glVertex.z) * 0.125/128.0 + now) * 2.0 * 3.14159);

509: sm.y = sin((glVertex.y * 0.125/128.0 + now) * 2.0 * 3.14159);

510: st += sm * amplitude;

511: }

512: if (f == GLSL_TMOD_SWAP)

513: {

514: vec2 sm = st;

515: st = vec2(sm.t, 1.0 - sm.s);

516: }

517: }
518: {

519: float f = u_tcModParms[tcOffs++];

520: if (f == GLSL_TMOD_NONE)

521: return;

522: if (f == GLSL_TMOD_MATRIX)

523: { // stupid ATI HD2600 can't parse 'a*u[t++]+b*u[t++]+u[t++]' :((

524: vec2 sm = st;

525: float pa, pb, pc, pd, pe, pf;

526: pa = u_tcModParms[tcOffs++];

527: pb = u_tcModParms[tcOffs++];

528: pc = u_tcModParms[tcOffs++];

529: pd = u_tcModParms[tcOffs++];

530: pe = u_tcModParms[tcOffs++];

531: pf = u_tcModParms[tcOffs++];

532: st.s = dot(vec3(sm, 1.0), vec3(pa, pb, pc));

533: st.t = dot(vec3(sm, 1.0), vec3(pd, pe, pf));

534: }

535: if (f == GLSL_TMOD_TURBULENT)

536: {

537: vec2 sm;

538: float now = u_tcModParms[tcOffs++];

539: float amplitude = u_tcModParms[tcOffs++];

540: sm.x = sin(((glVertex.x + glVertex.z) * 0.125/128.0 + now) * 2.0 * 3.14159);

541: sm.y = sin((glVertex.y * 0.125/128.0 + now) * 2.0 * 3.14159);

542: st += sm * amplitude;

543: }

544: if (f == GLSL_TMOD_SWAP)

545: {

546: vec2 sm = st;

547: st = vec2(sm.t, 1.0 - sm.s);

548: }

549: }
550: {

551: float f = u_tcModParms[tcOffs++];

552: if (f == GLSL_TMOD_NONE)

553: return;

554: if (f == GLSL_TMOD_MATRIX)

555: { // stupid ATI HD2600 can't parse 'a*u[t++]+b*u[t++]+u[t++]' :((

556: vec2 sm = st;

557: float pa, pb, pc, pd, pe, pf;

558: pa = u_tcModParms[tcOffs++];

559: pb = u_tcModParms[tcOffs++];

560: pc = u_tcModParms[tcOffs++];

561: pd = u_tcModParms[tcOffs++];

562: pe = u_tcModParms[tcOffs++];

563: pf = u_tcModParms[tcOffs++];

564: st.s = dot(vec3(sm, 1.0), vec3(pa, pb, pc));

565: st.t = dot(vec3(sm, 1.0), vec3(pd, pe, pf));

566: }

567: if (f == GLSL_TMOD_TURBULENT)

568: {

569: vec2 sm;

570: float now = u_tcModParms[tcOffs++];

571: float amplitude = u_tcModParms[tcOffs++];

572: sm.x = sin(((glVertex.x + glVertex.z) * 0.125/128.0 + now) * 2.0 * 3.14159);

573: sm.y = sin((glVertex.y * 0.125/128.0 + now) * 2.0 * 3.14159);

574: st += sm * amplitude;

575: }

576: if (f == GLSL_TMOD_SWAP)

577: {

578: vec2 sm = st;

579: st = vec2(sm.t, 1.0 - sm.s);

580: }

581: }

582:

583: }

584:

585: void main(void)

586: {

587: vec4 glVertex = DeformGeometry();

588: color = colorGen(glVertex.xyz, u_gen, u_parm0, u_parm1, u_parm2, u_parma0, u_parma1);

589: tcGen(texCoord, glVertex.xyz);

590: gl_Position = u_ModelViewProjectionMatrix * glVertex;

591: v_clipVertex = (u_ModelViewMatrix * glVertex).xyz;

592: }

593:

----- CL_Shutdown -----
RE_Shutdown( 1 )
Shutting down OpenGL subsystem
...wglMakeCurrent( NULL, NULL ): success
...deleting GL context: success
...releasing DC: success
...destroying window
...shutting down QGL
...unloading OpenGL DLL
-----------------------
_replace.vsh: bad GLSL shader


Комп дочки: GL_ARB_shader_objects not found

Berserker@Wolfenstein win-x86 Jan 3 2015
----- FS_Startup -----
Current search path:
e:\Games\Victors\main\victors_1.pk3 (5320 files)
e:\Games\Victors\main\victors_0.pk3 (905 files)
e:\Games\Victors/main

----------------------
6225 files in pk3 files
execing default.cfg
couldn't exec language.cfg
exec <filename> : execute a script file
exec <filename> : execute a script file
Hunk_Clear: reset the hunk ok
...detecting OS, found NT: Windows XP x86 Professional
...detecting CPU, found GenuineIntel MMX SSE SSE2 SSE3 (2/2 available/total logical CPUs) 3400 MHz
...switching keyboard to English
...using profile 'E?ony'
Registered for RawInput.
----- Client Initialization -----
----- Initializing Renderer ----
-------------------------------
----- Client Initialization Complete -----
----- R_Init -----
Initializing OpenGL subsystem
...initializing QGL
...calling LoadLibrary( 'C:\WINDOWS\system32\opengl32.dll' ): succeeded
...setting mode 2: 512 384 FullScreen
...registered window class
...created window@0,0 (512x384)
...getting DC: succeeded
...GLW_ChoosePFD( 32, 24 )
...41 PFDs found
...hardware acceleration found
...PIXELFORMAT 6 selected
...creating standart GL context: succeeded
...making context current: succeeded
...WGL_ARB_create_context not found
...using 1142 bytes of GL_EXTENSIONS string
...using 158 bytes of WGL_EXTENSIONS string (ARB)
X..GL_S3_s3tc not found
X..ignoring compression for textures
X..ignoring compression for normalmaps
...using GL_EXT_texture_filter_anisotropic [Max.level 4]
...using WGL_EXT_swap_control (EXT)
X..WGL_EXT_swap_control_tear not found
X..WGL_AMD_gpu_association not found
X..GL_EXT_framebuffer_blit not found
...using GL_ARB_multitexture (Core) [8 TMUs]
X..GL_EXT_texture_edge_clamp not found
...using GL_ARB_texture_border_clamp
----- CL_Shutdown -----
RE_Shutdown( 1 )
Shutting down OpenGL subsystem
...wglMakeCurrent( NULL, NULL ): success
...deleting GL context: success
...releasing DC: success
...destroying window
...shutting down QGL
...unloading OpenGL DLL
-----------------------
GL_ARB_shader_objects not found


Комп сына: glGetString(GL_EXTENSIONS) returned NULL

Berserker@Wolfenstein win-x86 Jan 3 2015
----- FS_Startup -----
Current search path:
D:\ea?u\Victors\main\victors_1.pk3 (5320 files)
D:\ea?u\Victors\main\victors_0.pk3 (905 files)
D:\ea?u\Victors/main

----------------------
6225 files in pk3 files
execing default.cfg
couldn't exec language.cfg
exec <filename> : execute a script file
exec <filename> : execute a script file
Hunk_Clear: reset the hunk ok
...detecting OS, found NT: Windows 7 x64 Ultimate Edition
...detecting CPU, found AuthenticAMD MMX SSE SSE2 SSE3 (2/2 available/total logical CPUs) 3000 MHz
...switching keyboard to English
...using profile 'eoe?ia'
Registered for RawInput.
----- Client Initialization -----
----- Initializing Renderer ----
-------------------------------
----- Client Initialization Complete -----
----- R_Init -----
Initializing OpenGL subsystem
...initializing QGL
...calling LoadLibrary( 'C:\Windows\system32\opengl32.dll' ): succeeded
...setting mode 10: 2048 1536 FullScreen
...WARNING: fullscreen unavailable in this mode
...setting mode 10: 2048 1536 Windowed
...registered window class
...created window@250,31 (2054x1564)
...getting DC: succeeded
...GLW_ChoosePFD( 32, 24 )
...101 PFDs found
...hardware acceleration found
...PIXELFORMAT 7 selected
...creating standart GL context: succeeded
...making context current: succeeded
...setting mode 10: 2048 1536 Windowed
...using WGL_ARB_create_context (ARB)
...deleting standard GL context: succeeded
...creating GL 3.2 compatible context: succeeded
glGetStringi: bad getprocaddress
----- CL_Shutdown -----
RE_Shutdown( 1 )
Shutting down OpenGL subsystem
...wglMakeCurrent( NULL, NULL ): failed
...releasing DC: success
...destroying window
...shutting down QGL
...unloading OpenGL DLL
-----------------------
glGetString(GL_EXTENSIONS) returned NULL
Заголовок сообщения: Re: Re: The Winners, Episode Single Player for RTCW
СообщениеДобавлено: 03 янв 2015 17:02
The Sims 3: Wolfenstein :D

Изображение
_________________
Официальный сайт Project-X

Заголовок сообщения: Re: Re: The Winners, Episode Single Player for RTCW
СообщениеДобавлено: 04 янв 2015 17:50
Скачал Catalist 13.1 - всё запустилось и работает пучком!
Заголовок сообщения: Re: Re: The Winners, Episode Single Player for RTCW
СообщениеДобавлено: 07 янв 2015 17:41
Hi all,
The victors will have 14 playable maps?
Thanks in advance!
Заголовок сообщения: Re: Re: The Winners, Episode Single Player for RTCW
СообщениеДобавлено: 10 янв 2015 10:30
Изображение
Изображение
_________________
Официальный сайт Project-X

Заголовок сообщения: Re: Re: The Winners, Episode Single Player for RTCW
СообщениеДобавлено: 10 янв 2015 11:21
Проволока снос мозга! :2beer:
Заголовок сообщения: Re: Re: The Winners, Episode Single Player for RTCW
СообщениеДобавлено: 14 янв 2015 15:32
Изображение
_________________
Официальный сайт Project-X

Заголовок сообщения: Re: Re: The Winners, Episode Single Player for RTCW
СообщениеДобавлено: 14 янв 2015 15:51
Решётки так массивно стали выглядеть... Надо текстуру какуюто другую найти и поменять.
Заголовок сообщения: Re: Re: The Winners, Episode Single Player for RTCW
СообщениеДобавлено: 14 янв 2015 15:52
Krot писал(а):
Решётки так массивно стали выглядеть... Надо текстуру какуюто другую найти и поменять.

старался рисовал :(
_________________
Официальный сайт Project-X

Заголовок сообщения: Re: Re: The Winners, Episode Single Player for RTCW
СообщениеДобавлено: 14 янв 2015 15:54
Ну так ты сделал копии родных. Они полностью соответствуют. Просто как то в глаза они не так бросались, как сейчас. Текстура то сама по себе хорошая, просто в данном месте выглядеть стала не очень.
Заголовок сообщения: Re: Re: The Winners, Episode Single Player for RTCW
СообщениеДобавлено: 15 авг 2015 10:05
Hi all,
Any progress for project?
Заголовок сообщения: Re: Re: The Winners, Episode Single Player for RTCW
СообщениеДобавлено: 26 ноя 2015 21:49
Здравствуйте, меня очень заинтересовал данный аддон. Судя по дате последних сообщений, разработка, я так понимаю приостановлена. Хотелось бы уточнить: на какой стадии разработки находится данный аддон. А также если это как-то ускорит выход данного творения в релиз, то и поучаствовать в тестировании.
Показать сообщения за:  Поле сортировки  
Страница 10 из 11
[ Сообщений: 158 ]

Часовой пояс: UTC + 3 часа


Кто сейчас на конференции

Сейчас этот форум просматривают: нет зарегистрированных пользователей и гости: 1


Кто сегодня был на конференции за последние 24 часа

Пользователи смотревшие этот форум за последние 24 часа: нет зарегистрированных пользователей и 1 гость


Вы не можете начинать темы
Вы не можете отвечать на сообщения
Вы не можете редактировать свои сообщения
Вы не можете удалять свои сообщения
Вы не можете добавлять вложения
Перейти:  

Работает на phpBB © 2000, 2002, 2005, 2007 phpBB Group
Русская поддержка phpBB