d3drm_private.h File Reference

#include <assert.h>
#include <math.h>
#include "dxfile.h"
#include "d3drmwin.h"
#include "rmxfguid.h"
#include "wine/debug.h"
#include "wine/list.h"

Include dependency graph for d3drm_private.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	d3drm_matrix
struct	d3drm_object
struct	d3drm_texture
struct	d3drm_frame
struct	d3drm_box
struct	d3drm_viewport
struct	d3drm_device
struct	d3drm_face
struct	d3drm_mesh_builder
struct	mesh_group
struct	d3drm_mesh
struct	d3drm_light
struct	color_rgb
struct	d3drm_material
struct	d3drm_animation_key
struct	d3drm_animation_keys
struct	d3drm_animation
struct	d3drm_wrap
struct	d3drm_file_header

Macros
#define	COBJMACROS

Functions
static struct d3drm_matrix *	d3drm_matrix (D3DRMMATRIX4D m)
HRESULT	d3drm_device_create (struct d3drm_device **device, IDirect3DRM *d3drm)
HRESULT	d3drm_device_create_surfaces_from_clipper (struct d3drm_device *object, IDirectDraw *ddraw, IDirectDrawClipper *clipper, int width, int height, IDirectDrawSurface **surface)
void	d3drm_device_destroy (struct d3drm_device *device)
HRESULT	d3drm_device_init (struct d3drm_device *device, UINT version, IDirectDraw *ddraw, IDirectDrawSurface *surface, BOOL create_z_surface)
void	d3drm_object_init (struct d3drm_object *object, const char *classname)
HRESULT	d3drm_object_add_destroy_callback (struct d3drm_object *object, D3DRMOBJECTCALLBACK cb, void *ctx)
HRESULT	d3drm_object_delete_destroy_callback (struct d3drm_object *object, D3DRMOBJECTCALLBACK cb, void *ctx)
HRESULT	d3drm_object_get_class_name (struct d3drm_object *object, DWORD *size, char *name)
HRESULT	d3drm_object_get_name (struct d3drm_object *object, DWORD *size, char *name)
HRESULT	d3drm_object_set_name (struct d3drm_object *object, const char *name)
void	d3drm_object_cleanup (IDirect3DRMObject *iface, struct d3drm_object *object)
struct d3drm_frame *	unsafe_impl_from_IDirect3DRMFrame (IDirect3DRMFrame *iface)
struct d3drm_frame *	unsafe_impl_from_IDirect3DRMFrame3 (IDirect3DRMFrame3 *iface)
struct d3drm_device *	unsafe_impl_from_IDirect3DRMDevice3 (IDirect3DRMDevice3 *iface)
HRESULT	d3drm_texture_create (struct d3drm_texture **texture, IDirect3DRM *d3drm)
HRESULT	d3drm_frame_create (struct d3drm_frame **frame, IUnknown *parent_frame, IDirect3DRM *d3drm)
HRESULT	d3drm_face_create (struct d3drm_face **face)
HRESULT	d3drm_viewport_create (struct d3drm_viewport **viewport, IDirect3DRM *d3drm)
HRESULT	d3drm_mesh_builder_create (struct d3drm_mesh_builder **mesh_builder, IDirect3DRM *d3drm)
HRESULT	d3drm_light_create (struct d3drm_light **light, IDirect3DRM *d3drm)
HRESULT	d3drm_material_create (struct d3drm_material **material, IDirect3DRM *d3drm)
HRESULT	d3drm_mesh_create (struct d3drm_mesh **mesh, IDirect3DRM *d3drm)
HRESULT	d3drm_animation_create (struct d3drm_animation **animation, IDirect3DRM *d3drm)
HRESULT	d3drm_wrap_create (struct d3drm_wrap **wrap, IDirect3DRM *d3drm)
HRESULT	load_mesh_data (IDirect3DRMMeshBuilder3 *iface, IDirectXFileData *data, D3DRMLOADTEXTURECALLBACK load_texture_proc, void *arg)
static BYTE	d3drm_color_component (float c)
static void	d3drm_set_color (D3DCOLOR *color, float r, float g, float b, float a)
BOOL	d3drm_array_reserve (void **elements, SIZE_T *capacity, SIZE_T element_count, SIZE_T element_size)

Variables
char	templates []

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 24 of file d3drm_private.h.

Function Documentation

d3drm_animation_create()

HRESULT d3drm_animation_create	(	struct d3drm_animation **	animation,
		IDirect3DRM *	d3drm
	)

Definition at line 3881 of file frame.c.

{
    static const char classname[] = "Animation";
    struct d3drm_animation *object;
    HRESULT hr = D3DRM_OK;
 
    TRACE("animation %p, d3drm %p.\n", animation, d3drm);
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IDirect3DRMAnimation_iface.lpVtbl = &d3drm_animation1_vtbl;
    object->IDirect3DRMAnimation2_iface.lpVtbl = &d3drm_animation2_vtbl;
    object->d3drm = d3drm;
    object->ref = 1;
    object->options = D3DRMANIMATION_CLOSED | D3DRMANIMATION_LINEARPOSITION;
 
    d3drm_object_init(&object->obj, classname);
 
    IDirect3DRM_AddRef(object->d3drm);
 
    *animation = object;
 
    return hr;
}

Referenced by d3drm1_CreateAnimation(), d3drm3_CreateAnimation(), and d3drm_create_animation_object().

d3drm_array_reserve()

BOOL d3drm_array_reserve	(	void **	elements,
		SIZE_T *	capacity,
		SIZE_T	element_count,
		SIZE_T	element_size
	)

Definition at line 260 of file meshbuilder.c.

{
    SIZE_T new_capacity, max_capacity;
    void *new_elements;
 
    if (element_count <= *capacity)
        return TRUE;
 
    max_capacity = ~(SIZE_T)0 / element_size;
    if (max_capacity < element_count)
        return FALSE;
 
    new_capacity = max(*capacity, 4);
    while (new_capacity < element_count && new_capacity <= max_capacity / 2)
        new_capacity *= 2;
 
    if (new_capacity < element_count)
        new_capacity = max_capacity;
 
    if (!(new_elements = realloc(*elements, new_capacity * element_size)))
        return FALSE;
 
    *elements = new_elements;
    *capacity = new_capacity;
    return TRUE;
}

Referenced by d3drm_animation2_AddKey(), d3drm_frame3_AddChild(), d3drm_frame3_AddLight(), d3drm_frame3_AddVisual(), d3drm_mesh_AddGroup(), d3drm_mesh_builder3_AddNormal(), d3drm_mesh_builder3_AddVertex(), and load_mesh_data().

