void SetupRC() { glClearColor(0.0f, 0.0f, 0.0f, 1.0f); shader = gltLoadShaderPairWithAttributes("pass_thru_shader.vp", "pass_thru_shader.fp", 2, GLT_ATTRIBUTE_VERTEX, "vVertex", GLT_ATTRIBUTE_NORMAL, "vNormal"); fprintf(stdout, "GLT_ATTRIBUTE_VERTEX : %d\nGLT_ATTRIBUTE_COLOR : %d \n", GLT_ATTRIBUTE_VERTEX, GLT_ATTRIBUTE_COLOR); MVPMatrixLocation = glGetUniformLocation(shader,"MVPMatrix"); normalMatrixLocation = glGetUniformLocation(shader,"normalMatrix"); MVMatrixLocation = glGetUniformLocation(shader,"MVMatrix"); shaderPositionLocation = glGetUniformLocation(shader, "light1.position"); shaderColorLocation = glGetUniformLocation(shader, "light1.color"); shaderAngleLocation = glGetUniformLocation(shader, "light1.angle"); shaderAttenuation0Location = glGetUniformLocation(shader, "light1.attenuation0"); shaderAttenuation1Location = glGetUniformLocation(shader, "light1.attenuation1"); shaderAttenuation2Location = glGetUniformLocation(shader, "light1.attenuation2"); shaderAmbientColorLocation = glGetUniformLocation(shader, "material.ambientColor"); shaderDiffuseColorLocation = glGetUniformLocation(shader, "material.diffuseColor"); shaderSpecularColorLocation = glGetUniformLocation(shader, "material.specularColor"); shaderSpecularExponentLocation = glGetUniformLocation(shader, "material.specularExponent"); glEnable(GL_DEPTH_TEST); LoadVertices(); LoadFaces(); }
void Init(HWND hWnd) { g_hWnd = hWnd; // Assign the window handle to a global window handle GetClientRect(g_hWnd, &g_rRect); // Assign the windows rectangle to a global RECT InitializeOpenGL(g_rRect.right, g_rRect.bottom); // Init OpenGL with the global rect // Position our camera g_Camera.PositionCamera(0, 30, 120, 0, 0, 0, 0, 1, 0); // This loads the vertices for the terrain LoadVertices(); // Calculate the bounding box of our scene. This will give us a width of // the cube that is needed to surround the whole world. We want to pass in // the vertices and the vertex count into this function to find the farthest point // from the center of the world. That will then be our width. Depending on the // world this doesn't always surround it perfectly. In the next tutorial we will fix that. g_Octree.GetSceneDimensions(g_pVertices, g_NumberOfVerts); // Here we pass in the information to create the root node. This will then // recursively subdivide the root node into the rest of the node. g_Octree.CreateNode(g_pVertices, g_NumberOfVerts, g_Octree.GetCenter(), g_Octree.GetWidth()); // Here, we turn on a light and enable lighting. We don't need to // set anything else for lighting because we will just take the defaults. // We also want color, so we turn that on too. We don't load any normals from // our .raw file so we will calculate some simple face normals to get a decent // perspective of the terrain. glEnable(GL_LIGHT0); // Turn on a light with defaults set glEnable(GL_LIGHTING); // Turn on lighting glEnable(GL_COLOR_MATERIAL); // Allow color }
vec2 Terrain::LoadVertices( const QuadTree<TerrainNode>::Iterator& node, const Image& hmap ) { //Setup vertex data vec2 res = vec2(1.0f, 0.0f); int verticesCount = (lodResolution + 1) * (lodResolution + 1); vector<vec3> vertices(verticesCount), colors(verticesCount); float deltaX = 1.0f / node.LayerSize() / lodResolution; float deltaY = 1.0f / node.LayerSize() / lodResolution; float x = node.OffsetFloat().x; for (int i = 0; i <= lodResolution; i++, x += deltaX) { float y = node.OffsetFloat().y; for (int j = 0; j <= lodResolution; j++, y += deltaY) { float h = hmap[vec2(x, y)].x; res = UniteSegments(res, vec2(h)); vertices[i*lodResolution + i + j] = vec3(x, h, y); colors[i*lodResolution + i + j] = vec3(0.2f, 0.2f + h, 0.4f - h); } } // VAO allocation glGenVertexArrays(1, &node->vaoID); // VAO setup glBindVertexArray(node->vaoID); // VBOs allocation glGenBuffers(2, node->vboID); // VBOs setup // vertices buffer glBindBuffer(GL_ARRAY_BUFFER, node->vboID[0]); glBufferData(GL_ARRAY_BUFFER, vertices.size() * 3 * sizeof(GLfloat), vertices.data(), GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), 0); glEnableVertexAttribArray(0); // colors buffer glBindBuffer(GL_ARRAY_BUFFER, node->vboID[1]); glBufferData(GL_ARRAY_BUFFER, colors.size() * 3 * sizeof(GLfloat), colors.data(), GL_STATIC_DRAW); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), 0); glEnableVertexAttribArray(1); // indices buffer glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, GetIndicesBufferID()); OPENGL_CHECK_FOR_ERRORS(); // release vertex data vertices.clear(); colors.clear(); if (node.Level() < maxLOD) { for (int i : {0, 1, 2, 3}) res = UniteSegments(res, LoadVertices(node.Add(i), hmap)); } node->heights = res; return res; }
void MeshEntry::LoadMesh(FbxMesh * mesh, QVector<quint32> &master_indices, QVector<float> &master_vertices, QVector<float> &master_normals, QVector<float> &master_uvs, QVector<float> &master_tangents, bool load_normals, bool load_uvs, bool load_tangents, qint32 & current_control_point_offset, qint32 & current_polygon_offset) { /** *Load vertices and indices of the mesh entry */ LoadIndices(mesh, master_indices, current_polygon_offset, current_control_point_offset); LoadVertices(mesh, master_vertices, current_control_point_offset); /** *Load the entry's layers */ if (load_normals) LoadNormals(mesh, master_normals); if (load_uvs) LoadUVs(mesh, master_uvs); if (load_tangents) LoadTangents(mesh, master_tangents); /** *Compute the transform and bounding box and load them */ LoadTransform(mesh); LoadBoundingBox(mesh); }
bool SceneLoader::ProcessMesh(ID3D11Device *ind3dDevice, aiMesh &inMesh , DrawableObject &inObject, std::vector<Vertex> &inVertexList, std::vector<UINT> &inIndexList, unsigned int inMaterialIndex) { int inPrevIndexListSize = inIndexList.size(); int inPrevVertexListSize = inVertexList.size(); LoadVertices(inMesh, inVertexList, mSceneBoundingSphere); LoadIndices(inMesh, inIndexList); inObject.AddPart(inPrevVertexListSize, inPrevIndexListSize, inIndexList.size() - inPrevIndexListSize, inMaterialIndex); return true; }
void Model::CreateRectangle(Vector2 dimensions, const char* vertexPath, const char* fragmentPath) { width = dimensions.x; height = dimensions.y; int halfWidth = width / 2; int halfHeight = height / 2; Vector3 positions[] = { Vector3(halfWidth, -halfHeight, 0.0f), Vector3(halfWidth, halfHeight, 0.0f), Vector3(-halfWidth, halfHeight, 0.0f), Vector3(-halfWidth, -halfHeight, 0.0f) }; Vector2 vTexCoords[] = { Vector2(1.0, 0.0), Vector2(1.0, 1.0), Vector2(0.0, 1.0), Vector2(0.0, 0.0) }; GLubyte vIndices[] = { 0, 1, 2, 2, 3, 0 }; if (!LoadShader(vertexPath, fragmentPath)) { // Log error here return; } glBindAttribLocation(shader.GetProgram(), 0, "vPosition"); shader.Link(); // Figure out how to deal with modelviewprojection matrices mvpMatrixHandle = glGetUniformLocation(shader.GetProgram(), "MVPMatrix"); LoadVertices(positions, vTexCoords, arraysize(positions)); LoadIndices(vIndices, arraysize(vIndices)); Initialize(); }
// For reading the triangle-mesh-data chunk static bool ReadTrimesh(OpenedFile& OFile, int32 ParentChunkEnd) { int32 Location = 0; OFile.GetPosition(Location); assert(ModelPtr); while(Location < ParentChunkEnd) { ChunkHeaderData ChunkHeader; if (!ReadChunkHeader(OFile,ChunkHeader)) return false; switch(ChunkHeader.ID) { case VERTICES: if (!LoadChunk(OFile,ChunkHeader)) return false; LoadVertices(); break; case TXTR_COORDS: if (!LoadChunk(OFile,ChunkHeader)) return false; LoadTextureCoordinates(); break; case FACE_DATA: if (!ReadContainer(OFile,ChunkHeader,ReadFaceData)) return false; break; default: if (!SkipChunk(OFile,ChunkHeader)) return false; } // Where are we now? OFile.GetPosition(Location); } if (Location > ParentChunkEnd) { if (DBOut) fprintf(DBOut,"ERROR: Overran parent chunk: %ld > %ld\n",Location,ParentChunkEnd); return false; } return true; }
bool Terrain::LoadFromFile(const string& filename) { //Unload previous terrain, if exists Unload(); WriteToLog("Loading heightmap from TGA file...\n"); Image img; if (!img.Load(filename)) { WriteToLog("ERROR: Failed to load heightmap.\n"); return false; } //Load neccessary data to GPU WriteToLog("Generating indices...\n"); GenerateIndices(); WriteToLog("Loading all vertex data to VAO...\n"); LoadVertices(heightmap.Heap(), img); WriteToLog("OK: Terrain was loaded\n"); return true; }
Obj* obj_load(char *filename) { // open and read obj file int i; Obj *newobject; if((stream = fopen( filename, "r+t" )) != NULL ) { // load objects, faces, and vertices How many objects in this file ? obj_CountObjects(); for (i=numobjects - objectsInFile;i<numobjects;i++) { // need error check here and other mallocs newobject = (Obj *)malloc(sizeof(Obj)); gameobject[i] = newobject; // Load in the faces LoadFaces(i - (numobjects - objectsInFile)); // Load the vertices LoadVertices(i - (numobjects - objectsInFile)); } fclose( stream ); } return newobject; }
////////////////////BSP::Load/////////////// //////////////////////////////////////////// bool BSP::Load(char * filename, int curveTesselation) { FILE * file; file=fopen(filename, "rb"); if(!file) { errorLog.OutputError("Unable to open %s", filename); return false; } //read in header fread(&header, sizeof(BSP_HEADER), 1, file); //check header data is correct if( header.string[0]!='I' || header.string[1]!='B' || header.string[2]!='S' || header.string[3]!='P' || header.version !=0x2E ) { errorLog.OutputError("%s is not a version 0x2E .bsp map file", filename); return false; } //Load in vertices if(!LoadVertices(file)) return false; //Load in mesh indices //Calculate number of indices int numMeshIndices=header.directoryEntries[bspMeshIndices].length/sizeof(int); //Create space meshIndices=new int[numMeshIndices]; if(!meshIndices) { errorLog.OutputError("Unable to allocate memory for %d mesh indices", numMeshIndices); return false; } //read in the mesh indices fseek(file, header.directoryEntries[bspMeshIndices].offset, SEEK_SET); fread(meshIndices, header.directoryEntries[bspMeshIndices].length, 1, file); //Load in faces if(!LoadFaces(file, curveTesselation)) return false; //Load textures if(!LoadTextures(file)) return false; //Load Lightmaps if(!LoadLightmaps(file)) return false; //Load BSP Data if(!LoadBSPData(file)) return false; //Load in entity string entityString=new char[header.directoryEntries[bspEntities].length]; if(!entityString) { errorLog.OutputError( "Unable to allocate memory for %d length entity string", header.directoryEntries[bspEntities].length); return false; } //Go to entity string in file fseek(file, header.directoryEntries[bspEntities].offset, SEEK_SET); fread(entityString, 1, header.directoryEntries[bspEntities].length, file); //Output the entity string //errorLog.OutputSuccess("Entity String: %s", entityString); fclose(file); errorLog.OutputSuccess("%s Loaded successfully", filename); return true; }
HRESULT InitDevice() { HRESULT hr = S_OK; RECT rc; GetClientRect(g_hWnd, &rc); UINT width = rc.right - rc.left; UINT height = rc.bottom - rc.top; UINT createDeviceFlags = 0; #ifdef _DEBUG createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; #endif D3D_DRIVER_TYPE driverTypes[] = { D3D_DRIVER_TYPE_HARDWARE, D3D_DRIVER_TYPE_WARP, D3D_DRIVER_TYPE_REFERENCE, }; UINT numDriverTypes = ARRAYSIZE(driverTypes); D3D_FEATURE_LEVEL featureLevels[] = { D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0, }; UINT numFeatureLevels = ARRAYSIZE(featureLevels); DXGI_SWAP_CHAIN_DESC sd; ZeroMemory(&sd, sizeof(sd)); sd.BufferCount = 1; sd.BufferDesc.Width = width; sd.BufferDesc.Height = height; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.BufferDesc.RefreshRate.Numerator = 60; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.OutputWindow = g_hWnd; sd.SampleDesc.Count = 1; sd.SampleDesc.Quality = 0; sd.Windowed = TRUE; sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; for (UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++) { g_driverType = driverTypes[driverTypeIndex]; hr = D3D11CreateDeviceAndSwapChain(NULL, g_driverType, NULL, createDeviceFlags, featureLevels, numFeatureLevels, D3D11_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice, &g_featureLevel, &g_pImmediateContext); if (SUCCEEDED(hr)) break; } if (FAILED(hr)) return hr; // Create a render target view ID3D11Texture2D* pBackBuffer = NULL; hr = g_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer); if (FAILED(hr)) return hr; hr = g_pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &g_pRenderTargetView); pBackBuffer->Release(); if (FAILED(hr)) return hr; // Create depth stencil texture D3D11_TEXTURE2D_DESC descDepth; ZeroMemory(&descDepth, sizeof(descDepth)); descDepth.Width = width; descDepth.Height = height; descDepth.MipLevels = 1; descDepth.ArraySize = 1; descDepth.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; descDepth.SampleDesc.Count = 1; descDepth.SampleDesc.Quality = 0; descDepth.Usage = D3D11_USAGE_DEFAULT; descDepth.BindFlags = D3D11_BIND_DEPTH_STENCIL; descDepth.CPUAccessFlags = 0; descDepth.MiscFlags = 0; hr = g_pd3dDevice->CreateTexture2D(&descDepth, NULL, &g_pDepthStencil); if (FAILED(hr)) return hr; // Create the depth stencil view D3D11_DEPTH_STENCIL_VIEW_DESC descDSV; ZeroMemory(&descDSV, sizeof(descDSV)); descDSV.Format = descDepth.Format; descDSV.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; descDSV.Texture2D.MipSlice = 0; hr = g_pd3dDevice->CreateDepthStencilView(g_pDepthStencil, &descDSV, &g_pDepthStencilView); if (FAILED(hr)) return hr; g_pImmediateContext->OMSetRenderTargets(1, &g_pRenderTargetView, g_pDepthStencilView); // Setup the viewport D3D11_VIEWPORT vp; vp.Width = (FLOAT)width; vp.Height = (FLOAT)height; vp.MinDepth = 0.0f; vp.MaxDepth = 1.0f; vp.TopLeftX = 0; vp.TopLeftY = 0; g_pImmediateContext->RSSetViewports(1, &vp); // Compile the vertex shader ID3DBlob* pVSBlob = NULL; hr = CompileShaderFromFile(L"Tutorial05.fx", "VS", "vs_4_0", &pVSBlob); if (FAILED(hr)) { MessageBox(NULL, L"The FX file cannot be compiled. Please run this executable from the directory that contains the FX file.", L"Error", MB_OK); return hr; } // Create the vertex shader hr = g_pd3dDevice->CreateVertexShader(pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), NULL, &g_pVertexShader); if (FAILED(hr)) { pVSBlob->Release(); return hr; } // Define the input layout D3D11_INPUT_ELEMENT_DESC layout[] = { { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 28, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 36, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "TANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 48, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "BINORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 60, D3D11_INPUT_PER_VERTEX_DATA, 0 }, }; UINT numElements = ARRAYSIZE(layout); // Create the input layout hr = g_pd3dDevice->CreateInputLayout(layout, numElements, pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), &g_pVertexLayout); pVSBlob->Release(); if (FAILED(hr)) return hr; // Set the input layout g_pImmediateContext->IASetInputLayout(g_pVertexLayout); // Compile the pixel shader ID3DBlob* pPSBlob = NULL; hr = CompileShaderFromFile(L"Tutorial05.fx", "PS", "ps_4_0", &pPSBlob); if (FAILED(hr)) { MessageBox(NULL, L"The FX file cannot be compiled. Please run this executable from the directory that contains the FX file.", L"Error", MB_OK); return hr; } // Create the pixel shader hr = g_pd3dDevice->CreatePixelShader(pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), NULL, &g_pPixelShader); pPSBlob->Release(); if (FAILED(hr)) return hr; // ------------------------------------------------------------- // JPE: Shaders para WireFrame // ------------------------------------------------------------- // Compile the vertex shader ID3DBlob* pVSBlobWF = NULL; hr = CompileShaderFromFile(L"Tutorial05.fx", "VS_WF", "vs_4_0", &pVSBlobWF); if (FAILED(hr)) { MessageBox(NULL, L"The FX file cannot be compiled. Please run this executable from the directory that contains the FX file.", L"Error", MB_OK); return hr; } // Create the vertex shader hr = g_pd3dDevice->CreateVertexShader(pVSBlobWF->GetBufferPointer(), pVSBlobWF->GetBufferSize(), NULL, &g_pVertexShaderWF); pVSBlobWF->Release(); if (FAILED(hr)) return hr; // Compile the pixel shader ID3DBlob* pPSBlobWF = NULL; hr = CompileShaderFromFile(L"Tutorial05.fx", "PS_WF", "ps_4_0", &pPSBlobWF); if (FAILED(hr)) { MessageBox(NULL, L"The FX file cannot be compiled. Please run this executable from the directory that contains the FX file.", L"Error", MB_OK); return hr; } // Create the pixel shader hr = g_pd3dDevice->CreatePixelShader(pPSBlobWF->GetBufferPointer(), pPSBlobWF->GetBufferSize(), NULL, &g_pPixelShaderWF); pPSBlobWF->Release(); if (FAILED(hr)) return hr; // ------------------------------------------------------------- // JPE: Create vertex buffer and index buffer SimpleVertex* vertices; WORD* indices; if (modelo == ModeloMono) { LoadFileOFF(&vertices, &indices, &cantVertices, &cantIndices); } else { LoadVertices(&vertices, &indices, &cantVertices, &cantIndices); } CalcularNormales(vertices, indices, cantVertices, cantIndices); // Crea Buffer para Vertices D3D11_BUFFER_DESC bd; ZeroMemory( &bd, sizeof(bd) ); bd.Usage = D3D11_USAGE_DEFAULT; bd.ByteWidth = sizeof( SimpleVertex ) * cantVertices; bd.BindFlags = D3D11_BIND_VERTEX_BUFFER; bd.CPUAccessFlags = 0; D3D11_SUBRESOURCE_DATA InitData; ZeroMemory( &InitData, sizeof(InitData) ); InitData.pSysMem = vertices; hr = g_pd3dDevice->CreateBuffer( &bd, &InitData, &g_pVertexBuffer ); if( FAILED( hr ) ) return hr; // Set vertex buffer UINT stride = sizeof( SimpleVertex ); UINT offset = 0; g_pImmediateContext->IASetVertexBuffers( 0, 1, &g_pVertexBuffer, &stride, &offset ); // Crea Buffer para Indexes bd.Usage = D3D11_USAGE_DEFAULT; bd.ByteWidth = sizeof( WORD ) * cantIndices; // 36 vertices needed for 12 triangles in a triangle list bd.BindFlags = D3D11_BIND_INDEX_BUFFER; bd.CPUAccessFlags = 0; InitData.pSysMem = indices; hr = g_pd3dDevice->CreateBuffer( &bd, &InitData, &g_pIndexBuffer ); if( FAILED( hr ) ) return hr; // Set index buffer g_pImmediateContext->IASetIndexBuffer( g_pIndexBuffer, DXGI_FORMAT_R16_UINT, 0 ); // Set primitive topology g_pImmediateContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST ); // Create the constant buffer bd.Usage = D3D11_USAGE_DEFAULT; bd.ByteWidth = sizeof(ConstantBuffer); bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER; bd.CPUAccessFlags = 0; hr = g_pd3dDevice->CreateBuffer( &bd, NULL, &g_pConstantBuffer ); if( FAILED( hr ) ) return hr; // JPE: Create the constant buffer for PixelShader bd.Usage = D3D11_USAGE_DEFAULT; bd.ByteWidth = sizeof(ConstantBufferPS); bd.BindFlags = D3D11_BIND_SHADER_RESOURCE; bd.CPUAccessFlags = 0; hr = g_pd3dDevice->CreateBuffer(&bd, NULL, &g_pConstantBufferPS); if (FAILED(hr)) return hr; // Initialize the world matrix g_World1 = XMMatrixIdentity(); g_World2 = XMMatrixIdentity(); SetViewMatrix(); // Initialize the projection matrix g_Projection = XMMatrixPerspectiveFovLH( XM_PIDIV2, width / (FLOAT)height, 0.01f, 100.0f ); // JPE: Texturas loadTextures(g_pd3dDevice); // JPE: Raster state ///* D3D11_RASTERIZER_DESC rasterDesc; // Setup the raster description which will determine how and what polygons will be drawn. rasterDesc.AntialiasedLineEnable = false; rasterDesc.CullMode = D3D11_CULL_BACK; rasterDesc.DepthBias = 0; rasterDesc.DepthBiasClamp = 0.0f; rasterDesc.DepthClipEnable = true; rasterDesc.FillMode = D3D11_FILL_SOLID; rasterDesc.FrontCounterClockwise = false; rasterDesc.MultisampleEnable = false; rasterDesc.ScissorEnable = false; rasterDesc.SlopeScaledDepthBias = 0.0f; // Create the rasterizer state from the description we just filled out. hr = g_pd3dDevice->CreateRasterizerState(&rasterDesc, &m_rasterState); if (FAILED(hr)) { return hr; } // Now set the rasterizer state. g_pImmediateContext->RSSetState(m_rasterState); //*/ // JPE: Raster state para WireFrame // Setup the raster description which will determine how and what polygons will be drawn. rasterDesc.AntialiasedLineEnable = false; rasterDesc.CullMode = D3D11_CULL_BACK; rasterDesc.DepthBias = 0; rasterDesc.DepthBiasClamp = 0.0f; rasterDesc.DepthClipEnable = true; rasterDesc.FillMode = D3D11_FILL_WIREFRAME; rasterDesc.FrontCounterClockwise = false; rasterDesc.MultisampleEnable = false; rasterDesc.ScissorEnable = false; rasterDesc.SlopeScaledDepthBias = 0.0f; // Create the rasterizer state from the description we just filled out. hr = g_pd3dDevice->CreateRasterizerState(&rasterDesc, &m_rasterStateWF); if (FAILED(hr)) { return hr; } // JPE: Parametros default if (modelo == ModeloMono) { bump = false; useTexture = false; rotate = false; } return S_OK; }
int Map_Load (const char *name) { int direxists; map_error = NULL; memset (&loadmap, 0, sizeof(loadmap)); if (Data_IsDir(name, &direxists) && direxists) { loaddir = name; Get = GetFromDir; } else { /* no directory with the map name; try a pak */ const char *ext = ".pak"; char path[2048]; if (strlen(name) > (sizeof(path) - strlen(ext) - 1)) return Error("map name too long"); strcpy (path, name); strcat (path, ext); if ((loadpak = Pak_Open(path)) == NULL) return Error("unable to open \"%s\"", path); Get = GetFromPak; } if (!LoadPlanes()) goto failed; if (!LoadVertices()) goto failed; if (!LoadEdges()) goto failed; if (!LoadEdgeLoops()) goto failed; if (!LoadSurfaces()) goto failed; if (!LoadPortals()) goto failed; if (!LoadNodes()) goto failed; if (!LoadLeafs()) goto failed; if (!LoadTextures()) goto failed; /* success; get rid of current map & switch over */ Map_Unload (); map = loadmap; memset (&loadmap, 0, sizeof(loadmap)); Get = NULL; loadpak = Pak_Close (loadpak); loaddir = NULL; return 1; failed: /* failure; keep the currently-loaded map running */ FreeMap (&loadmap); Get = NULL; loadpak = Pak_Close (loadpak); loaddir = NULL; return 0; }