Definition in file ASharedFunc.h.
#include "AEngine.h"
Include dependency graph for ASharedFunc.h:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Functions | |
| void | input_init () |
| void | overlay_init () |
| void | overlay_flush () |
| throw away all pending overlay operations | |
| void | overlay_render () |
| void | mesh_init () |
| void | mesh_flush () |
| throw away all pending mesh-rendering requests | |
| void | mesh_processRenderRequests () |
| void | profiler_reset () |
| void | profiler_render () |
| void | flare_init () |
| void | flare_process () |
| void | sprite_init () |
| void | sprite_process () |
| void | sprite_flush () |
| ATerrain | terrain_create (string filename, FLOAT sizeX, FLOAT sizeY, FLOAT sizeZ, FLOAT offsetZ) |
| void | terrain_flush () |
| void | terrain_processRenderRequest () |
|
|
Definition at line 29 of file ALerpParticle.cpp. References MAX_LERP_COUNT, util_loadPixelShader(), and util_loadVertexShader(). Referenced by sys_go().
00030 {
00031 int vbByteSize = MAX_LERP_COUNT * sizeof(LerpParticleVertex);
00032 if( FAILED( AS.pDevice->CreateVertexBuffer( vbByteSize, D3DUSAGE_WRITEONLY|D3DUSAGE_DYNAMIC|D3DUSAGE_POINTS,
00033 0, D3DPOOL_DEFAULT, &AS.flare_vb ) ))
00034 throw Error("Can't create flareVB");
00035
00036 AS.flare_startRenderingIndex = 0;
00037 AS.flare_renderCount = 0;
00038
00039 AS.vshader_lerpParticle = util_loadVertexShader( "shaders\\lerpParticle.vso", dwLerpParticleVertexDecl );
00040 AS.pshader_lerpParticle = util_loadPixelShader( "shaders\\lerpParticle.pso" );
00041 }
|
|
|
Definition at line 43 of file ALerpParticle.cpp. References device_setPixelShader(), device_setRenderState(), device_setRenderStateBlendMode(), device_setStreamSource(), device_setTexture(), device_setTextureStageState(), device_setVertexShader(), and Matx. Referenced by processRenderRequests().
00044 {
00045 if( AS.flare_renderCount==0 ) return;
00046 device_setVertexShader( AS.vshader_lerpParticle );
00047 device_setPixelShader( AS.pshader_lerpParticle );
00048 device_setTexture( 3, AS.res_textures[ AS.flare_texture ] );
00049 device_setStreamSource( 0, AS.flare_vb, sizeof(LerpParticleVertex) );
00050
00051 Matx matx;
00052 FLOAT sizeCalcConst[4] = { 3.0f, 640.0f, 0.0f, 0.0f };
00053 D3DXMatrixTranspose( &matx, &AS.camera_world2projMatrix);
00054 AS.pDevice->SetVertexShaderConstant( 0, &matx, 4 ); // world->proj matrix
00055 AS.pDevice->SetVertexShaderConstant( 4, &AS.camera_pos[0], 1 ); // camera pos
00056 AS.pDevice->SetVertexShaderConstant( 5, &sizeCalcConst, 1 ); // constants
00057
00058 device_setRenderStateBlendMode( BlendModes::ADD );
00059
00060 device_setRenderState( D3DRS_ZWRITEENABLE, FALSE );
00061 device_setRenderState( D3DRS_ZENABLE, FALSE );
00062 device_setRenderState( D3DRS_POINTSPRITEENABLE, TRUE );
00063 device_setTextureStageState( 3, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
00064 device_setTextureStageState( 3, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
00065 device_setTextureStageState( 3, D3DTSS_MIPFILTER, D3DTEXF_POINT );
00066
00067 AS.pDevice->DrawPrimitive( D3DPT_POINTLIST, AS.flare_startRenderingIndex, AS.flare_renderCount );
00068
00069 device_setRenderState( D3DRS_POINTSPRITEENABLE, FALSE );
00070 AS.flare_startRenderingIndex += AS.flare_renderCount;
00071 AS.flare_renderCount = 0;
00072 }
|
|
|
Definition at line 29 of file AInput.cpp. References DWORD, input_resetVKeyMapping(), and mouseSpeed. Referenced by sys_go().
00030 {
00031 DWORD rc = AS.ndxInput.Create( AS.hInst, AS.hWnd );
00032 if(rc!=NDXERR_OK) throw Error("Please do not switch application while game is loading. Try again");
00033 ZeroMemory( AS.keyDownLastCycle, sizeof(AS.keyDownLastCycle) );
00034 ZeroMemory( AS.keyDownThisCycle, sizeof(AS.keyDownThisCycle) );
00035 input_resetVKeyMapping();
00036
00037 AS.ndxInput.MouseLimit.left = 0;
00038 AS.ndxInput.MouseLimit.right = (int)(AS.windowWidth /mouseSpeed);
00039 AS.ndxInput.MouseLimit.top = 0;
00040 AS.ndxInput.MouseLimit.bottom = (int)(AS.windowHeight/mouseSpeed);
00041
00042 AS.input_mouseWheel = 0.5f;
00043 }
|
|
|
throw away all pending mesh-rendering requests
Definition at line 76 of file AMesh.cpp. Referenced by flushRenderRequests().
00077 {
00078 AS.mesh_renderList.resize(0);
00079 }
|
|
|
Definition at line 39 of file AMesh.cpp. References sys_console(), util_loadPixelShader(), and util_loadVertexShader(). Referenced by sys_go().
00040 {
00041 if(AS.res_meshes.size()==0) return;
00042
00043 // create Vertex&Index Buffer
00044 int vbByteSize = (int)AS.mesh_raw_vb.size() * sizeof(MeshVertex);
00045 int ibByteSize = (int)AS.mesh_raw_ib.size() * sizeof(USHORT);
00046 sys_console() << "Mesh : VertexBuffer Size = " << (int)AS.mesh_raw_vb.size() << endl;
00047 sys_console() << "Mesh : IndexBuffer Size = " << (int)AS.mesh_raw_ib.size() << endl;
00048
00049 AS.pDevice->CreateVertexBuffer( vbByteSize, D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &(AS.mesh_vb) );
00050 AS.pDevice->CreateIndexBuffer( ibByteSize, D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_MANAGED, &(AS.mesh_ib) );
00051
00052 MeshVertex *pVBdata;
00053 USHORT *pIBdata;
00054 if( FAILED( AS.mesh_vb->Lock(0,0, (BYTE**)&pVBdata, 0) )) throw Error("Can't Lock MeshVB");
00055 if( FAILED( AS.mesh_ib->Lock(0,0, (BYTE**)&pIBdata, 0) )) throw Error("Can't Lock MeshIB");
00056
00057 memcpy( pVBdata, &(AS.mesh_raw_vb[0]), vbByteSize );
00058 memcpy( pIBdata, &(AS.mesh_raw_ib[0]), ibByteSize );
00059
00060 AS.mesh_vb->Unlock();
00061 AS.mesh_ib->Unlock();
00062
00063 // create V&P Shaders
00064 AS.vshader_mesh = util_loadVertexShader( "shaders\\mesh.vso", dwMeshVertexDecl );
00065 AS.pshader_mesh = util_loadPixelShader( "shaders\\mesh.pso" );
00066 }
|
|
|
Definition at line 82 of file AMesh.cpp. References MeshRenderRequestEntry::bumpmap, device_setIndexSource(), device_setPixelShader(), device_setRenderState(), device_setRenderStateBlendMode(), device_setStreamSource(), device_setTexture(), device_setTextureStageState(), device_setVertexShader(), MeshRenderRequestEntry::dir, MeshEntry::IBstart, Matx, MeshRenderRequestEntry::mesh, MeshRenderRequestEntry::pos, MeshEntry::size, MeshRenderRequestEntry::size, MeshRenderRequestEntry::stripColor, MeshRenderRequestEntry::texture, MeshEntry::TriCount, MeshEntry::VBcount, and MeshEntry::VBmin. Referenced by processRenderRequests().
00083 {
00084 if(AS.res_meshes.size()==0) return;
00085 if(AS.mesh_renderList.size()==0) return;
00086
00087 device_setVertexShader( AS.vshader_mesh );
00088 device_setPixelShader( AS.pshader_mesh );
00089 device_setStreamSource( 0, AS.mesh_vb, sizeof(MeshVertex) );
00090 device_setIndexSource( AS.mesh_ib );
00091 device_setRenderState( D3DRS_ZENABLE, TRUE );
00092 device_setRenderState( D3DRS_ZWRITEENABLE, TRUE );
00093 device_setRenderState( D3DRS_SPECULARENABLE, FALSE );
00094 device_setTextureStageState( 0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
00095 device_setTextureStageState( 0, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
00096 device_setTextureStageState( 0, D3DTSS_MIPFILTER, D3DTEXF_LINEAR );
00097
00099 device_setRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
00100 device_setRenderStateBlendMode( BlendModes::NONE );
00101
00102 sort(AS.mesh_renderList.begin(), AS.mesh_renderList.end(), MeshRequestEntryComparer());
00103
00104 Matx matTrans, matScale, matTheta, matFinal, matLighting;
00105 int last = (int)AS.mesh_renderList.size();
00106
00107
00108 for( int i=0; i<last; i++ )
00109 {
00110 MeshRenderRequestEntry &e = AS.mesh_renderList[i];
00111 MeshEntry &m = AS.res_meshes[e.mesh];
00112
00113 // construct xform matrix
00114 D3DXMatrixTranslation( &matTrans, e.pos[0], e.pos[1], e.pos[2] );
00115 D3DXMatrixRotationZ( &matTheta, D3DXToRadian(e.dir[0]) );
00116 D3DXMatrixScaling( &matScale, e.size[0]/m.size[0], e.size[1]/m.size[1], e.size[2]/m.size[2] );
00117 matFinal = matScale * matTheta * matTrans * AS.camera_world2projMatrix;
00118 D3DXMatrixTranspose( &matFinal, &matFinal);
00119 D3DXMatrixTranspose( &matLighting, &matTheta);
00120
00121 AS.pDevice->SetVertexShaderConstant( 0, &matFinal, 4 ); // world->proj matrix
00122 AS.pDevice->SetVertexShaderConstant( 4, &matLighting, 4 ); // rotate normals matrix
00123
00124 FLOAT lightVec[4] = { 0.5882f, 0.1961f, 0.2843f, 0.0f };
00125 AS.pDevice->SetVertexShaderConstant( 8, &lightVec, 1 );
00126
00127 FLOAT t = 0.4f;
00128 FLOAT ambient[4] = { t,t,t,0.0f };
00129 AS.pDevice->SetVertexShaderConstant( 9, &ambient, 1 );
00130
00131 // strip color
00132 AS.pDevice->SetPixelShaderConstant( 0, &e.stripColor, 1 );
00133
00134 // set texture & bumpmap
00135 device_setTexture( 0, AS.res_textures[e.texture] );
00136 if(e.bumpmap!=NULL) device_setTexture( 0, AS.res_textures[e.bumpmap] );
00137
00138 // let the hardware render
00139 AS.pDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, m.VBmin, m.VBcount, m.IBstart, m.TriCount );
00140 }
00141 }
|
|
|
throw away all pending overlay operations
Definition at line 96 of file AOverlay.cpp. Referenced by displayLoadingScreen(), and flushRenderRequests().
00097 {
00098 AS.overlay_entries.resize(0);
00099 delete AS.overlay_pTextStream;
00100 AS.overlay_pTextStream = new ostringstream();
00101 }
|
|
|
Definition at line 71 of file AOverlay.cpp. References MAX_POINT, util_loadFont(), util_loadPixelShader(), and util_loadVertexShader(). Referenced by sys_go().
00072 {
00073 // create vertex buffer
00074 int byteSize = sizeof(OverlayVertex) * MAX_POINT;
00075 AS.pDevice->CreateVertexBuffer( byteSize, D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &AS.overlay_pVB );
00076
00077 // put in index to constant registers
00078 OverlayVertex *access;
00079 if( FAILED( AS.overlay_pVB->Lock(0,0, (BYTE**)&access, 0) )) throw Error("Can't Lock Overlay VB");
00080 for( int i=0; i<MAX_POINT; i++ )
00081 access[i].cIndex = i*3.0f;
00082 AS.overlay_pVB->Unlock();
00083
00084 // load default font
00085 AS.res_fonts.push_back( util_loadFont("Arial","",18) );
00086
00087 // load V&P Shader
00088 AS.vshader_overlay = util_loadVertexShader( "shaders\\overlay.vso", dwOverlayVertexDecl );
00089 AS.pshader_overlay = util_loadPixelShader( "shaders\\overlay.pso" );
00090 AS.pshader_textureConstAlpha = util_loadPixelShader( "shaders\\textureConstAlpha.pso" );
00091 AS.pshader_texturePixelAlpha = util_loadPixelShader( "shaders\\texturePixelAlpha.pso" );
00092
00093 AS.overlay_pTextStream = new ostringstream();
00094 }
|
|
|
Definition at line 115 of file AOverlay.cpp. References OverlayEntry::alpha, OverlayEntry::blendMode, OverlayEntry::color, convertToScreenCoord(), device_flushSettings(), device_setPixelShader(), device_setRenderStateBlendMode(), device_setTexture(), DWORD, OverlayEntry::op, OverlayEntry::pt1, OverlayEntry::pt2, OverlayEntry::resource, OverlayEntry::s, OverlayEntry::size, useOverlayShaders(), util_stringToTChar(), and WORD. Referenced by displayLoadingScreen(), and processRenderRequests().
00116 {
00117 sort(AS.overlay_entries.begin(), AS.overlay_entries.end(), OverlayEntryComparer());
00118 useOverlayShaders();
00119
00120 D3DLINEPATTERN linePattern;
00121
00122 int last = (int)AS.overlay_entries.size();
00123 for( int i=0; i<last; i++ )
00124 {
00125 OverlayEntry &e = AS.overlay_entries[i];
00126 device_setRenderStateBlendMode(e.blendMode);
00127 convertToScreenCoord(e.pt1);
00128 FLOAT x1, x2, y1, y2;
00129
00130 if(e.op==OpType::OP_IMAGE) // for image, pt2 is used for size
00131 {
00132 e.pt1 = e.pt1 - e.pt2;
00133 e.pt2 = 2.0f*e.pt2 + e.pt1;
00134 }
00135 else
00136 {
00137 convertToScreenCoord(e.pt2);
00138 }
00139 x1 = min( e.pt1[0], e.pt2[0] );
00140 x2 = max( e.pt1[0], e.pt2[0] );
00141 y1 = min( e.pt1[1], e.pt2[1] );
00142 y2 = max( e.pt1[1], e.pt2[1] );
00143 FLOAT dataA[12] = { x1,y1,0.0f, 10.0f, e.color[0], e.color[1], e.color[2], e.alpha, 0.0f, 1.0f };
00144 FLOAT dataB[12] = { x2,y1,0.0f, 10.0f, e.color[0], e.color[1], e.color[2], e.alpha, 1.0f, 1.0f };
00145 FLOAT dataC[12] = { x2,y2,0.0f, 10.0f, e.color[0], e.color[1], e.color[2], e.alpha, 1.0f, 0.0f };
00146 FLOAT dataD[12] = { x1,y2,0.0f, 10.0f, e.color[0], e.color[1], e.color[2], e.alpha, 0.0f, 0.0f };
00147
00148 switch(e.op)
00149 {
00150 case OpType::OP_IMAGE:
00151 {
00152 useOverlayShaders();
00153 if(e.blendMode==BlendModes::KEY)
00154 device_setPixelShader( AS.pshader_texturePixelAlpha );
00155 else
00156 device_setPixelShader( AS.pshader_textureConstAlpha );
00157 device_setTexture(0, AS.res_textures.at(e.resource) );
00158 AS.pDevice->SetVertexShaderConstant( 0, dataD, 3 );
00159 AS.pDevice->SetVertexShaderConstant( 3, dataC, 3 );
00160 AS.pDevice->SetVertexShaderConstant( 6, dataB, 3 );
00161 AS.pDevice->SetVertexShaderConstant( 9, dataA, 3 );
00162 AS.pDevice->DrawPrimitive( D3DPT_TRIANGLEFAN, 0, 2 );
00163 break;
00164 }
00165
00166 case OpType::OP_POINT:
00167 {
00168 useOverlayShaders();
00169 device_setPixelShader( AS.pshader_overlay );
00170 dataA[0]=e.pt1[0]; dataA[1]=e.pt1[1]; dataA[2]=0.0f; dataA[3]=e.size*4.0f;
00171 dataA[4]=e.color[0]; dataA[5]=e.color[1]; dataA[6]=e.color[2]; dataA[7]=e.alpha;
00172 AS.pDevice->SetVertexShaderConstant( 0, dataA, 2 );
00173 AS.pDevice->DrawPrimitive( D3DPT_POINTLIST, 0, 1 );
00174 break;
00175 }
00176
00177 case OpType::OP_LINE:
00178 {
00179 useOverlayShaders();
00180 int intPattern = *(int*)(&e.size);
00181 WORD patterns[3] = { 0xffff, 0x3333, 0x5555 };
00182 linePattern.wRepeatFactor = 1;
00183 linePattern.wLinePattern = patterns[ intPattern ];
00184 DWORD dwPattern = *(DWORD*)(&linePattern);
00185 //device_setRenderState( D3DRS_LINEPATTERN, dwPattern );
00186
00187 device_setPixelShader( AS.pshader_overlay );
00188 // send first point to GPU
00189 dataA[0]=e.pt1[0]; dataA[1]=e.pt1[1]; dataA[2]=0.0f; dataA[3]=10.0f;
00190 dataA[4]=e.color[0]; dataA[5]=e.color[1]; dataA[6]=e.color[2]; dataA[7]=e.alpha;
00191 AS.pDevice->SetVertexShaderConstant( 0, dataA, 2 );
00192
00193 // second point
00194 dataA[0]=e.pt2[0]; dataA[1]=e.pt2[1];
00195 AS.pDevice->SetVertexShaderConstant( 3, dataA, 2 );
00196
00197 AS.pDevice->DrawPrimitive( D3DPT_LINELIST, 0, 1 );
00198 break;
00199 }
00200
00201
00202 case OpType::OP_EMPTY_RECT:
00203 {
00204 useOverlayShaders();
00205 device_setPixelShader( AS.pshader_overlay );
00206 AS.pDevice->SetVertexShaderConstant( 0, dataA, 2 );
00207 AS.pDevice->SetVertexShaderConstant( 3, dataB, 2 );
00208 AS.pDevice->SetVertexShaderConstant( 6, dataC, 2 );
00209 AS.pDevice->SetVertexShaderConstant( 9, dataD, 2 );
00210 AS.pDevice->SetVertexShaderConstant(12, dataA, 2 );
00211 AS.pDevice->DrawPrimitive( D3DPT_LINESTRIP, 0, 4 );
00212 break;
00213 }
00214
00215 case OpType::OP_FILLED_RECT:
00216 {
00217 useOverlayShaders();
00218 device_setPixelShader( AS.pshader_overlay );
00219 AS.pDevice->SetVertexShaderConstant( 0, dataD, 2 );
00220 AS.pDevice->SetVertexShaderConstant( 3, dataC, 2 );
00221 AS.pDevice->SetVertexShaderConstant( 6, dataB, 2 );
00222 AS.pDevice->SetVertexShaderConstant( 9, dataA, 2 );
00223 AS.pDevice->DrawPrimitive( D3DPT_TRIANGLEFAN, 0, 2 );
00224 break;
00225 }
00226
00227 case OpType::OP_TEXT:
00228 {
00229 DWORD color = D3DXCOLOR( e.color[0], e.color[1], e.color[2], e.alpha );
00230 FLOAT scale = e.size * 0.025f;
00231 TCHAR *tStr = util_stringToTChar(e.s);
00232 AS.res_fonts.at(e.resource)->DrawTextScaled( e.pt1[0], -e.pt1[1], 0.0f,
00233 scale, scale, color, tStr, 0 );
00234 device_flushSettings();
00235 break;
00236 }
00237
00238 default:
00239 assert(false && "Invalid OpCode in Overlay pipeline");
00240 }
00241 }
00242
00243 AS.overlay_entries.resize(0);
00244 }
|
|
|
Definition at line 94 of file AProfiler.cpp. References getOSTime(), sys_console(), and UINT. Referenced by doGameLoop().
00095 {
00096 sys_console() << "-------BEGIN-PROFILER-SUMMARY-------" << endl;
00097 __int64 t = getOSTime();
00098 __int64 deltaT = t - AS.profiler_RDTSClastReset;
00099 for( UINT i=0; i<AS.profiler_names.size(); i++ )
00100 {
00101 string s = AS.profiler_names[i];
00102 FLOAT percent = AS.profiler_totalTime.find(s)->second * 100.0f / deltaT;
00103 while( s.length()<24 ) s += " ";
00104 sys_console() << s << percent << endl;
00105 }
00106 }
|
|
|
Definition at line 86 of file AProfiler.cpp. References getOSTime(), sys_getMilliSec(), and UINT. Referenced by doGameLoop().
00087 {
00088 for( UINT i=0; i<AS.profiler_names.size(); i++ )
00089 AS.profiler_totalTime.find( AS.profiler_names[i] )->second = 0;
00090 AS.profiler_RDTSClastReset = getOSTime();
00091 AS.profiler_MSlastReset = sys_getMilliSec();
00092 }
|
|
|
Definition at line 62 of file ASprite.cpp. Referenced by flushRenderRequests().
00063 {
00064 AS.sprite_renderList.resize(0);
00065 }
|
|
|
Definition at line 43 of file ASprite.cpp. References MAX_SPRITE_COUNT, util_loadPixelShader(), and util_loadVertexShader(). Referenced by sys_go().
00044 {
00045 int vbByteSize = MAX_SPRITE_COUNT * sizeof(SpriteVertex);
00046 if( FAILED( AS.pDevice->CreateVertexBuffer( vbByteSize, D3DUSAGE_WRITEONLY|D3DUSAGE_DYNAMIC|D3DUSAGE_POINTS,
00047 0, D3DPOOL_DEFAULT, &AS.sprite_vb ) ))
00048 throw Error("Can't create spriteVB");
00049
00050 AS.sprite_renderList.resize(0);
00051 AS.sprite_startRenderingIndex = 0;
00052
00053 AS.vshader_sprite = util_loadVertexShader( "shaders\\sprite.vso", dwSpriteVertexDecl );
00054 AS.pshader_sprite = util_loadPixelShader( "shaders\\sprite.pso" );
00055 }
|
|
|
Definition at line 67 of file ASprite.cpp. References ATexture, SpriteVertex::colorMultiplier, device_setPixelShader(), device_setRenderState(), device_setRenderStateBlendMode(), device_setStreamSource(), device_setTexture(), device_setTextureStageState(), device_setVertexShader(), Matx, MAX_SPRITE_COUNT, SpriteVertex::pos, and SpriteVertex::size. Referenced by processRenderRequests().
00068 {
00069 int renderCount = (int) AS.sprite_renderList.size();
00070 if(renderCount==0) return;
00071
00072 sort( AS.sprite_renderList.begin(), AS.sprite_renderList.end(), SpriteRequestEntryComparer() );
00073
00074 SpriteVertex *pVertex;
00075
00076 // check if there's enough space in current VB
00077 HRESULT res;
00078 if( AS.sprite_startRenderingIndex + renderCount < MAX_SPRITE_COUNT )
00079 {
00080 res = AS.sprite_vb->Lock( AS.sprite_startRenderingIndex*sizeof(SpriteVertex),
00081 renderCount*sizeof(SpriteVertex),
00082 (BYTE**)&pVertex, D3DLOCK_NOOVERWRITE );
00083 if( FAILED(res)) throw Error("Can't Lock spriteVB");
00084 }
00085 else // renew VB
00086 {
00087 AS.sprite_startRenderingIndex = 0;
00088 res = AS.sprite_vb->Lock( AS.sprite_startRenderingIndex*sizeof(SpriteVertex),
00089 renderCount*sizeof(SpriteVertex),
00090 (BYTE**)&pVertex, D3DLOCK_DISCARD );
00091 if( FAILED(res)) throw Error("Can't Lock/Renew spriteVB");
00092 }
00093
00094 // copy content to VB
00095 for( int i=0; i<renderCount; i++ )
00096 {
00097 pVertex[i].pos = AS.sprite_renderList[i].pos;
00098 pVertex[i].colorMultiplier = AS.sprite_renderList[i].multiplier;
00099 pVertex[i].size = AS.sprite_renderList[i].size;
00100 }
00101 AS.sprite_vb->Unlock();
00102
00103 // set rendering flags
00104 device_setVertexShader( AS.vshader_sprite );
00105 device_setPixelShader( AS.pshader_sprite );
00106 device_setStreamSource( 0, AS.sprite_vb, sizeof(SpriteVertex) );
00107
00108 Matx matx;
00109 FLOAT sizeCalcConst[4] = { 3.0f, 640.0f, 0.0f, 0.0f };
00110 D3DXMatrixTranspose( &matx, &AS.camera_world2projMatrix);
00111 AS.pDevice->SetVertexShaderConstant( 0, &matx, 4 ); // world->proj matrix
00112 AS.pDevice->SetVertexShaderConstant( 4, &AS.camera_pos[0], 1 ); // camera pos
00113 AS.pDevice->SetVertexShaderConstant( 5, &sizeCalcConst, 1 ); // constants
00114
00115 //device_setRenderState( D3DRS_ZENABLE, FALSE );
00116 device_setRenderState( D3DRS_ZWRITEENABLE, FALSE );
00117 device_setRenderState( D3DRS_POINTSPRITEENABLE, TRUE );
00118 device_setTextureStageState( 3, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
00119 device_setTextureStageState( 3, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
00120 device_setTextureStageState( 3, D3DTSS_MIPFILTER, D3DTEXF_POINT );
00121
00122 // render, one texture type at a time
00123 ATexture currentTex = AS.sprite_renderList[0].tex;
00124 int currentBlend = AS.sprite_renderList[0].blendMode;
00125
00126 int start = 0;
00127 for( int i=0; i<renderCount; i++ )
00128 {
00129 ATexture newTex = AS.sprite_renderList[i].tex;
00130 int newBlend = AS.sprite_renderList[i].blendMode;
00131 if( newTex!=currentTex || newBlend!=currentBlend )
00132 {
00133 device_setTexture( 3, AS.res_textures[ currentTex ] );
00134 device_setRenderStateBlendMode(currentBlend);
00135
00136 // render (start)..(i-1)
00137 AS.pDevice->DrawPrimitive( D3DPT_POINTLIST, AS.sprite_startRenderingIndex+start, (i-1)-start+1 );
00138
00139 start = i;
00140 currentTex = newTex;
00141 currentBlend = newBlend;
00142 }
00143 }
00144
00145 // render last remaining set
00146 // render (start)..(renderCount-1)
00147 device_setTexture( 3, AS.res_textures[ currentTex ] );
00148 device_setRenderStateBlendMode(currentBlend);
00149 AS.pDevice->DrawPrimitive( D3DPT_POINTLIST, AS.sprite_startRenderingIndex+start, (renderCount-1)-start+1 );
00150
00151 AS.sprite_startRenderingIndex += renderCount;
00152 device_setRenderState( D3DRS_POINTSPRITEENABLE, FALSE );
00153 }
|
|
||||||||||||||||||||||||
|
Definition at line 147 of file ATerrain.cpp. References ATerrain, createBMap(), createNMap(), createVIB(), createZMap(), TerrainEntry::doRender, CImage::GetHeight(), CImage::GetImageData(), CImage::GetWidth(), CImage::LoadTga(), TerrainEntry::offsetZ, TerrainEntry::sizeX, TerrainEntry::sizeY, TerrainEntry::sizeZ, TERR_COLS, TERR_ROWS, TerrainEntry::texHigh, TerrainEntry::texLow, TerrainEntry::texNormal, UBYTE, util_loadPixelShader(), and util_loadVertexShader(). Referenced by load_terrain().
00148 {
00149 CImage img;
00150 img.LoadTga(filename);
00151 assert(img.GetWidth()==TERR_COLS && img.GetHeight()==TERR_ROWS);
00152 UBYTE *imgData = img.GetImageData();
00153
00154 TerrainEntry e;
00155 e.doRender = false;
00156 e.texLow = (DWORD) -1;
00157 e.texHigh = (DWORD) -1;
00158 e.texNormal = (DWORD) -1;
00159 e.sizeX = sizeX;
00160 e.sizeY = sizeY;
00161 e.sizeZ = sizeZ;
00162 e.offsetZ = offsetZ;
00163
00164 createZMap(e,imgData);
00165 createNMap(e);
00166 createBMap(e,imgData);
00167 createVIB(e);
00168
00169 AS.res_terrains.push_back(e);
00170
00171 // create V&P shaders
00172 if(AS.vshader_terrain==0)
00173 {
00174 AS.vshader_terrain = util_loadVertexShader( "shaders\\terrain.vso", dwColoredTerrainVertexDecl );
00175 AS.pshader_terrain = util_loadPixelShader( "shaders\\terrain.pso" );
00176 }
00177
00178 return (ATerrain)AS.res_terrains.size()-1;
00179 }
|
|
|
Definition at line 190 of file ATerrain.cpp. References UINT. Referenced by flushRenderRequests().
00191 {
00192 for( UINT i=0; i<AS.res_terrains.size(); i++ )
00193 AS.res_terrains[i].doRender = false;
00194 }
|
|
|
Definition at line 196 of file ATerrain.cpp. References device_setIndexSource(), device_setPixelShader(), device_setRenderState(), device_setRenderStateBlendMode(), device_setStreamSource(), device_setTexture(), device_setTextureStageState(), device_setVertexShader(), DWORD, TerrainEntry::ib, Matx, TerrainEntry::sizeX, TerrainEntry::sizeY, TERR_COLS, TERR_ROWS, TerrainEntry::texHigh, TerrainEntry::texLow, TerrainEntry::texNormal, UINT, and TerrainEntry::vb. Referenced by processRenderRequests().
00197 {
00198 UINT i;
00199 for( i=0; i<AS.res_terrains.size(); i++ ) // find the one that needs rendering, if any
00200 if( AS.res_terrains[i].doRender ) break;
00201 if( i>=AS.res_terrains.size() ) return;
00202 TerrainEntry &e = AS.res_terrains[i];
00203
00204 device_setVertexShader( AS.vshader_terrain );
00205 device_setPixelShader( AS.pshader_terrain );
00206
00207 device_setTexture( 0, AS.res_textures[e.texLow] );
00208 device_setTexture( 1, AS.res_textures[e.texHigh] );
00209 device_setTexture( 2, AS.res_textures[e.texNormal] );
00210
00211 device_setStreamSource( 0, e.vb, sizeof(ColoredTerrainVertex) );
00212 device_setIndexSource( e.ib );
00213
00214 // rendering flags
00215 device_setRenderState( D3DRS_ZENABLE, TRUE );
00216 device_setRenderState( D3DRS_ZWRITEENABLE, TRUE );
00217 for( DWORD stage=0; stage<4; stage++ )
00218 {
00219 device_setTextureStageState( stage, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
00220 device_setTextureStageState( stage, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
00221 device_setTextureStageState( stage, D3DTSS_MIPFILTER, D3DTEXF_LINEAR );
00222 }
00223 device_setRenderState( D3DRS_CULLMODE, D3DCULL_CW );
00224 device_setRenderStateBlendMode( BlendModes::NONE );
00225 device_setRenderState( D3DRS_SPECULARENABLE, TRUE );
00226
00227 // set projXview matrix
00228 Matx mat;
00229 D3DXMatrixTranspose( &mat, &AS.camera_world2projMatrix);
00230 AS.pDevice->SetVertexShaderConstant( 0, &mat, 4 );
00231
00232 // set UV const
00233 FLOAT uvScale[4] = { 10.0f/e.sizeX, 10.0f/e.sizeY, 0.0f, 0.0f };
00234 FLOAT uvShift[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
00235 FLOAT nScale[4] = { 25.0f/e.sizeX, 25.0f/e.sizeY, 0.0f, 0.0f };
00236 AS.pDevice->SetVertexShaderConstant( 4, &uvScale, 1 );
00237 AS.pDevice->SetVertexShaderConstant( 5, &uvShift, 1 );
00238 AS.pDevice->SetVertexShaderConstant( 8, &nScale, 1 );
00239
00240 // set ATM const
00241 FLOAT lightVec[4] = { 0.5882f, 0.1961f, 0.7843f, 0.0f }; //lightVec = c6
00242 FLOAT lightAmbient[4] = { 0.24f, 0.24f, 0.2f };
00243 AS.pDevice->SetVertexShaderConstant( 6, &lightVec, 1 );
00244 AS.pDevice->SetVertexShaderConstant( 7, &lightAmbient, 1 );
00245
00246 FLOAT normalVec[4] = { 0.3882f, 0.1961f, 0.1843f, 0.0f }; // PS c0
00247 FLOAT atmColor[4] = { 0.6f, 0.8f, 1.0f, 0.0f };
00248 FLOAT zScale[4] = { 0.0025f };
00249 AS.pDevice->SetPixelShaderConstant( 0, &normalVec, 1 ); // PS c1 = atm color
00250 AS.pDevice->SetPixelShaderConstant( 1, &atmColor, 1 );
00251 AS.pDevice->SetVertexShaderConstant( 9, &zScale, 1 );
00252
00253 // render strip
00254 int numVertex = TERR_ROWS * TERR_COLS;
00255 int primCount = (TERR_ROWS-1)*2*TERR_COLS + (TERR_ROWS-2)*2 - 2;
00256 AS.pDevice->DrawIndexedPrimitive( D3DPT_TRIANGLESTRIP, 0, numVertex, 0, primCount );
00257 }
|
1.3-rc2