d3drm_color_component()

static BYTE d3drm_color_component ( float  c )

inlinestatic

Definition at line 316 of file d3drm_private.h.

{
    if (c <= 0.0f)
        return 0u;
    if (c >= 1.0f)
        return 0xffu;
    return floor(c * 255.0f);
}

Referenced by d3drm_set_color().

d3drm_device_create()

HRESULT d3drm_device_create	(	struct d3drm_device **	device,
		IDirect3DRM *	d3drm
	)

Definition at line 1656 of file device.c.

{
    static const char classname[] = "Device";
    struct d3drm_device *object;
 
    TRACE("device %p, d3drm %p.\n", device, d3drm);
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IDirect3DRMDevice_iface.lpVtbl = &d3drm_device1_vtbl;
    object->IDirect3DRMDevice2_iface.lpVtbl = &d3drm_device2_vtbl;
    object->IDirect3DRMDevice3_iface.lpVtbl = &d3drm_device3_vtbl;
    object->IDirect3DRMWinDevice_iface.lpVtbl = &d3drm_device_win_vtbl;
    object->d3drm = d3drm;
    d3drm_object_init(&object->obj, classname);
 
    *device = object;
 
    return D3DRM_OK;
}

Referenced by d3drm1_CreateDeviceFromClipper(), d3drm1_CreateDeviceFromD3D(), d3drm1_CreateDeviceFromSurface(), d3drm3_CreateDeviceFromClipper(), d3drm3_CreateDeviceFromD3D(), d3drm3_CreateDeviceFromSurface(), and d3drm_create_device_object().

d3drm_device_create_surfaces_from_clipper()

HRESULT d3drm_device_create_surfaces_from_clipper	(	struct d3drm_device *	object,
		IDirectDraw *	ddraw,
		IDirectDrawClipper *	clipper,
		int	width,
		int	height,
		IDirectDrawSurface **	surface
	)

Definition at line 69 of file device.c.

{
    DDSURFACEDESC surface_desc;
    IDirectDrawSurface *primary_surface, *render_target;
    HWND window;
    HRESULT hr;
 
    hr = IDirectDrawClipper_GetHWnd(clipper, &window);
    if (FAILED(hr))
        return hr;
 
    hr = IDirectDraw_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
    if (FAILED(hr))
        return hr;
 
    memset(&surface_desc, 0, sizeof(surface_desc));
    surface_desc.dwSize = sizeof(surface_desc);
    surface_desc.dwFlags = DDSD_CAPS;
    surface_desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
    hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &primary_surface, NULL);
    if (FAILED(hr))
        return hr;
    hr = IDirectDrawSurface_SetClipper(primary_surface, clipper);
    if (FAILED(hr))
    {
        IDirectDrawSurface_Release(primary_surface);
        return hr;
    }
 
    memset(&surface_desc, 0, sizeof(surface_desc));
    surface_desc.dwSize = sizeof(surface_desc);
    surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
    surface_desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
    surface_desc.dwWidth = width;
    surface_desc.dwHeight = height;
 
    hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &render_target, NULL);
    if (FAILED(hr))
    {
        IDirectDrawSurface_Release(primary_surface);
        return hr;
    }
 
    object->primary_surface = primary_surface;
    object->clipper = clipper;
    IDirectDrawClipper_AddRef(clipper);
    *surface = render_target;
 
    return D3DRM_OK;
}

Referenced by d3drm1_CreateDeviceFromClipper(), and d3drm3_CreateDeviceFromClipper().

d3drm_device_destroy()

void d3drm_device_destroy

(

struct d3drm_device *

device

)

Definition at line 40 of file device.c.

{
    d3drm_object_cleanup((IDirect3DRMObject *)&device->IDirect3DRMDevice_iface, &device->obj);
    if (device->device)
    {
        TRACE("Releasing attached ddraw interfaces.\n");
        IDirect3DDevice_Release(device->device);
    }
    if (device->render_target)
        IDirectDrawSurface_Release(device->render_target);
    if (device->primary_surface)
    {
        TRACE("Releasing primary surface and attached clipper.\n");
        IDirectDrawSurface_Release(device->primary_surface);
        IDirectDrawClipper_Release(device->clipper);
    }
    if (device->ddraw)
    {
        IDirectDraw_Release(device->ddraw);
        IDirect3DRM_Release(device->d3drm);
    }
    free(device);
}

Referenced by d3drm1_CreateDeviceFromClipper(), d3drm1_CreateDeviceFromD3D(), d3drm1_CreateDeviceFromSurface(), d3drm3_CreateDeviceFromClipper(), d3drm3_CreateDeviceFromD3D(), d3drm3_CreateDeviceFromSurface(), and d3drm_device3_Release().

d3drm_device_init()

HRESULT d3drm_device_init	(	struct d3drm_device *	device,
		UINT	version,
		IDirectDraw *	ddraw,
		IDirectDrawSurface *	surface,
		BOOL	create_z_surface
	)

Definition at line 120 of file device.c.

{
    DDSCAPS caps = { DDSCAPS_ZBUFFER };
    IDirectDrawSurface *ds = NULL;
    IDirect3DDevice *device1 = NULL;
    IDirect3DDevice2 *device2 = NULL;
    IDirect3DDevice3 *device3 = NULL;
    IDirect3D2 *d3d2 = NULL;
    IDirect3D3 *d3d3 = NULL;
    DDSURFACEDESC desc, surface_desc;
    HRESULT hr;
 
    device->ddraw = ddraw;
    IDirectDraw_AddRef(ddraw);
    IDirect3DRM_AddRef(device->d3drm);
    device->render_target = surface;
    IDirectDrawSurface_AddRef(surface);
 
    desc.dwSize = sizeof(desc);
    hr = IDirectDrawSurface_GetSurfaceDesc(surface, &desc);
    if (FAILED(hr))
        return hr;
 
    if (!(desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE))
        return DDERR_INVALIDCAPS;
 
    hr = IDirectDrawSurface_GetAttachedSurface(surface, &caps, &ds);
    if (SUCCEEDED(hr))
    {
        create_z_surface = FALSE;
        IDirectDrawSurface_Release(ds);
        ds = NULL;
    }
 
    if (create_z_surface)
    {
        memset(&surface_desc, 0, sizeof(surface_desc));
        surface_desc.dwSize = sizeof(surface_desc);
        surface_desc.dwFlags = DDSD_CAPS | DDSD_ZBUFFERBITDEPTH | DDSD_WIDTH | DDSD_HEIGHT;
        surface_desc.ddsCaps.dwCaps = DDSCAPS_ZBUFFER;
        surface_desc.dwZBufferBitDepth = 16;
        surface_desc.dwWidth = desc.dwWidth;
        surface_desc.dwHeight = desc.dwHeight;
        hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &ds, NULL);
        if (FAILED(hr))
            return hr;
 
        hr = IDirectDrawSurface_AddAttachedSurface(surface, ds);
        IDirectDrawSurface_Release(ds);
        if (FAILED(hr))
            return hr;
    }
 
    if (version == 1)
        hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirect3DRGBDevice, (void **)&device1);
    else if (version == 2)
    {
        IDirectDraw_QueryInterface(ddraw, &IID_IDirect3D2, (void**)&d3d2);
        hr = IDirect3D2_CreateDevice(d3d2, &IID_IDirect3DRGBDevice, surface, &device2);
        IDirect3D2_Release(d3d2);
    }
    else
    {
        IDirectDrawSurface4 *surface4 = NULL;
 
        IDirectDrawSurface_QueryInterface(surface, &IID_IDirectDrawSurface4, (void**)&surface4);
        IDirectDraw_QueryInterface(ddraw, &IID_IDirect3D3, (void**)&d3d3);
        hr = IDirect3D3_CreateDevice(d3d3, &IID_IDirect3DRGBDevice, surface4, &device3, NULL);
        IDirectDrawSurface4_Release(surface4);
        IDirect3D3_Release(d3d3);
    }
    if (FAILED(hr))
    {
        IDirectDrawSurface_DeleteAttachedSurface(surface, 0, ds);
        return hr;
    }
 
    if (version == 2)
    {
        hr = IDirect3DDevice2_QueryInterface(device2, &IID_IDirect3DDevice, (void**)&device1);
        IDirect3DDevice2_Release(device2);
        if (FAILED(hr))
        {
            IDirectDrawSurface_DeleteAttachedSurface(surface, 0, ds);
            return hr;
        }
    }
    else if (version == 3)
    {
        hr = IDirect3DDevice3_QueryInterface(device3, &IID_IDirect3DDevice, (void**)&device1);
        IDirect3DDevice3_Release(device3);
        if (FAILED(hr))
        {
            IDirectDrawSurface_DeleteAttachedSurface(surface, 0, ds);
            return hr;
        }
    }
    device->device = device1;
    device->width = desc.dwWidth;
    device->height = desc.dwHeight;
 
    return hr;
}

Referenced by d3drm1_CreateDeviceFromClipper(), d3drm1_CreateDeviceFromSurface(), d3drm3_CreateDeviceFromClipper(), and d3drm3_CreateDeviceFromSurface().

d3drm_face_create()

HRESULT d3drm_face_create

(

struct d3drm_face **

face

)

Definition at line 620 of file face.c.

{
    static const char classname[] = "Face";
    struct d3drm_face *object;
 
    TRACE("face %p.\n", face);
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IDirect3DRMFace_iface.lpVtbl = &d3drm_face1_vtbl;
    object->IDirect3DRMFace2_iface.lpVtbl = &d3drm_face2_vtbl;
    object->ref = 1;
 
    d3drm_object_init(&object->obj, classname);
 
    *face = object;
 
    return S_OK;
}

Referenced by d3drm1_CreateFace(), d3drm_create_face_object(), d3drm_mesh_builder2_CreateFace(), and d3drm_mesh_builder3_CreateFace().

d3drm_frame_create()

HRESULT d3drm_frame_create	(	struct d3drm_frame **	frame,
		IUnknown *	parent_frame,
		IDirect3DRM *	d3drm
	)

Definition at line 3129 of file frame.c.

{
    static const char classname[] = "Frame";
    struct d3drm_frame *object;
    HRESULT hr = D3DRM_OK;
 
    TRACE("frame %p, parent_frame %p, d3drm %p.\n", frame, parent_frame, d3drm);
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IDirect3DRMFrame_iface.lpVtbl = &d3drm_frame1_vtbl;
    object->IDirect3DRMFrame2_iface.lpVtbl = &d3drm_frame2_vtbl;
    object->IDirect3DRMFrame3_iface.lpVtbl = &d3drm_frame3_vtbl;
    object->d3drm = d3drm;
    object->ref = 1;
    d3drm_set_color(&object->scenebackground, 0.0f, 0.0f, 0.0f, 1.0f);
    object->traversal_options = D3DRMFRAME_RENDERENABLE | D3DRMFRAME_PICKENABLE;
 
    d3drm_object_init(&object->obj, classname);
 
    object->transform = identity;
 
    if (parent_frame)
    {
        IDirect3DRMFrame3 *p;
 
        if (FAILED(hr = IDirect3DRMFrame_QueryInterface(parent_frame, &IID_IDirect3DRMFrame3, (void **)&p)))
        {
            free(object);
            return hr;
        }
        IDirect3DRMFrame_Release(parent_frame);
        IDirect3DRMFrame3_AddChild(p, &object->IDirect3DRMFrame3_iface);
    }
 
    IDirect3DRM_AddRef(object->d3drm);
 
    *frame = object;
 
    return hr;
}

Referenced by d3drm1_CreateFrame(), d3drm2_CreateFrame(), d3drm3_CreateFrame(), and d3drm_create_frame_object().

d3drm_light_create()

HRESULT d3drm_light_create	(	struct d3drm_light **	light,
		IDirect3DRM *	d3drm
	)

Definition at line 371 of file light.c.

{
    static const char classname[] = "Light";
    struct d3drm_light *object;
 
    TRACE("light %p.\n", light);
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IDirect3DRMLight_iface.lpVtbl = &d3drm_light_vtbl;
    object->ref = 1;
    object->d3drm = d3drm;
    IDirect3DRM_AddRef(object->d3drm);
 
    d3drm_object_init(&object->obj, classname);
 
    *light = object;
 
    return S_OK;
}

Referenced by d3drm3_CreateLight(), d3drm3_CreateLightRGB(), and d3drm_create_light_object().

d3drm_material_create()

HRESULT d3drm_material_create	(	struct d3drm_material **	material,
		IDirect3DRM *	d3drm
	)

Definition at line 279 of file material.c.

{
    static const char classname[] = "Material";
    struct d3drm_material *object;
 
    TRACE("material %p, d3drm %p.\n", material, d3drm);
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IDirect3DRMMaterial2_iface.lpVtbl = &d3drm_material_vtbl;
    object->ref = 1;
    object->d3drm = d3drm;
    IDirect3DRM_AddRef(object->d3drm);
 
    object->specular.r = 1.0f;
    object->specular.g = 1.0f;
    object->specular.b = 1.0f;
 
    d3drm_object_init(&object->obj, classname);
 
    *material = object;
 
    return S_OK;
}

Referenced by d3drm3_CreateMaterial(), d3drm_create_material_object(), and load_mesh_data().

d3drm_matrix()

static struct d3drm_matrix * d3drm_matrix ( D3DRMMATRIX4D  m )

inlinestatic

Definition at line 41 of file d3drm_private.h.

{
    return (struct d3drm_matrix *)m;
}

d3drm_mesh_builder_create()

HRESULT d3drm_mesh_builder_create	(	struct d3drm_mesh_builder **	mesh_builder,
		IDirect3DRM *	d3drm
	)

Definition at line 2336 of file meshbuilder.c.

{
    static const char classname[] = "Builder";
    struct d3drm_mesh_builder *object;
 
    TRACE("mesh_builder %p.\n", mesh_builder);
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IDirect3DRMMeshBuilder2_iface.lpVtbl = &d3drm_mesh_builder2_vtbl;
    object->IDirect3DRMMeshBuilder3_iface.lpVtbl = &d3drm_mesh_builder3_vtbl;
    object->ref = 1;
    object->d3drm = d3drm;
    object->quality = D3DRMRENDER_GOURAUD;
    IDirect3DRM_AddRef(object->d3drm);
 
    d3drm_object_init(&object->obj, classname);
 
    *mesh_builder = object;
 
    return S_OK;
}

Referenced by d3drm2_CreateMeshBuilder(), d3drm3_CreateMeshBuilder(), and d3drm_create_mesh_builder_object().

d3drm_mesh_create()

HRESULT d3drm_mesh_create	(	struct d3drm_mesh **	mesh,
		IDirect3DRM *	d3drm
	)

Definition at line 2836 of file meshbuilder.c.

{
    static const char classname[] = "Mesh";
    struct d3drm_mesh *object;
 
    TRACE("mesh %p, d3drm %p.\n", mesh, d3drm);
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IDirect3DRMMesh_iface.lpVtbl = &d3drm_mesh_vtbl;
    object->ref = 1;
    object->d3drm = d3drm;
    IDirect3DRM_AddRef(object->d3drm);
 
    d3drm_object_init(&object->obj, classname);
 
    *mesh = object;
 
    return S_OK;
}

Referenced by d3drm3_CreateMesh(), and d3drm_create_mesh_object().

d3drm_object_add_destroy_callback()

HRESULT d3drm_object_add_destroy_callback	(	struct d3drm_object *	object,
		D3DRMOBJECTCALLBACK	cb,
		void *	ctx
	)

Definition at line 57 of file d3drm_main.c.

{
    struct destroy_callback *callback;
 
    if (!cb)
        return D3DRMERR_BADVALUE;
 
    if (!(callback = malloc(sizeof(*callback))))
        return E_OUTOFMEMORY;
 
    callback->cb = cb;
    callback->ctx = ctx;
 
    list_add_head(&object->destroy_callbacks, &callback->entry);
    return D3DRM_OK;
}

Referenced by d3drm_animation2_AddDestroyCallback(), d3drm_device3_AddDestroyCallback(), d3drm_face2_AddDestroyCallback(), d3drm_frame3_AddDestroyCallback(), d3drm_light_AddDestroyCallback(), d3drm_material_AddDestroyCallback(), d3drm_mesh_AddDestroyCallback(), d3drm_mesh_builder3_AddDestroyCallback(), d3drm_texture3_AddDestroyCallback(), d3drm_viewport2_AddDestroyCallback(), and d3drm_wrap_AddDestroyCallback().

d3drm_object_cleanup()

void d3drm_object_cleanup	(	IDirect3DRMObject *	iface,
		struct d3drm_object *	object
	)

Definition at line 155 of file d3drm_main.c.

{
    struct destroy_callback *callback, *callback2;
 
    LIST_FOR_EACH_ENTRY_SAFE(callback, callback2, &object->destroy_callbacks, struct destroy_callback, entry)
    {
        callback->cb(iface, callback->ctx);
        list_remove(&callback->entry);
        free(callback);
    }
 
    free(object->name);
    object->name = NULL;
}

Referenced by d3drm_animation2_Release(), d3drm_device_destroy(), d3drm_face1_Release(), d3drm_frame3_Release(), d3drm_light_Release(), d3drm_material_Release(), d3drm_mesh_builder2_Release(), d3drm_mesh_Release(), d3drm_texture_destroy(), d3drm_viewport_destroy(), and d3drm_wrap_Release().

d3drm_object_delete_destroy_callback()

HRESULT d3drm_object_delete_destroy_callback	(	struct d3drm_object *	object,
		D3DRMOBJECTCALLBACK	cb,
		void *	ctx
	)

Definition at line 74 of file d3drm_main.c.

{
    struct destroy_callback *callback;
 
    if (!cb)
        return D3DRMERR_BADVALUE;
 
    LIST_FOR_EACH_ENTRY(callback, &object->destroy_callbacks, struct destroy_callback, entry)
    {
        if (callback->cb == cb && callback->ctx == ctx)
        {
            list_remove(&callback->entry);
            free(callback);
            break;
        }
    }
 
    return D3DRM_OK;
}

Referenced by d3drm_animation2_DeleteDestroyCallback(), d3drm_device3_DeleteDestroyCallback(), d3drm_face2_DeleteDestroyCallback(), d3drm_frame3_DeleteDestroyCallback(), d3drm_light_DeleteDestroyCallback(), d3drm_material_DeleteDestroyCallback(), d3drm_mesh_builder3_DeleteDestroyCallback(), d3drm_mesh_DeleteDestroyCallback(), d3drm_texture3_DeleteDestroyCallback(), d3drm_viewport2_DeleteDestroyCallback(), and d3drm_wrap_DeleteDestroyCallback().

d3drm_object_get_class_name()

HRESULT d3drm_object_get_class_name	(	struct d3drm_object *	object,
		DWORD *	size,
		char *	name
	)

Definition at line 94 of file d3drm_main.c.

{
    DWORD req_size;
 
    if (!size)
        return E_INVALIDARG;
 
    req_size = strlen(object->classname) + 1;
    if (name && *size < req_size)
        return E_INVALIDARG;
 
    *size = req_size;
 
    if (name)
        memcpy(name, object->classname, req_size);
 
    return D3DRM_OK;
}

Referenced by d3drm_animation2_GetClassName(), d3drm_device3_GetClassName(), d3drm_face2_GetClassName(), d3drm_frame3_GetClassName(), d3drm_light_GetClassName(), d3drm_material_GetClassName(), d3drm_mesh_builder3_GetClassName(), d3drm_mesh_GetClassName(), d3drm_texture3_GetClassName(), d3drm_viewport2_GetClassName(), and d3drm_wrap_GetClassName().

d3drm_object_get_name()

HRESULT d3drm_object_get_name	(	struct d3drm_object *	object,
		DWORD *	size,
		char *	name
	)

Definition at line 113 of file d3drm_main.c.

{
    DWORD req_size;
 
    if (!size)
        return E_INVALIDARG;
 
    req_size = object->name ? strlen(object->name) + 1 : 0;
    if (name && *size < req_size)
        return E_INVALIDARG;
 
    if (name)
    {
        if (object->name)
            memcpy(name, object->name, req_size);
        else if (*size)
            *name = 0;
    }
 
    *size = req_size;
 
    return D3DRM_OK;
}

Referenced by d3drm_animation2_GetName(), d3drm_device3_GetName(), d3drm_face2_GetName(), d3drm_frame3_GetName(), d3drm_light_GetName(), d3drm_material_GetName(), d3drm_mesh_builder3_GetName(), d3drm_mesh_GetName(), d3drm_texture3_GetName(), d3drm_viewport2_GetName(), and d3drm_wrap_GetName().

d3drm_object_init()

void d3drm_object_init	(	struct d3drm_object *	object,
		const char *	classname
	)

Definition at line 41 of file d3drm_main.c.

{
    object->ref = 1;
    object->appdata = 0;
    list_init(&object->destroy_callbacks);
    object->classname = classname;
    object->name = NULL;
}

Referenced by d3drm_animation_create(), d3drm_device_create(), d3drm_face_create(), d3drm_frame_create(), d3drm_light_create(), d3drm_material_create(), d3drm_mesh_builder_create(), d3drm_mesh_create(), d3drm_texture_create(), d3drm_viewport_create(), and d3drm_wrap_create().

d3drm_object_set_name()

HRESULT d3drm_object_set_name	(	struct d3drm_object *	object,
		const char *	name
	)

Definition at line 137 of file d3drm_main.c.

{
    DWORD req_size;
 
    free(object->name);
    object->name = NULL;
 
    if (name)
    {
        req_size = strlen(name) + 1;
        if (!(object->name = malloc(req_size)))
            return E_OUTOFMEMORY;
        memcpy(object->name, name, req_size);
    }
 
    return D3DRM_OK;
}

Referenced by d3drm_animation2_SetName(), d3drm_device3_SetName(), d3drm_face2_SetName(), d3drm_frame3_SetName(), d3drm_light_SetName(), d3drm_material_SetName(), d3drm_mesh_builder3_SetName(), d3drm_mesh_SetName(), d3drm_texture3_SetName(), d3drm_viewport2_SetName(), and d3drm_wrap_SetName().

d3drm_set_color()

static void d3drm_set_color ( D3DCOLOR *  color, float  r, float  g, float  b, float  a  )

inlinestatic

Definition at line 325 of file d3drm_private.h.

{
    *color = RGBA_MAKE(d3drm_color_component(r), d3drm_color_component(g),
            d3drm_color_component(b), d3drm_color_component(a));
}

Referenced by d3drm_face2_SetColorRGB(), d3drm_frame3_SetSceneBackgroundRGB(), d3drm_frame_create(), d3drm_light_SetColorRGB(), d3drm_mesh_builder3_SetColorRGB(), d3drm_mesh_SetGroupColorRGB(), D3DRMCreateColorRGBA(), and load_mesh_data().

d3drm_texture_create()

HRESULT d3drm_texture_create	(	struct d3drm_texture **	texture,
		IDirect3DRM *	d3drm
	)

Definition at line 1460 of file texture.c.

{
    static const char classname[] = "Texture";
    struct d3drm_texture *object;
 
    TRACE("texture %p.\n", texture);
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IDirect3DRMTexture_iface.lpVtbl = &d3drm_texture1_vtbl;
    object->IDirect3DRMTexture2_iface.lpVtbl = &d3drm_texture2_vtbl;
    object->IDirect3DRMTexture3_iface.lpVtbl = &d3drm_texture3_vtbl;
    object->d3drm = d3drm;
    object->max_colors = 8;
    object->max_shades = 16;
    object->transparency = FALSE;
    object->decal_width = 1.0f;
    object->decal_height = 1.0f;
 
    d3drm_object_init(&object->obj, classname);
 
    *texture = object;
 
    return D3DRM_OK;
}

Referenced by d3drm1_LoadTexture(), d3drm1_LoadTextureFromResource(), d3drm2_LoadTextureFromResource(), d3drm3_CreateTexture(), d3drm3_CreateTextureFromSurface(), d3drm3_LoadTexture(), d3drm3_LoadTextureFromResource(), d3drm_create_texture_object(), and load_mesh_data().

d3drm_viewport_create()

HRESULT d3drm_viewport_create	(	struct d3drm_viewport **	viewport,
		IDirect3DRM *	d3drm
	)

Definition at line 1129 of file viewport.c.

{
    static const char classname[] = "Viewport";
    struct d3drm_viewport *object;
 
    TRACE("viewport %p, d3drm %p.\n", viewport, d3drm);
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IDirect3DRMViewport_iface.lpVtbl = &d3drm_viewport1_vtbl;
    object->IDirect3DRMViewport2_iface.lpVtbl = &d3drm_viewport2_vtbl;
    object->d3drm = d3drm;
    d3drm_object_init(&object->obj, classname);
 
    *viewport = object;
 
    return S_OK;
}

Referenced by d3drm3_CreateViewport(), and d3drm_create_viewport_object().

d3drm_wrap_create()

HRESULT d3drm_wrap_create	(	struct d3drm_wrap **	wrap,
		IDirect3DRM *	d3drm
	)

Definition at line 3022 of file meshbuilder.c.

{
    static const char classname[] = "";
    struct d3drm_wrap *object;
 
    TRACE("wrap %p, d3drm %p.\n", wrap, d3drm);
 
    if (!(object = calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->IDirect3DRMWrap_iface.lpVtbl = &d3drm_wrap_vtbl;
    object->ref = 1;
 
    d3drm_object_init(&object->obj, classname);
 
    *wrap = object;
 
    return S_OK;
}

Referenced by d3drm1_CreateWrap(), d3drm3_CreateWrap(), and d3drm_create_wrap_object().

load_mesh_data()

HRESULT load_mesh_data	(	IDirect3DRMMeshBuilder3 *	iface,
		IDirectXFileData *	data,
		D3DRMLOADTEXTURECALLBACK	load_texture_proc,
		void *	arg
	)

Definition at line 1022 of file meshbuilder.c.

{
    struct d3drm_mesh_builder *mesh_builder = impl_from_IDirect3DRMMeshBuilder3(iface);
    IDirectXFileData *pData2 = NULL;
    const GUID* guid;
    DWORD size;
    BYTE *ptr;
    HRESULT hr;
    HRESULT ret = D3DRMERR_BADOBJECT;
    DWORD* faces_vertex_idx_data = NULL;
    DWORD* faces_vertex_idx_ptr;
    DWORD faces_vertex_idx_size;
    DWORD* faces_normal_idx_data = NULL;
    DWORD* faces_normal_idx_ptr = NULL;
    DWORD* faces_data_ptr;
    DWORD faces_data_size = 0;
    DWORD i;
 
    TRACE("(%p)->(%p)\n", mesh_builder, pData);
 
    hr = IDirectXFileData_GetName(pData, NULL, &size);
    if (hr != DXFILE_OK)
        return hr;
    if (size)
    {
        char *name;
 
        if (!(name = malloc(size)))
            return E_OUTOFMEMORY;
 
        if (SUCCEEDED(hr = IDirectXFileData_GetName(pData, name, &size)))
            IDirect3DRMMeshBuilder3_SetName(iface, name);
        free(name);
        if (hr != DXFILE_OK)
            return hr;
    }
 
    TRACE("Mesh name is %s\n", debugstr_a(mesh_builder->obj.name));
 
    mesh_builder->nb_normals = 0;
 
    hr = IDirectXFileData_GetData(pData, NULL, &size, (void**)&ptr);
    if (hr != DXFILE_OK)
        goto end;
 
    mesh_builder->nb_vertices = *(DWORD*)ptr;
    mesh_builder->nb_faces = *(DWORD*)(ptr + sizeof(DWORD) + mesh_builder->nb_vertices * sizeof(D3DVECTOR));
    faces_vertex_idx_size = size - sizeof(DWORD) - mesh_builder->nb_vertices * sizeof(D3DVECTOR) - sizeof(DWORD);
 
    TRACE("Mesh: nb_vertices = %Iu, nb_faces = %ld, faces_vertex_idx_size = %ld\n", mesh_builder->nb_vertices,
            mesh_builder->nb_faces, faces_vertex_idx_size);
 
    if (!d3drm_array_reserve((void **)&mesh_builder->vertices, &mesh_builder->vertices_size, mesh_builder->nb_vertices,
           sizeof(*mesh_builder->vertices)))
    {
        hr = E_OUTOFMEMORY;
        goto end;
    }
    memcpy(mesh_builder->vertices, ptr + sizeof(DWORD), mesh_builder->nb_vertices * sizeof(D3DVECTOR));
 
    faces_vertex_idx_ptr = faces_vertex_idx_data = malloc(faces_vertex_idx_size);
    memcpy(faces_vertex_idx_data, ptr + sizeof(DWORD) + mesh_builder->nb_vertices * sizeof(D3DVECTOR) + sizeof(DWORD),
            faces_vertex_idx_size);
 
    /* Each vertex index will have its normal index counterpart so just allocate twice the size */
    mesh_builder->pFaceData = malloc(faces_vertex_idx_size * 2);
    faces_data_ptr = (DWORD*)mesh_builder->pFaceData;
 
    while (1)
    {
        IDirectXFileObject *object;
 
        hr =  IDirectXFileData_GetNextObject(pData, &object);
        if (hr == DXFILEERR_NOMOREOBJECTS)
        {
            TRACE("No more object\n");
            break;
        }
        if (hr != DXFILE_OK)
           goto end;
 
        hr = IDirectXFileObject_QueryInterface(object, &IID_IDirectXFileData, (void**)&pData2);
        IDirectXFileObject_Release(object);
        if (hr != DXFILE_OK)
            goto end;
 
        hr = IDirectXFileData_GetType(pData2, &guid);
        if (hr != DXFILE_OK)
            goto end;
 
        TRACE("Found object type whose GUID = %s\n", debugstr_guid(guid));
 
        if (IsEqualGUID(guid, &TID_D3DRMMeshNormals))
        {
            DWORD nb_faces_normals;
            DWORD faces_normal_idx_size;
 
            hr = IDirectXFileData_GetData(pData2, NULL, &size, (void**)&ptr);
            if (hr != DXFILE_OK)
                goto end;
 
            mesh_builder->nb_normals = *(DWORD*)ptr;
            nb_faces_normals = *(DWORD*)(ptr + sizeof(DWORD) + mesh_builder->nb_normals * sizeof(D3DVECTOR));
 
            TRACE("MeshNormals: nb_normals = %Iu, nb_faces_normals = %ld\n", mesh_builder->nb_normals, nb_faces_normals);
            if (nb_faces_normals != mesh_builder->nb_faces)
                WARN("nb_face_normals (%ld) != nb_faces (%ld)\n", nb_faces_normals, mesh_builder->nb_faces);
 
            if (!d3drm_array_reserve((void **)&mesh_builder->normals, &mesh_builder->normals_size,
                    mesh_builder->nb_normals, sizeof(*mesh_builder->normals)))
            {
                hr = E_OUTOFMEMORY;
                goto end;
            }
            memcpy(mesh_builder->normals, ptr + sizeof(DWORD), mesh_builder->nb_normals * sizeof(D3DVECTOR));
 
            faces_normal_idx_size = size - (2 * sizeof(DWORD) + mesh_builder->nb_normals * sizeof(D3DVECTOR));
            faces_normal_idx_ptr = faces_normal_idx_data = malloc(faces_normal_idx_size);
            memcpy(faces_normal_idx_data, ptr + sizeof(DWORD) + mesh_builder->nb_normals * sizeof(D3DVECTOR)
                    + sizeof(DWORD), faces_normal_idx_size);
        }
        else if (IsEqualGUID(guid, &TID_D3DRMMeshTextureCoords))
        {
            hr = IDirectXFileData_GetData(pData2, NULL, &size, (void**)&ptr);
            if (hr != DXFILE_OK)
                goto end;
 
            mesh_builder->nb_coords2d = *(DWORD*)ptr;
 
            TRACE("MeshTextureCoords: nb_coords2d = %ld\n", mesh_builder->nb_coords2d);
 
            mesh_builder->pCoords2d = calloc(mesh_builder->nb_coords2d, sizeof(*mesh_builder->pCoords2d));
            memcpy(mesh_builder->pCoords2d, ptr + sizeof(DWORD), mesh_builder->nb_coords2d * sizeof(*mesh_builder->pCoords2d));
        }
        else if (IsEqualGUID(guid, &TID_D3DRMMeshMaterialList))
        {
            DWORD nb_materials;
            DWORD nb_face_indices;
            DWORD data_size;
            IDirectXFileObject *child;
            DWORD i = 0;
            float* values;
            struct d3drm_texture *texture_object;
 
            TRACE("Process MeshMaterialList\n");
 
            hr = IDirectXFileData_GetData(pData2, NULL, &size, (void**)&ptr);
            if (hr != DXFILE_OK)
                goto end;
 
            nb_materials = *(DWORD*)ptr;
            nb_face_indices = *(DWORD*)(ptr + sizeof(DWORD));
            data_size = 2 * sizeof(DWORD) + nb_face_indices * sizeof(DWORD);
 
            TRACE("nMaterials = %lu, nFaceIndexes = %lu\n", nb_materials, nb_face_indices);
 
            if (size != data_size)
                WARN("Returned size %lu does not match expected one %lu\n", size, data_size);
 
            if (!(mesh_builder->material_indices = calloc(nb_face_indices,
                    sizeof(*mesh_builder->material_indices))))
                goto end;
            memcpy(mesh_builder->material_indices, ptr + 2 * sizeof(DWORD),
                    nb_face_indices * sizeof(*mesh_builder->material_indices));
 
            if (!(mesh_builder->materials = calloc(nb_materials, sizeof(*mesh_builder->materials))))
            {
                free(mesh_builder->material_indices);
                goto end;
            }
            mesh_builder->nb_materials = nb_materials;
 
            while (SUCCEEDED(hr = IDirectXFileData_GetNextObject(pData2, &child)) && (i < nb_materials))
            {
                IDirectXFileData *data;
                IDirectXFileDataReference *reference;
                IDirectXFileObject *material_child;
                struct d3drm_material *object;
 
                hr = IDirectXFileObject_QueryInterface(child, &IID_IDirectXFileData, (void **)&data);
                if (FAILED(hr))
                {
                    hr = IDirectXFileObject_QueryInterface(child, &IID_IDirectXFileDataReference, (void **)&reference);
                    IDirectXFileObject_Release(child);
                    if (FAILED(hr))
                        goto end;
 
                    hr = IDirectXFileDataReference_Resolve(reference, &data);
                    IDirectXFileDataReference_Release(reference);
                    if (FAILED(hr))
                        goto end;
                }
                else
                {
                    IDirectXFileObject_Release(child);
                }
 
                hr = d3drm_material_create(&object, mesh_builder->d3drm);
                if (FAILED(hr))
                {
                    IDirectXFileData_Release(data);
                    goto end;
                }
                mesh_builder->materials[i].material = &object->IDirect3DRMMaterial2_iface;
 
                hr = IDirectXFileData_GetData(data, NULL, &size, (void**)&ptr);
                if (hr != DXFILE_OK)
                {
                    IDirectXFileData_Release(data);
                    goto end;
                }
 
                if (size != 44)
                    WARN("Material size %lu does not match expected one %u\n", size, 44);
 
                values = (float*)ptr;
 
                d3drm_set_color(&mesh_builder->materials[i].color, values[0], values[1], values[2], values[3]);
 
                IDirect3DRMMaterial2_SetAmbient(mesh_builder->materials[i].material, values[0], values [1], values[2]); /* Alpha ignored */
                IDirect3DRMMaterial2_SetPower(mesh_builder->materials[i].material, values[4]);
                IDirect3DRMMaterial2_SetSpecular(mesh_builder->materials[i].material, values[5], values[6], values[7]);
                IDirect3DRMMaterial2_SetEmissive(mesh_builder->materials[i].material, values[8], values[9], values[10]);
 
                mesh_builder->materials[i].texture = NULL;
 
                hr = IDirectXFileData_GetNextObject(data, &material_child);
                if (hr == S_OK)
                {
                    IDirectXFileData *data;
                    char **filename;
 
                    if (FAILED(hr = IDirectXFileObject_QueryInterface(material_child,
                            &IID_IDirectXFileData, (void **)&data)))
                    {
                        IDirectXFileDataReference *reference;
 
                        if (SUCCEEDED(IDirectXFileObject_QueryInterface(material_child,
                                &IID_IDirectXFileDataReference, (void **)&reference)))
                        {
                            hr = IDirectXFileDataReference_Resolve(reference, &data);
                            IDirectXFileDataReference_Release(reference);
                        }
                    }
                    IDirectXFileObject_Release(material_child);
                    if (FAILED(hr))
                        goto end;
 
                    hr = IDirectXFileData_GetType(data, &guid);
                    if (hr != DXFILE_OK)
                        goto end;
                    if (!IsEqualGUID(guid, &TID_D3DRMTextureFilename))
                    {
                         WARN("Not a texture filename\n");
                         goto end;
                    }
 
                    size = 4;
                    hr = IDirectXFileData_GetData(data, NULL, &size, (void**)&filename);
                    if (SUCCEEDED(hr))
                    {
                        if (load_texture_proc)
                        {
                            IDirect3DRMTexture *texture;
 
                            hr = load_texture_proc(*filename, arg, &texture);
                            if (SUCCEEDED(hr))
                            {
                                hr = IDirect3DTexture_QueryInterface(texture, &IID_IDirect3DRMTexture3,
                                        (void **)&mesh_builder->materials[i].texture);
                                IDirect3DTexture_Release(texture);
                            }
                        }
                        else
                        {
                            HANDLE file;
 
                            /* If the texture file is not found, no texture is associated with the material */
                            file = CreateFileA(*filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
                            if (file != INVALID_HANDLE_VALUE)
                            {
                                CloseHandle(file);
                                if (FAILED(hr = d3drm_texture_create(&texture_object, NULL)))
                                {
                                    IDirectXFileData_Release(data);
                                    goto end;
                                }
                                mesh_builder->materials[i].texture = &texture_object->IDirect3DRMTexture3_iface;
                            }
                        }
                    }
                    IDirectXFileData_Release(data);
                }
                else if (hr != DXFILEERR_NOMOREOBJECTS)
                {
                    goto end;
                }
                hr = S_OK;
 
                IDirectXFileData_Release(data);
                i++;
            }
            if (hr == S_OK)
            {
                IDirectXFileObject_Release(child);
                WARN("Found more sub-objects than expected\n");
            }
            else if (hr != DXFILEERR_NOMOREOBJECTS)
            {
                goto end;
            }
            hr = S_OK;
        }
        else
        {
            FIXME("Unknown GUID %s, ignoring...\n", debugstr_guid(guid));
        }
 
        IDirectXFileData_Release(pData2);
        pData2 = NULL;
    }
 
    if (!mesh_builder->nb_normals)
    {
        /* Allocate normals, one per vertex */
        if (!d3drm_array_reserve((void **)&mesh_builder->normals, &mesh_builder->normals_size,
                mesh_builder->nb_vertices, sizeof(*mesh_builder->normals)))
            goto end;
        memset(mesh_builder->normals, 0, mesh_builder->nb_vertices * sizeof(*mesh_builder->normals));
    }
 
    for (i = 0; i < mesh_builder->nb_faces; i++)
    {
        DWORD j;
        DWORD nb_face_indexes;
        D3DVECTOR face_normal;
 
        if (faces_vertex_idx_size < sizeof(DWORD))
            WARN("Not enough data to read number of indices of face %ld\n", i);
 
        nb_face_indexes  = *(faces_data_ptr + faces_data_size++) = *(faces_vertex_idx_ptr++);
        faces_vertex_idx_size--;
        if (faces_normal_idx_data && (*(faces_normal_idx_ptr++) != nb_face_indexes))
            WARN("Faces indices number mismatch\n");
 
        if (faces_vertex_idx_size < (nb_face_indexes * sizeof(DWORD)))
            WARN("Not enough data to read all indices of face %ld\n", i);
 
        if (!mesh_builder->nb_normals)
        {
            /* Compute face normal */
            if (nb_face_indexes > 2
                    && faces_vertex_idx_ptr[0] < mesh_builder->nb_vertices
                    && faces_vertex_idx_ptr[1] < mesh_builder->nb_vertices
                    && faces_vertex_idx_ptr[2] < mesh_builder->nb_vertices)
            {
                D3DVECTOR a, b;
 
                D3DRMVectorSubtract(&a, &mesh_builder->vertices[faces_vertex_idx_ptr[2]], &mesh_builder->vertices[faces_vertex_idx_ptr[1]]);
                D3DRMVectorSubtract(&b, &mesh_builder->vertices[faces_vertex_idx_ptr[0]], &mesh_builder->vertices[faces_vertex_idx_ptr[1]]);
                D3DRMVectorCrossProduct(&face_normal, &a, &b);
                D3DRMVectorNormalize(&face_normal);
            }
            else
            {
                face_normal.x = 0.0f;
                face_normal.y = 0.0f;
                face_normal.z = 0.0f;
            }
        }
 
        for (j = 0; j < nb_face_indexes; j++)
        {
            /* Copy vertex index */
            *(faces_data_ptr + faces_data_size++) = *faces_vertex_idx_ptr;
            /* Copy normal index */
            if (mesh_builder->nb_normals)
            {
                /* Read from x file */
                *(faces_data_ptr + faces_data_size++) = *(faces_normal_idx_ptr++);
            }
            else
            {
                DWORD vertex_idx = *faces_vertex_idx_ptr;
                if (vertex_idx >= mesh_builder->nb_vertices)
                {
                    WARN("Found vertex index %lu but only %Iu vertices available => use index 0\n", vertex_idx,
                            mesh_builder->nb_vertices);
                    vertex_idx = 0;
                }
                *(faces_data_ptr + faces_data_size++) = vertex_idx;
                /* Add face normal to vertex normal */
                D3DRMVectorAdd(&mesh_builder->normals[vertex_idx], &mesh_builder->normals[vertex_idx], &face_normal);
            }
            faces_vertex_idx_ptr++;
        }
        faces_vertex_idx_size -= nb_face_indexes;
    }
 
    /* Last DWORD must be 0 */
    *(faces_data_ptr + faces_data_size++) = 0;
 
    /* Set size (in number of DWORD) of all faces data */
    mesh_builder->face_data_size = faces_data_size;
 
    if (!mesh_builder->nb_normals)
    {
        /* Normalize all normals */
        for (i = 0; i < mesh_builder->nb_vertices; i++)
        {
            D3DRMVectorNormalize(&mesh_builder->normals[i]);
        }
        mesh_builder->nb_normals = mesh_builder->nb_vertices;
    }
 
    /* If there is no texture coordinates, generate default texture coordinates (0.0f, 0.0f) for each vertex */
    if (!mesh_builder->pCoords2d)
    {
        mesh_builder->nb_coords2d = mesh_builder->nb_vertices;
        mesh_builder->pCoords2d = calloc(mesh_builder->nb_coords2d, sizeof(*mesh_builder->pCoords2d));
        for (i = 0; i < mesh_builder->nb_coords2d; ++i)
        {
            mesh_builder->pCoords2d[i].u = 0.0f;
            mesh_builder->pCoords2d[i].v = 0.0f;
        }
    }
 
    TRACE("Mesh data loaded successfully\n");
 
    ret = D3DRM_OK;
 
end:
 
    free(faces_normal_idx_data);
    free(faces_vertex_idx_data);
 
    return ret;
}

Referenced by d3drm_mesh_builder3_Load(), and load_data().

unsafe_impl_from_IDirect3DRMDevice3()

struct d3drm_device * unsafe_impl_from_IDirect3DRMDevice3

(

IDirect3DRMDevice3 *

iface

)

Definition at line 1647 of file device.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3drm_device3_vtbl);
 
    return impl_from_IDirect3DRMDevice3(iface);
}

Referenced by d3drm_viewport2_Init().

unsafe_impl_from_IDirect3DRMFrame()

struct d3drm_frame * unsafe_impl_from_IDirect3DRMFrame

(

IDirect3DRMFrame *

iface

)

Definition at line 3120 of file frame.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3drm_frame1_vtbl);
 
    return impl_from_IDirect3DRMFrame(iface);
}

Referenced by d3drm_frame1_AddChild(), d3drm_frame1_DeleteChild(), d3drm_viewport1_Init(), and d3drm_viewport1_SetCamera().

unsafe_impl_from_IDirect3DRMFrame3()

struct d3drm_frame * unsafe_impl_from_IDirect3DRMFrame3

(

IDirect3DRMFrame3 *

iface

)

Definition at line 3111 of file frame.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3drm_frame3_vtbl);
 
    return impl_from_IDirect3DRMFrame3(iface);
}

Referenced by d3drm_frame3_AddChild(), d3drm_frame3_DeleteChild(), d3drm_viewport1_GetCamera(), and d3drm_viewport2_SetCamera().

Variable Documentation

templates

char templates[]

extern

Definition at line 39 of file meshbuilder.c.

Referenced by d3drm3_Load(), d3drm_mesh_builder3_Load(), IDirectXFileSaveObjectImpl_SaveTemplates(), and xsltParseStylesheetTop().